基础设施比模型更重要：Stripe Minions 给 AI Agent 落地的启示

┌─────────────────────────────────────────────────────────────────┐
│                    IRMA 成熟度模型                               │
├──────────────┬──────────────────────────────────────────────────┤
│  Level 4     │  Autonomous Ready                                │
│  自治级      │  • 全自动化测试覆盖（>80%）                       │
│              │  • 一键部署 + 自动回滚                            │
│              │  • 标准化开发环境（devbox/容器）                   │
│              │  • 构建缓存 + 依赖缓存预热                        │
│              │  • 代码规范自动检查（lint/format）                 │
│              │  → Agent 可以独立开发、测试、提交 PR              │
├──────────────┼──────────────────────────────────────────────────┤
│  Level 3     │  Assisted Ready                                  │
│  辅助级      │  • 核心模块有自动化测试                           │
│              │  • CI/CD 流水线稳定                               │
│              │  • 开发环境可复现（Docker/devcontainer）          │
│              │  • 构建时间可接受（<10分钟）                      │
│              │  → Agent 可以辅助开发，需要人工 review            │
├──────────────┼──────────────────────────────────────────────────┤
│  Level 2     │  Experimental Ready                              │
│  实验级      │  • 有基本的 CI（能跑测试）                        │
│              │  • 开发环境靠文档描述                             │
│              │  • 构建时间较长（>30分钟）                        │
│              │  • 测试覆盖率低（<30%）                           │
│              │  → Agent 只能做简单任务，经常失败                 │
├──────────────┼──────────────────────────────────────────────────┤
│  Level 1     │  Not Ready                                       │
│  未就绪      │  • 没有自动化测试                                 │
│              │  • 没有 CI/CD                                     │
│              │  • 开发环境「在我机器上能跑」                      │
│              │  • 构建靠手动                                     │
│              │  → Agent 完全无法工作                             │
└──────────────┴──────────────────────────────────────────────────┘

from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
import subprocess
import os


class IRMALevel(Enum):
    """AI Agent Infrastructure Readiness Model levels."""
    NOT_READY = 1
    EXPERIMENTAL = 2
    ASSISTED = 3
    AUTONOMOUS = 4


@dataclass
class InfrastructureScore:
    """Assessment result for infrastructure readiness."""
    level: IRMALevel
    details: dict[str, bool]
    recommendations: list[str] = field(default_factory=list)

    def summary(self) -> str:
        """Generate a human-readable summary."""
        passed = sum(1 for v in self.details.values() if v)
        total = len(self.details)
        return (
            f"IRMA Level: {self.level.name} ({self.level.value}/4)\n"
            f"Checks passed: {passed}/{total}\n"
            f"Recommendations:\n" +
            "\n".join(f"  - {r}" for r in self.recommendations)
        )


def check_ci_cd() -> bool:
    """Check if CI/CD pipeline exists."""
    ci_indicators = [
        ".github/workflows",
        ".gitlab-ci.yml",
        ".circleci",
        "Jenkinsfile",
    ]
    return any(os.path.exists(p) for p in ci_indicators)


def check_test_coverage(threshold: float = 0.3) -> bool:
    """Check if test coverage meets threshold.

    This is a simplified check. In practice, you'd parse
    coverage reports or run coverage tools.
    """
    test_dirs = ["tests", "test", "__tests__", "spec"]
    has_tests = any(os.path.isdir(d) for d in test_dirs)
    # Rough heuristic: if test dir exists, assume basic coverage
    return has_tests


def check_dev_environment() -> bool:
    """Check if development environment is reproducible."""
    indicators = [
        "Dockerfile",
        "docker-compose.yml",
        ".devcontainer",
        "devbox.json",
        "flake.nix",
        "shell.nix",
    ]
    return any(os.path.exists(p) for p in indicators)


def check_build_cache() -> bool:
    """Check if build caching is configured."""
    cache_indicators = [
        "bazel.rc",  # Bazel remote cache
        ".gradle/caches",  # Gradle
        "target/dependency",  # Maven
        "node_modules/.cache",  # Node.js
    ]
    return any(os.path.exists(p) for p in cache_indicators)


def check_auto_lint() -> bool:
    """Check if automated linting/formatting is configured."""
    lint_indicators = [
        ".pre-commit-config.yaml",
        ".eslintrc",
        ".pylintrc",
        "ruff.toml",
        ".black",
        "pyproject.toml",
    ]
    return any(os.path.exists(p) for p in lint_indicators)


def assess_infrastructure() -> InfrastructureScore:
    """Assess current project's infrastructure readiness for AI Agents.

    Returns:
        InfrastructureScore with level, details, and recommendations.
    """
    checks = {
        "ci_cd": check_ci_cd(),
        "test_coverage": check_test_coverage(),
        "dev_environment": check_dev_environment(),
        "build_cache": check_build_cache(),
        "auto_lint": check_auto_lint(),
    }

    passed = sum(1 for v in checks.values() if v)
    recommendations = []

    if not checks["ci_cd"]:
        recommendations.append("建立 CI/CD 流水线（GitHub Actions / GitLab CI）")
    if not checks["test_coverage"]:
        recommendations.append("增加自动化测试覆盖（目标 >30%）")
    if not checks["dev_environment"]:
        recommendations.append("标准化开发环境（Docker / devcontainer / devbox）")
    if not checks["build_cache"]:
        recommendations.append("配置构建缓存以加速重复构建")
    if not checks["auto_lint"]:
        recommendations.append("配置自动代码检查和格式化（pre-commit hooks）")

    # Determine level
    if passed >= 5:
        level = IRMALevel.AUTONOMOUS
    elif passed >= 3:
        level = IRMALevel.ASSISTED
    elif passed >= 2:
        level = IRMALevel.EXPERIMENTAL
    else:
        level = IRMALevel.NOT_READY

    return InfrastructureScore(
        level=level,
        details=checks,
        recommendations=recommendations,
    )


if __name__ == "__main__":
    score = assess_infrastructure()
    print(score.summary())
# generated by hugo AI