contextl 1.2.10 → 1.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextl",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "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

@@ -22,7 +22,7 @@ from scanner import ScannedFile, ScanResult
 
 # Matches any ES6 import statement and captures the module path
 IMPORT_PATTERN = re.compile(
-    r"""import\s+(?:type\s+)?          # import or import type
+    r"""(?:import|export)\s+(?:type\s+)?          # import or import type or export
         (?:
             \{[^}]*\}                  # named imports: { Foo, Bar }
             |[\w*]+                    # default or namespace: Foo or *
@@ -38,11 +38,12 @@ IMPORT_PATTERN = re.compile(
 DYNAMIC_IMPORT_PATTERN = re.compile(r"""import\s*\(\s*['"](.*?)['"]\s*\)""")
 
 # Python
-PYTHON_FROM_IMPORT_PATTERN = re.compile(r"^from\s+([.\w]+)\s+import", re.MULTILINE)
-PYTHON_IMPORT_PATTERN = re.compile(r"^import\s+([.\w]+)", re.MULTILINE)
+PYTHON_FROM_IMPORT_PATTERN = re.compile(r"^[ \t]*from\s+([.\w]+)\s+import\s+(?:\(([^)]+)\)|([^#\n]+))", re.MULTILINE)
+PYTHON_IMPORT_PATTERN = re.compile(r"^[ \t]*import\s+([.\w]+)", re.MULTILINE)
 
 # Java
-JAVA_IMPORT_PATTERN = re.compile(r"^import\s+(?:static\s+)?([\w.]+);", re.MULTILINE)
+JAVA_IMPORT_PATTERN = re.compile(r"^import\s+(?:static\s+)?([\w.*]+);", re.MULTILINE)
+JAVA_PACKAGE_PATTERN = re.compile(r"^package\s+([\w.]+);", re.MULTILINE)
 
 
 @dataclass
@@ -83,7 +84,15 @@ def _extract_raw_imports(source_code: str, extension: str) -> list[str]:
             paths.append(match.group(1))
     elif extension == ".py":
         for match in PYTHON_FROM_IMPORT_PATTERN.finditer(source_code):
-            paths.append(match.group(1))
+            base = match.group(1)
+            paths.append(base)
+            symbols_str = match.group(2) or match.group(3)
+            if symbols_str:
+                symbols_str = symbols_str.replace('(', '').replace(')', '').replace('\\', '').strip()
+                for sym in symbols_str.split(','):
+                    sym = sym.split(' as ')[0].strip()
+                    if sym and sym != '*':
+                        paths.append(f"{base}.{sym}")
         for match in PYTHON_IMPORT_PATTERN.finditer(source_code):
             paths.append(match.group(1))
     elif extension == ".java":
@@ -191,6 +200,16 @@ def _find_file_in_repo(
         for path in file_index:
             if path.endswith(suffix):
                 return path
+        
+        # Fallback for static method/field imports: import static com.example.MyClass.myMethod;
+        # In this case, candidate_str is 'com/example/MyClass/myMethod'
+        if "/" in candidate_str:
+            parent_candidate = candidate_str.rsplit("/", 1)[0]
+            parent_suffix = parent_candidate + ".java"
+            for path in file_index:
+                if path.endswith(parent_suffix):
+                    return path
+                    
         return None
 
     if extension == ".py":
@@ -215,11 +234,21 @@ def _find_file_in_repo(
         if with_ext in file_index:
             return with_ext
 
-    # Node.js: Try as a directory index file
+    # Node.js / Deno: Try as a directory index/mod file
     for ext in [".tsx", ".ts", ".jsx", ".js"]:
         index_path = candidate_str + "/index" + ext
         if index_path in file_index:
             return index_path
+        mod_path = candidate_str + "/mod" + ext
+        if mod_path in file_index:
+            return mod_path
+
+    # Fuzzy fallback for dynamic paths (like P4A recipes)
+    if extension == ".py":
+        candidate_suffix = "/" + candidate_str + ".py"
+        matches = [p for p in file_index if p.endswith(candidate_suffix)]
+        if len(matches) == 1:
+            return matches[0]
 
     return None
 
@@ -311,6 +340,29 @@ def _detect_alias_map(scan_result: ScanResult) -> dict[str, str]:
             if alias_key not in alias_map:
                 alias_map[alias_key] = target_val
 
+    # Detect NPM Workspaces (monorepos)
+    for pkg in root.rglob("package.json"):
+        if any(p in ignore for p in pkg.parts):
+            continue
+        try:
+            import json
+            data = json.loads(pkg.read_text(encoding="utf-8"))
+            name = data.get("name")
+            if name and isinstance(name, str):
+                pkg_dir = pkg.parent
+                try:
+                    repo_rel = str(pkg_dir.relative_to(root)).replace("\\", "/")
+                    if repo_rel == ".":
+                        continue # Skip root package.json
+                    # For absolute imports like "@meshtastic/sdk-react"
+                    alias_map[name] = repo_rel
+                    # For sub-path imports like "@meshtastic/sdk-react/src/foo"
+                    alias_map[name + "/"] = repo_rel + "/"
+                except ValueError:
+                    pass
+        except Exception:
+            pass
+
     if not alias_map:
         # Heuristic fallback: single top-level source dir
         top_dirs = {Path(f.path).parts[0] for f in scan_result.files if Path(f.path).parts}
@@ -342,6 +394,27 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
     # Auto-detect alias map (e.g. @/ → frontend/)
     alias_map = _detect_alias_map(scan_result)
 
+    # Pre-pass for Java: build package map and implicit same-package relationships
+    java_packages = {}
+    for scanned_file in scan_result.files:
+        if scanned_file.extension == ".java":
+            try:
+                source_code = Path(scanned_file.absolute_path).read_text(encoding="utf-8")
+                pkg_match = JAVA_PACKAGE_PATTERN.search(source_code)
+                if pkg_match:
+                    pkg = pkg_match.group(1)
+                    java_packages.setdefault(pkg, []).append(scanned_file.path)
+            except Exception:
+                pass
+
+    for pkg, files in java_packages.items():
+        for source_file in files:
+            for target_file in files:
+                if source_file != target_file:
+                    result.relationships.append(
+                        ImportRelationship(source=source_file, target=target_file, raw_import=f"implicit_package:{pkg}")
+                    )
+
     for scanned_file in scan_result.files:
         try:
             source_code = Path(scanned_file.absolute_path).read_text(encoding="utf-8")
@@ -357,6 +430,14 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
 
             # Resolve to a candidate path string
             if scanned_file.extension == ".java":
+                if raw.endswith(".*"):
+                    pkg = raw[:-2]
+                    for target_file in java_packages.get(pkg, []):
+                        if target_file != scanned_file.path:
+                            result.relationships.append(
+                                ImportRelationship(source=scanned_file.path, target=target_file, raw_import=raw)
+                            )
+                    continue
                 candidate = raw.replace(".", "/")
             elif scanned_file.extension == ".py":
                 if raw.startswith("."):

package/python/main.py

@@ -198,9 +198,9 @@ def build_parser() -> argparse.ArgumentParser:
     search_parser.add_argument("--top", "-n", type=int, default=5, help="Number of results to return (default: 5)")
     search_parser.add_argument("--json", action="store_true", help="Output clean JSON instead of human-readable text")
 
-    # 2. Dead Code
-    dead_parser = subparsers.add_parser("dead-code", help="Find files with 0 in-degree dependencies")
-    dead_parser.add_argument("repo_path", help="Path to the repository root")
+    # 2. Standalone Files
+    standalone_parser = subparsers.add_parser("standalone", help="Find files with 0 in-degree dependencies (unimported)")
+    standalone_parser.add_argument("repo_path", help="Path to the repository root")
 
     # 3. Impact Analysis
     impact_parser = subparsers.add_parser("impact", help="Analyze the impact of changing a file")
@@ -218,7 +218,7 @@ def build_parser() -> argparse.ArgumentParser:
 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", "dead-code", "impact", "obsidian", "-h", "--help"]:
+    if len(sys.argv) >= 2 and sys.argv[1] not in ["search", "standalone", "impact", "obsidian", "-h", "--help"]:
         sys.argv.insert(1, "search")
 
     parser = build_parser()
@@ -243,14 +243,14 @@ def main():
         else:
             print(_format_human(args.query, args.repo_path, results, repo_graph, elapsed))
 
-    elif args.command == "dead-code":
-        from dead_code import find_dead_files
+    elif args.command == "standalone":
+        from standalone import find_standalone_files
         scan = scan_repo(args.repo_path)
         parse = parse_imports(scan)
         repo_graph = build_graph(scan, parse)
-        dead = find_dead_files(repo_graph)
-        print(f"Found {len(dead)} potentially dead files:")
-        for d in sorted(dead):
+        standalone = find_standalone_files(repo_graph)
+        print(f"Found {len(standalone)} standalone files:")
+        for d in sorted(standalone):
             print(f"  {d}")
 
     elif args.command == "impact":

package/python/mcp_server.py

@@ -35,7 +35,7 @@ from graph_builder import build_graph
 from query_engine import query as engine_query
 from main import _confidence, _reasoning
 from impact_analysis import analyze_impact
-from dead_code import find_dead_files
+from standalone import find_standalone_files
 from obsidian_export import export_obsidian_vault
 
 
@@ -145,11 +145,11 @@ async def list_tools() -> list[types.Tool]:
             },
         ),
         types.Tool(
-            name="find_dead_files",
+            name="find_standalone_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 "
-                "standard entry points and test files. Use this to identify dead code "
+                "standard entry points and test files. Use this to identify standalone code "
                 "and unused files that can potentially be deleted."
             ),
             inputSchema={
@@ -203,8 +203,8 @@ async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
     if name == "analyze_impact":
         return await _handle_impact(arguments)
 
-    if name == "find_dead_files":
-        return await _handle_dead_files(arguments)
+    if name == "find_standalone_files":
+        return await _handle_standalone_files(arguments)
 
     if name == "export_obsidian_vault":
         return await _handle_export_obsidian(arguments)
@@ -321,30 +321,30 @@ def _run_impact(repo_path: str, target_file: str, max_depth: int) -> dict:
     }
 
 
-async def _handle_dead_files(args: dict) -> list[types.TextContent]:
+async def _handle_standalone_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 loop.run_in_executor(None, _run_standalone_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_dead_files(repo_path: str) -> dict:
+def _run_standalone_files(repo_path: str) -> dict:
     """Synchronous pipeline — called from a thread executor."""
     scan = scan_repo(repo_path)
     parse = parse_imports(scan)
     repo_graph = build_graph(scan, parse)
-    dead_files = find_dead_files(repo_graph)
+    standalone_files = find_standalone_files(repo_graph)
 
     return {
         "repo": scan.root,
         "total_files_scanned": scan.total_files,
-        "total_dead_files": len(dead_files),
-        "dead_files": dead_files
+        "total_standalone_files": len(standalone_files),
+        "standalone_files": standalone_files
     }
 
 

package/python/obsidian_export.py

@@ -19,68 +19,95 @@ 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_explanation(file_path: str, extension: str, root_dir: str) -> str:
-    """Reads the top-level docstring or JSDoc block from the file."""
+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 = ""
     try:
         content = (Path(root_dir) / file_path).read_text(encoding="utf-8")
+        
+        # 1. Snippet (first 20 lines)
+        lines = content.splitlines()
+        snippet = "\n".join(lines[:20])
+        if len(lines) > 20:
+            snippet += "\n..."
+            
+        # 2. Explanation
         if extension == ".py":
             match = PYTHON_DOCSTRING_PATTERN.search(content)
             if match:
-                return match.group(1).strip()
+                explanation = match.group(1).strip()
         elif extension in {".ts", ".tsx", ".js", ".jsx", ".java"}:
             match = JS_DOC_PATTERN.search(content)
             if match:
-                # Clean up leading asterisks from JSDoc lines
-                lines = match.group(1).split('\n')
-                cleaned = [line.strip().lstrip('*').strip() for line in lines]
-                return "\n".join(cleaned).strip()
+                clean_lines = [line.strip().lstrip('*').strip() for line in match.group(1).split('\n')]
+                explanation = "\n".join(clean_lines).strip()
+                
+        # 3. Outline
+        for match in OUTLINE_PATTERN.finditer(content):
+            outline.append(match.group(1))
+            
     except Exception:
         pass
-    return "*No explanation provided in source code.*"
+        
+    return explanation, outline, snippet
 
 
 def export_obsidian_vault(repo_graph: RepoGraph, output_dir: str) -> str:
     """
-    Generates a markdown file for every node in the graph, with
-    Obsidian wikilinks connecting them based on imports.
+    Generates a markdown file for every node in the graph in a hierarchical folder structure, 
+    with Obsidian wikilinks connecting them based on imports.
     """
     out_path = Path(output_dir).resolve()
     
-    # Create the output directory (clean it if it exists)
     if out_path.exists():
         shutil.rmtree(out_path)
     out_path.mkdir(parents=True)
 
     for path, node in repo_graph.nodes.items():
-        # We replace slashes with dashes to keep a flat folder structure
-        # so Obsidian graph view looks clean, but keep original name as title
-        safe_name = path.replace("/", "-").replace("\\", "-")
-        md_file = out_path / f"{safe_name}.md"
+        md_file = out_path / f"{path}.md"
+        md_file.parent.mkdir(parents=True, exist_ok=True)
         
         dependencies = repo_graph.get_dependencies(path)
         dependents = repo_graph.get_dependents(path)
         
-        explanation = _extract_explanation(path, node.extension, repo_graph.root)
+        explanation, outline, snippet = _extract_file_context(path, node.extension, repo_graph.root)
         
         content = [
-            f"# {path}",
+            f"# {Path(path).name}",
+            "",
+            "## Architecture Metrics",
+            f"- **Path:** `{path}`",
+            f"- **Extension:** `{node.extension}`",
+            f"- **Size:** {node.size_bytes} bytes",
+            f"- **Centrality Score:** {node.centrality:.4f}",
+            f"- **In-Degree (Imported By):** {len(dependents)}",
+            f"- **Out-Degree (Imports):** {len(dependencies)}",
             "",
             "## Explanation",
             explanation,
             "",
-            "## Metrics",
-            f"**Extension:** `{node.extension}`",
-            f"**Size:** {node.size_bytes} bytes",
-            f"**Centrality Score:** {node.centrality:.4f}",
-            "",
-            "## Imports (Dependencies)",
+            "## Structural Outline",
         ]
         
+        if outline:
+            for symbol in outline:
+                content.append(f"- `{symbol}`")
+        else:
+            content.append("*No major classes or functions detected.*")
+            
+        content.extend([
+            "",
+            "## Imports (Dependencies)"
+        ])
+        
         if dependencies:
             for dep in sorted(dependencies):
-                dep_safe = dep.replace("/", "-").replace("\\", "-")
-                content.append(f"- [[{dep_safe}]]")
+                # Use full relative path for accurate linking in hierarchical vaults
+                content.append(f"- [[{dep}.md|{dep}]]")
         else:
             content.append("*No internal imports*")
             
@@ -91,11 +118,18 @@ def export_obsidian_vault(repo_graph: RepoGraph, output_dir: str) -> str:
         
         if dependents:
             for dep in sorted(dependents):
-                dep_safe = dep.replace("/", "-").replace("\\", "-")
-                content.append(f"- [[{dep_safe}]]")
+                content.append(f"- [[{dep}.md|{dep}]]")
         else:
             content.append("*Not imported by any file*")
             
+        content.extend([
+            "",
+            "## Source Code Snippet",
+            f"```{node.extension.lstrip('.')}",
+            snippet,
+            "```"
+        ])
+            
         md_file.write_text("\n".join(content), encoding="utf-8")
         
     return str(out_path)

package/python/{dead_code.py → standalone.py}

@@ -1,6 +1,6 @@
 """
 Repository Intelligence Engine
-Step 7: Dead Code Analysis
+Step 7: Standalone Files Analysis
 
 Finds files in the dependency graph that have an in-degree of 0 
 (meaning they are never imported by any other file), while filtering 
@@ -19,29 +19,33 @@ ENTRY_POINT_MARKERS = {
     "globals.css", "global.css", "tailwind.css",
     "index.ts", "index.js", "index.tsx", "index.jsx",
     "main.ts", "main.js", "main.py",
+    "app.ts", "app.js", "app.tsx", "app.jsx", "app.py",
+    "mcp_server.py", "server.ts", "server.js", "server.py",
     "__main__.py", "__init__.py", "setup.py", "conftest.py",
     "next.config", "tailwind.config", "postcss.config", "vite.config", "webpack.config"
 }
 
 def _is_entry_point(path: str) -> bool:
     lowered = path.lower()
+    if lowered.endswith(".d.ts"):
+        return True
     for marker in ENTRY_POINT_MARKERS:
         if marker in lowered:
             return True
     return False
 
-def find_dead_files(repo_graph: RepoGraph) -> list[str]:
+def find_standalone_files(repo_graph: RepoGraph) -> list[str]:
     """
     Find files with in-degree 0, excluding entry points and tests.
     """
-    dead_files = []
+    standalone_files = []
     
     for path, node in repo_graph.nodes.items():
         if node.in_degree == 0:
             if not _is_test_file(path) and not _is_entry_point(path):
-                dead_files.append(path)
+                standalone_files.append(path)
                 
-    return sorted(dead_files)
+    return sorted(standalone_files)
 
 if __name__ == "__main__":
     import sys
@@ -50,7 +54,7 @@ if __name__ == "__main__":
     from graph_builder import build_graph
 
     if len(sys.argv) < 2:
-        print("Usage: python dead_code.py <repo_path>")
+        print("Usage: python standalone.py <repo_path>")
         sys.exit(1)
 
     repo_path = sys.argv[1]
@@ -58,8 +62,8 @@ if __name__ == "__main__":
     parse = parse_imports(scan)
     repo_graph = build_graph(scan, parse)
 
-    dead = find_dead_files(repo_graph)
+    standalone = find_standalone_files(repo_graph)
     
-    print(f"Found {len(dead)} potentially dead files:")
-    for f in dead:
+    print(f"Found {len(standalone)} standalone files:")
+    for f in standalone:
         print(f"  - {f}")