contextl 1.2.15 → 1.2.17

package/README.md

@@ -140,6 +140,8 @@ Extracts the structural skeleton (API surface) of a source file using Tree-sitte
 
 
 
+## How the ranking works
+
 1. **Keyword match** — does the filename contain query terms?
 2. **Content match** — does the file's source code mention the terms?
 3. **Graph proximity** — files connected to high-scoring files get a relevance boost

package/package.json

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

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)
@@ -461,19 +471,19 @@ 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 loop.run_in_executor(None, _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)

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: