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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 0.4.0
+Version: 0.5.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.5.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.5.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.5.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.5.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
@@ -266,6 +267,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
 
@@ -367,6 +371,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.5.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.5.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.5.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.5.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.5.0}/pyproject.toml

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