codemap-python 0.1.0__py3-none-any.whl

analysis/__init__.py

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

analysis/architecture/__init__.py

@@ -0,0 +1 @@
+

analysis/architecture/architecture_engine.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Dict, Any, Optional, Set
+
+
+def _kind_for_fqn(fqn: str, repo_prefix: str) -> str:
+    value = str(fqn or "")
+    if value.startswith("builtins."):
+        return "builtin"
+    if repo_prefix and (value == repo_prefix or value.startswith(repo_prefix + ".")):
+        return "local"
+    return "external"
+
+
+def _symbol_locations(symbol_index) -> Dict[str, Dict[str, Any]]:
+    out: Dict[str, Dict[str, Any]] = {}
+    if symbol_index is None:
+        return out
+    try:
+        symbols = symbol_index.all_symbols()
+    except Exception:
+        return out
+
+    for sym in symbols:
+        try:
+            fqn = f"{sym.module}.{sym.qualified_name}"
+            out[fqn] = {
+                "file": str(getattr(sym, "file_path", "") or ""),
+                "start_line": int(getattr(sym, "start_line", 1) or 1),
+                "end_line": int(getattr(sym, "end_line", getattr(sym, "start_line", 1)) or 1),
+            }
+        except Exception:
+            continue
+    return out
+
+
+def _infer_repo_prefix(nodes: Set[str]) -> str:
+    counts: Dict[str, int] = defaultdict(int)
+    for fqn in nodes:
+        s = str(fqn or "")
+        if not s or s.startswith("builtins."):
+            continue
+        first = s.split(".", 1)[0]
+        if first:
+            counts[first] += 1
+    if not counts:
+        return ""
+    return sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))[0][0]
+
+
+def compute_architecture_metrics(
+    callgraph,
+    symbol_index,
+    repo_prefix: Optional[str] = None,
+    top_k: int = 25,
+    fanout_threshold: int = 10,
+    fanin_threshold: int = 10,
+) -> dict:
+    forward: Dict[str, Set[str]] = defaultdict(set)
+    reverse: Dict[str, Set[str]] = defaultdict(set)
+    all_nodes: Set[str] = set()
+
+    try:
+        callers = callgraph.all_callers()
+    except Exception:
+        callers = []
+
+    for caller in callers:
+        s = str(caller or "")
+        all_nodes.add(s)
+        for cs in callgraph.callees_of(s):
+            callee = str(getattr(cs, "callee_fqn", "") or "")
+            if not callee:
+                continue
+            forward[s].add(callee)
+            reverse[callee].add(s)
+            all_nodes.add(callee)
+
+    locations = _symbol_locations(symbol_index)
+    all_nodes.update(locations.keys())
+
+    prefix = str(repo_prefix or "").strip() or _infer_repo_prefix(all_nodes)
+
+    symbols_payload: Dict[str, Dict[str, Any]] = {}
+    for fqn in sorted(all_nodes):
+        loc = locations.get(fqn, {"file": "", "start_line": 1, "end_line": 1})
+        symbols_payload[fqn] = {
+            "fan_in": len(reverse.get(fqn, set())),
+            "fan_out": len(forward.get(fqn, set())),
+            "kind": _kind_for_fqn(fqn, prefix),
+            "location": {
+                "file": str(loc.get("file", "") or ""),
+                "start_line": int(loc.get("start_line", 1) or 1),
+                "end_line": int(loc.get("end_line", loc.get("start_line", 1)) or 1),
+            },
+        }
+
+    locals_only = [f for f, s in symbols_payload.items() if s.get("kind") == "local"]
+    dead_symbols = [f for f in locals_only if symbols_payload[f]["fan_in"] == 0 and not str(f).endswith(".<module>")]
+    orchestrators = [f for f in locals_only if symbols_payload[f]["fan_out"] >= int(fanout_threshold)]
+    critical = [f for f in locals_only if symbols_payload[f]["fan_in"] >= int(fanin_threshold)]
+
+    top_fan_in = sorted(
+        [{"fqn": f, "fan_in": symbols_payload[f]["fan_in"]} for f in symbols_payload],
+        key=lambda r: (-int(r["fan_in"]), r["fqn"]),
+    )[: int(top_k)]
+    top_fan_out = sorted(
+        [{"fqn": f, "fan_out": symbols_payload[f]["fan_out"]} for f in symbols_payload],
+        key=lambda r: (-int(r["fan_out"]), r["fqn"]),
+    )[: int(top_k)]
+
+    files_payload: Dict[str, Dict[str, int]] = {}
+    incoming_per_file: Dict[str, Set[str]] = defaultdict(set)
+    outgoing_per_file: Dict[str, Set[str]] = defaultdict(set)
+    edges_per_file: Dict[str, int] = defaultdict(int)
+
+    for caller, callees in forward.items():
+        caller_file = str(symbols_payload.get(caller, {}).get("location", {}).get("file", "") or "")
+        if not caller_file:
+            continue
+        for callee in sorted(callees):
+            callee_file = str(symbols_payload.get(callee, {}).get("location", {}).get("file", "") or "")
+            outgoing_per_file[caller_file].add(caller)
+            edges_per_file[caller_file] += 1
+            if callee_file:
+                incoming_per_file[callee_file].add(callee)
+
+    all_files = set(incoming_per_file.keys()) | set(outgoing_per_file.keys()) | set(edges_per_file.keys())
+    for fp in sorted(all_files):
+        files_payload[fp] = {
+            "incoming_symbols": len(incoming_per_file.get(fp, set())),
+            "outgoing_symbols": len(outgoing_per_file.get(fp, set())),
+            "edges": int(edges_per_file.get(fp, 0)),
+        }
+
+    return {
+        "ok": True,
+        "repo_prefix": prefix,
+        "repo": {
+            "total_nodes": len(symbols_payload),
+            "dead_symbols": sorted(dead_symbols),
+            "orchestrators": sorted(orchestrators),
+            "critical_symbols": sorted(critical),
+            "top_fan_in": top_fan_in,
+            "top_fan_out": top_fan_out,
+        },
+        "symbols": symbols_payload,
+        "files": files_payload,
+        "thresholds": {
+            "fanout_threshold": int(fanout_threshold),
+            "fanin_threshold": int(fanin_threshold),
+            "top_k": int(top_k),
+        },
+    }

analysis/architecture/dependency_cycles.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Dict, List, Set, Tuple
+
+
+def _module_from_fqn(fqn: str) -> str:
+    value = str(fqn or "").strip()
+    if "." not in value:
+        return value
+    return value.rsplit(".", 1)[0]
+
+
+def build_module_dependency_graph(resolved_calls: list, repo_prefix: str) -> dict:
+    graph: Dict[str, Set[str]] = defaultdict(set)
+    prefix = str(repo_prefix or "").strip()
+    if not prefix:
+        return {}
+
+    for row in resolved_calls or []:
+        if not isinstance(row, dict):
+            continue
+        caller_fqn = str(row.get("caller_fqn", "") or "").strip()
+        callee_fqn = str(row.get("callee_fqn", "") or "").strip()
+        if not caller_fqn or not callee_fqn:
+            continue
+
+        caller_module = _module_from_fqn(caller_fqn)
+        callee_module = _module_from_fqn(callee_fqn)
+
+        if not caller_module.startswith(prefix + "."):
+            continue
+        if not callee_module.startswith(prefix + "."):
+            continue
+        if caller_module == callee_module:
+            continue
+        graph[caller_module].add(callee_module)
+        graph.setdefault(callee_module, set())
+
+    return {k: set(v) for k, v in graph.items()}
+
+
+def _normalize_cycle(cycle: List[str]) -> Tuple[str, ...]:
+    # cycle is expected without duplicated closing node.
+    if not cycle:
+        return tuple()
+    nodes = list(cycle)
+    min_idx = min(range(len(nodes)), key=lambda i: nodes[i])
+    rotated = nodes[min_idx:] + nodes[:min_idx]
+    return tuple(rotated + [rotated[0]])
+
+
+def find_dependency_cycles(graph: dict, max_cycles: int = 50, max_depth: int = 20) -> list:
+    adjacency: Dict[str, List[str]] = {
+        str(k): sorted(str(x) for x in (v or [])) for k, v in (graph or {}).items()
+    }
+
+    found: List[List[str]] = []
+    seen: Set[Tuple[str, ...]] = set()
+
+    def dfs(start: str, node: str, path: List[str], visited: Set[str]) -> None:
+        if len(found) >= int(max_cycles):
+            return
+        if len(path) >= int(max_depth):
+            return
+
+        for nxt in adjacency.get(node, []):
+            if nxt == start and len(path) >= 2:
+                norm = _normalize_cycle(path)
+                if norm and norm not in seen:
+                    seen.add(norm)
+                    found.append(list(norm))
+                    if len(found) >= int(max_cycles):
+                        return
+                continue
+            if nxt in visited:
+                continue
+            visited.add(nxt)
+            path.append(nxt)
+            dfs(start, nxt, path, visited)
+            path.pop()
+            visited.remove(nxt)
+
+    for start in sorted(adjacency.keys()):
+        dfs(start, start, [start], {start})
+        if len(found) >= int(max_cycles):
+            break
+
+    return found[: int(max_cycles)]
+
+
+def compute_dependency_cycle_metrics(resolved_calls: list, repo_prefix: str) -> dict:
+    graph = build_module_dependency_graph(resolved_calls=resolved_calls, repo_prefix=repo_prefix)
+    cycles = find_dependency_cycles(graph)
+    edges = sum(len(v) for v in graph.values())
+    return {
+        "ok": True,
+        "repo_prefix": str(repo_prefix or ""),
+        "modules": len(graph),
+        "edges": int(edges),
+        "cycle_count": len(cycles),
+        "cycles": cycles,
+    }

analysis/architecture/risk_radar.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+
+
+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 _percentile_90(values: List[int], floor: int) -> int:
+    vals = sorted(int(v) for v in values if int(v) >= 0)
+    if not vals:
+        return int(floor)
+    idx = int(0.9 * (len(vals) - 1))
+    return max(int(floor), int(vals[idx]))
+
+
+def _risk_label(score: int) -> str:
+    if score >= 70:
+        return "high"
+    if score >= 40:
+        return "medium"
+    return "low"
+
+
+def _clamp(value: int, lo: int, hi: int) -> int:
+    return max(lo, min(hi, int(value)))
+
+
+def compute_risk_radar(cache_dir: str, top_k: int = 25) -> dict:
+    arch = _load_json(os.path.join(cache_dir, "architecture_metrics.json"), {})
+    dep = _load_json(os.path.join(cache_dir, "dependency_cycles.json"), {})
+    analysis = _load_json(os.path.join(cache_dir, "analysis_metrics.json"), {})
+
+    if not isinstance(arch, dict) or not arch:
+        raise RuntimeError("Missing architecture_metrics.json")
+
+    repo_prefix = str(arch.get("repo_prefix", "") or "")
+    repo = arch.get("repo", {}) if isinstance(arch.get("repo"), dict) else {}
+    symbols = arch.get("symbols", {}) if isinstance(arch.get("symbols"), dict) else {}
+    files = arch.get("files", {}) if isinstance(arch.get("files"), dict) else {}
+
+    local_symbols = {fqn: s for fqn, s in symbols.items() if isinstance(s, dict) and str(s.get("kind", "")) == "local"}
+    fan_in_vals = [int(s.get("fan_in", 0) or 0) for s in local_symbols.values()]
+    fan_out_vals = [int(s.get("fan_out", 0) or 0) for s in local_symbols.values()]
+    file_edges_vals = [int((v or {}).get("edges", 0) or 0) for v in files.values() if isinstance(v, dict)]
+
+    fan_in_hot = _percentile_90(fan_in_vals, 10)
+    fan_out_hot = _percentile_90(fan_out_vals, 10)
+    file_edges_hot = _percentile_90(file_edges_vals, 20)
+
+    total_calls = int(analysis.get("total_calls", 0) or 0)
+    unresolved_calls = int(analysis.get("unresolved_calls", 0) or 0)
+    unresolved_ratio = float(unresolved_calls / total_calls) if total_calls > 0 else 0.0
+    cycle_count = int(dep.get("cycle_count", 0) or 0)
+
+    orchestrators = set(str(x) for x in (repo.get("orchestrators") or []))
+    critical = set(str(x) for x in (repo.get("critical_symbols") or []))
+
+    hotspots: List[Dict[str, Any]] = []
+    for fqn, sym in local_symbols.items():
+        fan_in = int(sym.get("fan_in", 0) or 0)
+        fan_out = int(sym.get("fan_out", 0) or 0)
+        score = 0
+        reasons: List[str] = []
+        flags: List[str] = []
+
+        if fan_in >= fan_in_hot:
+            score += 40
+            reasons.append("High fan-in: many callers depend on it")
+        if fan_out >= fan_out_hot:
+            score += 40
+            reasons.append("High fan-out: orchestrates many calls")
+        if fqn in orchestrators:
+            score += 15
+            flags.append("orchestrator")
+        if fqn in critical:
+            score += 15
+            flags.append("critical")
+        if str(fqn).endswith(".<module>"):
+            score += 10
+            reasons.append("Module-level script orchestration")
+            flags.append("module_level")
+        if cycle_count > 0:
+            score += 10
+            reasons.append("Repo has dependency cycles")
+            flags.append("cycle_related")
+        if unresolved_ratio > 0.2:
+            score += 10
+            reasons.append("High unresolved call ratio")
+
+        score = _clamp(score, 0, 100)
+        loc = sym.get("location", {}) if isinstance(sym.get("location"), dict) else {}
+        hotspots.append(
+            {
+                "fqn": fqn,
+                "risk": _risk_label(score),
+                "score": score,
+                "reasons": reasons,
+                "fan_in": fan_in,
+                "fan_out": fan_out,
+                "location": {
+                    "file": str(loc.get("file", "") or ""),
+                    "start_line": int(loc.get("start_line", 1) or 1),
+                    "end_line": int(loc.get("end_line", loc.get("start_line", 1)) or 1),
+                },
+                "flags": sorted(set(flags)),
+            }
+        )
+
+    hotspots = sorted(hotspots, key=lambda h: (-int(h["score"]), h["fqn"]))[: int(top_k)]
+
+    file_out_vals = sorted([int((v or {}).get("outgoing_symbols", 0) or 0) for v in files.values() if isinstance(v, dict)])
+    file_in_vals = sorted([int((v or {}).get("incoming_symbols", 0) or 0) for v in files.values() if isinstance(v, dict)])
+    out_top = file_out_vals[int(0.9 * (len(file_out_vals) - 1))] if file_out_vals else 0
+    in_top = file_in_vals[int(0.9 * (len(file_in_vals) - 1))] if file_in_vals else 0
+
+    risky_files: List[Dict[str, Any]] = []
+    for file_path, fv in files.items():
+        if not isinstance(fv, dict):
+            continue
+        edges = int(fv.get("edges", 0) or 0)
+        incoming = int(fv.get("incoming_symbols", 0) or 0)
+        outgoing = int(fv.get("outgoing_symbols", 0) or 0)
+
+        score = 0
+        reasons: List[str] = []
+        if edges >= file_edges_hot:
+            score += 60
+            reasons.append("High edge density")
+        if outgoing >= out_top and out_top > 0:
+            score += 20
+            reasons.append("Top outgoing coupling")
+        if incoming >= in_top and in_top > 0:
+            score += 20
+            reasons.append("Top incoming coupling")
+
+        score = _clamp(score, 0, 100)
+        risky_files.append(
+            {
+                "file": str(file_path),
+                "risk": _risk_label(score),
+                "score": score,
+                "edges": edges,
+                "incoming_symbols": incoming,
+                "outgoing_symbols": outgoing,
+                "reasons": reasons,
+            }
+        )
+
+    risky_files = sorted(risky_files, key=lambda r: (-int(r["score"]), r["file"]))[: int(top_k)]
+
+    by_fan_out = sorted(hotspots, key=lambda h: (-int(h.get("fan_out", 0)), h["fqn"]))
+    by_fan_in = sorted(hotspots, key=lambda h: (-int(h.get("fan_in", 0)), h["fqn"]))
+    module_level = [h for h in hotspots if "module_level" in (h.get("flags") or [])]
+
+    refactor_targets: List[Dict[str, Any]] = []
+    if by_fan_out:
+        refactor_targets.append({
+            "title": "Break down top orchestrator",
+            "why": "High fan-out symbols coordinate too many responsibilities.",
+            "targets": [h["fqn"] for h in by_fan_out[:3]],
+        })
+    if by_fan_in:
+        refactor_targets.append({
+            "title": "Stabilize critical API",
+            "why": "High fan-in symbols affect many callers and should remain stable.",
+            "targets": [h["fqn"] for h in by_fan_in[:3]],
+        })
+    if module_level:
+        refactor_targets.append({
+            "title": "Reduce script-level work",
+            "why": "Module-level orchestration is harder to test and reuse.",
+            "targets": [h["fqn"] for h in module_level[:3]],
+        })
+    if unresolved_ratio > 0.2:
+        refactor_targets.append({
+            "title": "Investigate unresolved calls",
+            "why": "Unresolved calls hide dependencies and increase uncertainty.",
+            "targets": [f"unresolved_ratio={unresolved_ratio:.2f}"],
+        })
+    if cycle_count > 0:
+        cycle_preview = dep.get("cycles", []) if isinstance(dep.get("cycles"), list) else []
+        pretty = [" -> ".join(str(x) for x in c) for c in cycle_preview[:3] if isinstance(c, list)]
+        refactor_targets.append({
+            "title": "Address dependency cycles",
+            "why": "Cycles increase coupling and make changes risky.",
+            "targets": pretty,
+        })
+
+    return {
+        "ok": True,
+        "repo_prefix": repo_prefix,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "thresholds": {
+            "fan_in_hot": int(fan_in_hot),
+            "fan_out_hot": int(fan_out_hot),
+            "file_edges_hot": int(file_edges_hot),
+            "top_k": int(top_k),
+        },
+        "repo_health": {
+            "hotspot_symbols": len(hotspots),
+            "risky_files": len(risky_files),
+            "dead_symbols": len(repo.get("dead_symbols", []) if isinstance(repo.get("dead_symbols"), list) else []),
+            "dependency_cycles": cycle_count,
+            "unresolved_ratio": round(unresolved_ratio, 6),
+        },
+        "hotspots": hotspots,
+        "risky_files": risky_files,
+        "refactor_targets": refactor_targets[:6],
+    }

analysis/call_graph/__init__.py

@@ -0,0 +1 @@
+# Call graph package

analysis/call_graph/call_extractor.py

@@ -0,0 +1,91 @@
+# AST Call detection
+
+import ast
+
+class FunctionCallVisitor(ast.NodeVisitor):
+    def __init__(self, file_path):
+        self.file_path = file_path
+        self.current_function = None
+        self.current_class = None   # already existed ✔
+        self.calls = []
+
+    # 🔑 ADDED: track class context
+    def visit_ClassDef(self, node):
+        previous_class = self.current_class
+        self.current_class = node.name
+
+        self.generic_visit(node)
+
+        self.current_class = previous_class
+
+    def visit_FunctionDef(self, node):
+        previous_function = self.current_function
+        self.current_function = node.name
+
+        self.generic_visit(node)
+
+        self.current_function = previous_function
+
+    def visit_Call(self, node):
+        if self.current_function is None:
+            return
+
+        func_name = self._get_call_name(node.func)
+
+        obj_name = None
+        call_class = self.current_class
+        call_type = "local"
+        target = func_name
+
+        # obj.foo()
+        if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name):
+            obj_name = node.func.value.id
+
+            # 🔑 ADDED: self.method() resolution
+            if obj_name == "self" and self.current_class:
+                call_type = "method"
+                target = f"{self.current_class}.{func_name}"
+            else:
+                call_type = "attribute"
+                target = f"{obj_name}.{func_name}"
+
+        # builtin function
+        elif isinstance(node.func, ast.Name):
+            if func_name in dir(__builtins__):
+                call_type = "builtin"
+                target = f"builtins.{func_name}"
+
+        if func_name:
+            self.calls.append({
+                "caller": self.current_function,
+                "class": call_class,
+                "object": obj_name,
+                "callee": func_name,
+                "line": node.lineno,
+                "file": self.file_path,
+                "call_type": call_type,     # 🔑 ADDED
+                "target": target            # 🔑 ADDED
+            })
+
+        self.generic_visit(node)
+
+    def _get_call_name(self, node):
+        # foo()
+        if isinstance(node, ast.Name):
+            return node.id
+
+        # obj.foo()
+        elif isinstance(node, ast.Attribute):
+            return node.attr
+
+        return None
+
+
+def extract_function_calls(file_path):
+    with open(file_path, "r", encoding="utf-8") as f:
+        tree = ast.parse(f.read())
+
+    visitor = FunctionCallVisitor(file_path)
+    visitor.visit(tree)
+
+    return visitor.calls

analysis/call_graph/call_graph_builder.py

@@ -0,0 +1 @@
+# Build project-level graph

analysis/call_graph/call_resolver.py

@@ -0,0 +1,56 @@
+# Resolve what is called
+# analysis/call_graph/call_resolver.py
+
+import builtins
+
+def resolve_calls(calls, local_functions, imports, class_methods):
+    import builtins
+    builtin_funcs = set(dir(builtins))
+
+    imported_names = set()
+    for imp in imports:
+        if imp["type"] == "import":
+            imported_names.add(imp["module"].split(".")[0])
+        elif imp["type"] == "from_import":
+            imported_names.add(imp["name"])
+
+    resolved = []
+
+    for call in calls:
+        callee = call["callee"]
+        caller = call["caller"]
+        class_name = call.get("class")
+        obj = call.get("object")
+
+        # 🆕 STEP-3: method resolution (ONLY self.method())
+        if obj == "self" and class_name and callee in class_methods.get(class_name, set()):
+            resolved.append({
+                **call,
+                "caller": f"{class_name}.{caller}",
+                "callee": f"{class_name}.{callee}",
+                "call_type": "method"
+            })
+            continue
+
+        if callee in local_functions:
+            call_type = "local"
+            target = callee
+
+        elif callee in imported_names:
+            call_type = "imported"
+            target = callee
+
+        elif callee in builtin_funcs:
+            call_type = "builtin"
+            target = f"builtins.{callee}"
+
+        else:
+            call_type = "unknown"
+            target = callee
+
+        resolved.append({
+            **call,
+            "call_type": call_type,
+            "target": target
+        })
+    return resolved

analysis/call_graph/context_models.py

@@ -0,0 +1 @@
+# Execution metadata models