contextl 1.2.16 → 1.2.18

package/bin/contextl.js

@@ -106,7 +106,7 @@ function pipInstall(python, packageName) {
 function ensureDeps(python) {
   const required = [
     { importName: "networkx", pipName: "networkx" },
-    { importName: "mcp",      pipName: "mcp" },
+    { importName: "mcp",      pipName: "mcp>=1.0.0" },
     { importName: "tree_sitter", pipName: "tree-sitter>=0.22.0" },
     { importName: "tree_sitter_python", pipName: "tree-sitter-python>=0.22.0" },
     { importName: "tree_sitter_javascript", pipName: "tree-sitter-javascript>=0.22.0" },

package/package.json

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

package/python/git_review.py

@@ -58,13 +58,16 @@ def _run_git(args: list[str], cwd: str) -> list[str]:
 
 
 def _is_git_repo(repo_path: str) -> bool:
-    result = subprocess.run(
-        ["git", "rev-parse", "--is-inside-work-tree"],
-        cwd=repo_path,
-        capture_output=True,
-        text=True,
-    )
-    return result.returncode == 0
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
 
 
 def get_changed_files(

package/python/graph_builder.py

@@ -34,6 +34,10 @@ class FileNode:
     out_degree: int = 0       # files this imports
     centrality: float = 0.0   # PageRank score
 
+    # Text data (computed once)
+    content: str = ""
+    doc_length: int = 0
+
 
 @dataclass
 class RepoGraph:
@@ -126,16 +130,30 @@ def build_graph(scan_result, parse_result: ParseResult) -> RepoGraph:
     """
     G = nx.DiGraph()
 
+    import re
+
     # Add all scanned files as nodes
     file_nodes: dict[str, FileNode] = {}
     for f in scan_result.files:
+        abs_path = str(Path(scan_result.root) / f.path)
+        try:
+            with open(abs_path, "r", encoding="utf-8") as f_obj:
+                content = f_obj.read()
+            dl = len(re.findall(r"[a-z0-9]+", content.lower()))
+        except Exception:
+            content = ""
+            dl = 0
+
         node = FileNode(
             path=f.path,
             extension=f.extension,
             size_bytes=f.size_bytes,
+            content=content,
+            doc_length=dl,
         )
         file_nodes[f.path] = node
-        G.add_node(f.path, **vars(node))
+        # Add basic node properties to nx graph
+        G.add_node(f.path, path=node.path, extension=node.extension, size_bytes=node.size_bytes)
 
     # Add edges from import relationships
     for rel in parse_result.relationships:

package/python/import_parser.py

@@ -1367,6 +1367,85 @@ def _skeleton_rust(root: "Node") -> dict:
     return {"classes": classes, "functions": functions, "exports": exports, "docstrings": docstrings}
 
 
+
+def _skeleton_go(root: "Node") -> dict:
+    classes = []
+    functions = []
+    exports = []
+    docstrings = {}
+
+    def visit_fn(node: "Node") -> dict:
+        name = ""
+        params = ""
+        ret_type = ""
+        is_method = (node.type == "method_declaration")
+        receiver = ""
+
+        for child in node.children:
+            if child.type == "identifier" or child.type == "field_identifier":
+                if not name:
+                    name = _node_text(child)
+            elif child.type == "parameter_list":
+                if is_method and not receiver:
+                    receiver = _node_text(child)
+                else:
+                    params = _node_text(child)
+            elif child.type == "type_identifier":
+                ret_type = _node_text(child)
+
+        return {"name": name, "params": params, "return_type": ret_type, "visibility": "pub" if name and name[0].isupper() else "private", "is_async": False, "decorators": [], "receiver": receiver}
+
+    def visit(node: "Node"):
+        if node.type in ("function_declaration", "method_declaration"):
+            functions.append(visit_fn(node))
+        elif node.type == "type_spec":
+            name = ""
+            for child in node.children:
+                if child.type == "type_identifier":
+                    name = _node_text(child)
+                elif child.type == "struct_type" or child.type == "interface_type":
+                    if name:
+                        classes.append({"name": name, "fields": [], "methods": [], "extends": "", "implements": [], "properties": []})
+        for child in node.children:
+            visit(child)
+
+    visit(root)
+    return {"classes": classes, "functions": functions, "exports": exports, "docstrings": docstrings}
+
+def _skeleton_cpp(root: "Node") -> dict:
+    classes = []
+    functions = []
+    exports = []
+    docstrings = {}
+
+    def visit_fn(node: "Node") -> dict:
+        name = ""
+        params = ""
+        for child in node.children:
+            if child.type == "function_declarator":
+                for sub in child.children:
+                    if sub.type == "identifier" or sub.type == "field_identifier":
+                        name = _node_text(sub)
+                    elif sub.type == "parameter_list":
+                        params = _node_text(sub)
+        return {"name": name, "params": params, "return_type": "", "visibility": "pub", "is_async": False, "decorators": []}
+
+    def visit(node: "Node"):
+        if node.type == "function_definition":
+            functions.append(visit_fn(node))
+        elif node.type in ("class_specifier", "struct_specifier"):
+            name = ""
+            for child in node.children:
+                if child.type == "type_identifier":
+                    name = _node_text(child)
+            if name:
+                classes.append({"name": name, "fields": [], "methods": [], "extends": "", "implements": [], "properties": []})
+        for child in node.children:
+            visit(child)
+
+    visit(root)
+    return {"classes": classes, "functions": functions, "exports": exports, "docstrings": docstrings}
+
 _SKELETON_HANDLERS = {
     ".py":  _skeleton_python,
     ".ts":  _skeleton_ts_js,
@@ -1375,6 +1454,12 @@ _SKELETON_HANDLERS = {
     ".jsx": _skeleton_ts_js,
     ".java": _skeleton_java,
     ".rs":  _skeleton_rust,
+    ".go": _skeleton_go,
+    ".cpp": _skeleton_cpp,
+    ".h": _skeleton_cpp,
+    ".hpp": _skeleton_cpp,
+    ".cc": _skeleton_cpp,
+    ".c": _skeleton_cpp,
 }
 
 

package/python/mcp_server.py

@@ -14,7 +14,7 @@ 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
-    find_standalone_files  — find unimported files with in-degree 0
+    find_dead_files        — find unimported files with in-degree 0
     export_obsidian_vault  — export repo graph to an Obsidian markdown vault
 
 Performance:
@@ -61,10 +61,11 @@ class _CacheEntry:
     mtime_hash: float       # max mtime across all source files at build time
     scan: object            # ScanResult
     repo_graph: object      # RepoGraph
+    last_checked_time: float = 0.0
 
 
 _cache_lock = threading.Lock()
-_cache: Optional[_CacheEntry] = None
+_cache: dict[str, _CacheEntry] = {}
 
 
 def _compute_mtime_hash(repo_path: str) -> float:
@@ -95,16 +96,24 @@ def _get_graph(repo_path: str):
     On subsequent calls with unchanged files: returns instantly from cache.
     """
     global _cache
+    import time
 
     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):
+        now = time.time()
+        entry = _cache.get(resolved)
+        
+        # Fast path: bypass filesystem walk if checked within last 5 seconds
+        if entry and (now - entry.last_checked_time < 5.0):
+            return entry.scan, entry.repo_graph
+
+        mtime_hash = _compute_mtime_hash(resolved)
+
+        if entry and entry.mtime_hash == mtime_hash:
+            entry.last_checked_time = now
             print("[contextl] graph cache hit", file=sys.stderr, flush=True)
-            return _cache.scan, _cache.repo_graph
+            return entry.scan, entry.repo_graph
 
         # Cache miss — build the pipeline
         print("[contextl] building graph...", file=sys.stderr, flush=True)
@@ -112,11 +121,12 @@ def _get_graph(repo_path: str):
         parse = parse_imports(scan)
         repo_graph = build_graph(scan, parse)
 
-        _cache = _CacheEntry(
+        _cache[resolved] = _CacheEntry(
             repo_path=resolved,
             mtime_hash=mtime_hash,
             scan=scan,
             repo_graph=repo_graph,
+            last_checked_time=now,
         )
         print(f"[contextl] graph built: {scan.total_files} files", file=sys.stderr, flush=True)
         return scan, repo_graph
@@ -228,7 +238,7 @@ async def list_tools() -> list[types.Tool]:
             },
         ),
         types.Tool(
-            name="find_standalone_files",
+            name="find_dead_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 "
@@ -340,8 +350,8 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
     if name == "analyze_impact":
         return await _handle_impact(arguments)
 
-    if name == "find_standalone_files":
-        return await _handle_standalone_files(arguments)
+    if name == "find_dead_files":
+        return await _handle_dead_files(arguments)
 
     if name == "export_obsidian_vault":
         return await _handle_export_obsidian(arguments)
@@ -363,10 +373,8 @@ async def _handle_query(args: dict) -> list[types.TextContent]:
     query_str = args.get("query", "")
     top_n = min(int(args.get("top_n", 5)), 20)
 
-    # Run the engine (synchronous — wrap in thread to stay async-safe)
-    loop = asyncio.get_event_loop()
     try:
-        result = await loop.run_in_executor(None, _run_query, repo_path, query_str, top_n)
+        result = await asyncio.to_thread(_run_query, repo_path, query_str, top_n)
     except Exception as e:
         result = {"error": str(e), "query": query_str, "repo": repo_path, "results": []}
 
@@ -399,9 +407,8 @@ def _run_query(repo_path: str, query_str: str, top_n: int) -> dict:
 async def _handle_scan(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_scan, repo_path)
+        result = await asyncio.to_thread(_run_scan, repo_path)
     except Exception as e:
         result = {"error": str(e), "repo": repo_path}
 
@@ -426,9 +433,8 @@ async def _handle_impact(args: dict) -> list[types.TextContent]:
     target_file = args.get("target_file", "")
     max_depth = min(int(args.get("max_depth", 5)), 10)
 
-    loop = asyncio.get_event_loop()
     try:
-        result = await loop.run_in_executor(None, _run_impact, repo_path, target_file, max_depth)
+        result = await asyncio.to_thread(_run_impact, repo_path, target_file, max_depth)
     except Exception as e:
         result = {"error": str(e), "repo": repo_path, "target_file": target_file}
 
@@ -461,19 +467,18 @@ def _run_impact(repo_path: str, target_file: str, max_depth: int) -> dict:
     }
 
 
-async def _handle_standalone_files(args: dict) -> list[types.TextContent]:
+async def _handle_dead_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_standalone_files, repo_path)
+        result = await asyncio.to_thread(_run_dead_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_standalone_files(repo_path: str) -> dict:
+def _run_dead_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)
@@ -490,9 +495,8 @@ async def _handle_export_obsidian(args: dict) -> list[types.TextContent]:
     repo_path = args.get("repo_path", "")
     output_dir = args.get("output_dir", "")
 
-    loop = asyncio.get_event_loop()
     try:
-        result = await loop.run_in_executor(None, _run_export_obsidian, repo_path, output_dir)
+        result = await asyncio.to_thread(_run_export_obsidian, repo_path, output_dir)
     except Exception as e:
         result = {"error": str(e), "repo": repo_path, "output_dir": output_dir}
 
@@ -517,10 +521,9 @@ async def _handle_review_changes(args: dict) -> list[types.TextContent]:
     include_staged   = bool(args.get("staged", True))
     include_unstaged = bool(args.get("unstaged", True))
 
-    loop = asyncio.get_event_loop()
     try:
-        result = await loop.run_in_executor(
-            None, _run_review_changes, repo_path, include_staged, include_unstaged
+        result = await asyncio.to_thread(
+            _run_review_changes, repo_path, include_staged, include_unstaged
         )
     except Exception as e:
         result = {"error": str(e), "repo": repo_path}
@@ -554,9 +557,8 @@ def _run_review_changes(repo_path: str, include_staged: bool, include_unstaged:
 async def _handle_get_skeleton(args: dict) -> list[types.TextContent]:
     file_path = args.get("file_path", "")
 
-    loop = asyncio.get_event_loop()
     try:
-        result = await loop.run_in_executor(None, extract_skeleton, file_path)
+        result = await asyncio.to_thread(extract_skeleton, file_path)
     except Exception as e:
         result = {"error": str(e), "file": file_path}
 

package/python/obsidian_export.py

@@ -13,21 +13,18 @@ import re
 from pathlib import Path
 
 from scanner import scan_repo
-from import_parser import parse_imports
+from import_parser import parse_imports, extract_skeleton
 from graph_builder import build_graph, RepoGraph
 
-
-PYTHON_DOCSTRING_PATTERN = re.compile(r'^\s*["\']{3}(.*?)["\']{3}', re.DOTALL)
-JS_DOC_PATTERN = re.compile(r'^\s*/\*\*(.*?)\*/', re.DOTALL)
-OUTLINE_PATTERN = re.compile(r'^\s*(?:export\s+)?(?:class|def|function|interface|type)\s+([a-zA-Z0-9_]+)', re.MULTILINE)
-
 def _extract_file_context(file_path: str, extension: str, root_dir: str) -> tuple[str, list[str], str]:
     """Returns (explanation, outline_symbols, snippet)."""
     explanation = "*No explanation provided in source code.*"
     outline = []
     snippet = ""
+    abs_path = str(Path(root_dir) / file_path)
+    
     try:
-        content = (Path(root_dir) / file_path).read_text(encoding="utf-8")
+        content = Path(abs_path).read_text(encoding="utf-8")
         
         # 1. Snippet (first 20 lines)
         lines = content.splitlines()
@@ -35,21 +32,20 @@ def _extract_file_context(file_path: str, extension: str, root_dir: str) -> tupl
         if len(lines) > 20:
             snippet += "\n..."
             
-        # 2. Explanation
-        if extension == ".py":
-            match = PYTHON_DOCSTRING_PATTERN.search(content)
-            if match:
-                explanation = match.group(1).strip()
-        elif extension in {".ts", ".tsx", ".js", ".jsx", ".java"}:
-            match = JS_DOC_PATTERN.search(content)
-            if match:
-                clean_lines = [line.strip().lstrip('*').strip() for line in match.group(1).split('\n')]
-                explanation = "\n".join(clean_lines).strip()
+        # 2 & 3. Explanation and Outline from Tree-Sitter
+        skeleton = extract_skeleton(abs_path)
+        
+        if "error" not in skeleton:
+            # Grab the first docstring if it exists
+            if skeleton["docstrings"]:
+                explanation = list(skeleton["docstrings"].values())[0]
+                
+            # Collect classes and functions
+            for cls in skeleton["classes"]:
+                outline.append(cls["name"])
+            for fn in skeleton["functions"]:
+                outline.append(fn["name"])
                 
-        # 3. Outline
-        for match in OUTLINE_PATTERN.finditer(content):
-            outline.append(match.group(1))
-            
     except Exception:
         pass
         

package/python/query_engine.py

@@ -296,48 +296,37 @@ def query(
         return []
 
     # --- Pre-computation: Global TF-IDF & BM25 ---
-    import pathlib
     total_files = len(repo_graph.nodes)
     document_frequency = {term: 0 for term in query_terms}
     
-    file_contents = {}
-    doc_lengths = {}
     total_tokens_count = 0
     
     for path, node in repo_graph.nodes.items():
-        abs_path = node.path if hasattr(node, "absolute_path") else str(__import__("pathlib").Path(repo_graph.root) / path)
-        try:
-            content = open(abs_path, encoding="utf-8").read()
-            file_contents[path] = content
-            
-            raw_tokens = re.findall(r"[a-z0-9]+", content.lower())
-            dl = len(raw_tokens)
-            doc_lengths[path] = dl
-            total_tokens_count += dl
-            
-            content_tokens = set(raw_tokens)
+        content = node.content
+        dl = node.doc_length
+        total_tokens_count += dl
+        
+        raw_tokens = re.findall(r"[a-z0-9]+", content.lower())
+        content_tokens = set(raw_tokens)
+        
+        if path.endswith(".java"):
+            camel_tokens = []
+            for word in re.findall(r"[a-zA-Z]+", content):
+                if any(c.isupper() for c in word):
+                    sub = re.sub(r"([A-Z])", r" \1", word).lower()
+                    camel_tokens.extend(re.findall(r"[a-z0-9]+", sub))
+            content_tokens.update([t for t in camel_tokens if len(t) > 1])
             
-            if path.endswith(".java"):
-                camel_tokens = []
-                for word in re.findall(r"[a-zA-Z]+", content):
-                    if any(c.isupper() for c in word):
-                        sub = re.sub(r"([A-Z])", r" \1", word).lower()
-                        camel_tokens.extend(re.findall(r"[a-z0-9]+", sub))
-                content_tokens.update([t for t in camel_tokens if len(t) > 1])
-                
-            path_tokens = set(_path_tokens(path))
-            combined_tokens = content_tokens.union(path_tokens)
-            for term in query_terms:
-                if term in combined_tokens:
-                    document_frequency[term] += 1
-                elif len(term) > 3:
-                    for ct in combined_tokens:
-                        if term in ct:
-                            document_frequency[term] += 1
-                            break
-        except Exception:
-            file_contents[path] = ""
-            doc_lengths[path] = 0
+        path_tokens = set(_path_tokens(path))
+        combined_tokens = content_tokens.union(path_tokens)
+        for term in query_terms:
+            if term in combined_tokens:
+                document_frequency[term] += 1
+            elif len(term) > 3:
+                for ct in combined_tokens:
+                    if term in ct:
+                        document_frequency[term] += 1
+                        break
 
     avgdl = total_tokens_count / total_files if total_files > 0 else 1.0
 
@@ -357,8 +346,8 @@ def query(
 
     for path, node in repo_graph.nodes.items():
         kscore, kterms = _keyword_score(query_terms, path, idf_weights)
-        dl = doc_lengths.get(path, 0)
-        cscore, cterms = _content_score(query_terms, path, file_contents.get(path, ""), idf_weights, dl, avgdl)
+        dl = node.doc_length
+        cscore, cterms = _content_score(query_terms, path, node.content, idf_weights, dl, avgdl)
 
         keyword_scores[path] = kscore
         content_scores[path] = cscore
@@ -373,10 +362,10 @@ def query(
         
         base_scores[path] = combined
 
-    # --- Pass 3: neighbor bonus ---
+    # --- Pass 2: neighbor bonus ---
     boosted_scores = _apply_neighbor_bonus(base_scores, repo_graph)
 
-    # --- Pass 4: centrality tiebreaker ---
+    # --- Pass 3: centrality tiebreaker ---
     results = []
     for path, node in repo_graph.nodes.items():
         neighbor_bonus = boosted_scores[path] - base_scores[path]

package/python/scanner.py

@@ -3,7 +3,7 @@ Repository Intelligence Engine
 Step 1: Repository Scanner
 
 Walks a repository and discovers all relevant source files.
-Filters by supported extensions for the MVP (Next.js / React / TypeScript).
+Filters by supported extensions across 9 language families.
 """
 
 import os
@@ -17,7 +17,8 @@ SUPPORTED_EXTENSIONS = {".tsx", ".ts", ".jsx", ".js", ".py", ".java", ".go", ".r
 ignore_dirs = {
     ".git", "node_modules", "__pycache__", "venv", ".venv",
     "env", ".env", ".next", ".nuxt", "out", "build", "dist",
-    "coverage", ".nyc_output", ".pytest_cache", "npm", "pypi"
+    "coverage", ".nyc_output", ".pytest_cache", "npm", "pypi",
+    "vendor", "target", ".cargo", "Pods", "third_party"
 }
 
 def _should_ignore(path: str) -> bool: