codd-dev 3.7.1__tar.gz → 3.7.2__tar.gz

{codd_dev-3.7.1 → codd_dev-3.7.2}/PKG-INFO

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

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.7.1"
+__version__ = "3.7.2"

{codd_dev-3.7.1 → codd_dev-3.7.2}/codd/cli.py

@@ -434,6 +434,30 @@ def _display_path(path: Path, project_root: Path) -> str:
         return path.as_posix()
 
 
+def _detect_bootstrap_test_dirs(project_root: Path) -> list[str]:
+    """Detect the project's test directories for the bootstrap codd.yaml.
+
+    Reuses the extractor's inventory (``test``/``tests``/``spec``/``__tests__``)
+    so a project that uses ``test/`` is not silently excluded by a hardcoded
+    ``tests/`` default (which yields a vacuous task_completion). Falls back to the
+    conventional ``tests/`` when none exist so the config stays valid + editable.
+    """
+    from codd.extractor import _detect_test_dirs
+
+    found = _detect_test_dirs(project_root)
+    return [f"{d}/" for d in found] if found else ["tests/"]
+
+
+def _detect_bootstrap_doc_dirs(project_root: Path) -> list[str]:
+    """Detect the project's documentation directories for the bootstrap codd.yaml.
+
+    Mirrors :func:`_detect_bootstrap_test_dirs`: prefer what exists (``docs``
+    vs ``doc``), fall back to the conventional ``docs/`` when none exist.
+    """
+    found = [d for d in ("docs", "doc", "documentation") if (project_root / d).is_dir()]
+    return [f"{d}/" for d in found] if found else ["docs/"]
+
+
 def _ensure_bootstrap_codd_yaml(
     project_root: Path,
     *,
@@ -456,6 +480,8 @@ def _ensure_bootstrap_codd_yaml(
             "project_name": project_root.name,
             "language": language,
             "source_dirs": _format_yaml_list(source_dirs),
+            "test_dirs": _format_yaml_list(_detect_bootstrap_test_dirs(project_root)),
+            "doc_dirs": _format_yaml_list(_detect_bootstrap_doc_dirs(project_root)),
             "graph_path": f"{codd_dir_name}/scan",
         },
     )
@@ -2323,11 +2349,15 @@ def init(
     (codd_dir / "reports").mkdir(parents=True)
     (codd_dir / "scan").mkdir(exist_ok=True)
 
-    # Copy templates
+    # Copy templates. Greenfield init uses the conventional test/doc layout
+    # (brownfield extract detects the project's real dirs instead — see
+    # _ensure_bootstrap_codd_yaml).
     _render_template("codd.yaml.tmpl", codd_dir / "codd.yaml", {
         "project_name": project_name,
         "language": language,
         "source_dirs": _format_yaml_list(["src/"]),
+        "test_dirs": _format_yaml_list(["tests/"]),
+        "doc_dirs": _format_yaml_list(["docs/"]),
         "graph_path": f"{config_dir}/scan",
     })
     _render_template("gitignore.tmpl", codd_dir / ".gitignore", {})

{codd_dev-3.7.1 → codd_dev-3.7.2}/codd/dag/builder.py

@@ -1143,6 +1143,9 @@ def _convention_path_candidates(test_path: Path, project_root: Path, convention_
     return candidates
 
 
+_TEST_DIR_NAMES = {"tests", "test", "spec", "__tests__"}
+
+
 def _is_test_file(file_path: Path, project_root: Path) -> bool:
     relative_parts = _relative_id(file_path, project_root).split("/")
     name = file_path.name
@@ -1153,9 +1156,19 @@ def _is_test_file(file_path: Path, project_root: Path) -> bool:
         return True
     if file_path.suffix == ".bats":
         return True
-    if file_path.suffix == ".py" and any(part in {"tests", "test"} for part in relative_parts[:-1]):
-        return name.startswith("test_") or name.endswith("_test.py")
-    return False
+    in_test_dir = any(part in _TEST_DIR_NAMES for part in relative_parts[:-1])
+    if file_path.suffix == ".py":
+        # Python keeps the stricter pytest/unittest convention even under a test
+        # directory (``test_*.py`` / ``*_test.py``) to avoid pulling fixtures.
+        if in_test_dir:
+            return name.startswith("test_") or name.endswith("_test.py")
+        return False
+    # Other languages: a source file living under a conventional test directory
+    # is a test even without a ``.test.`` infix — e.g. Mocha/Tape ``test/app.js``
+    # (Express) or ``spec/foo.js``. The caller already gates on ``test_suffixes``
+    # and the configured ``test_file_patterns`` (scoped to the project's test
+    # dirs), so this never sweeps in arbitrary source files.
+    return in_test_dir
 
 
 def _load_import_aliases(project_root: Path, settings: dict[str, Any]) -> dict[str, list[str]]:

codd_dev-3.7.2/codd/dag/checks/transitive_closure.py

@@ -0,0 +1,211 @@
+"""Transitive closure DAG completeness check."""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from codd.dag.checks import register_dag_check
+
+
+@dataclass
+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
+    # ``status``/``skipped``/``checked_count`` close a vacuous-pass hole: an empty
+    # DAG (or one whose every node is ``common`` and therefore exempt from
+    # reachability) used to return a green PASS having examined zero nodes.
+    # ``checked_count`` is the number of non-common nodes whose reachability was
+    # actually evaluated; when it is 0 the run is a SKIP, not a clean pass.
+    status: str = "pass"
+    skipped: bool = False
+    checked_count: int = 0
+
+
+# Edge kinds that represent an in-project source-import dependency
+# (importer -> imported). Used to identify *code-entry roots*: source nodes that
+# nothing in the project imports. This is a structural classification of edges,
+# not a language/framework branch.
+_IMPORT_EDGE_KINDS = frozenset({"imports"})
+
+# Node kinds that are NOT first-class source nodes for entry-root detection:
+# design docs are handled by their own root rule, and ``common`` nodes are shared
+# infrastructure exempt from reachability. Anything else (``impl_file`` and any
+# future source kind) is treated as a source node — no per-language literal.
+_NON_SOURCE_KINDS = frozenset({"design_doc", "common"})
+
+
+@register_dag_check("transitive_closure")
+class TransitiveClosureCheck:
+    """Report unreachable nodes without blocking deploy.
+
+    A node is *reachable* if it can be reached from **any entry root**:
+
+    - **design_doc roots** — ``design_doc`` nodes with no incoming edge (the
+      classic "every artifact descends from a design document" model); and
+    - **code-entry roots** — source nodes (everything that is neither a
+      ``design_doc`` nor a ``common`` node) with no incoming in-project *import*
+      edge, i.e. the package's public entry points (e.g. a package
+      ``__init__`` or a CLI ``__main__`` that nothing else imports).
+
+    Seeding from the *union* of these makes reachability meaningful on doc-less
+    BROWNFIELD projects (raw external code with zero design docs but a fully
+    connected import graph) while leaving doc-rooted projects unchanged:
+    code-entry roots are purely additive. Only nodes unreachable from ALL entries
+    are flagged — genuine orphans.
+
+    Entry-root detection is structural (incoming-edge analysis on import-kind
+    edges), never a ``language ==`` branch.
+
+    Cycle / no-entry fallback: if a project has source nodes but none qualify as
+    a code-entry root (every source node has an in-project importer — a pure
+    cycle), reachability falls back to seeding from *all* source nodes for that
+    project, so connectivity is still measured rather than reported as a false
+    "everything unreachable". Cycles are traversed safely (visited-set guard).
+
+    Nodes with ``kind == "common"`` (shared infrastructure declared via
+    ``common_node_patterns`` or frontmatter ``node_type: common``) remain 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
+        self.project_root = project_root
+        self.settings = settings or {}
+
+    def run(
+        self,
+        dag=None,
+        project_root: Path | None = None,
+        settings: dict[str, Any] | None = None,
+    ) -> TransitiveClosureResult:
+        dag = dag or self.dag
+        if dag is None or not dag.nodes:
+            # No nodes at all → reachability examined nothing → SKIP (not a
+            # vacuous green PASS).
+            return TransitiveClosureResult(
+                status="skip",
+                skipped=True,
+                checked_count=0,
+            )
+
+        to_ids = {edge.to_id for edge in dag.edges}
+        design_roots = [
+            node.id
+            for node in dag.nodes.values()
+            if node.kind == "design_doc" and node.id not in to_ids
+        ]
+        code_roots = self._code_entry_roots(dag)
+
+        # Reachable from ANY entry: design-doc roots OR code-entry roots. The
+        # union keeps doc-rooted projects unchanged (design roots still seed) and
+        # makes doc-less brownfield projects measurable (code roots seed the
+        # connected impl graph).
+        roots = list(dict.fromkeys([*design_roots, *code_roots]))
+
+        visited = self._reachable_from(dag, roots)
+        common_count = sum(
+            1 for node in dag.nodes.values() if node.kind == "common"
+        )
+        # Common nodes are exempt from unreachable detection, so the number of
+        # nodes whose reachability is actually evaluated is the non-common set.
+        checked = 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"
+        ]
+
+        if checked == 0:
+            # Every node is exempt (all ``common``): reachability examined nothing.
+            # A clean PASS here is a vacuous false-green → SKIP instead.
+            return TransitiveClosureResult(
+                unreachable_nodes=[],
+                common_node_count=common_count,
+                passed=True,
+                status="skip",
+                skipped=True,
+                checked_count=0,
+            )
+
+        return TransitiveClosureResult(
+            unreachable_nodes=unreachable,
+            common_node_count=common_count,
+            passed=True,
+            status="pass",
+            skipped=False,
+            checked_count=checked,
+        )
+
+    def _code_entry_roots(self, dag) -> list[str]:
+        """Public entry points of the import graph (heads nothing imports).
+
+        A *source node* is any node that is neither a ``design_doc`` (handled by
+        its own root rule) nor a ``common`` node (exempt infrastructure). A source
+        node is a *code-entry root* when it **participates in the import graph as a
+        head**: it has at least one outgoing in-project import edge (it imports
+        something) AND no incoming import edge (nothing imports it). These are the
+        package's public entry points (e.g. ``__init__`` / ``__main__``).
+
+        Requiring an *outgoing* import edge is what preserves no-false-green: a
+        node with zero import edges (isolated -- imported by nothing and importing
+        nothing) is a genuine orphan, NOT an entry root, and therefore stays
+        flagged. Only nodes that actually anchor an import chain seed reachability.
+
+        Fallback (pure cycle / no head): if no source node qualifies as a head but
+        some source nodes still *participate* in the import graph (a cycle where
+        every node has an importer), seed from all participating source nodes so
+        connectivity is still measured instead of a false "everything
+        unreachable". Isolated orphans (no import edges) are never seeded and stay
+        flagged even in the fallback.
+        """
+        source_ids = {
+            node.id
+            for node in dag.nodes.values()
+            if node.kind not in _NON_SOURCE_KINDS
+        }
+        if not source_ids:
+            return []
+
+        import_to: set[str] = set()
+        import_from: set[str] = set()
+        for edge in dag.edges:
+            if edge.kind in _IMPORT_EDGE_KINDS:
+                import_to.add(edge.to_id)
+                import_from.add(edge.from_id)
+
+        # Heads: import something in-project, imported by nothing in-project.
+        entry_roots = [
+            nid
+            for nid in source_ids
+            if nid in import_from and nid not in import_to
+        ]
+        if entry_roots:
+            return entry_roots
+
+        # No clean head (pure cycle): seed from source nodes that participate in
+        # the import graph at all, so connectivity is still measured. Nodes with
+        # no import edges remain genuine orphans (never seeded here).
+        return [nid for nid in source_ids if nid in import_to or nid in import_from]
+
+    def _reachable_from(self, dag, roots: list[str]) -> set[str]:
+        visited: set[str] = set()
+        queue = deque(roots)
+
+        while queue:
+            current = queue.popleft()
+            if current in visited:
+                continue
+            visited.add(current)
+            for edge in dag.edges:
+                if edge.from_id == current and edge.to_id not in visited:
+                    queue.append(edge.to_id)
+
+        return visited

{codd_dev-3.7.1 → codd_dev-3.7.2}/codd/extract_ai.py

@@ -57,6 +57,60 @@ CONFIG_FILES = [
 # IaC patterns
 IAC_EXTENSIONS = {".bicep", ".bicepparam", ".tf", ".tfvars", ".hcl"}
 
+
+def ai_command_has_tools(ai_command: str) -> bool:
+    """Return whether ``ai_command`` grants the model file/shell tools.
+
+    The extract prompt's "Extraction Procedure" enumerates the codebase via bash
+    (``find``/``ls``/``rg``). That only works when the AI CLI can actually shell
+    out. The default ``ai_command`` disables tools (``--tools ""``), and agentic
+    CLIs are hardened to read-only from an empty workspace elsewhere — so the
+    procedural bash framing pushes the model into agentic mode and it stubs or
+    hangs. We therefore treat NO TOOLS as the safe default and require an
+    explicit grant to keep the tool-enabled path.
+
+    Tools are considered AVAILABLE only when a ``--tools``/``--allowedTools``
+    flag carries a non-empty value. ``--tools ""`` (or the flag absent) → no
+    tools. Unparseable commands fail closed to no-tools (context-only is always
+    correct because the full PROJECT CONTEXT is embedded in the prompt).
+    """
+    import shlex
+
+    try:
+        parts = shlex.split(ai_command)
+    except ValueError:
+        return False
+
+    tool_flags = {"--tools", "--allowedTools", "--allowed-tools"}
+    for i, part in enumerate(parts):
+        flag, sep, inline = part.partition("=")
+        if flag in tool_flags:
+            value = inline if sep else (parts[i + 1] if i + 1 < len(parts) else "")
+            if value.strip():
+                return True
+    return False
+
+
+# Prepended to the prompt when the AI CLI has no tools: it overrides the
+# template's bash "Extraction Procedure" so the model extracts from the embedded
+# PROJECT CONTEXT instead of trying to shell out (which it cannot do).
+_NO_TOOLS_DIRECTIVE = """# ═══ EXECUTION MODE: NO TOOLS (context-only) ═══
+
+You are running WITHOUT shell or file-system tools. Do NOT call any tool, do NOT
+run bash/`find`/`ls`/`rg`/`cat`, and do NOT attempt to read files from disk.
+
+The COMPLETE pre-scanned codebase — the directory tree plus the full contents of
+every relevant source, config, IaC, and test file — is embedded verbatim under
+"PROJECT CONTEXT (pre-scanned)" further down this prompt. That embedded context
+is your ONLY source of truth.
+
+When the "Extraction Procedure" below shows ```bash``` enumeration commands,
+treat them as a DESCRIPTION of what to look for, NOT as commands to execute.
+Instead, derive the same information by reading the embedded file contents
+directly. Produce the full output document set in one response from that context.
+
+"""
+
 # Schema file patterns
 SCHEMA_PATTERNS = [
     "prisma/schema.prisma", "db/schema.rb", "alembic/versions",
@@ -360,10 +414,20 @@ def pre_scan(project_root: Path) -> PreScanResult:
 # Phase 2: AI prompt building
 # ═══════════════════════════════════════════════════════════
 
-def _build_prompt(scan: PreScanResult) -> str:
-    """Build the AI prompt from pre-scan results + extract template."""
+def _build_prompt(scan: PreScanResult, *, tools_available: bool = False) -> str:
+    """Build the AI prompt from pre-scan results + extract template.
+
+    ``tools_available`` reflects whether the AI CLI can shell out (see
+    :func:`ai_command_has_tools`). When False (the default for ``--tools ""``),
+    a NO-TOOLS directive is prepended so the model extracts from the embedded
+    PROJECT CONTEXT instead of trying to run the template's bash procedure.
+    """
     sections: list[str] = []
 
+    # No-tools mode: override the template's bash procedure up front.
+    if not tools_available:
+        sections.append(_NO_TOOLS_DIRECTIVE)
+
     # Load prompt template
     if PROMPT_TEMPLATE_FILE.exists():
         template = PROMPT_TEMPLATE_FILE.read_text(encoding="utf-8")
@@ -810,6 +874,10 @@ def run_extract_ai(
     # Phase 1: Pre-scan
     scan = pre_scan(project_root)
 
+    # Whether the AI CLI can shell out. The default ``--tools ""`` disables
+    # tools, so the prompt must NOT lean on its bash enumeration procedure.
+    tools_available = ai_command_has_tools(ai_command)
+
     # Phase 2: Build prompt (custom or baseline)
     if prompt_file:
         custom_path = Path(prompt_file)
@@ -819,10 +887,10 @@ def run_extract_ai(
         # Temporarily swap template for custom prompt
         import codd.extract_ai as _self
         _self.PROMPT_TEMPLATE_FILE = custom_path
-        prompt = _build_prompt(scan)
+        prompt = _build_prompt(scan, tools_available=tools_available)
         _self.PROMPT_TEMPLATE_FILE = original_template
     else:
-        prompt = _build_prompt(scan)
+        prompt = _build_prompt(scan, tools_available=tools_available)
 
     # Phase 3: AI invocation
     raw_output = _invoke_ai_command(ai_command, prompt)

{codd_dev-3.7.1 → codd_dev-3.7.2}/codd/parsing/regex_strategies.py

@@ -189,12 +189,22 @@ def _imports_python(content, project_root, src_dir, file_path):
     return internal, external
 
 
+# Capture the module specifier from every JS/TS import form: ESM
+# ``import .. from '..'`` / ``from '..'``, plus CommonJS ``require('..')`` and
+# dynamic ``import('..')``. Mirrors codd.dag.extractor._IMPORT_SPECIFIER_RE so the
+# scan-path parser and the DAG builder agree on a CommonJS codebase's internal
+# dependency graph.
+_TS_JS_IMPORT_SPECIFIER_RE = re.compile(
+    r'''(?:import|from|require\(\s*|import\(\s*)\s*['"]([^'"]+)['"]'''
+)
+
+
 def _imports_ts_js(content, project_root, src_dir, file_path):
     internal: dict[str, list[str]] = {}
     external: set[str] = set()
 
     for line in content.splitlines():
-        m = re.search(r'''(?:import|from)\s+['"]([^'"]+)['"]''', line)
+        m = _TS_JS_IMPORT_SPECIFIER_RE.search(line)
         if not m:
             continue
         import_path = m.group(1)

{codd_dev-3.7.1 → codd_dev-3.7.2}/codd/parsing/treesitter.py

@@ -34,6 +34,20 @@ _JS_IMPORT_SUFFIXES = {
     "typescript": ("", ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", "/index.ts", "/index.tsx"),
 }
 
+
+def _strip_js_comments(src: str) -> str:
+    """Remove ``/* block */`` (including JSDoc) and ``// line`` comments.
+
+    Used to keep route-path extraction from reading example routes embedded in
+    documentation comments. String-literal edge cases are tolerated: route
+    specifiers of interest are app-relative paths (``/users``), never URLs that
+    would carry a ``//`` sequence inside a string literal.
+    """
+    src = re.sub(r"/\*.*?\*/", "", src, flags=re.S)
+    src = re.sub(r"//[^\n]*", "", src)
+    return src
+
+
 class TreeSitterExtractor:
     """Tree-sitter backend for Python and TypeScript/JavaScript source files."""
 
@@ -540,26 +554,71 @@ def _extract_typescript_imports_ast(
     external: set[str] = set()
 
     for node in _iter_named_nodes(root):
-        if node.type not in {"export_statement", "import_statement"}:
-            continue
-        source_node = node.child_by_field_name("source")
-        if source_node is None:
-            continue
-        import_path = _extract_string_literal(_node_text(content_bytes, source_node))
-        if not import_path:
+        if node.type in {"export_statement", "import_statement"}:
+            source_node = node.child_by_field_name("source")
+            if source_node is None:
+                continue
+            import_path = _extract_string_literal(_node_text(content_bytes, source_node))
+            if not import_path:
+                continue
+            _record_js_import(
+                import_path,
+                _normalize_ws(_node_text(content_bytes, node)),
+                internal,
+                external,
+                file_path=file_path,
+                src_dir=src_dir,
+                language=language,
+            )
             continue
-        _record_js_import(
-            import_path,
-            _normalize_ws(_node_text(content_bytes, node)),
-            internal,
-            external,
-            file_path=file_path,
-            src_dir=src_dir,
-            language=language,
-        )
+
+        # CommonJS ``require('..')`` and dynamic ``import('..')`` are
+        # call_expressions, not import_statements. A CommonJS codebase (e.g.
+        # Express) carries its entire internal dependency graph here, so the AST
+        # walk must capture it too — otherwise the scan reports no inter-module
+        # dependencies. Mirrors codd.dag.extractor._IMPORT_SPECIFIER_RE.
+        if node.type == "call_expression":
+            import_path = _call_expression_module_specifier(content_bytes, node)
+            if not import_path:
+                continue
+            _record_js_import(
+                import_path,
+                _normalize_ws(_node_text(content_bytes, node)),
+                internal,
+                external,
+                file_path=file_path,
+                src_dir=src_dir,
+                language=language,
+            )
 
     return internal, external
 
+
+def _call_expression_module_specifier(content_bytes: bytes, node: Any) -> str | None:
+    """Return the module specifier of a ``require('..')`` / ``import('..')`` call.
+
+    Returns ``None`` for any other call expression (including ``require(var)``
+    with a non-literal argument — only statically resolvable specifiers count).
+    """
+    func_node = node.child_by_field_name("function")
+    if func_node is None:
+        return None
+    callee = _node_text(content_bytes, func_node).strip()
+    # ``import(...)`` parses with an ``import`` callee; ``require(...)`` with an
+    # identifier callee. Accept both; reject everything else.
+    if callee != "require" and func_node.type != "import":
+        return None
+    args_node = node.child_by_field_name("arguments")
+    if args_node is None:
+        return None
+    for child in getattr(args_node, "named_children", []):
+        if child.type in {"string", "template_string"}:
+            return _extract_string_literal(_node_text(content_bytes, child))
+        # A non-literal first argument (e.g. require(modName)) is not statically
+        # resolvable — stop at the first argument either way.
+        break
+    return None
+
 def _detect_python_code_patterns(mod: ModuleInfo, root: Any, content: str) -> None:
     content_bytes = content.encode("utf-8", errors="ignore")
     routes: list[str] = []
@@ -624,9 +683,14 @@ def _detect_typescript_code_patterns(mod: ModuleInfo, root: Any, content: str) -
     if orm_models:
         mod.patterns["db_models"] = f"ORM models: {', '.join(sorted(set(orm_models)))}"
 
+    # Strip /* block */ (incl. JSDoc) and // line comments BEFORE pulling route
+    # path strings: framework docs embed example routes such as
+    # ``app.get('/user/:uid/photos/:file', ...)`` inside @example JSDoc blocks
+    # (e.g. express/lib/response.js), which would otherwise register as real
+    # endpoints (false positives).
     route_matches = re.findall(
         r'(?:app|router)\.(?:get|post|put|delete|patch)\s*\(\s*["\']([^"\']+)["\']',
-        content,
+        _strip_js_comments(content),
     )
     if route_matches:
         mod.patterns["api_routes"] = f"HTTP route handlers: {', '.join(sorted(set(route_matches)))}"

{codd_dev-3.7.1 → codd_dev-3.7.2}/codd/templates/codd.yaml.tmpl

@@ -4,10 +4,10 @@ codd_required_version: null
 codd_required_version_strict: false
 
 project:
-  name: "{{project_name}}"
-  language: "{{language}}"
-  frameworks: []
-
+  name: "{{project_name}}"
+  language: "{{language}}"
+  frameworks: []
+
 ai_command: "claude --print --permission-mode bypassPermissions --dangerously-skip-permissions --model claude-opus-4-8 --effort max --tools \"\""
 
 # codex_app_server:
@@ -46,27 +46,27 @@ coding_principles: null
 scan:
   source_dirs:
 {{source_dirs}}
-  test_dirs:
-    - "tests/"
-  doc_dirs:
-    - "docs/"
-  config_files: []
-  exclude:
-    - "**/node_modules/**"
-    - "**/__pycache__/**"
-    - "**/dist/**"
-
-graph:
-  store: "jsonl"
-  path: "{{graph_path}}"
-
-bands:
-  green:
-    min_confidence: 0.90
-    min_evidence_count: 2
-  amber:
-    min_confidence: 0.50
-
+  test_dirs:
+{{test_dirs}}
+  doc_dirs:
+{{doc_dirs}}
+  config_files: []
+  exclude:
+    - "**/node_modules/**"
+    - "**/__pycache__/**"
+    - "**/dist/**"
+
+graph:
+  store: "jsonl"
+  path: "{{graph_path}}"
+
+bands:
+  green:
+    min_confidence: 0.90
+    min_evidence_count: 2
+  amber:
+    min_confidence: 0.50
+
 propagation:
   max_depth: 10
   stop_at_contract_boundary: true

{codd_dev-3.7.1 → codd_dev-3.7.2}/pyproject.toml

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