codemap-python 0.1.0__py3-none-any.whl

analysis/graph/impact_analyzer.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import json
+import os
+from collections import defaultdict, deque
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+
+def _load_json(path: str, default: Any) -> Any:
+    if not os.path.exists(path):
+        return default
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return default
+
+
+def load_resolved_calls(cache_dir: str) -> List[dict]:
+    data = _load_json(os.path.join(cache_dir, "resolved_calls.json"), [])
+    return data if isinstance(data, list) else []
+
+
+def build_adjacency(resolved_calls: List[dict]) -> Tuple[Dict[str, Set[str]], Dict[str, Set[str]]]:
+    forward: Dict[str, Set[str]] = defaultdict(set)
+    backward: Dict[str, Set[str]] = defaultdict(set)
+    for row in resolved_calls:
+        if not isinstance(row, dict):
+            continue
+        caller = str(row.get("caller_fqn", "") or "")
+        callee = str(row.get("callee_fqn", "") or "")
+        if not caller or not callee:
+            continue
+        forward[caller].add(callee)
+        backward[callee].add(caller)
+        forward.setdefault(callee, set())
+        backward.setdefault(caller, set())
+    return forward, backward
+
+
+def infer_repo_prefix(cache_dir: str) -> str:
+    arch = _load_json(os.path.join(cache_dir, "architecture_metrics.json"), {})
+    if isinstance(arch, dict):
+        prefix = str(arch.get("repo_prefix", "") or "")
+        if prefix:
+            return prefix
+    return ""
+
+
+def resolve_target(target: str, repo_prefix: str, resolved_calls: List[dict], arch_metrics: Dict[str, Any]) -> Dict[str, Any]:
+    raw = str(target or "").strip()
+    if not raw:
+        return {"type": "symbol", "value": "", "start_nodes": []}
+
+    if "." in raw:
+        return {"type": "symbol", "value": raw, "start_nodes": [raw]}
+
+    match_suffix = raw.replace("\\", "/")
+    start_nodes: Set[str] = set()
+    for row in resolved_calls:
+        if not isinstance(row, dict):
+            continue
+        file_path = str(row.get("file", "") or "").replace("\\", "/")
+        if file_path.endswith(match_suffix):
+            caller = str(row.get("caller_fqn", "") or "")
+            if caller:
+                start_nodes.add(caller)
+
+    if not start_nodes and repo_prefix:
+        symbols = arch_metrics.get("symbols", {}) if isinstance(arch_metrics, dict) else {}
+        for fqn, meta in (symbols.items() if isinstance(symbols, dict) else []):
+            if not isinstance(meta, dict):
+                continue
+            loc = meta.get("location", {}) if isinstance(meta.get("location"), dict) else {}
+            file_path = str(loc.get("file", "") or "").replace("\\", "/")
+            if file_path.endswith(match_suffix):
+                start_nodes.add(str(fqn))
+
+    return {"type": "file", "value": raw, "start_nodes": sorted(start_nodes)}
+
+
+def _node_details(
+    fqn: str,
+    symbols: Dict[str, Any],
+    resolved_calls: List[dict],
+) -> Dict[str, Any]:
+    sym = symbols.get(fqn, {}) if isinstance(symbols, dict) and isinstance(symbols.get(fqn), dict) else {}
+    fan_in = int(sym.get("fan_in", 0) or 0)
+    fan_out = int(sym.get("fan_out", 0) or 0)
+    loc = sym.get("location", {}) if isinstance(sym.get("location"), dict) else {}
+    file_path = str(loc.get("file", "") or "")
+    line = int(loc.get("start_line", 1) or 1)
+
+    if not file_path:
+        for row in resolved_calls:
+            if not isinstance(row, dict):
+                continue
+            if str(row.get("caller_fqn", "") or "") == fqn or str(row.get("callee_fqn", "") or "") == fqn:
+                file_path = str(row.get("file", "") or "")
+                line = int(row.get("line", 1) or 1)
+                break
+
+    return {
+        "fqn": fqn,
+        "fan_in": fan_in,
+        "fan_out": fan_out,
+        "file": file_path,
+        "line": line,
+    }
+
+
+def _bfs(
+    starts: List[str],
+    adjacency: Dict[str, Set[str]],
+    depth: int,
+    max_nodes: int,
+) -> Tuple[Dict[str, int], List[Dict[str, str]], bool]:
+    visited_dist: Dict[str, int] = {}
+    edges: List[Dict[str, str]] = []
+    truncated = False
+
+    q: deque[Tuple[str, int]] = deque()
+    for s in starts:
+        q.append((s, 0))
+
+    while q:
+        node, dist = q.popleft()
+        if dist >= depth:
+            continue
+        neighbors = sorted(adjacency.get(node, set()))
+        for nxt in neighbors:
+            edges.append({"from": node, "to": nxt})
+            next_dist = dist + 1
+            prev = visited_dist.get(nxt)
+            if prev is None or next_dist < prev:
+                if len(visited_dist) >= max_nodes:
+                    truncated = True
+                    continue
+                visited_dist[nxt] = next_dist
+                q.append((nxt, next_dist))
+
+    return visited_dist, edges, truncated
+
+
+def summarize_impacted_files(nodes: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    counts: Dict[str, int] = defaultdict(int)
+    for n in nodes:
+        file_path = str(n.get("file", "") or "")
+        if file_path:
+            counts[file_path] += 1
+    rows = [{"file": f, "count": c} for f, c in counts.items()]
+    rows.sort(key=lambda r: (-int(r["count"]), r["file"]))
+    return rows
+
+
+def compute_impact(cache_dir: str, target: str, depth: int = 2, max_nodes: int = 200) -> dict:
+    depth = max(1, int(depth))
+    max_nodes = max(10, int(max_nodes))
+
+    resolved_calls = load_resolved_calls(cache_dir)
+    arch = _load_json(os.path.join(cache_dir, "architecture_metrics.json"), {})
+    if not isinstance(arch, dict):
+        arch = {}
+
+    repo_prefix = infer_repo_prefix(cache_dir)
+    symbols = arch.get("symbols", {}) if isinstance(arch.get("symbols"), dict) else {}
+    forward, backward = build_adjacency(resolved_calls)
+
+    target_info = resolve_target(target=target, repo_prefix=repo_prefix, resolved_calls=resolved_calls, arch_metrics=arch)
+    starts = [str(s) for s in (target_info.get("start_nodes") or []) if str(s)]
+
+    up_map, up_edges_raw, up_trunc = _bfs(starts=starts, adjacency=backward, depth=depth, max_nodes=max_nodes)
+    down_map, down_edges_raw, down_trunc = _bfs(starts=starts, adjacency=forward, depth=depth, max_nodes=max_nodes)
+
+    upstream_nodes = []
+    for fqn, dist in sorted(up_map.items(), key=lambda kv: (kv[1], kv[0])):
+        row = _node_details(fqn, symbols, resolved_calls)
+        row["distance"] = int(dist)
+        upstream_nodes.append(row)
+
+    downstream_nodes = []
+    for fqn, dist in sorted(down_map.items(), key=lambda kv: (kv[1], kv[0])):
+        row = _node_details(fqn, symbols, resolved_calls)
+        row["distance"] = int(dist)
+        downstream_nodes.append(row)
+
+    upstream_edges = [{"from": e["to"], "to": e["from"]} for e in up_edges_raw]
+    downstream_edges = list(down_edges_raw)
+
+    return {
+        "ok": True,
+        "repo_prefix": repo_prefix,
+        "target": {"type": target_info.get("type", "symbol"), "value": str(target_info.get("value", "") or "")},
+        "depth": depth,
+        "max_nodes": max_nodes,
+        "upstream": {
+            "nodes": upstream_nodes,
+            "edges": upstream_edges,
+            "truncated": bool(up_trunc),
+        },
+        "downstream": {
+            "nodes": downstream_nodes,
+            "edges": downstream_edges,
+            "truncated": bool(down_trunc),
+        },
+        "impacted_files": {
+            "upstream": summarize_impacted_files(upstream_nodes),
+            "downstream": summarize_impacted_files(downstream_nodes),
+        },
+    }

analysis/indexing/__init__.py

@@ -0,0 +1 @@
+# Indexing modules - Phase 4: Global knowledge layer

analysis/indexing/import_resolver.py

@@ -0,0 +1,156 @@
+# Resolves imports → actual files
+from dataclasses import dataclass
+from typing import Dict, Optional, List
+
+from analysis.indexing.symbol_index import SymbolIndex
+
+
+# ----------------------------
+# Data Model
+# ----------------------------
+
+@dataclass
+class ResolvedImport:
+    """
+    Represents a resolved import in a single file.
+    """
+    alias: str                 # local name used in file
+    module: str                # full module path
+    symbol: Optional[str]      # imported symbol (None for plain import)
+
+
+# ----------------------------
+# Import Resolver
+# ----------------------------
+
+class ImportResolver:
+    """
+    Resolves raw import statements into fully-qualified references.
+    Also stores per-module resolved import maps for later lookup.
+    """
+
+    def __init__(self, symbol_index: SymbolIndex):
+        self.symbol_index = symbol_index
+        # ✅ NEW: cache { module_name -> { alias -> ResolvedImport } }
+        self._imports_by_module: Dict[str, Dict[str, ResolvedImport]] = {}
+
+    # ----------------------------
+    # Public API
+    # ----------------------------
+    def resolve_imports(
+        self,
+        imports: List[dict],
+        current_module: str
+    ) -> Dict[str, ResolvedImport]:
+        """
+        Resolves all imports for a single file.
+
+        Returns:
+            Dict[alias -> ResolvedImport]
+        """
+        resolved: Dict[str, ResolvedImport] = {}
+
+        for imp in imports:
+            if imp["type"] == "import":
+                self._handle_import(imp, resolved)
+
+            elif imp["type"] == "from_import":
+                self._handle_from_import(imp, current_module, resolved)
+
+        return resolved
+
+    def index_module_imports(self, module_name: str, imports: List[dict]) -> Dict[str, ResolvedImport]:
+        """
+        ✅ NEW: Resolve and store imports for a module.
+        This is what your runner should call once per file.
+        """
+        resolved = self.resolve_imports(imports, module_name)
+        self._imports_by_module[module_name] = resolved
+        return resolved
+
+    def get_imports(self, module_name: str) -> Dict[str, ResolvedImport]:
+        """
+        ✅ NEW: Fetch resolved import map for a module.
+        Returns empty dict if module was never indexed.
+        """
+        return self._imports_by_module.get(module_name, {})
+
+    def clear_module(self, module_name: str):
+        """
+        ✅ Optional helper: remove cached imports for one module.
+        Useful later for incremental indexing in VS Code.
+        """
+        if module_name in self._imports_by_module:
+            del self._imports_by_module[module_name]
+
+    def clear(self):
+        """
+        ✅ Optional helper: clears all cached imports.
+        """
+        self._imports_by_module.clear()
+
+    # ----------------------------
+    # Internal Helpers
+    # ----------------------------
+    def _handle_import(self, imp: dict, resolved: Dict[str, ResolvedImport]):
+        """
+        Handles: import a.b.c as x
+        """
+        module = imp["module"]
+        alias = imp["alias"] if imp.get("alias") else module.split(".")[-1]
+
+        resolved[alias] = ResolvedImport(
+            alias=alias,
+            module=module,
+            symbol=None
+        )
+
+    def _handle_from_import(
+        self,
+        imp: dict,
+        current_module: str,
+        resolved: Dict[str, ResolvedImport]
+    ):
+        """
+        Handles: from a.b import c as d
+        Also supports relative imports.
+        """
+        base_module = imp["module"]
+        name = imp["name"]
+        alias = imp["alias"] if imp.get("alias") else name
+        level = imp.get("level", 0)
+
+        # Resolve relative imports
+        if level > 0:
+            base_module = self._resolve_relative_module(
+                current_module=current_module,
+                level=level,
+                target_module=base_module
+            )
+
+        resolved[alias] = ResolvedImport(
+            alias=alias,
+            module=base_module,
+            symbol=name
+        )
+
+    def _resolve_relative_module(
+        self,
+        current_module: str,
+        level: int,
+        target_module: Optional[str]
+    ) -> str:
+        """
+        Resolves relative imports like:
+        from ..utils import helper
+        """
+        parts = current_module.split(".")
+
+        if level > len(parts):
+            return target_module or ""
+
+        base = parts[:-level]
+        if target_module:
+            return ".".join(base + [target_module])
+
+        return ".".join(base)

analysis/indexing/symbol_index.py

@@ -0,0 +1,150 @@
+import ast
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Optional, Tuple
+
+
+class SymbolKind(Enum):
+    FUNCTION = "function"
+    CLASS = "class"
+    METHOD = "method"
+    MODULE = "module"
+    BUILTIN = "builtin"
+    EXTERNAL = "external"
+
+
+@dataclass
+class SymbolInfo:
+    name: str
+    qualified_name: str
+    kind: SymbolKind
+    module: str
+    file_path: str
+    start_line: int
+    end_line: int
+    class_name: Optional[str] = None
+    metadata: Dict = field(default_factory=dict)
+
+
+class SymbolIndex:
+    """Global registry of all symbols across the codebase."""
+
+    def __init__(self):
+        self._symbols: List[SymbolInfo] = []
+        self._by_name: Dict[str, List[SymbolInfo]] = {}
+        self._by_fqn: Dict[Tuple[str, str], SymbolInfo] = {}
+
+    def add_symbol(self, symbol: SymbolInfo):
+        key = (symbol.module, symbol.qualified_name)
+        if key in self._by_fqn:
+            return
+        self._symbols.append(symbol)
+        self._by_fqn[key] = symbol
+        self._by_name.setdefault(symbol.name, []).append(symbol)
+
+    def index_file(self, ast_tree: ast.AST, module: str, file_path: str):
+        max_line = 1
+        for node in ast.walk(ast_tree):
+            ln = getattr(node, "lineno", None)
+            end_ln = getattr(node, "end_lineno", None)
+            if isinstance(ln, int):
+                max_line = max(max_line, ln)
+            if isinstance(end_ln, int):
+                max_line = max(max_line, end_ln)
+
+        self.add_symbol(
+            SymbolInfo(
+                name="<module>",
+                qualified_name="<module>",
+                kind=SymbolKind.MODULE,
+                module=module,
+                file_path=file_path,
+                start_line=1,
+                end_line=max_line,
+            )
+        )
+
+        for node in ast.walk(ast_tree):
+            if isinstance(node, ast.FunctionDef):
+                symbol = SymbolInfo(
+                    name=node.name,
+                    qualified_name=node.name,
+                    kind=SymbolKind.FUNCTION,
+                    module=module,
+                    file_path=file_path,
+                    start_line=int(getattr(node, "lineno", 1) or 1),
+                    end_line=int(getattr(node, "end_lineno", getattr(node, "lineno", 1)) or getattr(node, "lineno", 1)),
+                )
+                self.add_symbol(symbol)
+
+            elif isinstance(node, ast.ClassDef):
+                class_symbol = SymbolInfo(
+                    name=node.name,
+                    qualified_name=node.name,
+                    kind=SymbolKind.CLASS,
+                    module=module,
+                    file_path=file_path,
+                    start_line=int(getattr(node, "lineno", 1) or 1),
+                    end_line=int(getattr(node, "end_lineno", getattr(node, "lineno", 1)) or getattr(node, "lineno", 1)),
+                )
+                self.add_symbol(class_symbol)
+
+                for item in node.body:
+                    if isinstance(item, ast.FunctionDef):
+                        method_symbol = SymbolInfo(
+                            name=item.name,
+                            qualified_name=f"{node.name}.{item.name}",
+                            kind=SymbolKind.METHOD,
+                            module=module,
+                            file_path=file_path,
+                            start_line=int(getattr(item, "lineno", 1) or 1),
+                            end_line=int(getattr(item, "end_lineno", getattr(item, "lineno", 1)) or getattr(item, "lineno", 1)),
+                            class_name=node.name,
+                        )
+                        self.add_symbol(method_symbol)
+
+    def load_snapshot(self, snapshot: List[Dict]):
+        self.clear()
+        if not isinstance(snapshot, list):
+            return
+        for row in snapshot:
+            if not isinstance(row, dict):
+                continue
+            kind_raw = str(row.get("kind", "function") or "function").lower()
+            try:
+                kind = SymbolKind(kind_raw)
+            except Exception:
+                kind = SymbolKind.FUNCTION
+            sym = SymbolInfo(
+                name=str(row.get("name", "") or ""),
+                qualified_name=str(row.get("qualified_name", "") or ""),
+                kind=kind,
+                module=str(row.get("module", "") or ""),
+                file_path=str(row.get("file_path", "") or ""),
+                start_line=int(row.get("start_line", 1) or 1),
+                end_line=int(row.get("end_line", row.get("start_line", 1)) or row.get("start_line", 1)),
+                class_name=row.get("class_name"),
+                metadata=row.get("metadata", {}) if isinstance(row.get("metadata"), dict) else {},
+            )
+            if sym.module and sym.qualified_name:
+                self.add_symbol(sym)
+
+    def get_by_name(self, name: str) -> List[SymbolInfo]:
+        return self._by_name.get(name, [])
+
+    def get(self, module: str, qualified_name: str) -> Optional[SymbolInfo]:
+        return self._by_fqn.get((module, qualified_name))
+
+    def all_symbols(self) -> List[SymbolInfo]:
+        return list(self._symbols)
+
+    def remove_by_file(self, file_path: str):
+        keep = [s for s in self._symbols if s.file_path != file_path]
+        self.clear()
+        for s in keep:
+            self.add_symbol(s)
+
+    def clear(self):
+        self._symbols.clear()
+        self._by_name.clear()
+        self._by_fqn.clear()

analysis/runners/__init__.py

@@ -0,0 +1 @@
+# Phase controllers

analysis/runners/phase4_runner.py

@@ -0,0 +1,137 @@
+# Orchestrates Phase-4 pipeline
+from __future__ import annotations
+
+from typing import Optional, Dict, Any, List
+
+import os
+import ast
+import json
+from analysis.indexing.symbol_index import SymbolIndex
+from analysis.indexing.import_resolver import ImportResolver
+from analysis.call_graph.cross_file_resolver import CrossFileResolver
+from analysis.call_graph.call_extractor import extract_function_calls
+from analysis.core.import_extractor import extract_imports
+from analysis.graph.callgraph_index import build_caller_fqn
+
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(__file__))
+
+
+def collect_python_files(root_dir: str) -> List[str]:
+    ignore_dirs = {".git", "__pycache__", ".codemap_cache", "node_modules", ".venv", "venv"}
+    py_files: List[str] = []
+    for root, dirs, files in os.walk(root_dir):
+        dirs[:] = [d for d in dirs if d not in ignore_dirs]
+        for file in files:
+            if file.endswith(".py") and not file.startswith("__"):
+                py_files.append(os.path.join(root, file))
+    return py_files
+
+
+def parse_ast(file_path: str):
+    with open(file_path, "r", encoding="utf-8") as f:
+        return ast.parse(f.read())
+
+
+def file_to_module(file_path: str, repo_root: str) -> str:
+    repo_root = os.path.abspath(repo_root)
+    file_path = os.path.abspath(file_path)
+
+    rel = os.path.relpath(file_path, repo_root).replace(os.sep, ".")
+    if rel.endswith(".py"):
+        rel = rel[:-3]
+
+    repo_name = os.path.basename(repo_root.rstrip("\\/"))
+    return f"{repo_name}.{rel}"
+
+
+def _symbol_snapshot(symbol_index: SymbolIndex) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    for sym in symbol_index.all_symbols():
+        rows.append(
+            {
+                "name": str(sym.name),
+                "qualified_name": str(sym.qualified_name),
+                "kind": str(getattr(sym.kind, "value", str(sym.kind))),
+                "module": str(sym.module),
+                "file_path": str(sym.file_path),
+                "start_line": int(sym.start_line),
+                "end_line": int(sym.end_line),
+                "class_name": sym.class_name,
+                "metadata": dict(sym.metadata or {}),
+            }
+        )
+    return rows
+
+
+def run(repo_dir: Optional[str] = None, output_dir: Optional[str] = None, force_rebuild: bool = False) -> Dict[str, Any]:
+    analysis_root = os.path.dirname(os.path.dirname(__file__))
+
+    if repo_dir is None:
+        repo_dir = os.path.join(analysis_root, "testing_repo")
+
+    if output_dir is None:
+        output_dir = os.path.join(analysis_root, "output")
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    python_files = collect_python_files(repo_dir)
+    symbol_index = SymbolIndex()
+    file_module_map: Dict[str, str] = {}
+
+    for file_path in python_files:
+        module_path = file_to_module(file_path, repo_dir)
+        file_module_map[file_path] = module_path
+        tree = parse_ast(file_path)
+        symbol_index.index_file(tree, module_path, file_path)
+
+    import_resolver = ImportResolver(symbol_index)
+    for file_path in python_files:
+        module_path = file_module_map[file_path]
+        imports = extract_imports(file_path)
+        import_resolver.index_module_imports(module_path, imports)
+
+    all_calls = []
+    for file_path in python_files:
+        all_calls.extend(extract_function_calls(file_path))
+
+    cross_resolver = CrossFileResolver(symbol_index, import_resolver)
+    resolved_calls = []
+    for call in all_calls:
+        call_file = call.get("file")
+        current_module = file_module_map.get(call_file)
+        symbol = cross_resolver.resolve_call(call, current_module)
+        caller_fqn = build_caller_fqn(call, current_module)
+        callee_fqn = f"{symbol.module}.{symbol.qualified_name}" if symbol else None
+        resolved_calls.append({
+            **call,
+            "caller_fqn": caller_fqn,
+            "callee_fqn": callee_fqn,
+            "resolved_target": callee_fqn,
+        })
+
+    resolved_calls_path = os.path.join(output_dir, "resolved_calls.json")
+    with open(resolved_calls_path, "w", encoding="utf-8") as f:
+        json.dump(resolved_calls, f, indent=2)
+
+    return {
+        "resolved_calls_path": resolved_calls_path,
+        "total_calls": len(resolved_calls),
+        "incremental": False,
+        "reindexed_files": len(python_files),
+        "impacted_files": len(python_files),
+        "symbol_snapshot": _symbol_snapshot(symbol_index),
+        "imports_snapshot": {},
+        "file_module_map": file_module_map,
+        "force_rebuild": bool(force_rebuild),
+    }
+
+
+def main():
+    result = run()
+    print(f"Saved: {result['resolved_calls_path']}")
+    print(f"Total calls: {result['total_calls']}")
+
+
+if __name__ == "__main__":
+    main()

analysis/utils/__init__.py

@@ -0,0 +1 @@
+# Utils package

analysis/utils/ast_helpers.py

@@ -0,0 +1 @@
+# AST name helpers