contextl 1.2.13 → 1.2.15

package/python/main.py

@@ -212,13 +212,20 @@ def build_parser() -> argparse.ArgumentParser:
     obsidian_parser.add_argument("repo_path", help="Path to the repository root")
     obsidian_parser.add_argument("output_dir", help="Absolute path to save the Obsidian markdown files")
 
+    # 5. Git Review
+    review_parser = subparsers.add_parser("review", help="Build AI-ready context from your git changes")
+    review_parser.add_argument("repo_path", help="Path to the repository root (must be a git repo)")
+    review_parser.add_argument("--staged", action="store_true", help="Only include staged changes")
+    review_parser.add_argument("--unstaged", action="store_true", help="Only include unstaged changes")
+    review_parser.add_argument("--json", action="store_true", help="Output clean JSON instead of human-readable text")
+
     return parser
 
 
 def main():
     # To maintain backward compatibility with old `contextl <repo> <query>`
     # we manually inject "search" if the first argument isn't a known command.
-    if len(sys.argv) >= 2 and sys.argv[1] not in ["search", "standalone", "impact", "obsidian", "-h", "--help"]:
+    if len(sys.argv) >= 2 and sys.argv[1] not in ["search", "standalone", "impact", "obsidian", "review", "-h", "--help"]:
         sys.argv.insert(1, "search")
 
     parser = build_parser()
@@ -276,6 +283,33 @@ def main():
         print(f"Obsidian Vault successfully generated at: {vault_path}")
         print("Open this folder in Obsidian to view your codebase graph!")
 
+    elif args.command == "review":
+        from git_review import _is_git_repo, get_changed_files, build_review_context, format_review_human, format_review_json
+
+        if not _is_git_repo(args.repo_path):
+            print(f"Error: '{args.repo_path}' is not a git repository.", file=sys.stderr)
+            sys.exit(1)
+
+        # Default: both staged + unstaged unless a flag is explicitly set
+        include_staged   = args.staged or (not args.staged and not args.unstaged)
+        include_unstaged = args.unstaged or (not args.staged and not args.unstaged)
+
+        staged, unstaged = get_changed_files(args.repo_path, include_staged, include_unstaged)
+
+        if not staged and not unstaged:
+            print("No changed files found. Make some edits and try again.")
+            sys.exit(0)
+
+        scan = scan_repo(args.repo_path)
+        parse = parse_imports(scan)
+        repo_graph = build_graph(scan, parse)
+        ctx = build_review_context(args.repo_path, staged, unstaged, repo_graph)
+
+        if args.json:
+            print(format_review_json(ctx))
+        else:
+            print(format_review_human(ctx))
+
 
 if __name__ == "__main__":
     main()

package/python/mcp_server.py

@@ -48,6 +48,8 @@ from main import _confidence, _reasoning
 from impact_analysis import analyze_impact
 from standalone import find_standalone_files
 from obsidian_export import export_obsidian_vault
+from git_review import _is_git_repo, get_changed_files, build_review_context, format_review_json
+from import_parser import extract_skeleton
 
 
 # ---------------------------------------------------------------------------
@@ -266,6 +268,60 @@ async def list_tools() -> list[types.Tool]:
                 "required": ["repo_path", "output_dir"],
             },
         ),
+        types.Tool(
+            name="review_changes",
+            description=(
+                "Git-aware context builder. Reads the current git diff (staged and/or "
+                "unstaged) to find what files you are editing, then automatically runs "
+                "impact analysis on each changed file to find every file that depends on "
+                "your changes. Returns a structured context bundle containing: the changed "
+                "files, their full blast radius (direct + transitive dependents), and a "
+                "list of test files that should be re-run. Use this at the START of any "
+                "code review or refactor session to instantly understand the full scope "
+                "of your changes before touching anything."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the git repository root.",
+                    },
+                    "staged": {
+                        "type": "boolean",
+                        "description": "Include staged changes (git diff --cached). Default true.",
+                        "default": True,
+                    },
+                    "unstaged": {
+                        "type": "boolean",
+                        "description": "Include unstaged working-tree changes (git diff). Default true.",
+                        "default": True,
+                    },
+                },
+                "required": ["repo_path"],
+            },
+        ),
+        types.Tool(
+            name="get_skeleton",
+            description=(
+                "Extract the structural skeleton (API surface) of a source file — all "
+                "class names, method signatures, function signatures, return types, and "
+                "docstrings — without any implementation bodies. "
+                "Use this when you need to understand a file's API without consuming its "
+                "full token count. A 5,000-line file becomes a ~100-line reference header. "
+                "Supports: Python, TypeScript, JavaScript, TSX, JSX, Java, Rust."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Absolute path to the source file to extract the skeleton from.",
+                    },
+                },
+                "required": ["file_path"],
+            },
+        ),
     ]
 
 
@@ -290,6 +346,12 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
     if name == "export_obsidian_vault":
         return await _handle_export_obsidian(arguments)
 
+    if name == "review_changes":
+        return await _handle_review_changes(arguments)
+
+    if name == "get_skeleton":
+        return await _handle_get_skeleton(arguments)
+
     return [types.TextContent(
         type="text",
         text=json.dumps({"error": f"Unknown tool: {name}"}),
@@ -450,6 +512,57 @@ def _run_export_obsidian(repo_path: str, output_dir: str) -> dict:
     }
 
 
+async def _handle_review_changes(args: dict) -> list[types.TextContent]:
+    repo_path = args.get("repo_path", "")
+    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
+        )
+    except Exception as e:
+        result = {"error": str(e), "repo": repo_path}
+
+    return [types.TextContent(type="text", text=json.dumps(result, indent=2))]
+
+
+def _run_review_changes(repo_path: str, include_staged: bool, include_unstaged: bool) -> dict:
+    """Uses cached graph — builds review context from current git diff."""
+    import json as _json
+
+    if not _is_git_repo(repo_path):
+        return {"error": f"'{repo_path}' is not a git repository."}
+
+    staged, unstaged = get_changed_files(repo_path, include_staged, include_unstaged)
+
+    if not staged and not unstaged:
+        return {
+            "repo": repo_path,
+            "message": "No changed files found.",
+            "changed_files": [],
+            "all_affected": [],
+            "suggested_tests": [],
+        }
+
+    _, repo_graph = _get_graph(repo_path)
+    ctx = build_review_context(repo_path, staged, unstaged, repo_graph)
+    return _json.loads(format_review_json(ctx))
+
+
+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)
+    except Exception as e:
+        result = {"error": str(e), "file": file_path}
+
+    return [types.TextContent(type="text", text=json.dumps(result, indent=2))]
+
+
 # ---------------------------------------------------------------------------
 # Entry point
 # ---------------------------------------------------------------------------

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",