codd-dev 0.4.0__tar.gz → 0.6.0__tar.gz

{codd_dev-0.4.0 → codd_dev-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 0.4.0
+Version: 0.6.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-0.4.0 → codd_dev-0.6.0}/codd/extractor.py

@@ -76,6 +76,9 @@ class ModuleInfo:
     patterns: dict[str, str] = field(default_factory=dict)  # pattern_type -> detail
     call_edges: list[CallEdge] = field(default_factory=list)
     interface_contract: Any = None  # InterfaceContract from contracts.py
+    test_coverage: Any = None       # TestCoverage from traceability.py
+    schema_refs: list[Any] = field(default_factory=list)    # SchemaRef from schema_refs.py
+    runtime_wires: list[Any] = field(default_factory=list)  # RuntimeWire from wiring.py
 
 
 @dataclass
@@ -104,6 +107,7 @@ class ProjectFacts:
     infra_config: dict[str, ConfigInfo] = field(default_factory=dict)
     build_deps: BuildDepsInfo | None = None
     feature_clusters: list[FeatureCluster] = field(default_factory=list)
+    change_risks: list[Any] = field(default_factory=list)  # ChangeRisk from risk.py
 
 
 @dataclass
@@ -184,6 +188,22 @@ def extract_facts(project_root: Path, language: str | None = None,
     from codd.clustering import build_feature_clusters
     build_feature_clusters(facts)
 
+    # R5.1: Test traceability
+    from codd.traceability import build_test_traceability
+    build_test_traceability(facts, project_root)
+
+    # R5.2: Schema-code dependency
+    from codd.schema_refs import build_schema_refs
+    build_schema_refs(facts, project_root)
+
+    # R5.3: Runtime wiring detection
+    from codd.wiring import build_runtime_wires
+    build_runtime_wires(facts, project_root)
+
+    # R5.4: Change risk scoring (depends on R4.3, R5.1)
+    from codd.risk import build_change_risks
+    build_change_risks(facts)
+
     return facts
 
 

{codd_dev-0.4.0 → codd_dev-0.6.0}/codd/parsing.py

@@ -301,6 +301,8 @@ class TreeSitterExtractor:
             root = self._parse(content)
             if self.language == "python":
                 return _extract_python_call_graph(root, content, file_path, symbols)
+            if self.language in {"typescript", "javascript"}:
+                return _extract_ts_call_graph(root, content, file_path, symbols)
         except Exception:
             return []
         return []
@@ -1009,6 +1011,105 @@ def _extract_python_call_graph(root: Any, content: str, file_path: str, symbols:
     return edges
 
 
+_TS_BUILTIN_NAMES = {
+    "console", "Math", "JSON", "Object", "Array", "Promise",
+    "setTimeout", "setInterval", "clearTimeout", "clearInterval",
+    "require", "parseInt", "parseFloat", "isNaN",
+    "encodeURIComponent", "decodeURIComponent",
+}
+
+
+def _extract_ts_call_graph(root: Any, content: str, file_path: str, symbols: list[Symbol]) -> list[CallEdge]:
+    """Extract function call edges from TypeScript/JavaScript AST using tree-sitter."""
+    from codd.extractor import CallEdge
+
+    content_bytes = content.encode("utf-8", errors="ignore")
+    edges: list[CallEdge] = []
+    symbol_names = {s.name for s in symbols}
+
+    def _current_scope(node: Any) -> str:
+        """Walk parents to find enclosing function/method/class scope."""
+        parts: list[str] = []
+        current = node.parent
+        while current is not None:
+            if current.type in (
+                "function_declaration",
+                "function",
+                "method_definition",
+                "arrow_function",
+                "class_declaration",
+                "class",
+            ):
+                name = _field_text(content_bytes, current, "name")
+                if name:
+                    parts.append(name)
+            current = current.parent
+        parts.reverse()
+        return ".".join(parts) if parts else "<module>"
+
+    def _callee_name(func_node: Any) -> str | None:
+        """Extract callee name from the function child of a call/new expression."""
+        if func_node is None:
+            return None
+        node_type = func_node.type
+        if node_type == "identifier":
+            return _node_text(content_bytes, func_node).strip()
+        if node_type in ("member_expression", "optional_chain"):
+            obj = func_node.child_by_field_name("object")
+            prop = func_node.child_by_field_name("property")
+            if obj is not None and prop is not None:
+                obj_text = _node_text(content_bytes, obj).strip()
+                prop_text = _node_text(content_bytes, prop).strip()
+                return f"{obj_text}.{prop_text}"
+            # Fallback: return full text
+            return _node_text(content_bytes, func_node).strip()
+        # Other node types (parenthesized_expression, etc.) — use full text
+        return _node_text(content_bytes, func_node).strip()
+
+    for node in _iter_named_nodes(root):
+        if node.type == "call_expression":
+            func_node = node.child_by_field_name("function")
+            is_async = node.parent is not None and node.parent.type == "await_expression"
+        elif node.type == "new_expression":
+            func_node = node.child_by_field_name("constructor")
+            is_async = False
+        else:
+            continue
+
+        callee_text = _callee_name(func_node)
+        if not callee_text:
+            continue
+
+        bare_name = callee_text.split(".")[-1] if "." in callee_text else callee_text
+
+        # Skip known JS/TS builtins
+        root_name = callee_text.split(".")[0]
+        if root_name in _TS_BUILTIN_NAMES or bare_name in _TS_BUILTIN_NAMES:
+            continue
+
+        # Only include calls to known project symbols (intra-project filter)
+        if bare_name not in symbol_names and callee_text not in symbol_names:
+            # Allow method calls on this/self (this.method)
+            if callee_text.startswith("this."):
+                method_name = callee_text[5:]
+                if method_name not in symbol_names:
+                    continue
+            else:
+                continue
+
+        caller = _current_scope(node)
+        line_no = node.start_point.row + 1
+
+        edges.append(CallEdge(
+            caller=caller,
+            callee=callee_text,
+            call_site=f"{file_path}:{line_no}",
+            is_async=is_async,
+        ))
+
+    return edges
+
+
 def _sql_first_object_name(content_bytes: bytes, node: Any) -> str:
     for child in getattr(node, "named_children", []):
         if child.type == "object_reference":

codd_dev-0.6.0/codd/risk.py

@@ -0,0 +1,100 @@
+"""R5.4 — Change risk scoring for codd extract.
+
+Computes per-module risk score based on:
+- Number of dependents (import + call + runtime)
+- Test coverage ratio (R5.1)
+- API surface ratio (R4.3)
+- Encapsulation violations (R4.3)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from codd.extractor import ProjectFacts
+
+
+@dataclass
+class ChangeRisk:
+    """Per-module change risk assessment."""
+    module: str
+    score: float = 0.0
+    factors: dict[str, float] = field(default_factory=dict)
+
+
+def build_change_risks(facts: ProjectFacts) -> None:
+    """Populate ``facts.change_risks`` with per-module risk scores."""
+    # Step 1: Count inbound dependents per module (import + call + runtime)
+    dependents: dict[str, int] = {name: 0 for name in facts.modules}
+
+    for mod in facts.modules.values():
+        # Import dependents
+        for dep_name in mod.internal_imports:
+            if dep_name in dependents:
+                dependents[dep_name] += 1
+        # Call dependents
+        for edge in mod.call_edges:
+            target = edge.callee.split(".")[0]
+            if target in dependents and target != mod.name:
+                dependents[target] += 1
+        # Runtime wire dependents
+        for wire in getattr(mod, "runtime_wires", []):
+            target = wire.target.split(".")[0]
+            if target in dependents and target != mod.name:
+                dependents[target] += 1
+
+    max_dep = max(dependents.values()) if dependents else 1
+    if max_dep == 0:
+        max_dep = 1
+
+    # Step 2: Collect max violations
+    violations: dict[str, int] = {}
+    for mod in facts.modules.values():
+        ic = mod.interface_contract
+        violations[mod.name] = len(ic.encapsulation_violations) if ic else 0
+    max_viol = max(violations.values()) if violations else 1
+    if max_viol == 0:
+        max_viol = 1
+
+    # Step 3: Compute risk score per module
+    risks: list[ChangeRisk] = []
+    for mod in facts.modules.values():
+        # Coverage ratio (from R5.1 test traceability)
+        tc = getattr(mod, "test_coverage", None)
+        coverage_ratio = tc.coverage_ratio if tc else 0.0
+
+        # API surface ratio (from R4.3 interface contracts)
+        ic = mod.interface_contract
+        api_ratio = ic.api_surface_ratio if ic else 1.0
+
+        # Violation count
+        viol_count = violations.get(mod.name, 0)
+
+        # Dependent count
+        dep_count = dependents.get(mod.name, 0)
+
+        # Formula
+        dep_factor = dep_count / max_dep
+        cov_factor = 1.0 - coverage_ratio
+        api_factor = api_ratio
+        viol_factor = viol_count / max_viol
+
+        score = (0.3 * dep_factor
+                 + 0.3 * cov_factor
+                 + 0.2 * api_factor
+                 + 0.2 * viol_factor)
+
+        risks.append(ChangeRisk(
+            module=mod.name,
+            score=round(score, 2),
+            factors={
+                "dependents": round(dep_factor, 2),
+                "uncovered": round(cov_factor, 2),
+                "api_surface": round(api_factor, 2),
+                "violations": round(viol_factor, 2),
+            },
+        ))
+
+    facts.change_risks = sorted(risks, key=lambda r: -r.score)

{codd_dev-0.4.0 → codd_dev-0.6.0}/codd/scanner.py

@@ -11,10 +11,10 @@ import re
 from pathlib import Path
 from typing import Any
 
-import yaml
-
-from codd.graph import CEG
-from codd.parsing import get_extractor
+import yaml
+
+from codd.graph import CEG
+from codd.parsing import get_extractor
 
 
 def run_scan(project_root: Path, codd_dir: Path):
@@ -228,6 +228,14 @@ def _load_frontmatter(ceg: CEG, doc_path: str, codd: dict):
             ceg.add_evidence(edge_id, "frontmatter", "frontmatter", 0.75,
                              detail=data_dep.get("condition", ""))
 
+    # R6.2: source_files bridge edges (extracted design → source file)
+    for source_file in codd.get("source_files", []):
+        file_node_id = f"file:{source_file}"
+        ceg.upsert_node(file_node_id, "file", path=source_file, name=file_node_id)
+        edge_id = ceg.add_edge(node_id, file_node_id, "extracted_from", "technical")
+        ceg.add_evidence(edge_id, "frontmatter", "source_files", 0.85,
+                         detail=f"design doc maps to source file {source_file}")
+
 
 # ═══════════════════════════════════════════════════════════
 # Legacy: annotations/ YAML support (backward compatibility)
@@ -323,8 +331,8 @@ def _load_legacy_data_dependency(ceg: CEG, dep: dict):
 # Phase 2: Source code scanning
 # ═══════════════════════════════════════════════════════════
 
-def _scan_source_directory(ceg: CEG, project_root: Path, src_dir: Path,
-                           language: str, exclude_patterns: list):
+def _scan_source_directory(ceg: CEG, project_root: Path, src_dir: Path,
+                           language: str, exclude_patterns: list):
     """Scan source files for import/call dependencies."""
     extensions = {
         "python": [".py"],
@@ -343,60 +351,60 @@ def _scan_source_directory(ceg: CEG, project_root: Path, src_dir: Path,
             full = Path(root) / fname
             rel = full.relative_to(project_root).as_posix()
 
-            if any(_match_glob(rel, pat) for pat in exclude_patterns):
-                continue
-
-            ceg.upsert_node(f"file:{rel}", "file", path=rel, name=fname)
-            file_count += 1
-            _extract_imports_basic(ceg, project_root, src_dir, full, rel, language)
+            if any(_match_glob(rel, pat) for pat in exclude_patterns):
+                continue
+
+            ceg.upsert_node(f"file:{rel}", "file", path=rel, name=fname)
+            file_count += 1
+            _extract_imports_basic(ceg, project_root, src_dir, full, rel, language)
 
     if file_count > 0:
         print(f"  Source: {file_count} {language} files in {src_dir.relative_to(project_root)}")
 
 
-def _extract_imports_basic(ceg: CEG, project_root: Path, src_dir: Path, file_path: Path,
-                           rel_path: str, language: str):
-    """Basic import extraction using the shared parsing backend."""
-    try:
-        content = file_path.read_text(errors="ignore")
-    except Exception:
-        return
-
-    source_id = f"file:{rel_path}"
-    extractor = get_extractor(language, "source")
-    internal, _ = extractor.extract_imports(content, file_path, project_root, src_dir)
-
-    if language in ("typescript", "javascript"):
-        for import_lines in internal.values():
-            for line in import_lines:
-                match = re.search(r'''(?:import|from)\s+['"]([^'"]+)['"]''', line)
-                if not match:
-                    continue
-                target_module = match.group(1)
-                if not target_module.startswith("."):
-                    continue
-                resolved = (file_path.parent / target_module).resolve()
-                extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"]
-                for ext in [""] + extensions:
-                    candidate = Path(f"{resolved}{ext}")
-                    if not candidate.exists():
-                        continue
-                    try:
-                        target_rel = candidate.relative_to(project_root).as_posix()
-                    except ValueError:
-                        continue
-                    target_id = f"file:{target_rel}"
-                    ceg.upsert_node(target_id, "file", path=target_rel)
-                    edge_id = ceg.add_edge(source_id, target_id, "imports", "structural")
-                    ceg.add_evidence(edge_id, "static", "ast_import", 0.95)
-                    break
-
-    elif language == "python":
-        for target_module in internal:
-            target_id = f"module:{target_module}"
-            ceg.upsert_node(target_id, "module", name=target_module)
-            edge_id = ceg.add_edge(source_id, target_id, "imports", "structural")
-            ceg.add_evidence(edge_id, "static", "ast_import", 0.90)
+def _extract_imports_basic(ceg: CEG, project_root: Path, src_dir: Path, file_path: Path,
+                           rel_path: str, language: str):
+    """Basic import extraction using the shared parsing backend."""
+    try:
+        content = file_path.read_text(errors="ignore")
+    except Exception:
+        return
+
+    source_id = f"file:{rel_path}"
+    extractor = get_extractor(language, "source")
+    internal, _ = extractor.extract_imports(content, file_path, project_root, src_dir)
+
+    if language in ("typescript", "javascript"):
+        for import_lines in internal.values():
+            for line in import_lines:
+                match = re.search(r'''(?:import|from)\s+['"]([^'"]+)['"]''', line)
+                if not match:
+                    continue
+                target_module = match.group(1)
+                if not target_module.startswith("."):
+                    continue
+                resolved = (file_path.parent / target_module).resolve()
+                extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"]
+                for ext in [""] + extensions:
+                    candidate = Path(f"{resolved}{ext}")
+                    if not candidate.exists():
+                        continue
+                    try:
+                        target_rel = candidate.relative_to(project_root).as_posix()
+                    except ValueError:
+                        continue
+                    target_id = f"file:{target_rel}"
+                    ceg.upsert_node(target_id, "file", path=target_rel)
+                    edge_id = ceg.add_edge(source_id, target_id, "imports", "structural")
+                    ceg.add_evidence(edge_id, "static", "ast_import", 0.95)
+                    break
+
+    elif language == "python":
+        for target_module in internal:
+            target_id = f"module:{target_module}"
+            ceg.upsert_node(target_id, "module", name=target_module)
+            edge_id = ceg.add_edge(source_id, target_id, "imports", "structural")
+            ceg.add_evidence(edge_id, "static", "ast_import", 0.90)
 
 
 # ═══════════════════════════════════════════════════════════

codd_dev-0.6.0/codd/schema_refs.py

@@ -0,0 +1,122 @@
+"""R5.2 — Schema-code dependency detection for codd extract.
+
+Detects ORM model definitions (SQLAlchemy, Django, Prisma) and raw SQL
+references in source code. Links source modules to schema tables.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from codd.extractor import ProjectFacts
+
+
+@dataclass
+class SchemaRef:
+    """A reference from source code to a database table or model."""
+    table_or_model: str
+    kind: str           # "sqlalchemy" | "django" | "prisma" | "raw_sql"
+    file: str
+    line: int
+
+
+# ── Detection patterns ──────────────────────────────────
+
+# SQLAlchemy: __tablename__ = 'users'
+_SQLA_TABLENAME_RE = re.compile(
+    r"""__tablename__\s*=\s*['"](\w+)['"]""",
+)
+
+# Django: class User(models.Model)
+_DJANGO_MODEL_RE = re.compile(
+    r"""class\s+(\w+)\s*\(\s*(?:models\.Model|AbstractUser|AbstractBaseUser)""",
+)
+
+# Prisma client: prisma.user.find_many() etc
+_PRISMA_CLIENT_RE = re.compile(
+    r"""prisma\.(\w+)\.\s*(?:find_many|find_first|find_unique|create|update|delete|count|aggregate|group_by)""",
+)
+
+# Raw SQL: SELECT/INSERT/UPDATE/DELETE ... FROM/INTO/TABLE tablename
+_RAW_SQL_RE = re.compile(
+    r"""(?:SELECT\s+.*?\s+FROM|INSERT\s+INTO|UPDATE|DELETE\s+FROM|CREATE\s+TABLE|ALTER\s+TABLE|DROP\s+TABLE)\s+[`"']?(\w+)[`"']?""",
+    re.IGNORECASE,
+)
+
+
+def detect_schema_refs(content: str, file_path: str) -> list[SchemaRef]:
+    """Detect schema/model references in source code."""
+    refs: list[SchemaRef] = []
+    lines = content.splitlines()
+
+    for line_no, line in enumerate(lines, 1):
+        # SQLAlchemy
+        m = _SQLA_TABLENAME_RE.search(line)
+        if m:
+            refs.append(SchemaRef(
+                table_or_model=m.group(1),
+                kind="sqlalchemy",
+                file=file_path,
+                line=line_no,
+            ))
+
+        # Django
+        m = _DJANGO_MODEL_RE.search(line)
+        if m:
+            refs.append(SchemaRef(
+                table_or_model=m.group(1),
+                kind="django",
+                file=file_path,
+                line=line_no,
+            ))
+
+        # Prisma client
+        m = _PRISMA_CLIENT_RE.search(line)
+        if m:
+            refs.append(SchemaRef(
+                table_or_model=m.group(1),
+                kind="prisma",
+                file=file_path,
+                line=line_no,
+            ))
+
+        # Raw SQL in string literals
+        # Only match inside quotes to avoid false positives
+        if any(kw in line.upper() for kw in ("SELECT", "INSERT", "UPDATE", "DELETE", "CREATE TABLE", "ALTER TABLE")):
+            for m2 in _RAW_SQL_RE.finditer(line):
+                table = m2.group(1)
+                # Filter out SQL keywords that got captured as table names
+                if table.upper() not in {"SET", "INTO", "FROM", "WHERE", "AND", "OR",
+                                          "TABLE", "INDEX", "VIEW", "VALUES", "NULL",
+                                          "NOT", "EXISTS", "AS", "ON", "JOIN", "LEFT",
+                                          "RIGHT", "INNER", "OUTER", "GROUP", "ORDER",
+                                          "BY", "HAVING", "LIMIT", "OFFSET", "UNION",
+                                          "ALL", "DISTINCT", "CASE", "WHEN", "THEN",
+                                          "ELSE", "END", "IF", "BEGIN", "COMMIT"}:
+                    refs.append(SchemaRef(
+                        table_or_model=table,
+                        kind="raw_sql",
+                        file=file_path,
+                        line=line_no,
+                    ))
+
+    return refs
+
+
+def build_schema_refs(facts: ProjectFacts, project_root: Path) -> None:
+    """Populate ``schema_refs`` on every module in *facts*."""
+    for mod in facts.modules.values():
+        all_refs: list[SchemaRef] = []
+        for rel_file in mod.files:
+            full = project_root / rel_file
+            try:
+                content = full.read_text(errors="ignore")
+            except Exception:
+                continue
+            refs = detect_schema_refs(content, rel_file)
+            all_refs.extend(refs)
+        mod.schema_refs = all_refs

{codd_dev-0.4.0 → codd_dev-0.6.0}/codd/synth.py

@@ -167,6 +167,7 @@ def synth_architecture(
         external_dependencies=_all_external_dependencies(facts),
         build_deps=_build_deps_context(facts.build_deps),
         deployment_hints=_deployment_hints(facts),
+        change_risks=facts.change_risks,
     )
     architecture_path.write_text(content, encoding="utf-8")
     return architecture_path
@@ -241,6 +242,7 @@ def _render_module_detail(env: Environment, facts: ProjectFacts, module: ModuleI
             confidence=_module_confidence(module),
             today=today,
             depends_on=_module_depends_on(facts, module),
+            source_files=sorted(module.files),
         ),
         mod=module,
         layer_name=layer_name,
@@ -266,6 +268,9 @@ def _render_module_detail(env: Environment, facts: ProjectFacts, module: ModuleI
         tests=_tests_context(module),
         call_edges=module.call_edges,
         interface_contract=module.interface_contract,
+        test_coverage=module.test_coverage,
+        schema_refs=module.schema_refs,
+        runtime_wires=module.runtime_wires,
     )
     return content
 
@@ -276,6 +281,7 @@ def _render_schema_design(env: Environment, relative_path: str, schema: Any, tod
             node_id=_schema_node_id(relative_path),
             confidence=_schema_confidence(schema),
             today=today,
+            source_files=[relative_path],
         ),
         relative_path=relative_path,
         slug=_slugify(Path(relative_path).with_suffix("").as_posix()),
@@ -298,6 +304,7 @@ def _render_api_contract(env: Environment, relative_path: str, spec: Any, today:
             node_id=_api_node_id(relative_path),
             confidence=_api_confidence(spec),
             today=today,
+            source_files=[relative_path],
         ),
         relative_path=relative_path,
         spec=spec,
@@ -314,6 +321,7 @@ def _build_frontmatter(
     confidence: float,
     today: str,
     depends_on: list[dict[str, Any]] | None = None,
+    source_files: list[str] | None = None,
 ) -> str:
     codd: dict[str, Any] = {
         "node_id": node_id,
@@ -322,6 +330,8 @@ def _build_frontmatter(
         "confidence": round(confidence, 2),
         "last_extracted": today,
     }
+    if source_files:
+        codd["source_files"] = source_files
     if depends_on:
         codd["depends_on"] = depends_on
     payload = yaml.safe_dump({"codd": codd}, sort_keys=False, allow_unicode=True)
@@ -367,6 +377,35 @@ def _module_depends_on(facts: ProjectFacts, module: ModuleInfo) -> list[dict[str
                         )
                         seen_ids.add(nid)
 
+    # R5.2: schema_uses edges
+    for ref in getattr(module, "schema_refs", []):
+        # Link to schema doc if one exists for this table
+        for schema_path in facts.schemas:
+            schema_obj = facts.schemas[schema_path]
+            tables = [t.get("name", "") for t in getattr(schema_obj, "tables", [])]
+            models = [m.get("name", "") for m in getattr(schema_obj, "models", [])]
+            if ref.table_or_model in tables or ref.table_or_model in models:
+                nid = _schema_node_id(schema_path)
+                if nid not in seen_ids:
+                    depends_on.append(
+                        {"id": nid, "relation": "schema_uses", "semantic": "technical"}
+                    )
+                    seen_ids.add(nid)
+
+    # R5.3: runtime_wires edges
+    wire_targets: set[str] = set()
+    for wire in getattr(module, "runtime_wires", []):
+        target = wire.target.split(".")[0]
+        if target in facts.modules and target != module.name:
+            wire_targets.add(target)
+    for target in sorted(wire_targets):
+        nid = _module_node_id(target)
+        if nid not in seen_ids:
+            depends_on.append(
+                {"id": nid, "relation": "runtime_wires", "semantic": "technical"}
+            )
+            seen_ids.add(nid)
+
     return depends_on
 
 

{codd_dev-0.4.0 → codd_dev-0.6.0}/codd/templates/extracted/architecture-overview.md.j2

@@ -58,6 +58,16 @@ Evidence: {{ cluster.evidence | join("; ") }}
 {% endfor %}
 {% endif %}
 
+{% if change_risks %}
+## Change Risk Summary
+
+| Module | Risk | Dependents | Uncovered | API Surface | Violations |
+|--------|------|------------|-----------|-------------|------------|
+{% for risk in change_risks -%}
+| `{{ risk.module }}` | {{ risk.score }} | {{ risk.factors.dependents }} | {{ risk.factors.uncovered }} | {{ risk.factors.api_surface }} | {{ risk.factors.violations }} |
+{% endfor %}
+{% endif %}
+
 ## Layer Violations
 
 {% if violations %}

{codd_dev-0.4.0 → codd_dev-0.6.0}/codd/templates/extracted/module-detail.md.j2

@@ -98,6 +98,39 @@
 {% endfor %}
 {% endif %}
 
+{% if test_coverage %}
+## Test Coverage
+
+**Coverage**: {{ test_coverage.coverage_ratio }} ({{ test_coverage.covered_symbols | length }} / {{ test_coverage.covered_symbols | length + test_coverage.uncovered_symbols | length }})
+{% if test_coverage.covering_tests %}
+Tests: {{ test_coverage.covering_tests | join(", ") }}
+{% endif %}
+{% if test_coverage.uncovered_symbols %}
+
+**Uncovered symbols**: {% for s in test_coverage.uncovered_symbols %}`{{ s }}`{% if not loop.last %}, {% endif %}{% endfor %}
+{% endif %}
+{% endif %}
+
+{% if schema_refs %}
+## Schema Dependencies
+
+| Table/Model | Kind | Location |
+|-------------|------|----------|
+{% for ref in schema_refs -%}
+| `{{ ref.table_or_model }}` | {{ ref.kind }} | `{{ ref.file }}:{{ ref.line }}` |
+{% endfor %}
+{% endif %}
+
+{% if runtime_wires %}
+## Runtime Wiring
+
+| Kind | Target | Framework | Location |
+|------|--------|-----------|----------|
+{% for wire in runtime_wires -%}
+| {{ wire.kind }} | `{{ wire.target }}` | {{ wire.framework }} | `{{ wire.source }}` |
+{% endfor %}
+{% endif %}
+
 {% if internal_dependencies %}
 ## Import Dependencies
 

codd_dev-0.6.0/codd/traceability.py

@@ -0,0 +1,67 @@
+"""R5.1 — Test traceability for codd extract.
+
+Maps test files to the source symbols they exercise, via import analysis
+of test code. Enables 'which tests to run' and 'untested symbols' queries.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from codd.extractor import ProjectFacts
+
+
+@dataclass
+class TestCoverage:
+    """Per-module test coverage summary."""
+    module: str
+    covered_symbols: list[str] = field(default_factory=list)
+    uncovered_symbols: list[str] = field(default_factory=list)
+    coverage_ratio: float = 0.0
+    covering_tests: list[str] = field(default_factory=list)
+
+
+def build_test_traceability(facts: ProjectFacts, project_root: Path) -> None:
+    """Populate ``test_coverage`` on every module in *facts*.
+
+    Strategy: For each module's test files, scan import lines and test
+    function call patterns to identify which source symbols are exercised.
+    """
+    for mod in facts.modules.values():
+        all_symbols = {s.name for s in mod.symbols}
+        if not all_symbols:
+            continue
+
+        covered: set[str] = set()
+        covering_tests: list[str] = []
+
+        for test_detail in mod.test_details:
+            covering_tests.append(test_detail.file_path)
+            # Read test file and scan for symbol references
+            test_path = project_root / test_detail.file_path
+            try:
+                test_content = test_path.read_text(errors="ignore")
+            except Exception:
+                continue
+            # Any source symbol name that appears in the test file = covered
+            for sym_name in all_symbols:
+                if sym_name in test_content:
+                    covered.add(sym_name)
+
+        # Deduplicate covering_tests
+        covering_tests = sorted(set(covering_tests))
+        covered_list = sorted(covered & all_symbols)
+        uncovered_list = sorted(all_symbols - covered)
+        total = len(all_symbols)
+        ratio = len(covered_list) / total if total else 0.0
+
+        mod.test_coverage = TestCoverage(
+            module=mod.name,
+            covered_symbols=covered_list,
+            uncovered_symbols=uncovered_list,
+            coverage_ratio=round(ratio, 2),
+            covering_tests=covering_tests,
+        )

codd_dev-0.6.0/codd/wiring.py

@@ -0,0 +1,146 @@
+"""R5.3 — Runtime wiring detection for codd extract.
+
+Detects framework-specific implicit dependencies that don't appear
+in import graphs or call graphs: DI injection, middleware chains,
+signal handlers, and decorator-based routing.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from codd.extractor import ProjectFacts
+
+
+@dataclass
+class RuntimeWire:
+    """An implicit runtime dependency detected from framework patterns."""
+    kind: str           # "depends" | "middleware" | "signal" | "decorator" | "task"
+    source: str         # file:line
+    target: str         # the function/class/module wired
+    framework: str      # "fastapi" | "django" | "flask" | "celery" | "generic"
+
+
+# ── Detection patterns ──────────────────────────────────
+
+# FastAPI Depends()
+_FASTAPI_DEPENDS_RE = re.compile(
+    r"""Depends\(\s*(\w[\w.]*)\s*\)""",
+)
+
+# Django MIDDLEWARE list
+_DJANGO_MIDDLEWARE_RE = re.compile(
+    r"""MIDDLEWARE\s*=\s*\[([^\]]*)\]""",
+    re.DOTALL,
+)
+
+# Django signals: signal.connect(handler)
+_DJANGO_SIGNAL_RE = re.compile(
+    r"""(\w+)\s*\.\s*connect\(\s*(\w[\w.]*)\s*""",
+)
+
+# Flask before/after request
+_FLASK_HOOK_RE = re.compile(
+    r"""@\s*(?:\w+\.)\s*(before_request|after_request|before_first_request|teardown_request|teardown_appcontext)\b""",
+)
+
+# Celery task
+_CELERY_TASK_RE = re.compile(
+    r"""@\s*(?:\w+\.)\s*task\b""",
+)
+
+# Generic event handler registration: on_event, add_event_handler, register
+_GENERIC_HANDLER_RE = re.compile(
+    r"""(?:on_event|add_event_handler|register_handler|subscribe)\(\s*['"](\w+)['"]\s*,\s*(\w[\w.]*)""",
+)
+
+
+def detect_runtime_wires(content: str, file_path: str) -> list[RuntimeWire]:
+    """Detect runtime wiring patterns in source code."""
+    wires: list[RuntimeWire] = []
+    lines = content.splitlines()
+
+    for line_no, line in enumerate(lines, 1):
+        source = f"{file_path}:{line_no}"
+
+        # FastAPI Depends()
+        for m in _FASTAPI_DEPENDS_RE.finditer(line):
+            wires.append(RuntimeWire(
+                kind="depends",
+                source=source,
+                target=m.group(1),
+                framework="fastapi",
+            ))
+
+        # Django signals
+        m = _DJANGO_SIGNAL_RE.search(line)
+        if m and m.group(1) in ("post_save", "pre_save", "post_delete",
+                                 "pre_delete", "m2m_changed", "post_init",
+                                 "pre_init", "request_started", "request_finished"):
+            wires.append(RuntimeWire(
+                kind="signal",
+                source=source,
+                target=m.group(2),
+                framework="django",
+            ))
+
+        # Flask hooks
+        m = _FLASK_HOOK_RE.search(line)
+        if m:
+            wires.append(RuntimeWire(
+                kind="decorator",
+                source=source,
+                target=m.group(1),
+                framework="flask",
+            ))
+
+        # Celery task
+        if _CELERY_TASK_RE.search(line):
+            wires.append(RuntimeWire(
+                kind="task",
+                source=source,
+                target="celery_task",
+                framework="celery",
+            ))
+
+        # Generic event handlers
+        m = _GENERIC_HANDLER_RE.search(line)
+        if m:
+            wires.append(RuntimeWire(
+                kind="signal",
+                source=source,
+                target=m.group(2),
+                framework="generic",
+            ))
+
+    # Django MIDDLEWARE (multiline)
+    for m in _DJANGO_MIDDLEWARE_RE.finditer(content):
+        raw = m.group(1)
+        for mw in re.findall(r"""['"]([^'"]+)['"]""", raw):
+            wires.append(RuntimeWire(
+                kind="middleware",
+                source=f"{file_path}:{content[:m.start()].count(chr(10)) + 1}",
+                target=mw,
+                framework="django",
+            ))
+
+    return wires
+
+
+def build_runtime_wires(facts: ProjectFacts, project_root: Path) -> None:
+    """Populate ``runtime_wires`` on every module in *facts*."""
+    for mod in facts.modules.values():
+        all_wires: list[RuntimeWire] = []
+        for rel_file in mod.files:
+            full = project_root / rel_file
+            try:
+                content = full.read_text(errors="ignore")
+            except Exception:
+                continue
+            wires = detect_runtime_wires(content, rel_file)
+            all_wires.extend(wires)
+        mod.runtime_wires = all_wires

{codd_dev-0.4.0 → codd_dev-0.6.0}/pyproject.toml

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