contextl 1.2.14 → 1.2.16

package/README.md

@@ -45,7 +45,7 @@ If you prefer to configure it manually, add this to your IDE's MCP config file:
 
 | IDE | Config path |
 |-----|-------------|
-| Antigravity | `~/.gemini/config/mcp_config.json` |
+| Gemini CLI | `~/.gemini/config/mcp_config.json` |
 | Cursor | `~/.cursor/mcp.json` |
 | Windsurf | `~/.codeium/windsurf/mcp_config.json` |
 | Claude Code | `~/.claude.json` |
@@ -57,18 +57,33 @@ Restart your IDE. Done — no cloning, no Python setup beyond having it installe
 
 ## What it gives your agent
 
-Three tools, automatically available once connected:
+Seven tools, automatically available once connected:
 
 ### `query_repo`
 *"Find the files relevant to this change."*
 
 Ranks every file in your repo against a natural-language query using filename matching, content matching, and graph proximity. Returns confidence-scored results with plain-English reasoning.
 
+```json
+{
+  "repo_path": "/path/to/repo",
+  "query": "fix the upload error handler",
+  "top_n": 5
+}
+```
+
 ### `analyze_impact`
 *"If I change this file, what breaks?"*
 
 Walks the dependency graph upstream from any file to find every direct and transitive dependent. Flags likely test files so your agent knows what to re-run. Essential before touching shared files like `types/`, `utils/`, or config.
 
+```json
+{
+  "repo_path": "/path/to/repo",
+  "target_file": "src/types/index.ts"
+}
+```
+
 ### `scan_repo`
 *"What files exist here?"*
 
@@ -79,11 +94,50 @@ Lists every source file `contextl` can see — useful for the agent to orient it
 
 Finds unused files and dead code by analyzing the dependency graph for files with an in-degree of 0. Automatically filters out standard entry points (like `page.tsx` or `index.ts`) and test files.
 
+```json
+{
+  "repo_path": "/path/to/repo"
+}
+```
+
 ### `export_obsidian_vault`
 *"Visualize this codebase in Obsidian."*
 
 Takes the exact dependency graph built by the intelligence engine and physically writes it to disk as a directory of interconnected Markdown files. Automatically injects file metadata, JSDoc/Docstring explanations, and uses standard `[[wikilinks]]` to map out dependencies. Open the generated folder as an Obsidian vault for a stunning 3D interactive graph of your architecture!
 
+```json
+{
+  "repo_path": "/path/to/repo",
+  "output_dir": "/path/to/save/vault"
+}
+```
+
+### `review_changes`
+*"I'm reviewing or changing some code. What's the impact?"*
+
+Git-aware context builder. Reads the current git diff to find what files you are editing, then automatically runs impact analysis to find every file that depends on your changes. Returns a structured context bundle with the changed files, full blast radius, and suggested tests to re-run.
+
+```json
+{
+  "repo_path": "/path/to/repo",
+  "staged": true,
+  "unstaged": true
+}
+```
+
+### `get_skeleton`
+*"Show me the API of this huge file."*
+
+Extracts the structural skeleton (API surface) of a source file using Tree-sitter — including all class names, method signatures, return types, and docstrings — without pulling in any implementation bodies. Shrinks a 5,000-line file into a ~100-line reference header.
+
+```json
+{
+  "file_path": "/path/to/src/api.py"
+}
+```
+
+
+
 
 
 ## How the ranking works
@@ -98,10 +152,12 @@ Takes the exact dependency graph built by the intelligence engine and physically
 ## Supported languages
 
 **JavaScript ecosystem**: TypeScript, TSX, JavaScript, JSX.
-**Backend ecosystem**: Python (`.py`) and Java (`.java`).
+**Backend ecosystem**: Python (`.py`), Java (`.java`), Rust (`.rs`), Go (`.go`), C/C++ (`.cpp`, `.c`, `.h`).
 
 The engine natively understands dot-notation module paths (`from X import Y`, `import com.example.X;`) and correctly resolves them to physical file paths to build the architecture graph.
 
+> **Note:** Wildcard imports (e.g. `use super::*`, `use crate::*`) are intentionally left unresolved. ContextL maps explicit dependency paths only.
+
 ---
 
 ## The Global CLI
@@ -120,6 +176,9 @@ contextl dead-code ./my-repo
 
 # 4. Generate an Obsidian vault
 contextl obsidian ./my-repo ./my_vault
+
+# 5. Git-aware review / impact of current edits
+contextl review ./my-repo
 ```
 
 *(Note: If you omit the sub-command, `contextl ./my-repo "query"` will automatically default to `search` for backwards compatibility).*

package/bin/contextl.js

@@ -107,6 +107,14 @@ function ensureDeps(python) {
   const required = [
     { importName: "networkx", pipName: "networkx" },
     { importName: "mcp",      pipName: "mcp" },
+    { 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" },
+    { importName: "tree_sitter_typescript", pipName: "tree-sitter-typescript>=0.22.0" },
+    { importName: "tree_sitter_java", pipName: "tree-sitter-java>=0.22.0" },
+    { importName: "tree_sitter_rust", pipName: "tree-sitter-rust>=0.22.0" },
+    { importName: "tree_sitter_go", pipName: "tree-sitter-go>=0.22.0" },
+    { importName: "tree_sitter_cpp", pipName: "tree-sitter-cpp>=0.22.0" },
   ];
 
   for (const { importName, pipName } of required) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextl",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "description": "contextl — finds the most relevant files in your codebase for any change request. MCP server for AI coding agents.",
   "keywords": [
     "mcp",
@@ -16,10 +16,13 @@
     "nextjs",
     "python",
     "java",
+    "rust",
+    "go",
+    "cpp",
     "obsidian",
     "repository"
   ],
-  "homepage": "https://github.com/DS0710-coder",
+  "homepage": "https://github.com/DS0710-coder/contextl",
   "license": "MIT",
   "author": "dev7shah",
   "bin": {

package/python/import_parser.py

@@ -213,7 +213,15 @@ def _ts_imports_rust(root: "Node") -> list[str]:
             # Grab the first meaningful child (scoped_identifier, scoped_use_list, identifier)
             for child in node.children:
                 if child.type not in ("use", ";"):
-                    results.append(child.text.decode("utf-8", errors="replace"))
+                    raw = child.text.decode("utf-8", errors="replace")
+                    import re
+                    match = re.match(r'^(.*?)::\{([^}]+)\}$', raw)
+                    if match:
+                        base = match.group(1)
+                        for item in match.group(2).split(','):
+                            results.append(f"{base}::{item.strip()}")
+                    else:
+                        results.append(raw)
                     break
         elif node.type == "extern_crate_declaration":
             for child in node.children:
@@ -419,11 +427,24 @@ def _resolve_relative(import_path: str, source_file: str) -> str:
     return str(PurePosixPath(*parts)) if parts else "."
 
 
+def _path_distance(source: str, target: str) -> int:
+    s_parts = source.split('/')[:-1]
+    t_parts = target.split('/')[:-1]
+    common = 0
+    for s, t in zip(s_parts, t_parts):
+        if s == t:
+            common += 1
+        else:
+            break
+    return (len(s_parts) - common) + (len(t_parts) - common)
+
+
 def _find_file_in_repo(
     candidate: str,
     file_index: dict,
     root: str,
     extension: str = "",
+    source_file: str = "",
 ) -> str | None:
     root_path = Path(root)
     candidate_path = Path(candidate)
@@ -452,6 +473,85 @@ def _find_file_in_repo(
                     return path
         return None
 
+    if extension in (".cpp", ".cc", ".cxx", ".h", ".hpp", ".c"):
+        suffix = "/" + candidate_str
+        matches = []
+        for path in file_index:
+            if path.endswith(suffix) or path == candidate_str:
+                matches.append(path)
+        if not matches and "/" in candidate_str:
+            base_name = "/" + candidate_str.split("/")[-1]
+            for path in file_index:
+                if path.endswith(base_name) or path == base_name.lstrip("/"):
+                    matches.append(path)
+        if matches:
+            if source_file:
+                matches.sort(key=lambda p: _path_distance(source_file, p))
+            return matches[0]
+        return None
+
+    if extension == ".rs":
+        if candidate_str.startswith("crate/"):
+            match_str = candidate_str[6:]
+        else:
+            match_str = candidate_str
+        
+        rs_suffix = "/" + match_str + ".rs"
+        mod_suffix = "/" + match_str + "/mod.rs"
+        matches = []
+        for path in file_index:
+            if path.endswith(rs_suffix) or path == match_str + ".rs":
+                matches.append(path)
+            if path.endswith(mod_suffix) or path == match_str + "/mod.rs":
+                matches.append(path)
+        
+        if not matches and "/" in match_str:
+            parts = match_str.split("/")
+            for i in range(len(parts) - 1, 0, -1):
+                sub_path = "/" + "/".join(parts[:i])
+                b_rs = sub_path + ".rs"
+                b_mod = sub_path + "/mod.rs"
+                for path in file_index:
+                    if path.endswith(b_rs) or path.endswith(b_mod) or path == b_rs.lstrip("/") or path == b_mod.lstrip("/"):
+                        matches.append(path)
+                if matches:
+                    break
+        
+        if matches:
+            if source_file:
+                matches.sort(key=lambda p: _path_distance(source_file, p))
+            return matches[0]
+        return None
+
+    if extension == ".go":
+        matches = []
+        for path in file_index:
+            parent_dir = path.rsplit("/", 1)[0] if "/" in path else ""
+            if parent_dir and candidate_str.endswith(parent_dir):
+                matches.append(path)
+            elif candidate_str.endswith(path.replace(".go", "")):
+                matches.append(path)
+        
+        if not matches:
+            last_part = candidate_str.split("/")[-1]
+            fallback_suffix = "/" + last_part + "/"
+            for path in file_index:
+                if fallback_suffix in path or path.startswith(last_part + "/"):
+                    matches.append(path)
+        
+        if matches:
+            matches.sort()
+            last_part = candidate_str.split("/")[-1]
+            preferred = "/" + last_part + ".go"
+            for m in matches:
+                if m.endswith(preferred) or m == preferred.lstrip("/"):
+                    return m
+            for m in matches:
+                if m.endswith("/mod.go") or m == "mod.go":
+                    return m
+            return matches[0]
+        return None
+
     if extension == ".py":
         py_ext = candidate_str + ".py"
         if py_ext in file_index:
@@ -565,6 +665,28 @@ def _detect_alias_map(scan_result: ScanResult) -> dict[str, str]:
         except Exception:
             pass
 
+    for gomod in root.rglob("go.mod"):
+        if any(p in ignore for p in gomod.parts):
+            continue
+        try:
+            text = gomod.read_text(encoding="utf-8")
+            for line in text.splitlines():
+                if line.startswith("module "):
+                    mod_name = line.split(" ")[1].strip()
+                    try:
+                        repo_rel = str(gomod.parent.relative_to(root)).replace("\\", "/")
+                        if repo_rel == ".":
+                            alias_map[mod_name] = ""
+                            alias_map[mod_name + "/"] = ""
+                        else:
+                            alias_map[mod_name] = repo_rel
+                            alias_map[mod_name + "/"] = repo_rel + "/"
+                    except ValueError:
+                        pass
+                    break
+        except Exception:
+            pass
+
     if not alias_map:
         top_dirs = {Path(f.path).parts[0] for f in scan_result.files if Path(f.path).parts}
         if len(top_dirs) == 1:
@@ -716,11 +838,17 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
                 else:
                     candidate = raw.replace(".", "/")
 
-            elif scanned_file.extension in (".rs", ".go", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".c"):
-                # Rust/Go/C++ — raw import strings don't map directly to file paths
-                # without more context; add to unresolved so graph ignores them gracefully
-                result.unresolved.append((scanned_file.path, raw))
-                continue
+            elif scanned_file.extension in (".cpp", ".cc", ".cxx", ".h", ".hpp", ".c"):
+                candidate = raw
+            elif scanned_file.extension == ".rs":
+                is_likely_external = not (raw.startswith("crate::") or raw.startswith("super::") or raw.startswith("self::"))
+                candidate = raw.replace("::", "/")
+            elif scanned_file.extension == ".go":
+                resolved = _resolve_alias(raw, alias_map)
+                if resolved is not None:
+                    candidate = resolved
+                else:
+                    candidate = raw
 
             else:
                 # Node.js / TypeScript
@@ -730,7 +858,7 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
                 else:
                     candidate = _resolve_relative(raw, scanned_file.path)
 
-            matched = _find_file_in_repo(candidate, file_index, scan_result.root, scanned_file.extension)
+            matched = _find_file_in_repo(candidate, file_index, scan_result.root, scanned_file.extension, scanned_file.path)
 
             if matched:
                 result.relationships.append(
@@ -741,6 +869,8 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
                     )
                 )
             else:
+                if scanned_file.extension == ".rs" and locals().get("is_likely_external", False):
+                    continue
                 result.unresolved.append((scanned_file.path, raw))
 
     return result

package/python/scanner.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from dataclasses import dataclass, field
 
 
-SUPPORTED_EXTENSIONS = {".tsx", ".ts", ".jsx", ".js", ".py", ".java"}
+SUPPORTED_EXTENSIONS = {".tsx", ".ts", ".jsx", ".js", ".py", ".java", ".go", ".rs", ".cpp", ".cc", ".c", ".h", ".hpp"}
 
 ignore_dirs = {
     ".git", "node_modules", "__pycache__", "venv", ".venv",