codd-dev 2.23.0__tar.gz → 2.24.0__tar.gz

{codd_dev-2.23.0 → codd_dev-2.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.23.0
+Version: 2.24.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-2.23.0 → codd_dev-2.24.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.23.0"
+__version__ = "2.24.0"

{codd_dev-2.23.0 → codd_dev-2.24.0}/codd/defaults.yaml

@@ -133,6 +133,43 @@ implement:
   # Default 3 (4 total attempts); minimum 0 (0 = opt out / legacy no-retry
   # hard-fail). NEVER unbounded.
   no_usable_file_retries: 3
+  # implement_oracle (default ON): the IMPLEMENT-TIME native-oracle gate. For a
+  # compiler-class stack (TypeScript = `tsc --noEmit`; Go/Rust later via profile
+  # + adapter) the greenfield implement stage runs the stack's native coherence
+  # oracle AFTER all units are generated and BEFORE verify -- while the SUT can
+  # still freely edit ALL files (source AND tests). It statically proves that
+  # independently-generated artifacts agree on the symbols/modules they import
+  # from each other (the src<->src and test<->helper mismatches -- TS2305/2724/
+  # 2459 -- that verify's `tsc` catches TOO LATE, where auto-repair is blocked
+  # from rewriting test files, so the mismatch ships as a permanent verify
+  # failure). Runs ONCE per stage (a per-unit tsc would false-fail on an import
+  # of a not-yet-generated unit). Before trusting a green result it CERTIFIES the
+  # oracle's config scope (tsconfig include/files) covers src + tests + e2e +
+  # helpers -- an uncovered test tree is a HARD FAIL, never a silent pass
+  # (anti-false-green). On failure it normalizes diagnostics to language-neutral
+  # evidence categories (missing_symbol / module_resolution_error /
+  # test_not_collected / environment_build_error / boundary_violation) and
+  # re-runs implementation with that feedback (bounded), so implement does not
+  # "succeed" until the oracle passes or fails honestly. A strict NO-OP for a
+  # stack with no declared implement-time oracle (Python today: its backstop
+  # stays the existing verify-stage coherence gates). Set false to opt out (this
+  # re-opens the false-green window the gate closes). Greenfield-only.
+  implement_oracle: true
+  # Total implement-oracle attempts: one initial check + bounded corrective
+  # retries that re-run implementation with normalized oracle feedback. Default 3
+  # (initial + 2); minimum 1. NEVER unbounded -- a genuinely uncurable
+  # incoherence still fails honestly (nothing is silently accepted). Only CURABLE
+  # incoherence is retried; an environment/toolchain failure (failed dependency
+  # install) is not handed to the SUT to "fix" in source.
+  oracle_max_attempts: 3
+  # Bounded wall-clock for ONE implement-oracle command run (seconds). tsc on a
+  # fresh build is fast, but a cold first run can compile a large module graph.
+  # Default 600.
+  oracle_timeout_seconds: 600
+  # Bounded wall-clock for the implement-oracle's BLOCKING dependency install
+  # (node stacks: npm/pnpm/yarn/bun -- so `tsc` + deps are materialized before
+  # the typecheck). A cold cache can pull a large tree. Default 900.
+  oracle_install_timeout_seconds: 900
   # Shared canonical output root for implement tasks WITHOUT an explicit
   # default_output_paths / implement_targets mapping (e.g. greenfield-derived
   # tasks). null = derive from scan.source_dirs[0] (usually "src/"). Every

{codd_dev-2.23.0 → codd_dev-2.24.0}/codd/greenfield/pipeline.py

@@ -701,6 +701,22 @@ class GreenfieldPipeline:
             self._checkpoint(project_root)
             self.echo(f"[greenfield] implement {task.task_id}: {detail}")
 
+        # Implement-time native-oracle gate — ONCE, after every unit is generated
+        # and BEFORE the run advances to verify, while the SUT can still freely
+        # edit ALL files (source AND tests). For a compiler-class stack (TS=tsc
+        # --noEmit) this proves cross-artifact symbol/module coherence statically
+        # — the src↔src and test↔helper mismatches (TS2305/2724/2459) that verify
+        # catches TOO LATE (where auto-repair is scope-blocked from rewriting test
+        # files). STAGE-level for the same forward-reference reason the VB gate is
+        # (a per-unit tsc would false-fail on an import of a not-yet-generated
+        # unit). On failure it normalizes diagnostics to evidence categories and
+        # re-runs implementation with that feedback (bounded), so implement does
+        # not "succeed" until the oracle passes — or fails HONESTLY. A NO-OP for
+        # stacks with no declared oracle (Python today): see
+        # codd.project_types.ImplementOracleSpec. Runs BEFORE the VB coverage gate
+        # — code that does not even typecheck cannot have meaningful VB coverage.
+        self._enforce_implement_oracle_gate(project_root, tasks, options)
+
         # Project-wide VB coverage gate — ONCE, after every implement task has
         # run and all covering tests therefore exist. Per-task enforcement was
         # disabled in _default_implement_task_runner precisely because the gate
@@ -714,6 +730,116 @@ class GreenfieldPipeline:
         )
         record["detail"] = f"{len(tasks)} task(s) implemented"
 
+    def _enforce_implement_oracle_gate(
+        self,
+        project_root: Path,
+        tasks: list[ImplementTaskRef],
+        options: dict[str, Any],
+    ) -> None:
+        """Run the implement-time native-oracle gate (see _stage_implement).
+
+        Ensures the stack topology is scaffolded first (idempotent — the same
+        ``_ensure_test_runner`` verify uses), so the oracle's config (tsconfig)
+        exists to certify and run against AT implement-time. Then runs the gate
+        with a ``rerun(feedback)`` callback that re-invokes implementation for
+        every task carrying the normalized oracle feedback (the cross-file
+        incoherence is not localized to one task, so the whole build is
+        regenerated under the feedback — the same broad-rerun shape the VB
+        coverage gate uses). A non-passing final result is a StageError; an
+        uncertifiable oracle scope (OracleScopeError) propagates as a hard
+        failure. The whole gate is a NO-OP for a stack without a declared
+        implement-time oracle.
+        """
+        from codd.implement_oracle import (
+            OracleScopeError,
+            resolve_implement_oracle,
+            run_implement_oracle_gate,
+        )
+
+        config, language, source_dirs, test_dirs = self._layout_inputs(project_root)
+        project_name = self._layout_project_name(project_root, config)
+
+        # Cheap NO-OP short-circuit: if the stack declares no implement-time
+        # oracle (Python today), do not even scaffold/echo — skip silently.
+        if resolve_implement_oracle(
+            project_root,
+            language=language,
+            project_name=project_name,
+            source_dirs=source_dirs,
+            test_dirs=test_dirs,
+            config=config,
+        ) is None:
+            return
+
+        # The oracle needs the scaffolded config (tsconfig) present NOW, at
+        # implement-time — verify's scaffold runs later. Idempotent + non-
+        # clobbering, so verify's re-scaffold is a no-op.
+        self._ensure_test_runner(project_root)
+
+        def _rerun(feedback: str) -> None:
+            self._rerun_tasks_with_feedback(project_root, tasks, feedback, options)
+
+        try:
+            result = run_implement_oracle_gate(
+                project_root,
+                language=language,
+                project_name=project_name,
+                source_dirs=source_dirs,
+                test_dirs=test_dirs,
+                config=config,
+                rerun=_rerun,
+                echo=self.echo,
+            )
+        except OracleScopeError as exc:
+            raise StageError(str(exc)) from exc
+
+        if not result.passed:
+            paths = f" (files: {', '.join(result.failed_paths)})" if result.failed_paths else ""
+            raise StageError(
+                f"implement-time native-oracle gate failed: the generated code does not "
+                f"typecheck — independently-generated artifacts disagree on the "
+                f"symbols/modules they import{paths}. Evidence categories: "
+                f"{result.category_counts()}. {result.detail}"
+            )
+
+    def _rerun_tasks_with_feedback(
+        self,
+        project_root: Path,
+        tasks: list[ImplementTaskRef],
+        feedback: str,
+        options: dict[str, Any],
+    ) -> None:
+        """Re-invoke implementation for every task carrying ``feedback``.
+
+        Routes through the SAME implement path the stage uses
+        (``implement_tasks`` with the resolved output paths), threading the
+        normalized oracle feedback so the SUT regenerates coherent files. Uses
+        the configured implement-task runner only when it is the default
+        (feedback-aware path); a custom injected runner has no feedback channel,
+        so this falls back to ``implement_tasks`` directly.
+        """
+        from codd.config import load_project_config
+        from codd.implementer import implement_tasks
+
+        try:
+            config = load_project_config(project_root)
+        except (FileNotFoundError, ValueError):
+            config = {}
+        for task in tasks:
+            output_paths = (
+                list(task.output_paths)
+                if task.output_paths
+                else _output_paths_for_task(config, task)
+            )
+            implement_tasks(
+                project_root,
+                design=task.design_node,
+                output_paths=output_paths,
+                ai_command=self.ai_command,
+                use_derived_steps=True,
+                feedback=feedback,
+            )
+
     def _default_implement_task_runner(
         self,
         project_root: Path,