codd-dev 2.14.0__tar.gz → 2.15.0__tar.gz

{codd_dev-2.14.0 → codd_dev-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.14.0
+Version: 2.15.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
@@ -153,11 +153,12 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.14.0 (current)** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) and `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52% amber noise); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout → 3600 s SSoT. Dogfood re-run: red 22 → 0. See [CHANGELOG](CHANGELOG.md).
-- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires a `justification` + `expires_at` for every config-level opt-out (`ci.provider=none`, etc.). Silent SKIP abolished; severity preserved. `codd validate` reports policy violations. See [post-mortem](docs/post-mortems/optout_loophole.md).
-- **v2.12.0** — Test-completeness gates: C7 `actors_without_journeys` amber promotion + new C8 `ci_health` static check (workflow presence, trigger coverage, verification-in-workflow). See [post-mortem](docs/post-mortems/test_completeness_gap.md).
-- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
-- **v2.15.0 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
+- **v2.15.0 (current)** — `kind: common` for shared infrastructure (cmd_467). Classify cross-cutting files (DB client, middleware, config) as `common` via `common_node_patterns:` glob or frontmatter. C5 amber −79.2% on dogfood LMS (125 → 26). `**` glob translator fix. See [CHANGELOG](CHANGELOG.md).
+- **v2.14.0** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) / `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52%); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout 3600 s SSoT. Red 22 → 0.
+- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires `justification` + `expires_at`. Silent SKIP abolished; severity preserved.
+- **v2.12.0** — Test-completeness gates: C7 amber promotion + C8 `ci_health` static check.
+- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly).
+- **v2.16.0 (next)** — `codd fix [PHENOMENON]` — express a desired change in natural language; CoDD identifies affected design docs, updates them, updates implementation and tests, then verifies the DAG. Interactive mode included.
 
 ---
 

{codd_dev-2.14.0 → codd_dev-2.15.0}/README.md

@@ -113,11 +113,12 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.14.0 (current)** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) and `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52% amber noise); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout → 3600 s SSoT. Dogfood re-run: red 22 → 0. See [CHANGELOG](CHANGELOG.md).
-- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires a `justification` + `expires_at` for every config-level opt-out (`ci.provider=none`, etc.). Silent SKIP abolished; severity preserved. `codd validate` reports policy violations. See [post-mortem](docs/post-mortems/optout_loophole.md).
-- **v2.12.0** — Test-completeness gates: C7 `actors_without_journeys` amber promotion + new C8 `ci_health` static check (workflow presence, trigger coverage, verification-in-workflow). See [post-mortem](docs/post-mortems/test_completeness_gap.md).
-- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
-- **v2.15.0 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
+- **v2.15.0 (current)** — `kind: common` for shared infrastructure (cmd_467). Classify cross-cutting files (DB client, middleware, config) as `common` via `common_node_patterns:` glob or frontmatter. C5 amber −79.2% on dogfood LMS (125 → 26). `**` glob translator fix. See [CHANGELOG](CHANGELOG.md).
+- **v2.14.0** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) / `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52%); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout 3600 s SSoT. Red 22 → 0.
+- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires `justification` + `expires_at`. Silent SKIP abolished; severity preserved.
+- **v2.12.0** — Test-completeness gates: C7 amber promotion + C8 `ci_health` static check.
+- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly).
+- **v2.16.0 (next)** — `codd fix [PHENOMENON]` — express a desired change in natural language; CoDD identifies affected design docs, updates them, updates implementation and tests, then verifies the DAG. Interactive mode included.
 
 ---
 

{codd_dev-2.14.0 → codd_dev-2.15.0}/codd/cli.py

@@ -5275,6 +5275,9 @@ def _dag_result_details(result: Any) -> list[str]:
             details.append(f"{key}: {rendered}")
         else:
             details.append(f"{key}: {value}")
+    common_count = _dag_result_value(result, "common_node_count")
+    if isinstance(common_count, int) and common_count > 0:
+        details.append(f"common_node_count: {common_count}")
     return details
 
 

{codd_dev-2.14.0 → codd_dev-2.15.0}/codd/dag/builder.py

@@ -125,11 +125,14 @@ def load_dag_settings(project_root: Path, settings: dict[str, Any] | None = None
     merged["test_suffixes"] = test_suffixes
     _apply_scan_patterns(merged, project_config)
     _apply_scan_patterns(merged, requested_settings)
+    _apply_common_node_patterns(merged, project_config)
+    _apply_common_node_patterns(merged, requested_settings)
     merged["coherence"] = _coherence_settings(project_config, requested_settings)
     merged["extraction"] = _extraction_settings(project_config, requested_settings)
     merged.setdefault("design_doc_patterns", [])
     merged.setdefault("impl_file_patterns", [])
     merged.setdefault("test_file_patterns", [])
+    merged.setdefault("common_node_patterns", [])
     # cmd_444 v2.11.0: implementation_plan.md is no longer the entry point.
     # `codd implement` now takes design_node + output_paths directly. Any
     # `plan_task_file` value present in legacy codd.yaml is silently ignored.
@@ -233,11 +236,16 @@ def _add_design_docs(dag: DAG, project_root: Path, settings: dict[str, Any]) ->
         metadata = extract_design_doc_metadata(md_path, frontmatter_alias=frontmatter_alias)
         attributes = metadata.get("attributes") or {}
         _validate_design_doc_journey_attributes(node_id, attributes)
+        node_kind = (
+            "common"
+            if _design_doc_declares_common(metadata.get("frontmatter"), attributes)
+            else "design_doc"
+        )
         _add_node_once(
             dag,
             Node(
                 id=node_id,
-                kind="design_doc",
+                kind=node_kind,
                 path=node_id,
                 attributes={
                     "frontmatter": metadata["frontmatter"],
@@ -260,6 +268,8 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
     impl_nodes: dict[str, Path] = {}
     capability_patterns = _capability_patterns(settings)
     implementation_suffixes = _suffix_tuple(settings.get("implementation_suffixes")) or LEGACY_IMPLEMENTATION_SUFFIXES
+    common_patterns = _common_node_patterns(settings)
+    project_root_resolved = Path(project_root).resolve()
     for file_path in _glob_project_paths(
         project_root,
         settings.get("impl_file_patterns", []),
@@ -273,11 +283,16 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
             continue
         node_id = _relative_id(file_path, project_root)
         impl_nodes[node_id] = file_path.resolve()
+        kind = "impl_file"
+        if common_patterns and _path_matches_any_pattern(
+            file_path, project_root_resolved, common_patterns
+        ):
+            kind = "common"
         _add_node_once(
             dag,
             Node(
                 id=node_id,
-                kind="impl_file",
+                kind=kind,
                 path=node_id,
                 attributes={
                     "language": _language_for_path(file_path),
@@ -292,6 +307,8 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
 def _add_test_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> dict[str, Path]:
     test_nodes: dict[str, Path] = {}
     test_suffixes = _suffix_tuple(settings.get("test_suffixes")) or LEGACY_TEST_SUFFIXES
+    common_patterns = _common_node_patterns(settings)
+    project_root_resolved = Path(project_root).resolve()
     for file_path in _glob_project_paths(
         project_root,
         settings.get("test_file_patterns", []),
@@ -301,11 +318,16 @@ def _add_test_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
             continue
         node_id = _relative_id(file_path, project_root)
         test_nodes[node_id] = file_path.resolve()
+        kind = "test_file"
+        if common_patterns and _path_matches_any_pattern(
+            file_path, project_root_resolved, common_patterns
+        ):
+            kind = "common"
         _add_node_once(
             dag,
             Node(
                 id=node_id,
-                kind="test_file",
+                kind=kind,
                 path=node_id,
                 attributes={
                     "language": _language_for_path(file_path),
@@ -1118,44 +1140,60 @@ def _path_matches_any_pattern(
     except ValueError:
         return False
     rel_text = relative.as_posix()
-    parts = relative.parts
 
     for pattern in patterns:
-        if fnmatch.fnmatch(rel_text, pattern):
+        if _glob_pattern_to_regex(pattern).match(rel_text):
             return True
-        # Honour shell-style "any depth" wildcards by stripping the outer
-        # ``**/`` and ``/**`` decorations and looking for the inner pattern
-        # against any path slice. Examples:
-        #   **/node_modules/**  -> "node_modules"  must appear as a path component
-        #   **/dist/**          -> "dist"          must appear as a path component
-        #   src/**/*.py         -> not stripped here; falls back to fnmatch above
-        inner = pattern
-        stripped = True
-        while stripped:
-            stripped = False
-            if inner.startswith("**/"):
-                inner = inner[3:]
-                stripped = True
-            if inner.endswith("/**"):
-                inner = inner[:-3]
-                stripped = True
-        if not inner or inner == pattern:
-            continue
-        if "/" not in inner and "*" not in inner:
-            if inner in parts:
-                return True
-            continue
-        # Inner still contains glob syntax: check every contiguous slice of
-        # the relative path against ``inner`` so e.g. ``a/b/c/d`` matches
-        # ``a/b`` or ``c/d`` etc.
-        for start in range(len(parts)):
-            for end in range(start + 1, len(parts) + 1):
-                candidate = "/".join(parts[start:end])
-                if fnmatch.fnmatch(candidate, inner):
-                    return True
     return False
 
 
+_GLOB_REGEX_CACHE: dict[str, "re.Pattern[str]"] = {}
+
+
+def _glob_pattern_to_regex(pattern: str) -> "re.Pattern[str]":
+    """Translate a glob pattern (with ``**`` recursion) into a regex.
+
+    Recognised tokens:
+
+    * ``**/`` — zero or more path segments (greedy across separators).
+    * ``**`` — anything (including ``/``); used at end of a pattern.
+    * ``*`` — any chars except ``/``.
+    * ``?`` — single char except ``/``.
+    * Anything else — literal.
+
+    Patterns such as ``**/dist/**`` match a path containing ``dist`` at any
+    depth, ``src/lib/**/*.ts`` matches both ``src/lib/x.ts`` and
+    ``src/lib/sub/x.ts``.
+    """
+
+    cached = _GLOB_REGEX_CACHE.get(pattern)
+    if cached is not None:
+        return cached
+
+    parts: list[str] = []
+    i = 0
+    n = len(pattern)
+    while i < n:
+        if pattern[i : i + 3] == "**/":
+            parts.append("(?:[^/]+/)*")
+            i += 3
+        elif pattern[i : i + 2] == "**":
+            parts.append(".*")
+            i += 2
+        elif pattern[i] == "*":
+            parts.append("[^/]*")
+            i += 1
+        elif pattern[i] == "?":
+            parts.append("[^/]")
+            i += 1
+        else:
+            parts.append(re.escape(pattern[i]))
+            i += 1
+    compiled = re.compile("^" + "".join(parts) + "$")
+    _GLOB_REGEX_CACHE[pattern] = compiled
+    return compiled
+
+
 def _expand_braces(pattern: str) -> list[str]:
     match = re.search(r"\{([^{}]+)\}", pattern)
     if not match:
@@ -1365,6 +1403,80 @@ def _capability_patterns(settings: dict[str, Any]) -> dict[str, Any]:
     return patterns if isinstance(patterns, dict) else {}
 
 
+def _apply_common_node_patterns(settings: dict[str, Any], config: dict[str, Any]) -> None:
+    """Capture ``common_node_patterns`` from project / requested config.
+
+    Recognises both ``common_node_patterns:`` at the top level (preferred,
+    sibling of ``scan:``) and ``scan.common_node_patterns:`` (nested under
+    scan for users who prefer to colocate scan-related knobs). Both feed
+    the same ``settings['common_node_patterns']`` list.
+    """
+
+    if not isinstance(config, dict):
+        return
+    patterns: list[str] = []
+    top = config.get("common_node_patterns")
+    if isinstance(top, list):
+        patterns.extend(
+            str(item) for item in top if isinstance(item, str) and item.strip()
+        )
+    scan = config.get("scan")
+    if isinstance(scan, dict):
+        nested = scan.get("common_node_patterns")
+        if isinstance(nested, list):
+            patterns.extend(
+                str(item) for item in nested if isinstance(item, str) and item.strip()
+            )
+    if patterns:
+        _extend_unique(settings, "common_node_patterns", patterns)
+
+
+def _design_doc_declares_common(
+    frontmatter: Any, attributes: Any
+) -> bool:
+    """Return True when a design doc opts into ``kind="common"`` via frontmatter.
+
+    Recognised keys (any one wins):
+    * ``codd.node_type`` (preferred, lives under the ``codd:`` block)
+    * top-level ``node_type`` (legacy / convenience)
+    """
+
+    for source in (frontmatter, attributes):
+        if not isinstance(source, dict):
+            continue
+        node_type = source.get("node_type")
+        if isinstance(node_type, str) and node_type.strip().lower() == "common":
+            return True
+        codd_block = source.get("codd")
+        if isinstance(codd_block, dict):
+            value = codd_block.get("node_type")
+            if isinstance(value, str) and value.strip().lower() == "common":
+                return True
+    return False
+
+
+def _common_node_patterns(settings: dict[str, Any]) -> list[str]:
+    """Return glob patterns that should be classified as ``kind='common'``.
+
+    Common nodes represent shared infrastructure (DB clients, middleware,
+    framework config, generated artifacts) that exist outside any single
+    design document's scope. They participate in the DAG so that change
+    impact can be traced, but they are exempt from C5 transitive_closure
+    unreachable_nodes since requiring every common file to have a parent
+    design_doc would force the entire codebase to be re-modelled as a tree.
+    """
+
+    raw = settings.get("common_node_patterns")
+    if not isinstance(raw, list):
+        return []
+    expanded: list[str] = []
+    for pattern in raw:
+        if not isinstance(pattern, str) or not pattern.strip():
+            continue
+        expanded.extend(_expand_braces(pattern.strip()))
+    return expanded
+
+
 def _runtime_evidence_for_file(file_path: Path, node_id: str, capability_patterns: dict[str, Any]) -> list[dict]:
     evidence = scan_capability_evidence(file_path, capability_patterns)
     absolute_prefix = f"{file_path.as_posix()}:"

{codd_dev-2.14.0 → codd_dev-2.15.0}/codd/dag/checks/transitive_closure.py

@@ -15,12 +15,20 @@ class TransitiveClosureResult:
     check_name: str = "transitive_closure"
     severity: str = "amber"
     unreachable_nodes: list[str] = field(default_factory=list)
+    common_node_count: int = 0
     passed: bool = True
 
 
 @register_dag_check("transitive_closure")
 class TransitiveClosureCheck:
-    """Report nodes unreachable from root design docs without blocking deploy."""
+    """Report nodes unreachable from root design docs without blocking deploy.
+
+    Nodes with ``kind == "common"`` (shared infrastructure declared via
+    ``common_node_patterns`` or frontmatter ``node_type: common``) are exempt
+    from unreachable detection. They participate in the DAG so change-impact
+    analysis still sees them, but they do not need to be the descendant of a
+    single design document.
+    """
 
     def __init__(self, dag=None, project_root: Path | None = None, settings: dict[str, Any] | None = None):
         self.dag = dag
@@ -45,8 +53,19 @@ class TransitiveClosureCheck:
         ]
 
         visited = self._reachable_from(dag, roots)
-        unreachable = [node_id for node_id in dag.nodes if node_id not in visited]
-        return TransitiveClosureResult(unreachable_nodes=unreachable, passed=True)
+        common_count = sum(
+            1 for node in dag.nodes.values() if node.kind == "common"
+        )
+        unreachable = [
+            node_id
+            for node_id, node in dag.nodes.items()
+            if node_id not in visited and node.kind != "common"
+        ]
+        return TransitiveClosureResult(
+            unreachable_nodes=unreachable,
+            common_node_count=common_count,
+            passed=True,
+        )
 
     def _reachable_from(self, dag, roots: list[str]) -> set[str]:
         visited: set[str] = set()

{codd_dev-2.14.0 → codd_dev-2.15.0}/pyproject.toml

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