contextl 1.2.13 → 1.2.15

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,14 +94,51 @@ 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
 
 1. **Keyword match** — does the filename contain query terms?
 2. **Content match** — does the file's source code mention the terms?
@@ -98,10 +150,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 +174,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.13",
+  "version": "1.2.15",
   "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/git_review.py

@@ -0,0 +1,245 @@
+"""
+Repository Intelligence Engine
+Feature #6: Git-Aware Context
+
+Reads git diff to find what you've changed, then builds a full blast-radius
+context package showing every file that depends on your changes — ready for
+AI review.
+"""
+
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Data structures
+# ---------------------------------------------------------------------------
+
+@dataclass
+class FileReview:
+    path: str
+    status: str           # "staged", "unstaged", or "staged+unstaged"
+    direct_dependents: list[str] = field(default_factory=list)
+    transitive_dependents: list[str] = field(default_factory=list)
+    test_files: list[str] = field(default_factory=list)
+
+
+@dataclass
+class ReviewContext:
+    repo: str
+    changed_files: list[FileReview]
+    all_affected: list[str]        # union of all dependents, deduped, sorted
+    suggested_tests: list[str]     # union of all test files, deduped, sorted
+    staged_count: int
+    unstaged_count: int
+
+
+# ---------------------------------------------------------------------------
+# Git helpers
+# ---------------------------------------------------------------------------
+
+def _run_git(args: list[str], cwd: str) -> list[str]:
+    """Run a git command and return non-empty lines of stdout."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.returncode != 0:
+            return []
+        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return []
+
+
+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
+
+
+def get_changed_files(
+    repo_path: str,
+    include_staged: bool = True,
+    include_unstaged: bool = True,
+) -> tuple[set[str], set[str]]:
+    """
+    Returns (staged_files, unstaged_files) as sets of relative paths.
+    Only includes files that actually exist on disk (deleted files are excluded).
+    """
+    staged: set[str] = set()
+    unstaged: set[str] = set()
+
+    if include_staged:
+        for f in _run_git(["diff", "--cached", "--name-only", "--diff-filter=ACMRT"], repo_path):
+            full = Path(repo_path) / f
+            if full.exists():
+                staged.add(f)
+
+    if include_unstaged:
+        for f in _run_git(["diff", "--name-only", "--diff-filter=ACMRT"], repo_path):
+            full = Path(repo_path) / f
+            if full.exists():
+                unstaged.add(f)
+
+    return staged, unstaged
+
+
+# ---------------------------------------------------------------------------
+# Core review engine
+# ---------------------------------------------------------------------------
+
+def build_review_context(
+    repo_path: str,
+    staged: set[str],
+    unstaged: set[str],
+    repo_graph,
+) -> ReviewContext:
+    """
+    For each changed file, run impact analysis and aggregate into a ReviewContext.
+    """
+    # Avoid circular import — import here
+    from impact_analysis import analyze_impact
+
+    resolved = str(Path(repo_path).resolve())
+    all_changed = staged | unstaged
+
+    all_affected: set[str] = set()
+    suggested_tests: set[str] = set()
+    file_reviews: list[FileReview] = []
+
+    for rel_path in sorted(all_changed):
+        # Determine status label
+        in_staged = rel_path in staged
+        in_unstaged = rel_path in unstaged
+        if in_staged and in_unstaged:
+            status = "staged+unstaged"
+        elif in_staged:
+            status = "staged"
+        else:
+            status = "unstaged"
+
+        # Run impact analysis (may raise ValueError if file not in graph)
+        direct: list[str] = []
+        transitive: list[str] = []
+        tests: list[str] = []
+        try:
+            report = analyze_impact(rel_path, repo_graph, max_depth=5)
+            direct = [f.path for f in report.directly_affected]
+            transitive = [f.path for f in report.transitively_affected]
+            tests = report.test_files
+        except (ValueError, KeyError):
+            # File isn't tracked in graph (new file, binary, etc.) — still include it
+            pass
+
+        file_reviews.append(FileReview(
+            path=rel_path,
+            status=status,
+            direct_dependents=direct,
+            transitive_dependents=transitive,
+            test_files=tests,
+        ))
+
+        all_affected.update(direct)
+        all_affected.update(transitive)
+        suggested_tests.update(tests)
+
+    # Don't list changed files as "affected by themselves"
+    all_affected -= all_changed
+    suggested_tests -= all_changed
+
+    return ReviewContext(
+        repo=resolved,
+        changed_files=file_reviews,
+        all_affected=sorted(all_affected),
+        suggested_tests=sorted(suggested_tests),
+        staged_count=len(staged),
+        unstaged_count=len(unstaged),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Output formatters
+# ---------------------------------------------------------------------------
+
+def format_review_human(ctx: ReviewContext) -> str:
+    BOLD  = "\033[1m"
+    DIM   = "\033[2m"
+    GREEN = "\033[32m"
+    YELLOW= "\033[33m"
+    CYAN  = "\033[36m"
+    RED   = "\033[31m"
+    RESET = "\033[0m"
+
+    total = ctx.staged_count + ctx.unstaged_count
+    lines = [
+        "",
+        f"{BOLD}Repository Intelligence Engine — Git Review{RESET}",
+        f"{DIM}{'─' * 60}{RESET}",
+        f"  Repo    : {ctx.repo}",
+        f"  Changed : {total} file(s)  "
+        f"({ctx.staged_count} staged, {ctx.unstaged_count} unstaged)",
+        f"{DIM}{'─' * 60}{RESET}",
+        "",
+    ]
+
+    # Changed files section
+    lines.append(f"  {BOLD}CHANGED FILES{RESET}  {DIM}(what you edited){RESET}")
+    if not ctx.changed_files:
+        lines.append(f"  {DIM}No changed files found.{RESET}")
+    for fr in ctx.changed_files:
+        label_color = GREEN if fr.status == "staged" else YELLOW if fr.status == "unstaged" else CYAN
+        label = f"{label_color}[{fr.status}]{RESET}"
+        lines.append(f"  {CYAN}{fr.path}{RESET}  {label}")
+    lines.append("")
+
+    # Blast radius section
+    lines.append(f"  {BOLD}BLAST RADIUS{RESET}  {DIM}(files that depend on your changes){RESET}")
+    if not ctx.all_affected:
+        lines.append(f"  {DIM}No dependent files found.{RESET}")
+    else:
+        for path in ctx.all_affected:
+            is_test = any(t in path for t in [".test.", ".spec.", "_test.", "test_"])
+            test_badge = f"  {RED}[TEST]{RESET}" if is_test else ""
+            lines.append(f"  {DIM}→{RESET} {path}{test_badge}")
+    lines.append("")
+
+    # Suggested tests
+    lines.append(f"  {BOLD}SUGGESTED TESTS{RESET}  ({len(ctx.suggested_tests)} file(s) to re-run)")
+    if not ctx.suggested_tests:
+        lines.append(f"  {DIM}No test files identified.{RESET}")
+    for t in ctx.suggested_tests:
+        lines.append(f"  {RED}→{RESET} {t}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def format_review_json(ctx: ReviewContext) -> str:
+    import json
+    return json.dumps({
+        "repo": ctx.repo,
+        "staged_count": ctx.staged_count,
+        "unstaged_count": ctx.unstaged_count,
+        "changed_files": [
+            {
+                "path": fr.path,
+                "status": fr.status,
+                "direct_dependents": fr.direct_dependents,
+                "transitive_dependents": fr.transitive_dependents,
+                "test_files": fr.test_files,
+            }
+            for fr in ctx.changed_files
+        ],
+        "all_affected": ctx.all_affected,
+        "suggested_tests": ctx.suggested_tests,
+    }, indent=2)