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

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

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

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

codd_dev-3.27.0/codd/json_safe.py

@@ -0,0 +1,32 @@
+"""Shared JSON serialization defaults for CoDD.
+
+Design-doc frontmatter and impact/event payloads can carry values the stdlib
+``json`` encoder rejects — most commonly a bare ``date: 2026-05-29`` which PyYAML
+parses to a :class:`datetime.date` (issue #28). Every ``json.dumps`` that may
+serialize frontmatter-derived or impact/event data must pass
+``default=json_default`` so serialization never raises.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date, datetime
+from typing import Any
+
+
+def json_default(obj: Any) -> Any:
+    """Fallback for ``json.dumps(default=...)``.
+
+    Coerce date/datetime to ISO 8601 and any other non-serializable value to its
+    string form so serialization never raises. Generic by design: not tied to any
+    field name, project, or code path.
+    """
+    if isinstance(obj, (date, datetime)):
+        return obj.isoformat()
+    return str(obj)
+
+
+def dumps(obj: Any, **kwargs: Any) -> str:
+    """``json.dumps`` with :func:`json_default` pre-wired (override via kwargs)."""
+    kwargs.setdefault("default", json_default)
+    return json.dumps(obj, **kwargs)

{codd_dev-3.25.0 → codd_dev-3.27.0}/codd/languages/adapters/oracle_cpp.py

@@ -214,6 +214,37 @@ _CPP_HEADER_NOT_FOUND_CLANG = re.compile(
     r"^'(?P<header>[^']+)'\s+file not found\b"
 )
 
+#: GNU ld's undefined-reference diagnostic — the LINK-time analogue of the
+#: undeclared-symbol family (an implementation artifact fails to DEFINE a symbol
+#: another artifact demands). Two shapes, both anchored on the message tail:
+#:   * ``/usr/bin/ld: file.cpp:(.text+0x40): undefined reference to `sym'``
+#:   * ``file.cpp:(.text+0x40): undefined reference to `sym'``   (no ld prefix)
+#: The referencing TU (``file.cpp``) and the SYMBOL are captured: the symbol is the
+#: repair-feedback identity (WHAT is missing), the TU the best-available file
+#: attribution (WHO demands it). lld/mold keep the same message tail. Without this
+#: regex a pure link failure had NO parseable diagnostic and collapsed to an opaque
+#: environment_build_error, aborting the repair loop (cpp2 exprcalc dogfood,
+#: 2026-07-11).
+_CPP_LD_UNDEFINED_RE = re.compile(
+    r"^(?:\S*ld(?:\.\w+)?:\s*)?"
+    r"(?:(?P<path>[^\s:][^:\n]*\.(?:h|hpp|hh|hxx|c|cc|cpp|cxx|cppm|ixx)):\(\S*\):\s*)?"
+    r"undefined reference to [`'](?P<symbol>[^']+)'"
+)
+
+#: ld's two-line context header (``…/main.cpp.o: in function `main':``) — context
+#: for the positioned undefined-reference that follows, never a diagnostic itself.
+_CPP_LD_CONTEXT_RE = re.compile(
+    r"^(?:\S*ld(?:\.\w+)?:\s*)?\S+\.o(?:bj)?:\s*in function\s"
+)
+
+#: collect2's sign-off (``collect2: error: ld returned 1 exit status``) — a SUMMARY
+#: epilog after the explicit ld error lines above it. Skipped in PARSING only (the
+#: undefined-reference findings are the authority); deliberately NOT recognized in
+#: the benign-accounting path, so a collect2 line with NO accompanying parsed
+#: diagnostic stays an honest opaque RED (anti-false-green — same reasoning as the
+#: ``ninja:`` note above).
+_CPP_LD_EPILOG_RE = re.compile(r"^collect2:\s*(?:fatal error|error):\s*ld returned")
+
 #: cmake progress / informational chatter that is NOT a failure — the C++ analogue
 #: of Go's ``# pkg`` headers + ``ok``/``?`` run-summary noise. ``--`` status lines
 #: (``-- Configuring done``, ``-- Detecting C compiler ...``, ``-- Build files have
@@ -412,6 +443,7 @@ def _parse_cpp_tool_output(
     """
     findings: list[ImplementOracleFinding] = []
     failed_paths: list[str] = []
+    seen_ld_refs: set[tuple[str | None, str]] = set()
 
     def _add(category: str, code: str, message: str, rel: str | None) -> None:
         findings.append(
@@ -437,6 +469,28 @@ def _parse_cpp_tool_output(
         ):
             continue
 
+        # ld undefined-reference → missing_symbol, deduped per (TU, symbol): ld
+        # repeats the same reference once per call site; per-site duplicates add
+        # no repair signal. The symbol identity rides the message (feedback).
+        ld = _CPP_LD_UNDEFINED_RE.match(line)
+        if ld is not None:
+            symbol = ld.group("symbol").strip()
+            raw_path = ld.group("path")
+            rel = _cpp_rel_path(raw_path, project_root) if raw_path else None
+            key = (rel, symbol)
+            if key not in seen_ld_refs:
+                seen_ld_refs.add(key)
+                _add(
+                    EVIDENCE_MISSING_SYMBOL,
+                    "CPP_LD_UNDEFINED_REFERENCE",
+                    f"undefined reference to `{symbol}' (link-time; referenced "
+                    f"from {rel or 'unknown TU'})",
+                    rel,
+                )
+            continue
+        if _CPP_LD_CONTEXT_RE.match(line) or _CPP_LD_EPILOG_RE.match(line):
+            continue  # ld context / collect2 epilog — the reference lines above are the authority
+
         m = _CPP_DIAG_LINE.match(line)
         if m is not None:
             severity = (m.group("severity") or "").strip().lower()

{codd_dev-3.25.0 → codd_dev-3.27.0}/codd/languages/adapters/oracle_java.py

@@ -139,6 +139,22 @@ _JAVA_ERROR_SUMMARY_RE = re.compile(
     r"after the errors? )",
 )
 
+#: A POSITIONLESS fatal compiler-plugin failure. javac/maven emit it WITHOUT any
+#: ``File.java:`` anchor — canonical shapes:
+#:   * ``[ERROR] Failed to execute goal …maven-compiler-plugin…: Fatal error
+#:     compiling: error: release version 21 not supported -> [Help 1]``
+#:   * ``[ERROR] Fatal error compiling: error: invalid target release: 21``
+#: The tail after ``Fatal error compiling:`` is the authoritative message (the
+#: trailing ``-> [Help N]`` pointer is stripped). Without this catch the whole run
+#: had NO parseable diagnostic — the ``Failed to execute goal`` wrapper is
+#: summary-echo noise — and collapsed to an opaque environment_build_error that
+#: aborts the repair loop (java2 exprcalc dogfood, 2026-07-11). The C# adapter's
+#: positionless ``error CS####`` catch (``_CS_DIAG_NO_POS``) is the parity
+#: precedent for a positionless first-class diagnostic.
+_JAVA_FATAL_COMPILING_RE = re.compile(
+    r"\bFatal error compiling:\s*(?P<message>.+?)\s*(?:->\s*\[Help[^\]]*\]?\s*)?$"
+)
+
 
 # ── pure helpers ─────────────────────────────────────────────────────────────
 
@@ -209,12 +225,31 @@ def _parse_java_tool_output(
     """
     findings: list[ImplementOracleFinding] = []
     failed_paths: list[str] = []
+    seen_fatal: set[str] = set()
     for raw_line in (output or "").splitlines():
         line = raw_line.rstrip()
         if not line.strip():
             continue
         matched = _match_java_diagnostic(line)
         if matched is None:
+            # A positionless ``Fatal error compiling: …`` (toolchain-level compile
+            # failure, e.g. a --release the installed JDK cannot satisfy) is a
+            # first-class diagnostic even without a File.java anchor. Deduped by
+            # message: maven prints the same fatal in both the Failed-to-execute-
+            # goal wrapper and the bare echo form.
+            fatal = _JAVA_FATAL_COMPILING_RE.search(line)
+            if fatal is not None:
+                message = fatal.group("message").strip()
+                if message not in seen_fatal:
+                    seen_fatal.add(message)
+                    findings.append(
+                        ImplementOracleFinding(
+                            category=EVIDENCE_OTHER,
+                            code="JAVA_FATAL_COMPILING",
+                            message=f"[{tool}] Fatal error compiling: {message}",
+                            path=None,
+                        )
+                    )
             continue
         path_raw, message = matched
         category, code = _classify_java_diagnostic(message)

{codd_dev-3.25.0 → codd_dev-3.27.0}/codd/languages/profiles/java.yaml

@@ -282,6 +282,20 @@ scaffold:
     compiler_plugin_version: "3.13.0"
     build_helper_plugin_version: "3.6.0"
 
+  # Host-toolchain version clamp — the environment-continuation projection of
+  # toolchain materialization (v3.15.0 lineage) applied to scaffold DEFAULTS: a
+  # declared toolchain level must never EXCEED what the host provides, or the
+  # scaffolded pom demands a --release the installed JDK cannot satisfy and the
+  # implement oracle reds on "Fatal error compiling: error: release version N
+  # not supported" (java2 exprcalc dogfood, 2026-07-11). The probe runs once at
+  # scaffold time; min semantics (declared 21 + host 17 → 17; declared 11 +
+  # host 17 → 11); probe failure keeps the declared value (fail-open).
+  # CONTENT-only: clamped variables must never appear in a template `path`.
+  host_version_clamps:
+    java_version:
+      probe_argv: ["javac", "-version"]
+      version_pattern: '(\d+)'
+
   templates:
     # Single pom.xml: Java's package_root.kind=none means there is no C#-style
     # nested lib/test project split to enforce deliverable purity. Maven's own

{codd_dev-3.25.0 → codd_dev-3.27.0}/codd/project_types.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 import dataclasses
 import json
 import os
+import re
 import subprocess
 import sys
 from collections.abc import Callable, Mapping
@@ -2807,6 +2808,96 @@ def _generic_template_substitutions(
     return subst
 
 
+def _probe_host_toolchain_version(argv: tuple[str, ...], pattern: str) -> int | None:
+    """Best-effort host-toolchain MAJOR-version probe (``javac -version`` → ``17``).
+
+    Runs the profile-declared probe argv (10s timeout), searches ``pattern``
+    (first group = the major) across stdout+stderr (``javac -version`` printed to
+    stderr before JDK 9, stdout after), and returns the integer major — or
+    ``None`` on ANY failure (missing binary, timeout, no match, non-integer
+    group). The caller treats ``None`` as "keep the declared default"
+    (fail-open): the probe can only ever LOWER a doomed default, never introduce
+    a new failure mode.
+    """
+    try:
+        proc = subprocess.run(
+            list(argv), capture_output=True, text=True, timeout=10, check=False
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    match = re.search(pattern, f"{proc.stdout}\n{proc.stderr}")
+    if match is None:
+        return None
+    try:
+        return int(match.group(1))
+    except (IndexError, ValueError):
+        return None
+
+
+def _generic_template_host_clamps(
+    language: str | None,
+) -> dict[str, Mapping[str, Any]]:
+    """The profile's ``scaffold.host_version_clamps`` mapping (raw view), or ``{}``.
+
+    Read from ``raw`` like ``scaffold.defaults`` (the ScaffoldSpec dataclass
+    models only adapter/owned_files/templates; ``raw`` is the documented
+    later-phase escape hatch).
+    """
+    lang_profile = _resolve_kernel_language_profile(language)
+    raw = getattr(lang_profile, "raw", None) if lang_profile is not None else None
+    if isinstance(raw, Mapping):
+        raw_scaffold = raw.get("scaffold")
+        if isinstance(raw_scaffold, Mapping):
+            clamps = raw_scaffold.get("host_version_clamps")
+            if isinstance(clamps, Mapping):
+                return {
+                    str(k): v for k, v in clamps.items() if isinstance(v, Mapping)
+                }
+    return {}
+
+
+def _resolve_host_clamped_defaults(
+    defaults: Mapping[str, str], clamps: Mapping[str, Mapping[str, Any]]
+) -> tuple[dict[str, str], list[str]]:
+    """Clamp scaffold DEFAULTS to the host toolchain — the environment-continuation
+    projection of toolchain materialization (v3.15.0 lineage) applied to the
+    generic-template scaffold's substitution variables.
+
+    For each profile-declared clamp key: probe the host (profile-declared
+    argv+pattern); when the probed major is LOWER than the declared default's
+    leading integer, replace the default with the probed major (min semantics —
+    a declared ``21`` on a JDK-17 host scaffolds ``17``; a declared ``11`` on a
+    JDK-17 host stays ``11``). A probe failure or a non-numeric declared value
+    keeps the declared default (fail-open). Returns ``(resolved defaults,
+    human-readable clamp notes)`` — the notes ride the scaffold detail so a
+    clamp is never silent. CONTENT-only: the harness-owned PATH declaration
+    (:meth:`LayoutProfile.harness_owned_scaffold_paths`) substitutes UNCLAMPED
+    defaults, so a clamped variable must never appear in a template ``path``.
+    """
+    out = dict(defaults)
+    notes: list[str] = []
+    for key, spec in (clamps or {}).items():
+        declared = out.get(key)
+        if declared is None:
+            continue
+        declared_match = re.match(r"\s*(\d+)", str(declared))
+        if declared_match is None:
+            continue  # non-numeric default → this clamp cannot reason about it
+        declared_major = int(declared_match.group(1))
+        argv = tuple(str(a) for a in (spec.get("probe_argv") or ()) if str(a).strip())
+        if not argv:
+            continue
+        pattern = str(spec.get("version_pattern") or r"(\d+)")
+        probed = _probe_host_toolchain_version(argv, pattern)
+        if probed is None or probed >= declared_major:
+            continue
+        out[key] = str(probed)
+        notes.append(
+            f"host-clamped {key} {declared}→{probed} (probe: {' '.join(argv)})"
+        )
+    return out, notes
+
+
 def _apply_template_substitutions(text: str, subst: Mapping[str, str]) -> str:
     """Replace each ``{key}`` token with its value (replace-based, NOT ``str.format`` — so
     a template's literal braces never raise; mirrors the oracle gate's ``{package_name}``
@@ -2862,6 +2953,9 @@ def _scaffold_generic_template(
     code branch — a new generic-template stack is one YAML profile + the opt-in key.
     """
     templates, defaults, _owned = spec
+    defaults, clamp_notes = _resolve_host_clamped_defaults(
+        defaults, _generic_template_host_clamps(profile.language)
+    )
     subst = _generic_template_substitutions(profile, defaults)
     created: list[str] = []
     skipped: list[str] = []
@@ -2891,6 +2985,8 @@ def _scaffold_generic_template(
         f"generic-template: {len(created)} created, {len(skipped)} skipped "
         f"(package={profile.package_name})"
     )
+    if clamp_notes:
+        detail += "; " + "; ".join(clamp_notes)
     return ScaffoldResult(
         language=profile.language,
         created=tuple(created),

{codd_dev-3.25.0 → codd_dev-3.27.0}/codd/scanner.py

@@ -14,7 +14,7 @@ from typing import Any
 import yaml
 
 from codd.discovery import scan_exclude_patterns
-from codd.frontmatter import read_frontmatter
+from codd.frontmatter import as_list, read_frontmatter
 from codd.graph import CEG
 from codd.parsing import get_extractor
 from codd.path_safety import require_project_path, resolve_project_path
@@ -344,8 +344,14 @@ def _load_frontmatter(ceg: CEG, doc_path: str, codd: dict):
     node_type = codd.get("type", "document")
     ceg.upsert_node(node_id, node_type, path=doc_path, name=node_id)
 
-    # Process depends_on (outgoing edges from this document)
-    for dep in codd.get("depends_on", []):
+    # Process depends_on (outgoing edges from this document).
+    # ``as_list`` normalizes null-vs-missing: a bare ``depends_on:`` key parses
+    # to None, which would raise TypeError on iteration (issue #33). Non-dict
+    # entries are malformed shape (the validator reports them); skip them here so
+    # a scan never crashes on hand-authored frontmatter.
+    for dep in as_list(codd.get("depends_on")):
+        if not isinstance(dep, dict):
+            continue
         target_id = dep.get("id")
         if not target_id:
             continue
@@ -357,8 +363,11 @@ def _load_frontmatter(ceg: CEG, doc_path: str, codd: dict):
         ceg.add_evidence(edge_id, "frontmatter", "frontmatter", 0.9,
                          detail=f"from {doc_path}")
 
-    # Process depended_by (incoming edges — other things that depend on this)
-    for dep in codd.get("depended_by", []):
+    # Process depended_by (incoming edges — other things that depend on this).
+    # Same null-vs-missing normalization + malformed-shape skip as depends_on.
+    for dep in as_list(codd.get("depended_by")):
+        if not isinstance(dep, dict):
+            continue
         source_id = dep.get("id")
         if not source_id:
             continue

{codd_dev-3.25.0 → codd_dev-3.27.0}/codd/vb_marker_authenticity.py

@@ -3488,8 +3488,19 @@ _CSHARP_SKIP_ARG_RE = re.compile(r"\bSkip\s*=")
 #: ``(?<![A-Za-z0-9_.])`` so a member access ``foo.Assert.X`` (an unrelated SUT
 #: type that happens to expose an ``Assert`` member) does not masquerade as the
 #: framework's static ``Assert``.
+#: Optional generic type-argument list between the method name and ``(`` —
+#: ``Assert.IsType<ParseError>(x)``, ``Assert.Throws<T>(() => …)``, nested up to
+#: depth 3 (``Assert.IsType<Dictionary<string, List<int>>>(x)``). ``;{}`` are
+#: excluded so a malformed ``<`` can never swallow past a statement boundary.
+#: Without this, generic-only asserts were reported as "test with NO assertion"
+#: (false-RED observed on the csharp exprcalc greenfield dogfood, 2026-07-11).
+_CSHARP_GENERIC_ARGS = (
+    r"<[^<>;{}]*(?:<[^<>;{}]*(?:<[^<>;{}]*>[^<>;{}]*)*>[^<>;{}]*)*>"
+)
 _CSHARP_ASSERT_CALL_RE = re.compile(
-    r"(?<![A-Za-z0-9_.])Assert\.[A-Z][A-Za-z0-9_]*\s*\("
+    r"(?<![A-Za-z0-9_.])Assert\.[A-Z][A-Za-z0-9_]*\s*(?:"
+    + _CSHARP_GENERIC_ARGS
+    + r")?\s*\("
 )
 
 

{codd_dev-3.25.0 → codd_dev-3.27.0}/codd/watch/propagation_log.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
+from codd.json_safe import json_default
 from codd.watch.events import FileChangeEvent
 
 PROPAGATION_LOG_PATH = ".codd/propagation_log.jsonl"
@@ -26,7 +27,9 @@ def append_propagation_log(
 
     with log_path.open("w", encoding="utf-8") as handle:
         for item in entries:
-            handle.write(json.dumps(item, ensure_ascii=False) + "\n")
+            # default=json_default: a propagated design doc's `date:` frontmatter
+            # parses to datetime.date, which raw json.dumps rejects (issue #28).
+            handle.write(json.dumps(item, ensure_ascii=False, default=json_default) + "\n")
 
 
 def read_propagation_log(project_root: Path) -> list[dict]:

{codd_dev-3.25.0 → codd_dev-3.27.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "3.25.0"
+version = "3.27.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"