codd-dev 2.49.0__tar.gz → 2.51.0__tar.gz

{codd_dev-2.49.0 → codd_dev-2.51.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.49.0
+Version: 2.51.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.49.0 → codd_dev-2.51.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.49.0"
+__version__ = "2.51.0"

{codd_dev-2.49.0 → codd_dev-2.51.0}/codd/generator.py

@@ -607,33 +607,144 @@ def generate_wave(
         if output_path.exists() and not force:
             results.append(GenerationResult(node_id=artifact.node_id, path=output_path, status="skipped"))
             continue
-
-        dependency_documents = _load_dependency_documents(project_root, artifact.depends_on, document_node_paths)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        combined_conventions = deepcopy(global_conventions) + deepcopy(artifact.conventions)
-        content = _render_document(
-            artifact=artifact,
-            global_conventions=global_conventions,
-            depended_by=depended_by_map.get(artifact.node_id, []),
-            body=_generate_document_body(
+        results.append(
+            _generate_one_artifact(
                 artifact=artifact,
-                dependency_documents=dependency_documents,
-                conventions=combined_conventions,
-                ai_command=resolved_ai_command,
                 project_root=project_root,
-                feedback=feedback,
-                max_retries=body_max_retries,
+                global_conventions=global_conventions,
+                depended_by_map=depended_by_map,
+                document_node_paths=document_node_paths,
+                resolved_ai_command=resolved_ai_command,
+                body_max_retries=body_max_retries,
                 capabilities=capabilities,
                 project_language=project_language,
-            ),
+                feedback=feedback,
+            )
         )
-        output_path.write_text(content, encoding="utf-8")
-        results.append(GenerationResult(node_id=artifact.node_id, path=output_path, status="generated"))
 
     _enforce_vb_declaration_coherence(project_root, config, results)
     return results
 
 
+def _generate_one_artifact(
+    *,
+    artifact: WaveArtifact,
+    project_root: Path,
+    global_conventions: list[dict[str, Any]],
+    depended_by_map: dict[str, list[dict[str, Any]]],
+    document_node_paths: dict[str, Path],
+    resolved_ai_command: str,
+    body_max_retries: int,
+    capabilities: "ProjectCapabilities | None",
+    project_language: str | None,
+    feedback: str | None,
+) -> GenerationResult:
+    """Render ONE artifact's document and write it (overwriting any prior file).
+
+    The shared per-artifact rendering step used by both :func:`generate_wave`
+    (the wave loop) and :func:`regenerate_artifact` (the single-doc repair seam).
+    Always (re)writes the output; skip-if-exists is the wave loop's decision, not
+    this helper's, so a scoped repair can overwrite exactly one doc.
+    """
+
+    output_path = project_root / artifact.output
+    dependency_documents = _load_dependency_documents(
+        project_root, artifact.depends_on, document_node_paths
+    )
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    combined_conventions = deepcopy(global_conventions) + deepcopy(artifact.conventions)
+    content = _render_document(
+        artifact=artifact,
+        global_conventions=global_conventions,
+        depended_by=depended_by_map.get(artifact.node_id, []),
+        body=_generate_document_body(
+            artifact=artifact,
+            dependency_documents=dependency_documents,
+            conventions=combined_conventions,
+            ai_command=resolved_ai_command,
+            project_root=project_root,
+            feedback=feedback,
+            max_retries=body_max_retries,
+            capabilities=capabilities,
+            project_language=project_language,
+        ),
+    )
+    output_path.write_text(content, encoding="utf-8")
+    return GenerationResult(node_id=artifact.node_id, path=output_path, status="generated")
+
+
+def regenerate_artifact(
+    project_root: Path,
+    *,
+    node_id: str | None = None,
+    output_path: str | None = None,
+    feedback: str | None = None,
+    ai_command: str | None = None,
+) -> GenerationResult:
+    """Regenerate a SINGLE wave artifact in place, scoped to one document.
+
+    The thin seam the greenfield generate-time VB-registry repair uses: it
+    rewrites ONLY the canonical VB doc (``docs/test/test_strategy.md``) with
+    repair feedback, WITHOUT re-running the whole wave (which would clobber the
+    sibling governance/design docs already generated). Reuses the exact wave
+    plumbing (:func:`_generate_one_artifact` → ``_load_dependency_documents`` /
+    ``_render_document`` / ``_generate_document_body``); only the artifact
+    selection (by ``node_id`` or ``output``) and the forced overwrite differ.
+
+    Identify the target by ``node_id`` (preferred) or ``output_path`` (the
+    artifact's ``output``). Raises ``ValueError`` if no/!=1 wave artifact matches
+    — an ambiguous or absent target must fail loudly, never silently no-op.
+    """
+
+    from codd.scanner import build_document_node_path_map
+
+    if not node_id and not output_path:
+        raise ValueError("regenerate_artifact requires node_id or output_path")
+
+    config = _load_project_config(project_root)
+    artifacts = _load_wave_artifacts(config)
+
+    def _matches(candidate: WaveArtifact) -> bool:
+        if node_id is not None and candidate.node_id == node_id:
+            return True
+        if output_path is not None:
+            want = output_path.replace("\\", "/").strip("/")
+            have = str(candidate.output).replace("\\", "/").strip("/")
+            if want == have:
+                return True
+        return False
+
+    matched = [artifact for artifact in artifacts if _matches(artifact)]
+    if not matched:
+        target = node_id or output_path
+        raise ValueError(f"wave_config has no artifact matching {target!r}")
+    if len(matched) > 1:
+        target = node_id or output_path
+        raise ValueError(f"wave_config has {len(matched)} artifacts matching {target!r}; ambiguous")
+
+    artifact = matched[0]
+    resolved_ai_command = _resolve_ai_command(config, ai_command, command_name="generate")
+    global_conventions = _normalize_conventions(config.get("conventions", []))
+    depended_by_map = _build_depended_by_map(artifacts)
+    document_node_paths = build_document_node_path_map(project_root, config)
+    body_max_retries = _body_max_retries(config)
+    capabilities = _resolve_generation_capabilities(config, project_root)
+    project_language = _resolve_project_language(config)
+
+    return _generate_one_artifact(
+        artifact=artifact,
+        project_root=project_root,
+        global_conventions=global_conventions,
+        depended_by_map=depended_by_map,
+        document_node_paths=document_node_paths,
+        resolved_ai_command=resolved_ai_command,
+        body_max_retries=body_max_retries,
+        capabilities=capabilities,
+        project_language=project_language,
+        feedback=feedback,
+    )
+
+
 def _enforce_vb_declaration_coherence(
     project_root: Path,
     config: dict[str, Any],

{codd_dev-2.49.0 → codd_dev-2.51.0}/codd/greenfield/pipeline.py

@@ -657,8 +657,181 @@ class GreenfieldPipeline:
             record["units"][key] = STATUS_DONE
             self._checkpoint(project_root)
             self.echo(f"[greenfield] generate wave {wave}: {detail}")
+
+        # After ALL waves are generated, enforce the canonical VB-registry
+        # completeness contract (model-independence): a weak model can reference
+        # VB ids in acceptance-criteria tables yet declare none in the canonical
+        # registry, which honest-REDs only later at implement with a confusing
+        # orphan message. Catch it HERE and drive a bounded, canonical-doc-scoped
+        # repair so a coherent registry exists before implement — or fail
+        # honestly at generate. Runs BEFORE implement by construction.
+        self._enforce_generate_vb_registry_gate(project_root, options)
         record["detail"] = f"{len(waves)} wave(s) generated"
 
+    def _enforce_generate_vb_registry_gate(
+        self, project_root: Path, options: dict[str, Any]
+    ) -> None:
+        """Generate-time canonical VB-registry completeness gate + bounded repair.
+
+        Adopts the GPT design (B as contract + A as bounded generate repair). On
+        error-level :func:`validate_vb_registry_completeness` issues (empty
+        canonical registry / unresolved AC references / missing canonical doc),
+        re-invoke generation SCOPED TO the canonical VB doc only
+        (:func:`codd.generator.regenerate_artifact`) with repair feedback, then
+        re-validate. After the bounded attempts (1–2), a still-failing registry
+        raises :class:`StageError` (generate honest-RED).
+
+        The MODEL writes the declarations — this is NOT deterministic auto-derive.
+        Acceptance-criteria references are used ONLY as the candidate list in the
+        repair feedback, NEVER auto-inserted into the canonical table (rejecting
+        design option C). Skipped for a project with no verifiable-behavior
+        surface (:func:`project_expects_vb_registry`) and when the owner turned
+        the coverage gate off — the registry contract tracks the coverage gate.
+        """
+        from codd.config import load_project_config
+        from codd.verifiable_behavior_audit import (
+            _CANONICAL_VB_OUTPUT_PATH,
+            coverage_gate_enabled,
+            project_expects_vb_registry,
+            validate_vb_registry_completeness,
+        )
+
+        if not bool(options.get("coverage_gate", True)):
+            return
+        try:
+            config = load_project_config(project_root)
+        except (FileNotFoundError, ValueError):
+            config = {}
+        if not coverage_gate_enabled(config):
+            return
+        if not project_expects_vb_registry(project_root, config):
+            # No VB surface planned/declared — nothing to certify. Mirrors the
+            # brownfield "nothing to audit -> pass" rule; a minimal greenfield
+            # project with only design docs is not forced to invent behaviors.
+            return
+
+        max_attempts = max(1, int(self._option_overrides.get("max_repair_attempts") or 0) or 2)
+        max_attempts = min(max_attempts, 2)  # bounded: 1–2 attempts (design)
+
+        # Reference the seam through the module (not a bound name) so a test's
+        # monkeypatch on ``codd.generator.regenerate_artifact`` is honored.
+        from codd import generator as generator_module
+
+        issues = validate_vb_registry_completeness(project_root, config, strict=True)
+        errors = [issue for issue in issues if issue.severity == "error"]
+        attempt = 0
+        while errors and attempt < max_attempts:
+            attempt += 1
+            feedback = self._build_vb_registry_repair_feedback(project_root, config, errors)
+            self.echo(
+                f"[greenfield] generate VB-registry gate: {len(errors)} issue(s); "
+                f"re-generating {_CANONICAL_VB_OUTPUT_PATH} with repair feedback "
+                f"(attempt {attempt}/{max_attempts})"
+            )
+            try:
+                generator_module.regenerate_artifact(
+                    project_root,
+                    output_path=_CANONICAL_VB_OUTPUT_PATH,
+                    feedback=feedback,
+                    ai_command=self.ai_command,
+                )
+            except (FileNotFoundError, ValueError) as exc:
+                # The canonical doc is not a planned artifact, or regeneration
+                # failed — cannot repair. Fail honestly with the original gap.
+                raise StageError(
+                    f"generate VB-registry gate: canonical registry repair could not run "
+                    f"({exc}); the canonical VB document ({_CANONICAL_VB_OUTPUT_PATH}) must "
+                    "declare every verifiable behavior as a first-column VB-* row."
+                ) from exc
+            issues = validate_vb_registry_completeness(project_root, config, strict=True)
+            errors = [issue for issue in issues if issue.severity == "error"]
+
+        if errors:
+            detail = "\n".join(f"  - {issue.message}" for issue in errors)
+            raise StageError(
+                "generate VB-registry gate FAILED: the generated canonical verifiable-behavior "
+                f"registry ({_CANONICAL_VB_OUTPUT_PATH}) is still incomplete after "
+                f"{attempt} repair attempt(s):\n{detail}\n"
+                "Declare every real verifiable behavior exactly once as a first-column VB-* row "
+                "in the canonical doc so coverage/authenticity can certify the system."
+            )
+        if attempt:
+            self.echo(
+                f"[greenfield] generate VB-registry gate: canonical registry repaired "
+                f"after {attempt} attempt(s) — OK"
+            )
+
+    def _build_vb_registry_repair_feedback(
+        self, project_root: Path, config: dict[str, Any], errors: list[Any]
+    ) -> str:
+        """Repair feedback for the canonical-doc-scoped regeneration.
+
+        Lists the canonical-registry declaration count + the unresolved AC
+        references (the CANDIDATE id list, never auto-inserted) + the repair
+        rules in the shape the GPT design specified. The references are a hint
+        about which behaviors likely exist — the model decides which correspond
+        to real behaviors and declares them; nothing is derived deterministically.
+        """
+        from codd.verifiable_behavior_audit import (
+            _CANONICAL_VB_OUTPUT_PATH,
+            _config_without_doc_pin,
+            _iter_doc_texts,
+            _normalize_vb_id,
+            is_canonical_vb_doc,
+            parse_vb_references,
+            parse_vb_table,
+        )
+
+        # Scan the WHOLE test-doc tree (not just test_coverage.docs) so the
+        # candidate-reference list mirrors what validate_vb_registry_completeness
+        # saw (an AC doc that references VB ids is not in test_coverage.docs).
+        doc_texts = _iter_doc_texts(project_root, config=_config_without_doc_pin(config))
+        canonical_count = 0
+        declared: set[str] = set()
+        for doc, text in doc_texts:
+            if not is_canonical_vb_doc(output_path=doc):
+                continue
+            rows = parse_vb_table(text, source_doc=doc)
+            canonical_count += len(rows)
+            declared.update(_normalize_vb_id(row.vb_id) for row in rows)
+
+        # Collect unresolved references (id -> the docs that reference it) as the
+        # CANDIDATE list only — never auto-inserted into the canonical table.
+        candidates: dict[str, set[str]] = {}
+        for doc, text in doc_texts:
+            if is_canonical_vb_doc(output_path=doc):
+                continue
+            for ref in parse_vb_references(text, source_doc=doc):
+                if _normalize_vb_id(ref.vb_id) in declared:
+                    continue
+                candidates.setdefault(ref.vb_id, set()).add(doc)
+
+        lines = [
+            "The generated verifiable-behavior (VB) registry is incomplete.",
+            "",
+            "Canonical registry:",
+            f"- {_CANONICAL_VB_OUTPUT_PATH} declares {canonical_count} canonical VB-* row(s).",
+        ]
+        if candidates:
+            lines.append("")
+            lines.append("Unresolved VB references (candidate ids — NOT yet declared canonically):")
+            for vb_id in sorted(candidates):
+                docs = ", ".join(sorted(candidates[vb_id]))
+                lines.append(f"- {vb_id} (referenced in {docs})")
+        lines.extend(
+            [
+                "",
+                "Repair rules:",
+                f"- Rewrite ONLY {_CANONICAL_VB_OUTPUT_PATH}.",
+                "- Declare every real verifiable behavior exactly once as a first-column VB-* row.",
+                "- Use a referenced id only when it corresponds to a real behavior derived from "
+                "the requirements/design; fix a reference elsewhere only if its id is genuinely wrong.",
+                "- Do NOT add or modify `codd: covers` markers.",
+                "- Do NOT edit source or executable tests.",
+            ]
+        )
+        return "\n".join(lines)
+
     # ── stage: implement ────────────────────────────────────
 
     def _stage_implement(self, project_root: Path, record: dict[str, Any], options: dict[str, Any]) -> None:
@@ -2522,6 +2695,7 @@ def _enforce_stage_coverage_gate(
         coverage_gate_enabled,
         coverage_gate_max_retries,
         format_gap_feedback,
+        project_expects_vb_registry,
         run_implement_coverage_gate,
     )
 
@@ -2536,6 +2710,24 @@ def _enforce_stage_coverage_gate(
     if not coverage_gate_enabled(config):
         return
 
+    # GREENFIELD-ONLY empty-registry hard-fail (rear guard behind the generate
+    # gate). For a project that is EXPECTED to own a canonical VB registry (it
+    # plans/declares one — see project_expects_vb_registry), an empty audit means
+    # NO verifiable behaviors were declared, so orphan never fires and the
+    # marker-authenticity gate has nothing to judge — verify could pass over a
+    # build whose VB-coverage contract was never generated. Fail honestly here.
+    # This does NOT change the brownfield run_implement_coverage_gate
+    # "nothing to audit -> pass" rule (that path is untouched); it gates ONLY the
+    # greenfield autopilot, and ONLY when a VB surface was expected — a minimal
+    # greenfield project with no VB surface still passes.
+    if project_expects_vb_registry(project_root, config):
+        if not build_vb_coverage_audit(project_root, config=config).rows:
+            raise StageError(
+                "greenfield requires a non-empty canonical VB registry in "
+                "docs/test/test_strategy.md; no verifiable behaviors were declared, "
+                "so coverage/authenticity cannot certify the generated system."
+            )
+
     # Pass the configured test dirs as the audited output paths so the gate
     # treats this as a test-related run (it is — every test the build will ever
     # have now exists) and evaluates the FULL project VB universe in one pass.

{codd_dev-2.49.0 → codd_dev-2.51.0}/codd/vb_marker_authenticity.py

@@ -829,6 +829,40 @@ def _python_decorator_start_lines(text: str) -> dict[int, int]:
     return starts
 
 
+def _python_test_function_nodes(
+    text: str,
+) -> list[ast.FunctionDef | ast.AsyncFunctionDef]:
+    """Top-level ``test_*`` functions (module- or class-level) via AST.
+
+    AST is signature-layout-agnostic, so a multi-line ``def test_x(\n  a,\n) -> None:``
+    yields the CORRECT body extent — unlike the legacy line-scanner, which read the
+    closing ``)`` line (at the def's own indent) as the body dedent and collapsed
+    the body to the parameter-annotation lines (the ``no_assertion`` FALSE-RED this
+    fixes). A ``test_*`` nested INSIDE another function is excluded (not a
+    pytest-collected unit). Returns [] on syntax error (caller falls back to the
+    line-scanner).
+    """
+
+    try:
+        tree = ast.parse(text)
+    except (SyntaxError, ValueError):
+        return []
+    parents: dict[ast.AST, ast.AST] = {}
+    for parent in ast.walk(tree):
+        for child in ast.iter_child_nodes(parent):
+            parents[child] = parent
+    nodes: list[ast.FunctionDef | ast.AsyncFunctionDef] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if not str(node.name).startswith("test_"):
+            continue
+        if not isinstance(parents.get(node), (ast.Module, ast.ClassDef)):
+            continue
+        nodes.append(node)
+    return sorted(nodes, key=lambda n: int(n.lineno))
+
+
 @dataclass(frozen=True)
 class PythonTestBlockProfile:
     """pytest / unittest structural adapter.
@@ -847,6 +881,48 @@ class PythonTestBlockProfile:
         return rel_path.endswith(".py")
 
     def parse_test_blocks(self, text: str) -> list[TestBlock]:
+        # AST is the authoritative body-extent source. The legacy line-scanner
+        # (kept as a fallback for syntactically-invalid files) mis-reads a
+        # MULTI-LINE def signature: the closing ``) -> None:`` sits at the def's
+        # own indent, so it was taken as the body dedent and the body collapsed to
+        # the parameter-annotation lines (a ``no_assertion`` FALSE-RED on a test
+        # that genuinely asserts). AST yields the true ``body[0]..end_lineno``
+        # extent regardless of signature layout, return annotation, decorators, or
+        # nested defs. has_assertion stays the raw primitive check (unchanged).
+        try:
+            ast.parse(text)
+        except (SyntaxError, ValueError):
+            return self._parse_test_blocks_linescan(text)
+        lines = text.splitlines()
+        blocks: list[TestBlock] = []
+        for node in _python_test_function_nodes(text):
+            def_line = int(node.lineno)
+            start_line = min(
+                [int(d.lineno) for d in node.decorator_list], default=def_line
+            )
+            body_start = int(node.body[0].lineno) if node.body else def_line
+            body_end = int(getattr(node, "end_lineno", body_start) or body_start)
+            body_text = "\n".join(lines[body_start - 1 : body_end])
+            skipped = bool(re.search(r"\bpytest\.skip\s*\(", body_text)) or bool(
+                re.search(r"\bself\.skipTest\s*\(", body_text)
+            )
+            decorator_text = "\n".join(lines[start_line - 1 : def_line - 1])
+            if _PY_SKIP_DECORATOR_RE.search(decorator_text):
+                skipped = True
+            has_assertion = bool(_PY_PRIMITIVE_ASSERT_RE.search(body_text))
+            blocks.append(
+                TestBlock(
+                    start_line=start_line,
+                    end_line=body_end,
+                    is_executable=not skipped,
+                    has_assertion=has_assertion,
+                    label=node.name,
+                    body_text=body_text,
+                )
+            )
+        return blocks
+
+    def _parse_test_blocks_linescan(self, text: str) -> list[TestBlock]:
         lines = text.splitlines()
         marker_lines = _shared_marker_lines(text)
         decorator_starts = _python_decorator_start_lines(text)