codd-dev 3.7.5__tar.gz → 3.25.0__tar.gz

{codd_dev-3.7.5 → codd_dev-3.25.0}/.gitignore

@@ -33,3 +33,6 @@ dogfood/*
 
 # Internal task reports (cmd_* process records) — kept LOCAL, not published
 reports/
+
+# Claude Code project-local settings (machine-specific paths, e.g. autoMemoryDirectory) — kept LOCAL, not published
+.claude/

{codd_dev-3.7.5 → codd_dev-3.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 3.7.5
+Version: 3.25.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
@@ -118,6 +118,8 @@ codd greenfield --requirements docs/requirements/requirements.md
 
 It saves a checkpoint after every step, so `codd greenfield --resume` continues where it left off. Add `--dry-run` to preview the plan first, or `--ntfy-topic <topic>` to get progress pings on your phone.
 
+> **Language coverage today:** unattended greenfield is empirically validated end-to-end on **TypeScript and Python**. The other supported languages share the same language-profile machinery but have not yet had unattended end-to-end validation.
+
 The same one-command pipeline (`codd greenfield --requirements FILE`) also ships as three transparent, adaptable vehicles you can read and tweak: a shell script ([`examples/greenfield_autopilot.sh`](examples/greenfield_autopilot.sh)), a Claude Code workflow ([`examples/claude_workflows/codd-greenfield.js`](examples/claude_workflows/codd-greenfield.js)), and a skill (`codd skills install codd-greenfield --target both`).
 
 ### 2. Work on an existing codebase — `codd init` + `codd scan`

{codd_dev-3.7.5 → codd_dev-3.25.0}/README.md

@@ -76,6 +76,8 @@ codd greenfield --requirements docs/requirements/requirements.md
 
 It saves a checkpoint after every step, so `codd greenfield --resume` continues where it left off. Add `--dry-run` to preview the plan first, or `--ntfy-topic <topic>` to get progress pings on your phone.
 
+> **Language coverage today:** unattended greenfield is empirically validated end-to-end on **TypeScript and Python**. The other supported languages share the same language-profile machinery but have not yet had unattended end-to-end validation.
+
 The same one-command pipeline (`codd greenfield --requirements FILE`) also ships as three transparent, adaptable vehicles you can read and tweak: a shell script ([`examples/greenfield_autopilot.sh`](examples/greenfield_autopilot.sh)), a Claude Code workflow ([`examples/claude_workflows/codd-greenfield.js`](examples/claude_workflows/codd-greenfield.js)), and a skill (`codd skills install codd-greenfield --target both`).
 
 ### 2. Work on an existing codebase — `codd init` + `codd scan`

{codd_dev-3.7.5 → codd_dev-3.25.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.7.5"
+__version__ = "3.25.0"

{codd_dev-3.7.5 → codd_dev-3.25.0}/codd/brownfield/pipeline.py

@@ -28,6 +28,7 @@ class BrownfieldResult:
     lexicon_path: Path | None = None
     extract_result: Any | None = None
     elicit_result: ElicitResult | Any | None = None
+    stage_status: dict[str, Any] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         payload: dict[str, Any] = {
@@ -44,6 +45,11 @@ class BrownfieldResult:
                 "merged_findings": len(self.merged_findings),
             },
         }
+        # Machine-readable honesty signal: when a stage was skipped/partial/empty
+        # the counts above are not the whole story. Only emitted for real
+        # pipeline runs (directly-constructed results stay byte-stable / legacy).
+        if self.stage_status is not None:
+            payload["stage_status"] = self.stage_status
         if isinstance(self.elicit_result, ElicitResult):
             payload["elicit"] = {
                 "all_covered": self.elicit_result.all_covered,
@@ -86,7 +92,9 @@ class BrownfieldPipeline:
         extract_output = project_root / ".codd" / "extract"
         extract_result = self._run_extract(project_root, extract_output)
         result_output = Path(getattr(extract_result, "output_dir", extract_output))
-        extract_input = _ensure_aggregate_extract(result_output, getattr(extract_result, "generated_files", []))
+        extract_input, extract_status = _ensure_aggregate_extract(
+            result_output, getattr(extract_result, "generated_files", [])
+        )
 
         requirements = _resolve_optional_file(
             project_root,
@@ -97,6 +105,11 @@ class BrownfieldPipeline:
         diff_findings: list[Finding] = []
         if requirements is not None:
             diff_findings = list(self._run_diff(project_root, extract_input, requirements))
+        diff_status: dict[str, Any] = (
+            {"status": "executed", "reason": None}
+            if requirements is not None
+            else {"status": "skipped", "reason": "no requirements.md"}
+        )
 
         lexicon = _resolve_optional_path(
             project_root,
@@ -107,6 +120,16 @@ class BrownfieldPipeline:
         lexicon_config = self._load_lexicon(lexicon) if lexicon is not None else None
         elicit_result = self._run_elicit(project_root, lexicon_config)
         elicit_findings = _findings_from_elicit_result(elicit_result)
+        elicit_status = {
+            "status": "ok",
+            "mode": "lexicon" if lexicon is not None else "discovery",
+        }
+
+        stage_status = {
+            "extract": extract_status,
+            "diff": diff_status,
+            "elicit": elicit_status,
+        }
 
         merged_findings = merge_findings(diff_findings, elicit_findings)
         return BrownfieldResult(
@@ -119,6 +142,7 @@ class BrownfieldPipeline:
             merged_findings=merged_findings,
             extract_result=extract_result,
             elicit_result=elicit_result,
+            stage_status=stage_status,
         )
 
     def _run_extract(self, project_root: Path, output_dir: Path) -> Any:
@@ -188,6 +212,10 @@ def format_brownfield_result(result: BrownfieldResult, format_name: str) -> str:
 def _format_brownfield_markdown(result: BrownfieldResult) -> str:
     from codd.elicit.formatters.md import MdFormatter
 
+    stage_status = result.stage_status
+    diff_stage = (stage_status or {}).get("diff") or {}
+    diff_skipped = diff_stage.get("status") == "skipped"
+
     lines = [
         "# Brownfield Report",
         "",
@@ -197,17 +225,64 @@ def _format_brownfield_markdown(result: BrownfieldResult) -> str:
         f"- extract_input: `{_path_text(result.extract_input)}`",
         f"- requirements_path: `{_path_text(result.requirements_path) or 'skipped'}`",
         f"- lexicon_path: `{_path_text(result.lexicon_path) or 'discovery mode'}`",
-        f"- diff_findings: {len(result.diff_findings)}",
-        f"- elicit_findings: {len(result.elicit_findings)}",
-        f"- merged_findings: {len(result.merged_findings)}",
-        "",
     ]
+    if diff_skipped:
+        reason = diff_stage.get("reason") or "no requirements.md"
+        # Honest headline: a skipped diff must not read as "0 findings" (pass).
+        lines.append(f"- diff: SKIPPED ({reason})")
+    else:
+        lines.append(f"- diff_findings: {len(result.diff_findings)}")
+    lines.extend(
+        [
+            f"- elicit_findings: {len(result.elicit_findings)}",
+            f"- merged_findings: {len(result.merged_findings)}",
+            "",
+        ]
+    )
+    if stage_status:
+        lines.extend(_format_stage_status_markdown(stage_status))
     findings_report = MdFormatter().format(result.merged_findings).strip()
     lines.append(findings_report)
     lines.append("")
     return "\n".join(lines)
 
 
+def _format_stage_status_markdown(stage_status: dict[str, Any]) -> list[str]:
+    lines = ["## Stage status", ""]
+
+    extract = stage_status.get("extract") or {}
+    failed = extract.get("files_failed") or []
+    extract_status = extract.get("status", "unknown")
+    if extract_status == "reused":
+        # A reused aggregate was not re-read: report no fabricated count.
+        lines.append(
+            "- extract: reused (prior aggregate reused; content not re-verified; "
+            f"discovered={extract.get('files_discovered', 0)})"
+        )
+    else:
+        lines.append(
+            f"- extract: {extract_status} "
+            f"(discovered={extract.get('files_discovered', 0)}, "
+            f"aggregated={extract.get('files_aggregated', 0)}, "
+            f"failed={len(failed)})"
+        )
+    for entry in failed:
+        path, reason = entry[0], entry[1]
+        lines.append(f"  - failed: `{path}` — {reason}")
+
+    diff = stage_status.get("diff") or {}
+    if diff.get("status") == "skipped":
+        reason = diff.get("reason") or "no requirements.md"
+        lines.append(f"- diff: SKIPPED ({reason})")
+    else:
+        lines.append(f"- diff: {diff.get('status', 'unknown')}")
+
+    elicit = stage_status.get("elicit") or {}
+    lines.append(f"- elicit: {elicit.get('status', 'unknown')} (mode={elicit.get('mode', 'unknown')})")
+    lines.append("")
+    return lines
+
+
 def _resolve_project_root(value: Path | str) -> Path:
     project_root = Path(value).expanduser().resolve()
     if not project_root.exists():
@@ -251,18 +326,36 @@ def _resolve_optional_path(
     return None
 
 
-def _ensure_aggregate_extract(output_dir: Path, generated_files: Iterable[Path]) -> Path:
+def _ensure_aggregate_extract(
+    output_dir: Path, generated_files: Iterable[Path]
+) -> tuple[Path, dict[str, Any]]:
     output_dir = Path(output_dir)
     aggregate_path = output_dir / "extracted.md"
+    paths = _extract_markdown_paths(output_dir, generated_files)
     if aggregate_path.is_file():
-        return aggregate_path
+        # A prior run already built the aggregate; reuse it as-is. We do NOT
+        # re-read or re-aggregate its content, so we must NOT fabricate an "ok"
+        # verdict or an aggregated count over unread inputs. Since nothing ever
+        # deletes/rewrites this file, every run after the first lands here — a
+        # fabricated "ok" would make the honesty signal first-run-only. Emit an
+        # honest "reused" status instead (files_aggregated=None = "not counted").
+        status = {
+            "status": "reused",
+            "files_discovered": len(paths),
+            "files_aggregated": None,
+            "files_failed": [],
+        }
+        return aggregate_path, status
 
-    paths = _extract_markdown_paths(output_dir, generated_files)
     sections: list[str] = []
+    files_failed: list[tuple[str, str]] = []
     for path in paths:
         try:
             text = path.read_text(encoding="utf-8", errors="replace").strip()
-        except OSError:
+        except OSError as exc:
+            # Do NOT silently drop read failures: a partial aggregate that hides
+            # unreadable inputs is a false-green. Collect and surface them.
+            files_failed.append((_relative_to(path, output_dir), str(exc) or exc.__class__.__name__))
             continue
         if not text:
             continue
@@ -271,7 +364,22 @@ def _ensure_aggregate_extract(output_dir: Path, generated_files: Iterable[Path])
     body = "\n\n---\n\n".join(sections) if sections else "No extracted documents generated."
     output_dir.mkdir(parents=True, exist_ok=True)
     aggregate_path.write_text(f"# Extracted Brownfield Facts\n\n{body}\n", encoding="utf-8")
-    return aggregate_path
+
+    if not sections:
+        # A stub body (currently written unconditionally) is NOT an "ok" extract:
+        # nothing usable was aggregated.
+        status_name = "empty"
+    elif files_failed:
+        status_name = "partial"
+    else:
+        status_name = "ok"
+    status = {
+        "status": status_name,
+        "files_discovered": len(paths),
+        "files_aggregated": len(sections),
+        "files_failed": files_failed,
+    }
+    return aggregate_path, status
 
 
 def _extract_markdown_paths(output_dir: Path, generated_files: Iterable[Path]) -> list[Path]:

{codd_dev-3.7.5 → codd_dev-3.25.0}/codd/cli.py

@@ -427,6 +427,59 @@ def _format_yaml_list(items: list[str], *, indent: int = 4) -> str:
     return "\n".join(f'{" " * indent}- "{item}"' for item in items)
 
 
+def _default_scan_source_dirs(language: str) -> list[str]:
+    """Compute the default ``scan.source_dirs`` for a freshly-``codd init``'d project.
+
+    Baseline is the historical ``["src/"]`` default — preserved byte-for-byte
+    when the language is blank/unresolvable, or its profile declares no
+    ``layout.source_sets`` beyond a templated root (e.g. Python's
+    ``src/{package_name}``: substitution is PathPlanner's job, not this
+    bootstrap default's, so a templated root is skipped here).
+
+    When the resolved profile declares additional LITERAL source-set roots not
+    already covered by an entry already in the list — e.g. C++'s conventional
+    ``include/`` public-header split sitting alongside ``src/`` (design: public
+    headers and implementation are separate ``source_sets``, both
+    ``role: first_party*``) — each is appended, in profile order. A root
+    "covered" by an existing entry (e.g. Java's ``src/main/java`` under the
+    ``src/`` baseline) is skipped to avoid a redundant/overlapping scan root.
+
+    This is the language-free resolution seam (mirrors
+    ``codd.project_types._resolve_kernel_language_profile``): it keys off
+    profile DATA (``layout.source_sets``), never a ``language == "..."``
+    literal, so any current or future multi-root language layout is covered
+    with zero changes here — the only thing that decides the result is what
+    that language's profile YAML declares.
+    """
+    source_dirs = ["src/"]
+    try:
+        from codd.languages.registry import UnknownLanguageError, default_registry
+    except Exception:  # noqa: BLE001 — registry optional; degrade to the baseline.
+        return source_dirs
+    try:
+        profile = default_registry.resolve(language)
+    except UnknownLanguageError:
+        return source_dirs
+    except Exception:  # noqa: BLE001 — a malformed profile is the loader's gate; degrade here.
+        return source_dirs
+
+    for source_set in profile.layout.source_sets:
+        root = (source_set.root or "").strip()
+        if not root or "{" in root:
+            # Unresolved template placeholder — not a literal path we can use
+            # for a bootstrap default (mirrors PathPlanner._subst_root's own
+            # "{" in root test for the same distinction).
+            continue
+        normalized = f"{root.strip('/')}/"
+        if any(
+            Path(normalized.rstrip("/")).is_relative_to(Path(existing.rstrip("/")))
+            for existing in source_dirs
+        ):
+            continue
+        source_dirs.append(normalized)
+    return source_dirs
+
+
 def _display_path(path: Path, project_root: Path) -> str:
     try:
         return path.relative_to(project_root).as_posix()
@@ -816,12 +869,14 @@ def check_cmd(project_path: str, run_full: bool, apply_fixes: bool, output_forma
     else:
         _line("  PASS — no warnings")
 
-    # --- vb declarations (gate) -------------------------------------------
+    # --- verifiable-behavior declarations (gate) --------------------------
     # Incoherent verifiable-behavior declarations (same id, different meaning in
     # two docs) make 100% coverage structurally impossible — fail loudly. The
     # WARNING-severity case (a non-canonical doc with first-column VB rows) is
-    # already surfaced as a doctor advisory above with migration guidance.
-    _section("vb declarations")
+    # already surfaced as a doctor advisory above with migration guidance. The
+    # label spells out "verifiable-behavior" (the ``vb`` abbreviation read like
+    # Visual Basic — it is the V-Model verification boundary, not a language).
+    _section("verifiable-behavior declarations")
     try:
         vb_errors = _vb_declaration_issue_messages(project_root, load_project_config(project_root), severity="error")
     except (FileNotFoundError, ValueError) as exc:
@@ -2355,7 +2410,7 @@ def init(
     _render_template("codd.yaml.tmpl", codd_dir / "codd.yaml", {
         "project_name": project_name,
         "language": language,
-        "source_dirs": _format_yaml_list(["src/"]),
+        "source_dirs": _format_yaml_list(_default_scan_source_dirs(language)),
         "test_dirs": _format_yaml_list(["tests/"]),
         "doc_dirs": _format_yaml_list(["docs/"]),
         "graph_path": f"{config_dir}/scan",
@@ -3775,6 +3830,37 @@ def brownfield_cmd(
         f"elicit_findings={len(result.elicit_findings)}, "
         f"merged_findings={len(result.merged_findings)}"
     )
+
+    stage_status = getattr(result, "stage_status", None)
+    if stage_status:
+        extract = stage_status.get("extract") or {}
+        diff = stage_status.get("diff") or {}
+        elicit = stage_status.get("elicit") or {}
+        if extract.get("status") == "reused":
+            # Reused aggregate was not re-read: no fabricated aggregated count.
+            click.echo(
+                "  extract: reused (prior aggregate reused; content not re-verified; "
+                f"discovered={extract.get('files_discovered', 0)})"
+            )
+        else:
+            click.echo(
+                f"  extract: {extract.get('status', 'unknown')} "
+                f"(discovered={extract.get('files_discovered', 0)}, "
+                f"aggregated={extract.get('files_aggregated', 0)}, "
+                f"failed={len(extract.get('files_failed') or [])})"
+            )
+        if diff.get("status") == "skipped":
+            click.echo(f"  diff: SKIPPED ({diff.get('reason') or 'no requirements.md'})")
+        else:
+            click.echo(f"  diff: {diff.get('status', 'unknown')}")
+        click.echo(f"  elicit: {elicit.get('status', 'unknown')} (mode={elicit.get('mode', 'unknown')})")
+
+        # Honest headline: if any coherence surface was skipped/partial/empty, the
+        # "complete" line above is not the whole story. Exit code stays 0 (an
+        # exit-code escalation is a NEW red and is owner-gated).
+        if extract.get("status") in {"partial", "empty"} or diff.get("status") == "skipped":
+            click.echo("PARTIAL — not all coherence surfaces were checked")
+
     click.echo(f"Output: {_display_path(output_path, project_root)}")