codd-dev 1.32.0__tar.gz → 1.34.0__tar.gz

{codd_dev-1.32.0 → codd_dev-1.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.32.0
+Version: 1.34.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-1.32.0 → codd_dev-1.34.0}/codd/cli.py

@@ -30,6 +30,7 @@ class _CliVerificationResult:
     passed: bool
     exit_code: int
     failure: Any | None = None
+    failures: list[Any] | None = None
 
 
 @dataclass(frozen=True)
@@ -1733,6 +1734,7 @@ def assemble(path: str, output_dir: str | None, ai_cmd: str | None):
 )
 @click.option("--auto-repair", is_flag=True, default=False, help="Run RepairLoop when verification fails")
 @click.option("--max-attempts", default=None, type=click.IntRange(min=1), help="Maximum repair attempts")
+@click.option("--baseline-ref", default=None, help="Baseline git ref for repair classification")
 @click.option("--engine", "engine_name", default=None, help="Repair engine name")
 def verify(
     path: str,
@@ -1743,6 +1745,7 @@ def verify(
     design_md: bool,
     auto_repair: bool,
     max_attempts: int | None,
+    baseline_ref: str | None,
     engine_name: str | None,
 ) -> None:
     """Run build + test verification and trace failures to design documents."""
@@ -1772,8 +1775,10 @@ def verify(
         result.failure,
         repair_config=repair_config,
         max_attempts=max_attempts,
+        baseline_ref=baseline_ref,
         engine_name=engine_name,
         verify_callable=lambda: _run_verify_once(path=path, sprint=sprint, prefer_standalone=True),
+        initial_verify_result=result,
     )
     click.echo(f"Repair outcome: {outcome.status}")
     click.echo(f"Repair history: {_display_path(outcome.history_session_dir, project_root)}")
@@ -3586,6 +3591,7 @@ def _cli_result_from_standalone_verify(result: Any) -> _CliVerificationResult:
         passed=bool(result.passed),
         exit_code=0 if result.passed else 1,
         failure=getattr(result, "failure", None),
+        failures=list(getattr(result, "failures", []) or []),
     )
 
 
@@ -3619,9 +3625,12 @@ def _run_repair_loop(
     *,
     repair_config: dict[str, Any],
     max_attempts: int | None,
+    baseline_ref: str | None = None,
     engine_name: str | None,
     verify_callable,
+    initial_verify_result: Any | None = None,
 ):
+    from codd.deployment.providers.ai_command import SubprocessAiCommand
     from codd.dag import DAG
     from codd.dag.builder import build_dag
     from codd.repair import RepairLoop, RepairLoopConfig
@@ -3641,16 +3650,24 @@ def _run_repair_loop(
         approval_mode=str(repair.get("approval_mode") or "required"),  # type: ignore[arg-type]
         history_dir=Path(str(repair.get("history_dir") or ".codd/repair_history")),
         engine_name=str(engine_name or repair.get("engine_name") or repair.get("engine") or "llm"),
+        llm_client=SubprocessAiCommand(project_root=project_root, config=repair_config),
+        repo_path=project_root,
+    )
+    return RepairLoop(config, project_root).run(
+        resolved_failure,
+        dag,
+        verify_callable=verify_callable,
+        baseline_ref=baseline_ref,
+        initial_verify_result=initial_verify_result,
     )
-    return RepairLoop(config, project_root).run(resolved_failure, dag, verify_callable=verify_callable)
 
 
 def _repair_max_attempts(repair: dict[str, Any], max_attempts: int | None) -> int:
-    raw = max_attempts if max_attempts is not None else repair.get("max_attempts", 3)
+    raw = max_attempts if max_attempts is not None else repair.get("max_attempts", 10)
     try:
         return max(1, int(raw))
     except (TypeError, ValueError):
-        return 3
+        return 10
 
 
 def _dag_snapshot(dag: Any, project_root: Path) -> dict[str, Any]:
@@ -3686,6 +3703,8 @@ def _utc_timestamp() -> str:
 def _repair_exit_code(status: str) -> int:
     return {
         "REPAIR_SUCCESS": 0,
+        "PARTIAL_SUCCESS": 2,
+        "MAX_ATTEMPTS_REACHED": 2,
         "REPAIR_REJECTED_BY_HITL": 1,
         "REPAIR_EXHAUSTED": 2,
         "REPAIR_FAILED": 3,
@@ -3790,9 +3809,17 @@ def _load_repair_proposal(path: Path) -> Any:
 @click.option("--from-report", "from_report", type=click.Path(exists=True, dir_okay=False, path_type=Path))
 @click.option("--path", "project_path", default=".", help="Project root directory")
 @click.option("--max-attempts", default=None, type=click.IntRange(min=1), help="Maximum repair attempts")
+@click.option("--baseline-ref", default=None, help="Baseline git ref for repair classification")
 @click.option("--engine", "engine_name", default=None, help="Repair engine name")
 @click.pass_context
-def repair(ctx, from_report: Path | None, project_path: str, max_attempts: int | None, engine_name: str | None):
+def repair(
+    ctx,
+    from_report: Path | None,
+    project_path: str,
+    max_attempts: int | None,
+    baseline_ref: str | None,
+    engine_name: str | None,
+):
     """Run and inspect repair sessions."""
     if ctx.invoked_subcommand is not None:
         return
@@ -3812,6 +3839,7 @@ def repair(ctx, from_report: Path | None, project_path: str, max_attempts: int |
             failure,
             repair_config=repair_config,
             max_attempts=max_attempts,
+            baseline_ref=baseline_ref,
             engine_name=engine_name,
             verify_callable=lambda: _run_verify_once(path=str(project_root), sprint=None),
         )

{codd_dev-1.32.0 → codd_dev-1.34.0}/codd/deployment/providers/verification/cdp_browser.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import importlib.util
 import subprocess
 import time
 from collections.abc import Callable, Mapping
@@ -91,6 +92,7 @@ class CdpBrowser(VerificationTemplate):
 
         try:
             plan = _parse_plan(command)
+            _import_project_cdp_plugins(_optional_project_root(plan))
             config = self._resolve_config(plan)
             timeout_seconds = _float_config(config, "timeout_seconds", 60.0)
             step_timeout = _float_config(config, "step_timeout_seconds", timeout_seconds)
@@ -432,6 +434,23 @@ def _optional_project_root(plan: Mapping[str, Any]) -> Path | None:
     return Path(str(value)).resolve()
 
 
+def _import_project_cdp_plugins(project_root: Path | None) -> None:
+    if project_root is None:
+        return
+    plugin_root = project_root / "codd_plugins" / "cdp_browser"
+    if not plugin_root.is_dir():
+        return
+    for path in sorted(plugin_root.rglob("*.py")):
+        if path.name == "__init__.py":
+            continue
+        module_name = "codd_project_cdp_plugin_" + "_".join(path.relative_to(plugin_root).with_suffix("").parts)
+        spec = importlib.util.spec_from_file_location(module_name, path)
+        if spec is None or spec.loader is None:
+            raise ValueError(f"cannot load CDP plug-in: {path}")
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+
 def _steps(plan: Mapping[str, Any]) -> list[Mapping[str, Any]]:
     steps = plan.get("steps", [])
     if not isinstance(steps, list):

{codd_dev-1.32.0 → codd_dev-1.34.0}/codd/implementer/typecheck_loop.py

@@ -103,10 +103,22 @@ class TypecheckRepairLoop:
                 "failure": None if final_run.passed else _typecheck_failure(final_run, scoped_files, dag),
             }
 
-        config = RepairLoopConfig(max_attempts=self.max_attempts, engine_name=self.engine_name)
+        from codd.deployment.providers.ai_command import SubprocessAiCommand
+
+        config = RepairLoopConfig(
+            max_attempts=self.max_attempts,
+            engine_name=self.engine_name,
+            llm_client=SubprocessAiCommand(command=ai_command, project_root=project_root),
+            repo_path=project_root,
+        )
         repair_loop = self.repair_loop_factory(config, project_root)
         outcome = repair_loop.run(failure, dag, verify_callable=verify_callable)
-        status: TypecheckLoopStatus = "REPAIR_SUCCESS" if outcome.success else "REPAIR_EXHAUSTED"
+        status: TypecheckLoopStatus = (
+            "REPAIR_SUCCESS"
+            if getattr(outcome, "status", None) == "REPAIR_SUCCESS"
+            or (getattr(outcome, "status", None) is None and outcome.success)
+            else "REPAIR_EXHAUSTED"
+        )
         return TypecheckLoopResult(status, _attempts_to_dicts(outcome), final_run.output)
 
     def _run_typecheck(self, project_root: Path) -> _TypecheckRun:

{codd_dev-1.32.0 → codd_dev-1.34.0}/codd/repair/__init__.py

@@ -2,6 +2,7 @@
 
 from codd.repair.llm_repair_engine import LlmRepairEngine, RepairFailed
 from codd.repair.loop import RepairLoop, RepairLoopConfig, RepairLoopOutcome
+from codd.repair.repair_result import RepairResult
 from codd.repair.verify_runner import VerificationResult, VerifyRunner
 
 __all__ = [
@@ -10,6 +11,7 @@ __all__ = [
     "RepairLoop",
     "RepairLoopConfig",
     "RepairLoopOutcome",
+    "RepairResult",
     "VerificationResult",
     "VerifyRunner",
 ]

{codd_dev-1.32.0 → codd_dev-1.34.0}/codd/repair/history.py

@@ -53,15 +53,25 @@ class RepairHistory:
         _write_yaml(attempt_dir / "apply_result.yaml", apply_result)
         _write_yaml(attempt_dir / "post_repair_verify.yaml", post_verify)
 
-    def finalize(self, session_dir: Path, outcome: str) -> None:
+    def finalize(self, session_dir: Path, outcome: str, details: dict[str, Any] | None = None) -> None:
         """Write the final repair session outcome."""
 
-        allowed = {"REPAIR_SUCCESS", "REPAIR_EXHAUSTED", "REPAIR_REJECTED_BY_HITL", "REPAIR_FAILED"}
+        allowed = {
+            "REPAIR_SUCCESS",
+            "PARTIAL_SUCCESS",
+            "MAX_ATTEMPTS_REACHED",
+            "REPAIR_EXHAUSTED",
+            "REPAIR_REJECTED_BY_HITL",
+            "REPAIR_FAILED",
+        }
         if outcome not in allowed:
             raise ValueError(f"outcome must be one of {sorted(allowed)}")
+        payload = {"outcome": outcome, "timestamp": _timestamp()}
+        if details:
+            payload.update(details)
         _write_yaml(
             Path(session_dir) / "final_status.yaml",
-            {"outcome": outcome, "timestamp": _timestamp()},
+            payload,
         )
 
     def load_session(self, session_dir: Path) -> dict:
@@ -111,7 +121,15 @@ def _read_yaml(path: Path) -> Any:
 
 def _to_plain_data(value: Any) -> Any:
     if is_dataclass(value) and not isinstance(value, type):
-        return asdict(value)
+        return _to_plain_data(asdict(value))
+    if isinstance(value, dict):
+        return {str(key): _to_plain_data(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_to_plain_data(item) for item in value]
+    if isinstance(value, tuple):
+        return [_to_plain_data(item) for item in value]
+    if isinstance(value, Path):
+        return str(value)
     return value