codecompass-mcp 3.2.0__tar.gz → 3.2.1__tar.gz

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 3.2.0
+Version: 3.2.1
 Summary: Structural code context for AI coding agents — a local code knowledge graph for blast radius, impact, deps, dead code, and flow tracing
 Author: CodeCompass contributors
 License: MIT
@@ -20,10 +20,8 @@ License-File: LICENSE
 Requires-Dist: anthropic>=0.40.0
 Requires-Dist: fastmcp>=2.0.0
 Requires-Dist: networkx>=3.0
-Requires-Dist: pypdf2>=3.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rich>=13.0.0
-Requires-Dist: tqdm>=4.66.0
 Requires-Dist: tree-sitter>=0.21.0
 Requires-Dist: tree-sitter-python>=0.21.0
 Requires-Dist: tree-sitter-javascript>=0.21.0

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/codecompass_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 3.2.0
+Version: 3.2.1
 Summary: Structural code context for AI coding agents — a local code knowledge graph for blast radius, impact, deps, dead code, and flow tracing
 Author: CodeCompass contributors
 License: MIT
@@ -20,10 +20,8 @@ License-File: LICENSE
 Requires-Dist: anthropic>=0.40.0
 Requires-Dist: fastmcp>=2.0.0
 Requires-Dist: networkx>=3.0
-Requires-Dist: pypdf2>=3.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rich>=13.0.0
-Requires-Dist: tqdm>=4.66.0
 Requires-Dist: tree-sitter>=0.21.0
 Requires-Dist: tree-sitter-python>=0.21.0
 Requires-Dist: tree-sitter-javascript>=0.21.0

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/codecompass_mcp.egg-info/SOURCES.txt

@@ -11,32 +11,22 @@ codecompass_mcp.egg-info/entry_points.txt
 codecompass_mcp.egg-info/requires.txt
 codecompass_mcp.egg-info/top_level.txt
 graph/__init__.py
-graph/cli.py
 graph/code_graph_client.py
 graph/code_query_cli.py
-graph/setup.py
 ingestion/__init__.py
-ingestion/chunker.py
 ingestion/code_normalizer.py
 ingestion/code_parser.py
 ingestion/description_enricher.py
-ingestion/entity_resolver.py
 ingestion/file_watcher.py
-ingestion/graph_writer.py
 ingestion/hierarchy_builder.py
-ingestion/reader_agent.py
 ingestion/source_context.py
 models/__init__.py
 models/code_types.py
-models/types.py
 tests/test_accuracy_fixes.py
 tests/test_batch_impact.py
 tests/test_blast_radius.py
 tests/test_code_parser.py
 tests/test_description_enricher.py
-tests/test_ingestion.py
 tests/test_lit_css_parser.py
 tests/test_mcp_server.py
-tests/test_php_parser.py
-utils/__init__.py
-utils/formatting.py
+tests/test_php_parser.py

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/codecompass_mcp.egg-info/entry_points.txt

@@ -1,3 +1,3 @@
 [console_scripts]
-codecompass = graph.cli:main
+codecompass = main:main
 codecompass-mcp = mcp_server:main

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/codecompass_mcp.egg-info/requires.txt

@@ -1,10 +1,8 @@
 anthropic>=0.40.0
 fastmcp>=2.0.0
 networkx>=3.0
-pypdf2>=3.0.0
 python-dotenv>=1.0.0
 rich>=13.0.0
-tqdm>=4.66.0
 tree-sitter>=0.21.0
 tree-sitter-python>=0.21.0
 tree-sitter-javascript>=0.21.0

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/codecompass_mcp.egg-info/top_level.txt

@@ -4,4 +4,3 @@ ingestion
 main
 mcp_server
 models
-utils

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/graph/code_graph_client.py

@@ -10,7 +10,7 @@ import os
 import re
 import networkx as nx
 from datetime import datetime, timezone
-from typing import Optional, Any
+from typing import Optional
 
 from models.code_types import CodeTriple, FileNode, FolderNode
 

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/graph/code_query_cli.py

@@ -3,7 +3,7 @@
     python -m graph.code_query_cli --impact "login()" <repo_path>
     python -m graph.code_query_cli --deps src/auth/login.py <repo_path>
     python -m graph.code_query_cli --styles LoginForm <repo_path>
-    python -m graph.code_query_cli --trace "main()" <repo_path>
+    python -m graph.code_query_cli --flow "main()" <repo_path>
     python -m graph.code_query_cli --tree <repo_path>
 
 Output is plain text by default (agent-friendly). Pass --rich for formatted tables.
@@ -12,16 +12,12 @@ Output is plain text by default (agent-friendly). Pass --rich for formatted tabl
 from __future__ import annotations
 
 import argparse
+from contextlib import closing
 import json
 import os
 import sys
 import xml.etree.ElementTree as ET
 from datetime import datetime, timezone
-from pathlib import Path
-
-_project_root = Path(__file__).resolve().parent.parent
-if str(_project_root) not in sys.path:
-    sys.path.insert(0, str(_project_root))
 
 from rich.console import Console
 from rich.table import Table
@@ -42,88 +38,64 @@ STALE_WARN_HOURS = 24
 
 def fetch_impact(entity_name: str, repo_path: str, project: str, max_hops: int = DEFAULT_HOPS) -> dict:
     """Return callers of entity_name as structured data."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         rows = client.find_callers(entity_name, project, max_hops)
         updated_at = _entity_updated_at(client, entity_name)
-    finally:
-        client.close()
     return {"entity": entity_name, "callers": rows, "updated_at": updated_at}
 
 
 def fetch_grep(pattern: str, repo_path: str, project: str, field: str = "all",
                ignore_case: bool = True, limit: int = 100) -> dict:
     """Regex-search the graph — 'grep' over indexed entities, not file lines."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         return client.grep_graph(pattern, project, field=field,
                                  ignore_case=ignore_case, limit=limit)
-    finally:
-        client.close()
 
 
 def fetch_search(query: str, repo_path: str, project: str, limit: int = 30,
                  kind: str | None = None) -> dict:
     """Search the graph for entities matching a keyword — the discovery entry point."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         rows = client.search_entities(query, project, limit=limit, kind=kind)
-    finally:
-        client.close()
     return {"query": query, "matches": rows, "count": len(rows)}
 
 
 def fetch_map(repo_path: str, project: str, include_tests: bool = False) -> dict:
     """Compact `{file: [symbols]}` index for an agent to reason over during discovery."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         m = client.symbol_map(project, include_tests=include_tests)
-    finally:
-        client.close()
     return {"project": project, "files": m, "file_count": len(m)}
 
 
 def fetch_deps(file_path: str, repo_path: str, project: str, max_hops: int = DEFAULT_HOPS) -> dict:
     """Return what file_path imports as structured data."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         rows = client.find_dependencies(file_path, project, max_hops)
         updated_at = client.get_file_updated_at(file_path, project)
-    finally:
-        client.close()
     return {"file": file_path, "dependencies": rows, "updated_at": updated_at}
 
 
 def fetch_styles(element_name: str, repo_path: str, project: str) -> dict:
     """Return CSS selectors that style element_name as structured data."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         rows = client.find_styles(element_name, project)
         updated_at = _entity_updated_at(client, element_name)
-    finally:
-        client.close()
     return {"element": element_name, "selectors": rows, "updated_at": updated_at}
 
 
 def fetch_trace(start_name: str, repo_path: str, project: str, max_hops: int = DEFAULT_HOPS) -> dict:
     """Return forward call chain from start_name as structured data."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         rows = client.trace_calls(start_name, project, max_hops)
         updated_at = _entity_updated_at(client, start_name)
-    finally:
-        client.close()
     return {"entity": start_name, "calls": rows, "updated_at": updated_at}
 
 
 def fetch_blast_radius(target: str, repo_path: str, project: str, max_hops: int = DEFAULT_HOPS) -> dict:
     """Return blast radius of target as structured data."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         rows, target_file = client.get_blast_radius(target, project, max_hops)
         updated_at = client.get_file_updated_at(target_file, project) if target_file else None
-    finally:
-        client.close()
 
     if target_file is None:
         return {"target": target, "found": False, "files": [], "updated_at": None}
@@ -153,9 +125,7 @@ def fetch_batch_impact(targets: list[str], repo_path: str, project: str, max_hop
     for t in targets:
         flat_targets.extend(s.strip() for s in t.split(",") if s.strip())
 
-    input_set = set(flat_targets)
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         merged: dict[str, dict] = {}
         resolved: list[str] = []
         staleness_ts: str | None = None
@@ -181,8 +151,6 @@ def fetch_batch_impact(targets: list[str], repo_path: str, project: str, max_hop
                     if h < merged[f]["hops"]:
                         merged[f]["hops"] = h
                     merged[f]["via"].add(target)
-    finally:
-        client.close()
 
     deduped = sorted(
         [{"file": f, "hops": v["hops"], "via": sorted(v["via"])} for f, v in merged.items()],
@@ -199,11 +167,8 @@ def fetch_batch_impact(targets: list[str], repo_path: str, project: str, max_hop
 
 def fetch_dead_code(repo_path: str, project: str, show_entrypoints: bool = False) -> dict:
     """Return dead-code candidates as structured data."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         result = client.find_dead_code(project)
-    finally:
-        client.close()
     return {
         "project": project,
         "dead": result["dead"],
@@ -214,12 +179,9 @@ def fetch_dead_code(repo_path: str, project: str, show_entrypoints: bool = False
 
 def fetch_tree(repo_path: str, project: str) -> dict:
     """Return project hierarchy as structured data."""
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         rows = client.get_project_tree(project)
         last_ingested = client.get_project_last_ingested(project)
-    finally:
-        client.close()
     return {"project": project, "tree": rows, "last_ingested": last_ingested}
 
 
@@ -231,11 +193,8 @@ def fetch_flow(start_name: str, repo_path: str, project: str, max_hops: int = DE
     line — NO embedded source, docstrings, narration, or rendered image. Use
     fetch_flow_summary for a human-facing walkthrough (mermaid + narration).
     """
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         data = client.trace_flow(start_name, project, max_hops, include_external=include_external)
-    finally:
-        client.close()
 
     nodes = data["nodes"]
     edges = data["edges"]
@@ -272,11 +231,8 @@ def fetch_flow_summary(start_name: str, repo_path: str, project: str, max_hops:
     "drawio" renders a diagram. Heavier than fetch_flow — use when a person needs
     to read the flow, not when an agent just needs the structure.
     """
-    client = get_client(repo_path)
-    try:
+    with closing(get_client(repo_path)) as client:
         data = client.trace_flow(start_name, project, max_hops, include_external=include_external)
-    finally:
-        client.close()
 
     nodes = data["nodes"]
     edges = data["edges"]
@@ -327,8 +283,6 @@ def main() -> None:
         run_deps(args.deps, repo_path, project, max_hops=args.hops, rich=rich)
     elif args.styles:
         run_styles(args.styles, repo_path, project, rich=rich)
-    elif args.trace:
-        run_trace(args.trace, repo_path, project, max_hops=args.hops, rich=rich)
     elif args.flow:
         run_flow(args.flow, repo_path, project, max_hops=args.hops, rich=rich,
                  output=args.flow_output, include_external=args.include_external,
@@ -437,33 +391,6 @@ def run_styles(element_name: str, repo_path: str, project: str, rich: bool = Fal
             print(f"  {row.get('selector','')} in {row.get('source_file','')} line {row.get('line','')}")
 
 
-def run_trace(start_name: str, repo_path: str, project: str, max_hops: int = DEFAULT_HOPS, rich: bool = False) -> None:
-    """Trace the call chain forward from start_name."""
-    data = fetch_trace(start_name, repo_path, project, max_hops)
-    rows = data["calls"]
-    updated_at = data["updated_at"]
-
-    if not rows:
-        print(f"'{start_name}' makes no tracked calls within {max_hops} hops.")
-        return
-
-    stamp = _staleness_line(updated_at, rich_mode=rich)
-    if rich:
-        console.print(f"\n[bold blue]Call trace from:[/] {start_name}")
-        if stamp:
-            console.print(stamp)
-        table = _make_table(title=f"Call chain from '{start_name}'", columns=["Callee", "Type", "File", "Depth"])
-        for row in rows:
-            table.add_row(row.get("callee_name",""), row.get("callee_type",""), row.get("callee_file",""), str(row.get("depth","")))
-        console.print(table)
-    else:
-        if stamp:
-            print(stamp)
-        print(f"Call chain from '{start_name}':")
-        for row in rows:
-            print(f"  {row.get('callee_name','')} ({row.get('callee_type','')}) in {row.get('callee_file','')} [depth {row.get('depth','')}]")
-
-
 def run_blast_radius(target: str, repo_path: str, project: str, max_hops: int = DEFAULT_HOPS, rich: bool = False) -> None:
     """Show every file that DEPENDS ON the target (reverse: callers/importers/subclasses)."""
     data = fetch_blast_radius(target, repo_path, project, max_hops)
@@ -1018,7 +945,6 @@ def _parse_args() -> argparse.Namespace:
     parser.add_argument("--impact", metavar="ENTITY")
     parser.add_argument("--deps", metavar="FILE")
     parser.add_argument("--styles", metavar="ELEMENT")
-    parser.add_argument("--trace", metavar="ENTITY")
     parser.add_argument("--flow", metavar="ENTITY")
     parser.add_argument("--flow-summary", metavar="ENTITY",
                         help="Flow trace + rendered narration (mermaid by default) for a human")

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/ingestion/code_normalizer.py

@@ -17,6 +17,7 @@ import json
 from typing import Any
 
 import anthropic
+from rich.progress import track
 
 from config import anthropic_api_key
 from models.code_types import CodeTriple
@@ -67,14 +68,7 @@ def normalize_triples(triples: list[CodeTriple], progress: bool = False) -> list
     batches = _split_into_batches(triples, BATCH_SIZE)
     normalized: list[CodeTriple] = []
 
-    if progress:
-        try:
-            from tqdm import tqdm
-            batches_iter = tqdm(batches, desc="Normalizing batches", unit="batch")
-        except ImportError:
-            batches_iter = batches
-    else:
-        batches_iter = batches
+    batches_iter = track(batches, description="Normalizing batches") if progress else batches
 
     for batch in batches_iter:
         corrected = _normalize_batch(client, batch)

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/ingestion/code_parser.py

@@ -13,6 +13,7 @@ import re
 from pathlib import Path
 from typing import Callable
 
+from rich.progress import track
 from tree_sitter import Language, Parser, Node
 
 from models.code_types import CodeTriple
@@ -316,11 +317,6 @@ def _extract_python(root: Node, source: bytes, file_path: str) -> list[CodeTripl
     return triples
 
 
-def _extract_python_callee(call_node: Node) -> str | None:
-    """Back-compat shim: callee name only."""
-    return _extract_python_call_parts(call_node)[0]
-
-
 def _extract_python_call_parts(call_node: Node) -> tuple[str | None, str | None, Node | None]:
     """Return (callee_name, receiver_text, receiver_object_node) for a `call`."""
     if not call_node.children:
@@ -1444,11 +1440,6 @@ def _resolve_receiver_type(receiver: str | None, obj: Node | None, call_node: No
     return None
 
 
-def _extract_js_callee(call_node: Node) -> str | None:
-    """Back-compat shim: callee name only."""
-    return _extract_js_call(call_node)[0]
-
-
 def _extract_js_require_target(call_node: Node) -> str | None:
     """Module string of a `require('x')` or dynamic `import('x')` call, else None.
 
@@ -1785,14 +1776,7 @@ def parse_directory(
             if Path(filename).suffix.lower() in SUPPORTED_EXTENSIONS:
                 source_files.append(os.path.join(dirpath, filename))
 
-    if progress:
-        try:
-            from tqdm import tqdm
-            source_files_iter = tqdm(source_files, desc="Parsing files", unit="file")
-        except ImportError:
-            source_files_iter = source_files
-    else:
-        source_files_iter = source_files
+    source_files_iter = track(source_files, description="Parsing files") if progress else source_files
 
     triples: list[CodeTriple] = []
     for full_path in source_files_iter:

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/ingestion/file_watcher.py

@@ -16,8 +16,6 @@ from __future__ import annotations
 import os
 import time
 from pathlib import Path
-from typing import Optional
-
 from watchdog.events import FileSystemEventHandler, FileSystemEvent
 from watchdog.observers import Observer
 
@@ -48,7 +46,7 @@ class _CodeFileEventHandler(FileSystemEventHandler):
         self._project_root = project_root
         self._project_name = project_name
         self._client = client
-        self._file_id_map = file_id_map  # {rel_path: neo4j_file_node_id}
+        self._file_id_map = file_id_map  # {rel_path: file_node_id}
 
     def on_modified(self, event: FileSystemEvent) -> None:
         if event.is_directory:
@@ -81,7 +79,7 @@ class _CodeFileEventHandler(FileSystemEventHandler):
     # ------------------------------------------------------------------
 
     def _handle_change(self, abs_path: str) -> None:
-        """Re-parse a changed file and apply only the delta to Neo4j."""
+        """Re-parse a changed file and apply only the delta to the local graph."""
         ext = Path(abs_path).suffix.lower()
         if ext not in SUPPORTED_EXTENSIONS:
             return

{codecompass_mcp-3.2.0 → codecompass_mcp-3.2.1}/ingestion/hierarchy_builder.py

@@ -1,4 +1,4 @@
-"""Hierarchy builder — walks a repo and writes the Project → Folder → File skeleton to Neo4j.
+"""Hierarchy builder — walks a repo and writes the Project → Folder → File skeleton to the local graph.
 
 This runs before code_parser so every file has a node to attach entities to.
 No API calls — purely local filesystem traversal.
@@ -24,9 +24,9 @@ _SOURCE_EXTENSIONS = {".py", ".js", ".jsx", ".ts", ".tsx", ".html", ".css", ".sc
 
 
 def build_hierarchy(project_root: str, project_name: str, client) -> dict[str, str]:
-    """Walk project_root and write Project → Folder → File nodes to Neo4j.
+    """Walk project_root and write Project → Folder → File nodes to the local graph.
 
-    Returns a mapping of {relative_file_path: neo4j_node_id} so the caller
+    Returns a mapping of {relative_file_path: node_id} so the caller
     can attach entity nodes to the correct File nodes.
 
     Args:
@@ -74,34 +74,6 @@ def build_hierarchy(project_root: str, project_name: str, client) -> dict[str, s
     return file_id_map
 
 
-def collect_file_nodes(project_root: str) -> list[FileNode]:
-    """Return FileNode objects for every supported source file under project_root.
-
-    Useful for dry-run inspection or passing file lists to other pipeline stages.
-    """
-    nodes: list[FileNode] = []
-    for dirpath, dirnames, filenames in os.walk(project_root):
-        dirnames[:] = [d for d in dirnames if d not in _SKIP_DIRS]
-        for filename in filenames:
-            ext = Path(filename).suffix.lower()
-            if ext in _SOURCE_EXTENSIONS:
-                full_path = os.path.join(dirpath, filename)
-                rel_path = os.path.relpath(full_path, project_root)
-                nodes.append(_make_file_node(rel_path, project_root))
-    return nodes
-
-
-def collect_folder_nodes(project_root: str) -> list[FolderNode]:
-    """Return FolderNode objects for every non-skipped directory under project_root."""
-    nodes: list[FolderNode] = []
-    for dirpath, dirnames, _ in os.walk(project_root):
-        dirnames[:] = [d for d in dirnames if d not in _SKIP_DIRS]
-        rel_dir = os.path.relpath(dirpath, project_root)
-        if rel_dir != ".":
-            nodes.append(_make_folder_node(rel_dir, project_root))
-    return nodes
-
-
 # ---------------------------------------------------------------------------
 # Internal helpers
 # ---------------------------------------------------------------------------