contextl 1.2.11 → 1.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextl",
-  "version": "1.2.11",
+  "version": "1.2.13",
   "description": "contextl — finds the most relevant files in your codebase for any change request. MCP server for AI coding agents.",
   "keywords": [
     "mcp",

package/python/main.py

@@ -198,9 +198,9 @@ def build_parser() -> argparse.ArgumentParser:
     search_parser.add_argument("--top", "-n", type=int, default=5, help="Number of results to return (default: 5)")
     search_parser.add_argument("--json", action="store_true", help="Output clean JSON instead of human-readable text")
 
-    # 2. Dead Code
-    dead_parser = subparsers.add_parser("dead-code", help="Find files with 0 in-degree dependencies")
-    dead_parser.add_argument("repo_path", help="Path to the repository root")
+    # 2. Standalone Files
+    standalone_parser = subparsers.add_parser("standalone", help="Find files with 0 in-degree dependencies (unimported)")
+    standalone_parser.add_argument("repo_path", help="Path to the repository root")
 
     # 3. Impact Analysis
     impact_parser = subparsers.add_parser("impact", help="Analyze the impact of changing a file")
@@ -218,7 +218,7 @@ def build_parser() -> argparse.ArgumentParser:
 def main():
     # To maintain backward compatibility with old `contextl <repo> <query>`
     # we manually inject "search" if the first argument isn't a known command.
-    if len(sys.argv) >= 2 and sys.argv[1] not in ["search", "dead-code", "impact", "obsidian", "-h", "--help"]:
+    if len(sys.argv) >= 2 and sys.argv[1] not in ["search", "standalone", "impact", "obsidian", "-h", "--help"]:
         sys.argv.insert(1, "search")
 
     parser = build_parser()
@@ -243,14 +243,14 @@ def main():
         else:
             print(_format_human(args.query, args.repo_path, results, repo_graph, elapsed))
 
-    elif args.command == "dead-code":
-        from dead_code import find_dead_files
+    elif args.command == "standalone":
+        from standalone import find_standalone_files
         scan = scan_repo(args.repo_path)
         parse = parse_imports(scan)
         repo_graph = build_graph(scan, parse)
-        dead = find_dead_files(repo_graph)
-        print(f"Found {len(dead)} potentially dead files:")
-        for d in sorted(dead):
+        standalone = find_standalone_files(repo_graph)
+        print(f"Found {len(standalone)} standalone files:")
+        for d in sorted(standalone):
             print(f"  {d}")
 
     elif args.command == "impact":

package/python/mcp_server.py

@@ -11,16 +11,27 @@ Usage (the IDE does this for you, but you can test manually):
     python mcp_server.py
 
 Tools exposed:
-    query_repo      — rank files by relevance to a natural-language query
-    scan_repo       — list all source files the engine can see in a repo
-    analyze_impact  — find every file affected by changing a target file
+    query_repo             — rank files by relevance to a natural-language query
+    scan_repo              — list all source files the engine can see in a repo
+    analyze_impact         — find every file affected by changing a target file
+    find_standalone_files  — find unimported files with in-degree 0
+    export_obsidian_vault  — export repo graph to an Obsidian markdown vault
+
+Performance:
+    A shared graph cache is maintained per repo path + file mtime fingerprint.
+    The 4-step build pipeline (scan → parse → graph → query) runs ONCE per
+    session and is reused by all tool calls. Subsequent calls on an unchanged
+    repo return from cache in <1ms.
 """
 
-import argparse
 import asyncio
 import json
+import os
 import sys
+import threading
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Optional
 
 import mcp.types as types
 from mcp.server import Server
@@ -35,10 +46,80 @@ from graph_builder import build_graph
 from query_engine import query as engine_query
 from main import _confidence, _reasoning
 from impact_analysis import analyze_impact
-from dead_code import find_dead_files
+from standalone import find_standalone_files
 from obsidian_export import export_obsidian_vault
 
 
+# ---------------------------------------------------------------------------
+# Shared graph cache — one pipeline build per repo per session
+# ---------------------------------------------------------------------------
+@dataclass
+class _CacheEntry:
+    repo_path: str          # resolved absolute path
+    mtime_hash: float       # max mtime across all source files at build time
+    scan: object            # ScanResult
+    repo_graph: object      # RepoGraph
+
+
+_cache_lock = threading.Lock()
+_cache: Optional[_CacheEntry] = None
+
+
+def _compute_mtime_hash(repo_path: str) -> float:
+    """Walk repo_path and return the maximum file modification time."""
+    max_mtime = 0.0
+    for dirpath, _, filenames in os.walk(repo_path):
+        # Skip hidden dirs and common noise dirs
+        dirpath_obj = Path(dirpath)
+        if any(part.startswith(".") or part in ("node_modules", "__pycache__", ".git", "dist", "build", "target")
+               for part in dirpath_obj.parts):
+            continue
+        for fname in filenames:
+            try:
+                mtime = os.path.getmtime(os.path.join(dirpath, fname))
+                if mtime > max_mtime:
+                    max_mtime = mtime
+            except OSError:
+                pass
+    return max_mtime
+
+
+def _get_graph(repo_path: str):
+    """
+    Return (scan, repo_graph) for the given repo_path.
+
+    On first call (or after any source file changes): runs the full
+    4-step pipeline and stores the result in the module-level cache.
+    On subsequent calls with unchanged files: returns instantly from cache.
+    """
+    global _cache
+
+    resolved = str(Path(repo_path).resolve())
+    mtime_hash = _compute_mtime_hash(resolved)
+
+    with _cache_lock:
+        if (_cache is not None
+                and _cache.repo_path == resolved
+                and _cache.mtime_hash == mtime_hash):
+            print("[contextl] graph cache hit", file=sys.stderr, flush=True)
+            return _cache.scan, _cache.repo_graph
+
+        # Cache miss — build the pipeline
+        print("[contextl] building graph...", file=sys.stderr, flush=True)
+        scan = scan_repo(resolved)
+        parse = parse_imports(scan)
+        repo_graph = build_graph(scan, parse)
+
+        _cache = _CacheEntry(
+            repo_path=resolved,
+            mtime_hash=mtime_hash,
+            scan=scan,
+            repo_graph=repo_graph,
+        )
+        print(f"[contextl] graph built: {scan.total_files} files", file=sys.stderr, flush=True)
+        return scan, repo_graph
+
+
 # ---------------------------------------------------------------------------
 # Server setup
 # ---------------------------------------------------------------------------
@@ -145,11 +226,11 @@ async def list_tools() -> list[types.Tool]:
             },
         ),
         types.Tool(
-            name="find_dead_files",
+            name="find_standalone_files",
             description=(
                 "Find files in the repository that are never imported by any other file "
                 "(in-degree of 0 in the dependency graph). Automatically filters out "
-                "standard entry points and test files. Use this to identify dead code "
+                "standard entry points and test files. Use this to identify standalone code "
                 "and unused files that can potentially be deleted."
             ),
             inputSchema={
@@ -203,8 +284,8 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
     if name == "analyze_impact":
         return await _handle_impact(arguments)
 
-    if name == "find_dead_files":
-        return await _handle_dead_files(arguments)
+    if name == "find_standalone_files":
+        return await _handle_standalone_files(arguments)
 
     if name == "export_obsidian_vault":
         return await _handle_export_obsidian(arguments)
@@ -231,10 +312,8 @@ async def _handle_query(args: dict) -> list[types.TextContent]:
 
 
 def _run_query(repo_path: str, query_str: str, top_n: int) -> dict:
-    """Synchronous pipeline — called from a thread executor."""
-    scan = scan_repo(repo_path)
-    parse = parse_imports(scan)
-    repo_graph = build_graph(scan, parse)
+    """Uses cached graph — pipeline runs only on first call or after file changes."""
+    scan, repo_graph = _get_graph(repo_path)
     ranked = engine_query(query_str, repo_graph, top_n=top_n)
 
     return {
@@ -268,7 +347,8 @@ async def _handle_scan(args: dict) -> list[types.TextContent]:
 
 
 def _run_scan(repo_path: str) -> dict:
-    scan = scan_repo(repo_path)
+    """Uses cached graph — pipeline runs only on first call or after file changes."""
+    scan, _ = _get_graph(repo_path)
     return {
         "repo": scan.root,
         "total_files": scan.total_files,
@@ -294,10 +374,8 @@ async def _handle_impact(args: dict) -> list[types.TextContent]:
 
 
 def _run_impact(repo_path: str, target_file: str, max_depth: int) -> dict:
-    """Synchronous pipeline — called from a thread executor."""
-    scan = scan_repo(repo_path)
-    parse = parse_imports(scan)
-    repo_graph = build_graph(scan, parse)
+    """Uses cached graph — pipeline runs only on first call or after file changes."""
+    scan, repo_graph = _get_graph(repo_path)
     report = analyze_impact(target_file, repo_graph, max_depth=max_depth)
 
     return {
@@ -321,30 +399,28 @@ def _run_impact(repo_path: str, target_file: str, max_depth: int) -> dict:
     }
 
 
-async def _handle_dead_files(args: dict) -> list[types.TextContent]:
+async def _handle_standalone_files(args: dict) -> list[types.TextContent]:
     repo_path = args.get("repo_path", "")
 
     loop = asyncio.get_event_loop()
     try:
-        result = await loop.run_in_executor(None, _run_dead_files, repo_path)
+        result = await loop.run_in_executor(None, _run_standalone_files, repo_path)
     except Exception as e:
         result = {"error": str(e), "repo": repo_path}
 
     return [types.TextContent(type="text", text=json.dumps(result, indent=2))]
 
 
-def _run_dead_files(repo_path: str) -> dict:
-    """Synchronous pipeline — called from a thread executor."""
-    scan = scan_repo(repo_path)
-    parse = parse_imports(scan)
-    repo_graph = build_graph(scan, parse)
-    dead_files = find_dead_files(repo_graph)
+def _run_standalone_files(repo_path: str) -> dict:
+    """Uses cached graph — pipeline runs only on first call or after file changes."""
+    scan, repo_graph = _get_graph(repo_path)
+    standalone_files = find_standalone_files(repo_graph)
 
     return {
         "repo": scan.root,
         "total_files_scanned": scan.total_files,
-        "total_dead_files": len(dead_files),
-        "dead_files": dead_files
+        "total_standalone_files": len(standalone_files),
+        "standalone_files": standalone_files
     }
 
 
@@ -362,13 +438,10 @@ async def _handle_export_obsidian(args: dict) -> list[types.TextContent]:
 
 
 def _run_export_obsidian(repo_path: str, output_dir: str) -> dict:
-    """Synchronous pipeline — called from a thread executor."""
-    scan = scan_repo(repo_path)
-    parse = parse_imports(scan)
-    repo_graph = build_graph(scan, parse)
-    
+    """Uses cached graph — pipeline runs only on first call or after file changes."""
+    scan, repo_graph = _get_graph(repo_path)
     vault_path = export_obsidian_vault(repo_graph, output_dir)
-    
+
     return {
         "repo": scan.root,
         "vault_path": vault_path,

package/python/{dead_code.py → standalone.py}

@@ -1,6 +1,6 @@
 """
 Repository Intelligence Engine
-Step 7: Dead Code Analysis
+Step 7: Standalone Files Analysis
 
 Finds files in the dependency graph that have an in-degree of 0 
 (meaning they are never imported by any other file), while filtering 
@@ -19,29 +19,33 @@ ENTRY_POINT_MARKERS = {
     "globals.css", "global.css", "tailwind.css",
     "index.ts", "index.js", "index.tsx", "index.jsx",
     "main.ts", "main.js", "main.py",
+    "app.ts", "app.js", "app.tsx", "app.jsx", "app.py",
+    "mcp_server.py", "server.ts", "server.js", "server.py",
     "__main__.py", "__init__.py", "setup.py", "conftest.py",
     "next.config", "tailwind.config", "postcss.config", "vite.config", "webpack.config"
 }
 
 def _is_entry_point(path: str) -> bool:
     lowered = path.lower()
+    if lowered.endswith(".d.ts"):
+        return True
     for marker in ENTRY_POINT_MARKERS:
         if marker in lowered:
             return True
     return False
 
-def find_dead_files(repo_graph: RepoGraph) -> list[str]:
+def find_standalone_files(repo_graph: RepoGraph) -> list[str]:
     """
     Find files with in-degree 0, excluding entry points and tests.
     """
-    dead_files = []
+    standalone_files = []
     
     for path, node in repo_graph.nodes.items():
         if node.in_degree == 0:
             if not _is_test_file(path) and not _is_entry_point(path):
-                dead_files.append(path)
+                standalone_files.append(path)
                 
-    return sorted(dead_files)
+    return sorted(standalone_files)
 
 if __name__ == "__main__":
     import sys
@@ -50,7 +54,7 @@ if __name__ == "__main__":
     from graph_builder import build_graph
 
     if len(sys.argv) < 2:
-        print("Usage: python dead_code.py <repo_path>")
+        print("Usage: python standalone.py <repo_path>")
         sys.exit(1)
 
     repo_path = sys.argv[1]
@@ -58,8 +62,8 @@ if __name__ == "__main__":
     parse = parse_imports(scan)
     repo_graph = build_graph(scan, parse)
 
-    dead = find_dead_files(repo_graph)
+    standalone = find_standalone_files(repo_graph)
     
-    print(f"Found {len(dead)} potentially dead files:")
-    for f in dead:
+    print(f"Found {len(standalone)} standalone files:")
+    for f in standalone:
         print(f"  - {f}")