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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 0.5.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.5.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.5.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.5.0 → codd_dev-0.6.0}/codd/synth.py

@@ -242,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,
@@ -280,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()),
@@ -302,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,
@@ -318,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,
@@ -326,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)

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

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