codemap-python 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

analysis/call_graph/call_extractor.py

@@ -85,8 +85,11 @@ class FunctionCallVisitor(ast.NodeVisitor):
 def extract_function_calls(file_path):
     source = read_source_file(file_path)
     tree = parse_source_to_ast(source, file_path=file_path)
-
-    visitor = FunctionCallVisitor(file_path)
-    visitor.visit(tree)
-
-    return visitor.calls
+    return extract_function_calls_from_tree(tree, file_path)
+
+
+def extract_function_calls_from_tree(tree, file_path):
+    visitor = FunctionCallVisitor(file_path)
+    visitor.visit(tree)
+
+    return visitor.calls

analysis/core/import_extractor.py

@@ -3,43 +3,47 @@
 
 import ast
 from analysis.utils.bom_handler import read_source_file, parse_source_to_ast
-
-
+
+
+def extract_imports_from_tree(tree, file_path):
+    """Extract imports from an already-parsed AST tree."""
+    imports = []
+
+    for node in ast.walk(tree):
+
+        # import module
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append({
+                    "type": "import",
+                    "module": alias.name,
+                    "name": None,
+                    "alias": alias.asname,
+                    "line": node.lineno,
+                    "file": file_path
+                })
+
+        # from module import name
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module
+            level = node.level  # 0 = absolute, >0 = relative
+
+            for alias in node.names:
+                imports.append({
+                    "type": "from_import",
+                    "module": module,
+                    "name": alias.name,
+                    "alias": alias.asname,
+                    "level": level,
+                    "line": node.lineno,
+                    "file": file_path
+                })
+
+    return imports
+
+
 def extract_imports(file_path):
     """Extract imports from a Python file with automatic encoding and BOM handling."""
     source = read_source_file(file_path)
     tree = parse_source_to_ast(source, file_path=file_path)
-    
-    imports = []
-
-    for node in ast.walk(tree):
-
-        # import module
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                imports.append({
-                    "type": "import",
-                    "module": alias.name,
-                    "name": None,
-                    "alias": alias.asname,
-                    "line": node.lineno,
-                    "file": file_path
-                })
-
-        # from module import name
-        elif isinstance(node, ast.ImportFrom):
-            module = node.module
-            level = node.level  # 0 = absolute, >0 = relative
-
-            for alias in node.names:
-                imports.append({
-                    "type": "from_import",
-                    "module": module,
-                    "name": alias.name,
-                    "alias": alias.asname,
-                    "level": level,
-                    "line": node.lineno,
-                    "file": file_path
-                })
-
-    return imports
+    return extract_imports_from_tree(tree, file_path)

analysis/explain/explain_runner.py

@@ -7,22 +7,24 @@ from typing import Optional, Dict, Any
 
 import json
 import os
-
-from analysis.indexing.symbol_index import SymbolIndex, SymbolInfo
-from analysis.graph.callgraph_index import CallGraphIndex, CallSite
-from analysis.explain.docstring_extractor import extract_docstrings
-from analysis.explain.signature_extractor import extract_signatures
-from analysis.explain.return_analyzer import analyze_returns
-from analysis.explain.summary_generator import generate_symbol_summary
-
-
-def collect_python_files(root_dir: str):
-    py_files = []
-    for root, _, files in os.walk(root_dir):
-        for file in files:
-            if file.endswith(".py") and not file.startswith("__"):
-                py_files.append(os.path.join(root, file))
-    return py_files
+
+from analysis.indexing.symbol_index import SymbolIndex, SymbolInfo
+from analysis.graph.callgraph_index import CallGraphIndex, CallSite
+from analysis.explain.docstring_extractor import extract_docstrings
+from analysis.explain.signature_extractor import extract_signatures
+from analysis.explain.return_analyzer import analyze_returns
+from analysis.explain.summary_generator import generate_symbol_summary
+from analysis.utils.repo_walk import filter_skipped_dirs
+
+
+def collect_python_files(root_dir: str):
+    py_files = []
+    for root, dirs, files in os.walk(root_dir):
+        dirs[:] = filter_skipped_dirs(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):
@@ -78,7 +80,11 @@ def merge_maps(dst: dict, src: dict):
         dst[k].update(src.get(k, {}))
 
 
-def run(repo_dir: Optional[str] = None, output_dir: Optional[str] = None) -> Dict[str, Any]:
+def run(
+    repo_dir: Optional[str] = None,
+    output_dir: Optional[str] = None,
+    symbol_snapshot: Optional[list] = None,
+) -> Dict[str, Any]:
     """
     Callable explain pipeline (Phase-5/6), suitable for CLI/VS Code.
 
@@ -114,23 +120,25 @@ def run(repo_dir: Optional[str] = None, output_dir: Optional[str] = None) -> Dic
     # 2) Collect repo python files
     python_files = collect_python_files(repo_dir)
 
-    # 3) Build symbol index + extractors across repo
-    symbol_index = SymbolIndex()
-
-    repo_docstrings = {"module": None, "classes": {}, "functions": {}, "methods": {}}
-    repo_signatures = {"functions": {}, "methods": {}}
-    repo_returns = {"functions": {}, "methods": {}}
-
-    for file_path in python_files:
-        tree = parse_ast(file_path)
-        module_path = file_to_module(file_path, repo_dir)
-
-
-        # index symbols
-        symbol_index.index_file(tree, module_path, file_path)
-
-        # extract per-file and merge
-        merge_maps(repo_docstrings, extract_docstrings(tree))
+    # 3) Build symbol index + extractors across repo
+    symbol_index = SymbolIndex()
+    loaded_snapshot = False
+    if isinstance(symbol_snapshot, list) and symbol_snapshot:
+        symbol_index.load_snapshot(symbol_snapshot)
+        loaded_snapshot = True
+
+    repo_docstrings = {"module": None, "classes": {}, "functions": {}, "methods": {}}
+    repo_signatures = {"functions": {}, "methods": {}}
+    repo_returns = {"functions": {}, "methods": {}}
+
+    for file_path in python_files:
+        tree = parse_ast(file_path)
+        if not loaded_snapshot:
+            module_path = file_to_module(file_path, repo_dir)
+            symbol_index.index_file(tree, module_path, file_path)
+
+        # extract per-file and merge
+        merge_maps(repo_docstrings, extract_docstrings(tree))
 
         sigs = extract_signatures(tree)
         repo_signatures["functions"].update(sigs.get("functions", {}))

analysis/explain/summary_generator.py

@@ -11,11 +11,14 @@ from analysis.indexing.symbol_index import SymbolInfo
 from analysis.graph.callgraph_index import CallGraphIndex
 
 
-def _first_line(text: Optional[str]) -> Optional[str]:
-    if not text:
-        return None
-    line = text.strip().splitlines()[0].strip()
-    return line or None
+def _first_line(text: Optional[str]) -> Optional[str]:
+    if not text:
+        return None
+    stripped = text.strip()
+    if not stripped:
+        return None
+    line = stripped.splitlines()[0].strip()
+    return line or None
 
 
 def _humanize_name(name: str) -> str:

analysis/runners/phase4_runner.py

@@ -5,25 +5,25 @@ from typing import Optional, Dict, Any, List
 
 import os
 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
+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_tree
+from analysis.core.import_extractor import extract_imports_from_tree
+from analysis.graph.callgraph_index import build_caller_fqn
+from analysis.utils.repo_walk import filter_skipped_dirs
 
 
 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))
+def collect_python_files(root_dir: str) -> List[str]:
+    py_files: List[str] = []
+    for root, dirs, files in os.walk(root_dir):
+        dirs[:] = filter_skipped_dirs(dirs)
+        for file in files:
+            if file.endswith(".py") and not file.startswith("__"):
+                py_files.append(os.path.join(root, file))
     return py_files
 
 
@@ -75,25 +75,27 @@ def run(repo_dir: Optional[str] = None, output_dir: Optional[str] = None, force_
 
     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))
+    python_files = collect_python_files(repo_dir)
+    symbol_index = SymbolIndex()
+    file_module_map: Dict[str, str] = {}
+    parsed_trees: Dict[str, Any] = {}
+
+    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)
+        parsed_trees[file_path] = tree
+        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_from_tree(parsed_trees[file_path], file_path)
+        import_resolver.index_module_imports(module_path, imports)
+
+    all_calls = []
+    for file_path in python_files:
+        all_calls.extend(extract_function_calls_from_tree(parsed_trees[file_path], file_path))
 
     cross_resolver = CrossFileResolver(symbol_index, import_resolver)
     resolved_calls = []

analysis/utils/cache_manager.py

@@ -5,15 +5,15 @@ import json
 import os
 import shutil
 import tempfile
-from datetime import datetime, timezone
-from threading import RLock
-from typing import Any, Dict, List, Optional, Tuple
-
-from security_utils import redact_secrets
-
-_LOCK = RLock()
-_SENSITIVE_KEYS = ("api_key", "token", "authorization", "bearer", "basic", "secret", "password")
-_SKIP_DIRS = {".git", "__pycache__", ".codemap_cache", ".venv", "venv", "node_modules"}
+from datetime import datetime, timezone
+from threading import RLock
+from typing import Any, Dict, List, Optional, Tuple
+
+from analysis.utils.repo_walk import filter_skipped_dirs
+from security_utils import redact_secrets
+
+_LOCK = RLock()
+_SENSITIVE_KEYS = ("api_key", "token", "authorization", "bearer", "basic", "secret", "password")
 
 
 def _project_root() -> str:
@@ -195,14 +195,14 @@ def save_policy(policy: Dict[str, Any], base_dir: Optional[str] = None) -> Dict[
 
 def collect_fingerprints(repo_dir: str) -> Dict[str, Dict[str, int]]:
     repo_root = os.path.abspath(repo_dir)
-    out: Dict[str, Dict[str, int]] = {}
-    if not os.path.isdir(repo_root):
-        return out
-    for root, dirs, files in os.walk(repo_root):
-        dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
-        for name in files:
-            if not name.endswith(".py"):
-                continue
+    out: Dict[str, Dict[str, int]] = {}
+    if not os.path.isdir(repo_root):
+        return out
+    for root, dirs, files in os.walk(repo_root):
+        dirs[:] = filter_skipped_dirs(dirs)
+        for name in files:
+            if not name.endswith(".py"):
+                continue
             fp = os.path.join(root, name)
             try:
                 st = os.stat(fp)
@@ -250,16 +250,21 @@ def save_manifest(repo_dir: str, manifest: Dict[str, Any], base_dir: Optional[st
         _atomic_json_write(_manifest_path(repo_dir, base_dir), _scrub_payload(payload))
 
 
-def should_rebuild(repo_dir: str, analysis_version: str = "2.2", base_dir: Optional[str] = None) -> bool:
+def should_rebuild(
+    repo_dir: str,
+    analysis_version: str = "2.2",
+    base_dir: Optional[str] = None,
+    current_fingerprints: Optional[Dict[str, Any]] = None,
+) -> bool:
     manifest = load_manifest(repo_dir, base_dir=base_dir)
     if not manifest:
         return True
     if str(manifest.get("analysis_version", "") or "") != str(analysis_version or ""):
         return True
     previous = manifest.get("fingerprints", {}) if isinstance(manifest.get("fingerprints"), dict) else {}
-    current = collect_fingerprints(repo_dir)
-    delta = diff_fingerprints(previous, current)
-    return bool(delta.get("changed_count", 0))
+    current = current_fingerprints if isinstance(current_fingerprints, dict) else collect_fingerprints(repo_dir)
+    delta = diff_fingerprints(previous, current)
+    return bool(delta.get("changed_count", 0))
 
 
 def _default_metadata(repo_hash: str) -> Dict[str, Any]:

analysis/utils/repo_walk.py

@@ -0,0 +1,27 @@
+"""Shared repository walking rules for source analysis."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+
+SKIP_DIR_NAMES = {
+    ".git",
+    "__pycache__",
+    ".codemap_cache",
+    ".venv",
+    "venv",
+    "env",
+    "ENV",
+    ".env",
+    "node_modules",
+    "site-packages",
+    "dist-packages",
+    ".tox",
+    ".nox",
+}
+
+
+def filter_skipped_dirs(dir_names: Iterable[str]) -> list[str]:
+    """Return directory names that should still be traversed."""
+    return [name for name in dir_names if name not in SKIP_DIR_NAMES]

cli.py → codemap_app.py

@@ -1,20 +1,22 @@
-import argparse
-import json
-import os
-import shutil
-import sys
-import webbrowser
-from datetime import datetime, timezone
-from typing import Dict, Any, List, Optional, Tuple
-
-from security_utils import redact_payload, redact_secrets
+import argparse
+import json
+import os
+import shutil
+import sys
+import time
+import webbrowser
+from datetime import datetime, timezone
+from typing import Dict, Any, List, Optional, Tuple
+
+from analysis.utils.repo_walk import filter_skipped_dirs
+from security_utils import redact_payload, redact_secrets
 
 def print_json(obj) -> None:
     safe_obj = redact_payload(obj)
     sys.stdout.write(json.dumps(safe_obj, indent=2))
     sys.stdout.write("\n")
 
-MISSING_ANALYSIS_MESSAGE = "Run: python cli.py api analyze --path <repo>"
+MISSING_ANALYSIS_MESSAGE = "Run: python codemap_app.py api analyze --path <repo>"
 ANALYSIS_VERSION = "2.2"
 
 
@@ -35,8 +37,8 @@ def _print_public_help() -> int:
 
 
 
-def _analysis_root() -> str:
-    # cli.py is at project root; analysis/ is sibling
+def _analysis_root() -> str:
+    # codemap_app.py is at project root; analysis/ is sibling
     return os.path.join(os.path.dirname(__file__), "analysis")
 
 
@@ -267,16 +269,16 @@ def api_cache_help(_args) -> int:
     print_json({
         "ok": True,
         "commands": [
-            "python cli.py api cache list",
-            "python cli.py api cache info --path <repo>",
-            "python cli.py api cache info --github <url> --ref <ref> --mode <git|zip>",
-            "python cli.py api cache clear --path <repo> [--dry-run] [--yes]",
-            "python cli.py api cache clear --repo-hash <hash> [--dry-run] [--yes]",
-            "python cli.py api cache clear --all [--dry-run] --yes",
-            "python cli.py api cache retention --path <repo> --days 7 --yes",
-            "python cli.py api cache retention --repo-hash <hash> --days 30 --yes",
-            "python cli.py api cache sweep --dry-run",
-            "python cli.py api cache sweep --yes",
+            "python codemap_app.py api cache list",
+            "python codemap_app.py api cache info --path <repo>",
+            "python codemap_app.py api cache info --github <url> --ref <ref> --mode <git|zip>",
+            "python codemap_app.py api cache clear --path <repo> [--dry-run] [--yes]",
+            "python codemap_app.py api cache clear --repo-hash <hash> [--dry-run] [--yes]",
+            "python codemap_app.py api cache clear --all [--dry-run] --yes",
+            "python codemap_app.py api cache retention --path <repo> --days 7 --yes",
+            "python codemap_app.py api cache retention --repo-hash <hash> --days 30 --yes",
+            "python codemap_app.py api cache sweep --dry-run",
+            "python codemap_app.py api cache sweep --yes",
         ],
     })
     return 0
@@ -354,7 +356,7 @@ def api_cache_info(args) -> int:
 
     target = _resolve_cache_target(args)
     if not target.get("ok"):
-        print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python cli.py api cache help"})
+        print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python codemap_app.py api cache help"})
         return 1
 
     cache_item = next((c for c in list_caches() if str(c.get("repo_hash")) == str(target["repo_hash"])), None)
@@ -363,7 +365,7 @@ def api_cache_info(args) -> int:
             "ok": False,
             "error": "CACHE_NOT_FOUND",
             "message": f"Cache directory not found: {target['cache_dir']}",
-            "hint": "Run: python cli.py api analyze --path <repo>",
+            "hint": "Run: python codemap_app.py api analyze --path <repo>",
         })
         return 1
 
@@ -385,9 +387,9 @@ def api_cache_info(args) -> int:
     }
     notes = []
     if files["explain_path"] is None:
-        notes.append("missing explain.json; run: python cli.py api analyze --path <repo>")
+        notes.append("missing explain.json; run: python codemap_app.py api analyze --path <repo>")
     if files["resolved_calls_path"] is None:
-        notes.append("missing resolved_calls.json; run: python cli.py api analyze --path <repo>")
+        notes.append("missing resolved_calls.json; run: python codemap_app.py api analyze --path <repo>")
 
     print_json({
         "ok": True,
@@ -446,7 +448,7 @@ def api_cache_clear(args) -> int:
     if not repo_hash_arg:
         target = _resolve_cache_target(args)
         if not target.get("ok"):
-            print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python cli.py api cache help"})
+            print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python codemap_app.py api cache help"})
             return 1
         repo_hash_arg = str(target["repo_hash"])
 
@@ -476,7 +478,7 @@ def api_cache_retention(args) -> int:
     if not repo_hash_arg:
         target = _resolve_cache_target(args)
         if not target.get("ok"):
-            print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python cli.py api cache help"})
+            print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python codemap_app.py api cache help"})
             return 1
         repo_hash_arg = str(target["repo_hash"])
 
@@ -508,7 +510,7 @@ def api_cache_delete(args) -> int:
 
     target = _resolve_cache_target(args)
     if not target.get("ok"):
-        print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python cli.py api cache help"})
+        print_json({"ok": False, "error": target.get("error"), "message": target.get("message"), "hint": "Use: python codemap_app.py api cache help"})
         return 1
 
     dry_run = bool(getattr(args, "dry_run", False))
@@ -671,20 +673,19 @@ def api_cache_sweep(args) -> int:
     return api_cache_cleanup(args)
 
 
-def _build_project_tree_snapshot(repo_dir: str) -> Dict[str, Any]:
-    repo_dir = os.path.abspath(repo_dir)
-    ignore_dirs = {".git", ".codemap_cache", "__pycache__", ".venv", "venv", "node_modules"}
-    root = {
-        "name": os.path.basename(repo_dir.rstrip("\\/")) or repo_dir,
-        "type": "directory",
-        "path": "",
-        "children": [],
+def _build_project_tree_snapshot(repo_dir: str) -> Dict[str, Any]:
+    repo_dir = os.path.abspath(repo_dir)
+    root = {
+        "name": os.path.basename(repo_dir.rstrip("\\/")) or repo_dir,
+        "type": "directory",
+        "path": "",
+        "children": [],
     }
     nodes: Dict[str, Dict[str, Any]] = {"": root}
-
-    for current_root, dirs, files in os.walk(repo_dir):
-        dirs[:] = sorted([d for d in dirs if d not in ignore_dirs and not d.startswith(".")])
-        files = sorted([f for f in files if not f.startswith(".")])
+
+    for current_root, dirs, files in os.walk(repo_dir):
+        dirs[:] = sorted([d for d in filter_skipped_dirs(dirs) if not d.startswith(".")])
+        files = sorted([f for f in files if not f.startswith(".")])
 
         rel_root = os.path.relpath(current_root, repo_dir)
         rel_root = "" if rel_root == "." else rel_root.replace("\\", "/")
@@ -736,7 +737,7 @@ def load_explain_db(repo: Optional[str] = None) -> Dict[str, Any]:
     path = paths["explain_path"]
     if not os.path.exists(path):
         hint = (
-            "Run:\n  python cli.py api analyze --path <repo>\n"
+            "Run:\n  python codemap_app.py api analyze --path <repo>\n"
             "to build repo-scoped cache before querying with --repo."
             if repo else
             "Run:\n  python -m analysis.explain.explain_runner\n"
@@ -802,7 +803,7 @@ def cmd_explain(args) -> int:
             for s in suggestions:
                 print(f"  - {s}")
         else:
-            print("No similar symbols found. Try: python cli.py search <keyword>")
+            print("No similar symbols found. Try: python codemap_app.py search <keyword>")
         print()
         return 1
 
@@ -996,7 +997,7 @@ def api_repo_summary(args) -> int:
             "repo_hash": compute_repo_hash(repo_dir),
             "cached": False,
             "summary": {},
-            "error": "Missing architecture cache. Run: python cli.py api analyze --path <repo>",
+            "error": "Missing architecture cache. Run: python codemap_app.py api analyze --path <repo>",
         })
         return 1
 
@@ -1269,40 +1270,77 @@ def api_analyze(args) -> int:
     llm_cache_path = os.path.join(cache_dir, "llm_cache.json")
     project_tree_path = os.path.join(cache_dir, "project_tree.json")
 
-    previous_manifest = load_manifest(repo_dir)
-    previous_fingerprints = previous_manifest.get("fingerprints", {})
-    current_fingerprints = collect_fingerprints(repo_dir)
-    delta = diff_fingerprints(previous_fingerprints, current_fingerprints)
-    version_mismatch = previous_manifest.get("analysis_version") != ANALYSIS_VERSION
-
-    rebuild_required = bool(force_full_rebuild or should_rebuild(repo_dir, analysis_version=ANALYSIS_VERSION))
-    architecture_missing = not os.path.exists(architecture_metrics_path)
-    dependency_missing = not os.path.exists(dependency_cycles_path)
-    risk_missing = not os.path.exists(risk_radar_path)
-    r1 = {}
-    r2 = {}
-    metrics = {}
-
-    # Start progress spinner for large repositories
-    spinner = ProgressSpinner("Analyzing repository...")
-    spinner.start()
-
-    try:
-        if rebuild_required:
-            r1 = run_phase4(
-                repo_dir=repo_dir,
-                output_dir=cache_dir,
-                force_rebuild=bool(version_mismatch or force_full_rebuild),
-            )
-            r2 = run_explain(repo_dir=repo_dir, output_dir=cache_dir)
-            resolved_calls_path = r1.get("resolved_calls_path", resolved_calls_path)
-            metrics = write_hub_metrics_from_resolved_calls(
-                resolved_calls_path=resolved_calls_path,
-                output_path=analysis_metrics_path,
-            )
-            save_manifest(
-                repo_dir,
-                build_manifest(
+    overall_started = time.perf_counter()
+    stage_timings: Dict[str, float] = {}
+    current_stage = "initializing"
+    stage_started = overall_started
+
+    def _start_stage(stage_name: str, spinner_message: Optional[str] = None) -> None:
+        nonlocal current_stage, stage_started
+        current_stage = stage_name
+        stage_started = time.perf_counter()
+        if spinner_message:
+            spinner.update(spinner_message)
+
+    def _finish_stage(stage_name: str) -> None:
+        stage_timings[stage_name] = round(time.perf_counter() - stage_started, 3)
+
+    spinner = ProgressSpinner("Scanning repository...")
+    spinner.start()
+
+    _start_stage("fingerprint_scan", "Scanning repository...")
+    previous_manifest = load_manifest(repo_dir)
+    previous_fingerprints = previous_manifest.get("fingerprints", {})
+    current_fingerprints = collect_fingerprints(repo_dir)
+    delta = diff_fingerprints(previous_fingerprints, current_fingerprints)
+    version_mismatch = previous_manifest.get("analysis_version") != ANALYSIS_VERSION
+
+    rebuild_required = bool(
+        force_full_rebuild
+        or should_rebuild(
+            repo_dir,
+            analysis_version=ANALYSIS_VERSION,
+            current_fingerprints=current_fingerprints,
+        )
+    )
+    _finish_stage("fingerprint_scan")
+    architecture_missing = not os.path.exists(architecture_metrics_path)
+    dependency_missing = not os.path.exists(dependency_cycles_path)
+    risk_missing = not os.path.exists(risk_radar_path)
+    r1 = {}
+    r2 = {}
+    metrics = {}
+
+    try:
+        if rebuild_required:
+            _start_stage("phase4_analysis", "Building call graph...")
+            r1 = run_phase4(
+                repo_dir=repo_dir,
+                output_dir=cache_dir,
+                force_rebuild=bool(version_mismatch or force_full_rebuild),
+            )
+            _finish_stage("phase4_analysis")
+
+            _start_stage("explain_generation", "Generating symbol explanations...")
+            r2 = run_explain(
+                repo_dir=repo_dir,
+                output_dir=cache_dir,
+                symbol_snapshot=r1.get("symbol_snapshot", []),
+            )
+            _finish_stage("explain_generation")
+            resolved_calls_path = r1.get("resolved_calls_path", resolved_calls_path)
+
+            _start_stage("analysis_metrics", "Computing analysis metrics...")
+            metrics = write_hub_metrics_from_resolved_calls(
+                resolved_calls_path=resolved_calls_path,
+                output_path=analysis_metrics_path,
+            )
+            _finish_stage("analysis_metrics")
+
+            _start_stage("manifest_write", "Saving analysis manifest...")
+            save_manifest(
+                repo_dir,
+                build_manifest(
                     repo_dir,
                     current_fingerprints,
                     metadata={
@@ -1320,28 +1358,37 @@ def api_analyze(args) -> int:
                             "critical_apis": len(metrics.get("critical_apis", [])),
                             "orchestrators": len(metrics.get("orchestrators", [])),
                         },
-                    },
-                ),
-            )
-            tree_snapshot = _build_project_tree_snapshot(repo_dir)
-            with open(project_tree_path, "w", encoding="utf-8") as f:
-                json.dump(tree_snapshot, f, indent=2)
-        elif os.path.exists(resolved_calls_path):
-            metrics = write_hub_metrics_from_resolved_calls(
-                resolved_calls_path=resolved_calls_path,
-                output_path=analysis_metrics_path,
-            )
-            if not os.path.exists(project_tree_path):
-                tree_snapshot = _build_project_tree_snapshot(repo_dir)
-                with open(project_tree_path, "w", encoding="utf-8") as f:
-                    json.dump(tree_snapshot, f, indent=2)
-
-        # Derived architecture outputs:
-        # - regenerate on rebuild
-        # - regenerate if architecture/dependency artifacts are missing
-        if rebuild_required or architecture_missing or dependency_missing:
-            with open(resolved_calls_path, "r", encoding="utf-8") as f:
-                resolved_calls = json.load(f)
+                    },
+                ),
+            )
+            _finish_stage("manifest_write")
+
+            _start_stage("project_tree", "Building project tree...")
+            tree_snapshot = _build_project_tree_snapshot(repo_dir)
+            with open(project_tree_path, "w", encoding="utf-8") as f:
+                json.dump(tree_snapshot, f, indent=2)
+            _finish_stage("project_tree")
+        elif os.path.exists(resolved_calls_path):
+            _start_stage("analysis_metrics", "Computing analysis metrics...")
+            metrics = write_hub_metrics_from_resolved_calls(
+                resolved_calls_path=resolved_calls_path,
+                output_path=analysis_metrics_path,
+            )
+            _finish_stage("analysis_metrics")
+            if not os.path.exists(project_tree_path):
+                _start_stage("project_tree", "Building project tree...")
+                tree_snapshot = _build_project_tree_snapshot(repo_dir)
+                with open(project_tree_path, "w", encoding="utf-8") as f:
+                    json.dump(tree_snapshot, f, indent=2)
+                _finish_stage("project_tree")
+
+        # Derived architecture outputs:
+        # - regenerate on rebuild
+        # - regenerate if architecture/dependency artifacts are missing
+        if rebuild_required or architecture_missing or dependency_missing:
+            _start_stage("architecture_metrics", "Computing architecture metrics...")
+            with open(resolved_calls_path, "r", encoding="utf-8") as f:
+                resolved_calls = json.load(f)
 
             callgraph = CallGraphIndex()
             for c in resolved_calls:
@@ -1374,22 +1421,27 @@ def api_analyze(args) -> int:
                 repo_prefix=repo_prefix,
             )
 
-            with open(architecture_metrics_path, "w", encoding="utf-8") as f:
-                json.dump(arch_payload, f, indent=2)
-            with open(dependency_cycles_path, "w", encoding="utf-8") as f:
-                json.dump(dep_payload, f, indent=2)
-
-        # Risk radar derived output:
-        # - regenerate on rebuild
-        # - regenerate when missing (cached analyze run)
-        # - regenerate when architecture/dependency were regenerated
-        if rebuild_required or risk_missing or architecture_missing or dependency_missing:
-            risk_payload = compute_risk_radar(cache_dir=cache_dir, top_k=25)
-            with open(risk_radar_path, "w", encoding="utf-8") as f:
-                json.dump(risk_payload, f, indent=2)
-        repo_hash = compute_repo_hash(repo_dir)
-        upsert_metadata(
-            repo_hash=repo_hash,
+            with open(architecture_metrics_path, "w", encoding="utf-8") as f:
+                json.dump(arch_payload, f, indent=2)
+            with open(dependency_cycles_path, "w", encoding="utf-8") as f:
+                json.dump(dep_payload, f, indent=2)
+            _finish_stage("architecture_metrics")
+
+        # Risk radar derived output:
+        # - regenerate on rebuild
+        # - regenerate when missing (cached analyze run)
+        # - regenerate when architecture/dependency were regenerated
+        if rebuild_required or risk_missing or architecture_missing or dependency_missing:
+            _start_stage("risk_radar", "Computing risk radar...")
+            risk_payload = compute_risk_radar(cache_dir=cache_dir, top_k=25)
+            with open(risk_radar_path, "w", encoding="utf-8") as f:
+                json.dump(risk_payload, f, indent=2)
+            _finish_stage("risk_radar")
+
+        _start_stage("cache_metadata", "Updating cache metadata...")
+        repo_hash = compute_repo_hash(repo_dir)
+        upsert_metadata(
+            repo_hash=repo_hash,
             source=source,
             repo_path=os.path.abspath(repo_dir),
             repo_url=repo_url or "",
@@ -1398,20 +1450,31 @@ def api_analyze(args) -> int:
             analysis_version=ANALYSIS_VERSION,
             private_mode=bool(private_repo_mode),
         )
-        set_retention(
-            repo_hash=repo_hash,
-            days=int(retention_days_effective),
-        )
-        touch_last_accessed(repo_hash)
-    except Exception as e:
-        spinner.stop()
-        print_json({"ok": False, "error": "ANALYZE_FAILED", "message": redact_secrets(str(e))})
-        return 1
-
-    spinner.stop()
-    print_json({
-        "ok": True,
-        "source": source,
+        set_retention(
+            repo_hash=repo_hash,
+            days=int(retention_days_effective),
+        )
+        touch_last_accessed(repo_hash)
+        _finish_stage("cache_metadata")
+    except Exception as e:
+        spinner.stop()
+        if current_stage and current_stage not in stage_timings:
+            stage_timings[current_stage] = round(time.perf_counter() - stage_started, 3)
+        stage_timings["total"] = round(time.perf_counter() - overall_started, 3)
+        print_json({
+            "ok": False,
+            "error": "ANALYZE_FAILED",
+            "message": redact_secrets(str(e)),
+            "failed_stage": current_stage,
+            "timings": stage_timings,
+        })
+        return 1
+
+    spinner.stop()
+    stage_timings["total"] = round(time.perf_counter() - overall_started, 3)
+    print_json({
+        "ok": True,
+        "source": source,
         "mode": mode,
         "auth": auth,
         "private_repo_mode": private_repo_mode,
@@ -1442,13 +1505,14 @@ def api_analyze(args) -> int:
         "fetched": fetched,
         "downloaded": downloaded,
         "zip_url": zip_url,
-        "repo_dir": repo_dir,
-        "retention": {
-            "mode": retention_mode,
-            "ttl_days": int(retention_days_effective),
-        },
-    })
-    return 0
+        "repo_dir": repo_dir,
+        "retention": {
+            "mode": retention_mode,
+            "ttl_days": int(retention_days_effective),
+        },
+        "timings": stage_timings,
+    })
+    return 0
 
 
 def cmd_ui(args) -> int:

codemap_cli.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from cli import main as _main
+from codemap_app import main as _main
 
 
 def main() -> int:

{codemap_python-0.1.4.dist-info → codemap_python-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codemap-python
-Version: 0.1.4
+Version: 0.1.5
 Summary: Local Python code analysis tool - understand architecture, dependencies, and call graphs
 Author-email: ADITYA <aditykushwaha69@gmail.com>
 License-Expression: MIT

{codemap_python-0.1.4.dist-info → codemap_python-0.1.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
-cli.py,sha256=cJZtfufG23l55sRla2iObgV5ZjjTTEsPPL6vDZV02eQ,73155
-codemap_cli.py,sha256=W6GWcVQsIUQwUq5xTe0R-6hSKOwkqgpJxlosdSEyYco,175
+codemap_app.py,sha256=CSPT7lVdHVXrutscUVHCNdfSlGtoZKz85oQAdLcs1ps,75678
+codemap_cli.py,sha256=BzQpgP7ZEKvMwjWlrAXR0dr_WcZFIDk3QVwH5GHNflE,182
 security_utils.py,sha256=6wmKx3qeYQmyIhc69ENocdclzKjIskhGhbbYzyrOfSs,1958
 analysis/__init__.py,sha256=gk7XcsmXhT6ewXV3CFezT6R5Q8E2RJ_W1lAPYWmloUQ,20
 analysis/architecture/__init__.py,sha256=8Bo3TpyB49uJs6QpQMTWpUR2hJhqEpbkK_E_GW7tYpU,5
@@ -7,7 +7,7 @@ analysis/architecture/architecture_engine.py,sha256=8aWqfvdGHP9gIf03VdLrkn1vF670
 analysis/architecture/dependency_cycles.py,sha256=fu1kQY1N4jmAdCdh2V2g9e8aZRoC17WtGEy6rPStDbI,3342
 analysis/architecture/risk_radar.py,sha256=3nCxjH96cicb_UQ67T4Hk63cIWWgG5syQhlaoFsoWEA,8681
 analysis/call_graph/__init__.py,sha256=w0foWNOGbFJTxtZUs08tnR3MM5mRTfA0xz6DtGRNGOk,22
-analysis/call_graph/call_extractor.py,sha256=N30G0SS0bf1S-in2wQmSmnAeOqr86jH-MIFnFe2fo2I,2756
+analysis/call_graph/call_extractor.py,sha256=EBeXK-Dbj3HNossNFWzEwnzgx-TFfbLTa5JZxrNtOVU,2868
 analysis/call_graph/call_graph_builder.py,sha256=h3D2SzvNmyPtVEBvwGTHM2LVsUwxq9MBLEMhkMi8gGc,29
 analysis/call_graph/call_resolver.py,sha256=gdSAy_042xxXby65FfSIMGBYI3yU4-jT-zMvpajHdF8,1600
 analysis/call_graph/context_models.py,sha256=pYCvdJOEdR35p-BO42BtXoJIFdieF6CEp-f_rSFbd0Q,29
@@ -20,15 +20,15 @@ analysis/core/ast_context.py,sha256=kQZB3jM4Mnqy8VtnlT5Towdo5Rfg6sr2hF-eVxjQY6Q,
 analysis/core/ast_parser.py,sha256=gFNicvvMFP8wR6afFKBdDFUJWJZaAZu4ZX4DlNXgxxM,759
 analysis/core/class_extractor.py,sha256=YJctW3TigWa7gra02qgZJXoVboDDTikkIyPzEDfNiI8,1039
 analysis/core/function_extractor.py,sha256=5y0teAJ8vzGTZ8Te80m9i0ihP8g2jgR2FEcddxIvhwc,436
-analysis/core/import_extractor.py,sha256=e-2HgVkORusvL5pFa5TJL7nW38Ylj8M4ziQMmrt8O40,1419
+analysis/core/import_extractor.py,sha256=lxlhzTy4-3t06JUNKYrRl6UAGgjUSgG-fpgVmSqB7AY,1541
 analysis/explain/__init__.py,sha256=2FsKrvLP_OgFFTuoFToaXRs6lM3lmz6lpEqjy5Agko8,55
 analysis/explain/docstring_extractor.py,sha256=9AO1ITf48KMg5ezZm_GYJzTlFi8sOBYih3uXlyectWM,1449
-analysis/explain/explain_runner.py,sha256=dHggiH4CAdEE1Z9WDqs0YJfiH2-Z2xIhlWSULD2UVNU,5661
+analysis/explain/explain_runner.py,sha256=dsZLz_KwtW5ATc28EHF9aAIkkTB75kNneMlsPJxGI7M,5975
 analysis/explain/repo_summary_generator.py,sha256=eCNve4-eHG0d2XLJttFA-Bh5suZIvKack_jBRaMHrHc,6474
 analysis/explain/return_analyzer.py,sha256=KjHj7SHWTUMQAzLUi0A8BL5cv5tCxr5XeAw2VG-uyYg,3100
 analysis/explain/risk_flags.py,sha256=QNV101q4PMMIJ_LKv80EwX6uaAysiZC-aGyYTSbwPb8,39
 analysis/explain/signature_extractor.py,sha256=Wx-8tvCArg8B9LtMsvw0O5kd48PsGf0KjiEDF7uzTmc,3430
-analysis/explain/summary_generator.py,sha256=Km39BqMIBFOljlxTy9-NdyFNnVbx14XQXH2NVbnoWRU,9944
+analysis/explain/summary_generator.py,sha256=s1mZePpU2KHvNW82a4ZS0xrdbysXhzxp231hDwYlH_o,10004
 analysis/graph/__init__.py,sha256=JcO7GEPE5fMocTUC1ou9AKGCnv3RwpTKt1CrNKQ-puM,52
 analysis/graph/callgraph_index.py,sha256=34LE8Vgv-z6kVOIoCdKJ19ej550ENEYI-78xuhF6QQE,3770
 analysis/graph/entrypoint_detector.py,sha256=4NDD4z-tAIcryTVcHkV7dMLDOQp3J-QKDFPUcIESRsg,40
@@ -37,24 +37,25 @@ analysis/indexing/__init__.py,sha256=eiE_smnnd-0xjpMBKDQilIypx5oiLA9N_40xBxDQSe4
 analysis/indexing/import_resolver.py,sha256=ZkTyx3RdzrEwdHMVax0uM5D4AjJNEo1FoXAD1rsx5QY,4697
 analysis/indexing/symbol_index.py,sha256=RoBsehau9u0tYB8hUEvN5K4dINgtiGH07qV0vznKAhA,5491
 analysis/runners/__init__.py,sha256=4caStudxQFG1nCXBGpoyV7DvxN5ySfwVm4ENQc46w6s,21
-analysis/runners/phase4_runner.py,sha256=9PMf63VAsXDrBWFm4BMDSvp-pW96GnK88h5-6-C36Rw,4966
+analysis/runners/phase4_runner.py,sha256=Pta7tF-JU4EWFRE5dgnRKhqTVgq8NbMPM7xwR2MO0WI,5048
 analysis/utils/__init__.py,sha256=sJCGmNWVjSiFK21dDvTzQFMUPyQYNP3b4-Lj42DNA-s,17
 analysis/utils/ast_helpers.py,sha256=qMny-x6kvMt7F1b9Q8HtR2o0nen6bR-MyQsClBzLNpI,20
 analysis/utils/bom_handler.py,sha256=WkDvE1jMGEJgxW-aS5gPfHmFKv7NNDT35j6dbPBFQ3c,4059
-analysis/utils/cache_manager.py,sha256=FUuZOO_CSHP_A2cFO4Kk8WQc34AYfqTol2w6n7DmTBE,24579
+analysis/utils/cache_manager.py,sha256=wOVDm-udThUV0mxEA3CLfL2d8SOPwW_BvvUwIayY_tI,24654
 analysis/utils/path_resolver.py,sha256=NprapbBX8E1c_5jp2R1OLIYMeqrFeNfaxnmIlwqs9hI,27
 analysis/utils/progress_spinner.py,sha256=l_2YeddB3xSp46H8pF3vc3h_XxbCu03lfLBJQndO4sI,2792
 analysis/utils/repo_fetcher.py,sha256=bCUBG0qUypcXXgQPAAdJAaRoQSc75Nd53B7HD72Euno,15105
+analysis/utils/repo_walk.py,sha256=pMVX9pMLtOV-5ln6mRbJ6vVApkjo1vnkJl7YPvXiGNk,546
 ui/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-ui/app.py,sha256=FM-odEwfRQ1TQaNPTzdaoq90eQSRdRyBpFw-fof3FUM,82050
+ui/app.py,sha256=LJct_PfF10eHRTsgD-9IJcZlVCSXQBqvw6Mdk38gWJA,82085
 ui/device_id.py,sha256=gAan8gMnSY_lDpDSllafK27CSskFT-_OdFw2m8y2QUA,708
-ui/static/app.js,sha256=E8N2rfoha_4RZQHOpZSiIpVRIlhrB0Qs5FjCog4SUhU,118335
+ui/static/app.js,sha256=WzTs9ZywGoCXHrqeuqFzCbzXdtMShAMfXUVwDaqAm6Y,118377
 ui/static/styles.css,sha256=B_QkNK8zziUDl-m8HzcpyO1FFujYf-DdO05Ly7JZbB8,23639
 ui/templates/index.html,sha256=x8isBJyxzt8UdkLJK4NDqBlEjn_FbXdFc1O_llti-R0,11945
 ui/utils/__init__.py,sha256=8Bo3TpyB49uJs6QpQMTWpUR2hJhqEpbkK_E_GW7tYpU,5
 ui/utils/registry_manager.py,sha256=jEhWMQJ3H1ZtyUP2ObneqFOVDTdDqiBvUh-46-rGFDw,6730
-codemap_python-0.1.4.dist-info/METADATA,sha256=xrlNhbwZeFjtfRwgNE7fQKGglkUpNJBODVYFopI1AcA,11131
-codemap_python-0.1.4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-codemap_python-0.1.4.dist-info/entry_points.txt,sha256=71TCgwo56CPxSfh-YSmofpNwq4-kSsjmBL_qzJ5kfmk,45
-codemap_python-0.1.4.dist-info/top_level.txt,sha256=JOu1LG-DyeBXc4u2Cn7KznNz-bZExhsf1CB7fV4r-t8,43
-codemap_python-0.1.4.dist-info/RECORD,,
+codemap_python-0.1.5.dist-info/METADATA,sha256=KnQdf8myIYhINPfL_UnaFe3aIvt865bTSFIOD8bYknY,11131
+codemap_python-0.1.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codemap_python-0.1.5.dist-info/entry_points.txt,sha256=71TCgwo56CPxSfh-YSmofpNwq4-kSsjmBL_qzJ5kfmk,45
+codemap_python-0.1.5.dist-info/top_level.txt,sha256=ut06MYFLgR7psHfy_wVlrKDzJO4NX0LWIj_dgkaOXSE,51
+codemap_python-0.1.5.dist-info/RECORD,,

{codemap_python-0.1.4.dist-info → codemap_python-0.1.5.dist-info}/top_level.txt

@@ -1,5 +1,5 @@
 analysis
-cli
+codemap_app
 codemap_cli
 security_utils
 ui

ui/app.py

@@ -61,7 +61,7 @@ ANALYSIS_ROOT = os.path.join(PROJECT_ROOT, "analysis")
 DEFAULT_REPO = os.getenv("CODEMAP_UI_REPO", "testing_repo")
 GLOBAL_CACHE_DIR = os.path.join(PROJECT_ROOT, ".codemap_cache")
 
-MISSING_CACHE_MESSAGE = "Not analyzed yet. Run: python cli.py api analyze --path <repo>"
+MISSING_CACHE_MESSAGE = "Not analyzed yet. Run: python codemap_app.py api analyze --path <repo>"
 
 _SENSITIVE_FIELD_RE = re.compile(r"(?i)(api[_-]?key|token|authorization|bearer|basic|secret|password)")
 
@@ -372,7 +372,7 @@ def _cli_json_with_input(
     stdin_text: Optional[str] = None,
     extra_env: Optional[Dict[str, str]] = None,
 ) -> Dict[str, Any]:
-    cmd = [sys.executable, os.path.join(PROJECT_ROOT, "cli.py"), "api"] + list(args)
+    cmd = [sys.executable, os.path.join(PROJECT_ROOT, "codemap_app.py"), "api"] + list(args)
     env = os.environ.copy()
     if isinstance(extra_env, dict):
         for k, v in extra_env.items():
@@ -426,8 +426,8 @@ def _repo_analyze_command(repo: Dict[str, Any]) -> str:
         repo_url = str(repo.get("repo_url", "") or "").strip()
         ref = str(repo.get("ref", "") or "").strip() or "main"
         mode = str(repo.get("mode", "") or "zip")
-        return f"python cli.py api analyze --github {repo_url} --ref {ref} --mode {mode}"
-    return f"python cli.py api analyze --path {repo.get('path', '<repo>')}"
+        return f"python codemap_app.py api analyze --github {repo_url} --ref {ref} --mode {mode}"
+    return f"python codemap_app.py api analyze --path {repo.get('path', '<repo>')}"
 
 
 def _get_active_repo_entry() -> Optional[Dict[str, str]]:
@@ -1670,7 +1670,7 @@ def api_architecture(repo: Optional[str] = Query(default=None)):
             content={
                 "ok": False,
                 "error": "MISSING_ARCHITECTURE_CACHE",
-                "message": "Run: python cli.py api analyze --path <repo>",
+                "message": "Run: python codemap_app.py api analyze --path <repo>",
                 "missing_files": missing,
             },
         )

ui/static/app.js

@@ -231,13 +231,13 @@
 
   function analyzeCommandForRepo(repo) {
     const r = repo || currentRepoEntry();
-    if (!r) return "python cli.py api analyze --path <repo>";
+    if (!r) return "python codemap_app.py api analyze --path <repo>";
     if (String(r.source || "filesystem") === "github" && r.repo_url) {
       const ref = r.ref || "main";
       const mode = r.mode || "zip";
-      return `python cli.py api analyze --github ${r.repo_url} --ref ${ref} --mode ${mode}`;
+      return `python codemap_app.py api analyze --github ${r.repo_url} --ref ${ref} --mode ${mode}`;
     }
-    return `python cli.py api analyze --path ${r.repo_path || "<repo>"}`;
+    return `python codemap_app.py api analyze --path ${r.repo_path || "<repo>"}`;
   }
 
   function updateAiModeUi() {
@@ -612,7 +612,7 @@
   }
 
   function repoSummarySection() {
-    const cmd = `python cli.py api repo_summary --repo ${repoName || "<repo>"}`;
+    const cmd = `python codemap_app.py api repo_summary --repo ${repoName || "<repo>"}`;
     const controls = `
       <div class="repo-row-actions">
         <button id='repo-summary-view' class='repo-refresh-btn' type='button'>View summary</button>
@@ -730,7 +730,7 @@
   }
 
   function riskRadarSection() {
-    const cmd = `python cli.py api risk_radar --repo ${repoName || "<repo>"}`;
+    const cmd = `python codemap_app.py api risk_radar --repo ${repoName || "<repo>"}`;
     if (riskRadarStatus === "loading") {
       return `<div class="card"><div class="section-title">Risk Radar</div><div class="path">Loading risk radar...</div></div>`;
     }
@@ -913,7 +913,7 @@
         <div class="card arch-missing">
           <div class="section-title">Architecture Insights Unavailable</div>
           <div>${esc((e && (e.message || e.error)) || "Missing architecture cache artifacts.")}</div>
-          <div class="path">Run: python cli.py api analyze --path &lt;repo&gt;</div>
+          <div class="path">Run: python codemap_app.py api analyze --path &lt;repo&gt;</div>
         </div>
       `;
     }