把 AI 编码助手变成“确定性 Spring 升级专家”：一套可复制的升级流程

deterministic-ai-spring-upgrades-demo/
├── deterministic_upgrade_router.py
└── upgrade_findings.json

[
  {
    "id": "SPRING-001",
    "description": "Replace deprecated configuration property names after Spring Boot upgrade",
    "signal": "compiler warning and migration guide mapping",
    "deterministic": true,
    "risk": "low"
  },
  {
    "id": "SPRING-002",
    "description": "Migrate Spock-based integration tests to JUnit where Spring Boot 4 support is removed",
    "signal": "known incompatible testing framework",
    "deterministic": true,
    "risk": "medium"
  },
  {
    "id": "SPRING-003",
    "description": "Choose replacement for an unsupported internal authentication starter",
    "signal": "internal framework has no Spring Boot 4 compatible release",
    "deterministic": false,
    "risk": "high"
  },
  {
    "id": "SPRING-004",
    "description": "Adjust one service method after changed exception semantics",
    "signal": "compile passes but integration behavior changed",
    "deterministic": false,
    "risk": "medium"
  }
]

#!/usr/bin/env python3
"""Classify Spring upgrade findings into deterministic recipes or agent skills."""

from __future__ import annotations

import json
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Literal

ResolutionType = Literal["deterministic_recipe", "agent_skill", "manual_review"]


@dataclass(frozen=True)
class Finding:
    """One migration finding discovered during a framework upgrade."""

    id: str
    description: str
    signal: str
    deterministic: bool
    risk: str


@dataclass(frozen=True)
class RoutedFinding:
    """Finding plus the selected execution lane."""

    id: str
    lane: ResolutionType
    action: str
    risk: str


def load_findings(path: Path) -> list[Finding]:
    """Load findings from a JSON file."""
    data = json.loads(path.read_text(encoding="utf-8"))
    if not isinstance(data, list):
        raise ValueError("findings JSON must be a list")
    findings: list[Finding] = []
    for item in data:
        findings.append(
            Finding(
                id=str(item["id"]),
                description=str(item["description"]),
                signal=str(item["signal"]),
                deterministic=bool(item["deterministic"]),
                risk=str(item["risk"]),
            )
        )
    return findings


def route_finding(finding: Finding) -> RoutedFinding:
    """Choose a lane for one upgrade finding."""
    if finding.risk == "high" and not finding.deterministic:
        return RoutedFinding(
            id=finding.id,
            lane="manual_review",
            action="require human design decision before agent edits code",
            risk=finding.risk,
        )
    if finding.deterministic:
        return RoutedFinding(
            id=finding.id,
            lane="deterministic_recipe",
            action="implement OpenRewrite/codemod recipe and run in CI",
            risk=finding.risk,
        )
    return RoutedFinding(
        id=finding.id,
        lane="agent_skill",
        action="write a scoped agent skill with compile/test checks",
        risk=finding.risk,
    )


def build_plan(findings: list[Finding]) -> dict[str, object]:
    """Build an auditable upgrade plan."""
    routed = [route_finding(finding) for finding in findings]
    return {
        "summary": {
            "total": len(routed),
            "deterministic_recipe": sum(1 for item in routed if item.lane == "deterministic_recipe"),
            "agent_skill": sum(1 for item in routed if item.lane == "agent_skill"),
            "manual_review": sum(1 for item in routed if item.lane == "manual_review"),
        },
        "items": [item.__dict__ for item in routed],
        "ci_gate": ["compile", "unit_tests", "deprecation_warnings", "dependency_audit"],
    }


def main(argv: list[str]) -> int:
    """CLI entrypoint."""
    if len(argv) != 2:
        print("usage: deterministic_upgrade_router.py findings.json", file=sys.stderr)
        return 2
    plan = build_plan(load_findings(Path(argv[1])))
    print(json.dumps(plan, ensure_ascii=False, indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv))

python3 deterministic_upgrade_router.py upgrade_findings.json

{
  "summary": {
    "total": 4,
    "deterministic_recipe": 2,
    "agent_skill": 1,
    "manual_review": 1
  },
  "ci_gate": [
    "compile",
    "unit_tests",
    "deprecation_warnings",
    "dependency_audit"
  ]
}

将 service-a 从 Spring Boot 2.7.x 升级到受支持的 3.x 或 4.x 路径，先处理编译和依赖兼容，再进入运行时回归。

cf repo unpack-skills
cf repo upgrade-plan
cf repo apply-upgrade-plan

目标：只修复 Spring Boot 升级后的编译错误和弃用警告。
禁止：修改业务语义、替换认证框架、升级未列入计划的依赖。
验证：每次修改后运行 ./mvnw test；若同一错误连续失败 2 次，停止并报告。

compile
unit_tests
integration_tests（如存在）
dependency_audit
deprecation_warnings
upgrade_plan_artifact_nonempty

vulnerability_scan_no_known_blocker
rollback_plan_exists
release_owner_approved