contextl 1.2.17 → 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.17",
+  "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/mcp_server.py

@@ -373,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": []}
 
@@ -409,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}
 
@@ -436,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}
 
@@ -474,9 +470,8 @@ def _run_impact(repo_path: str, target_file: str, max_depth: int) -> dict:
 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_dead_files, repo_path)
+        result = await asyncio.to_thread(_run_dead_files, repo_path)
     except Exception as e:
         result = {"error": str(e), "repo": repo_path}
 
@@ -500,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}
 
@@ -527,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}
@@ -564,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]