contextl 1.1.4 → 1.2.0

package/README.md

@@ -74,6 +74,16 @@ Walks the dependency graph upstream from any file to find every direct and trans
 
 Lists every source file `contextl` can see — useful for the agent to orient itself before doing anything else.
 
+### `find_dead_files`
+*"Which files are never imported by anything?"*
+
+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.
+
+### `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!
+
 ---
 
 ## How the ranking works
@@ -87,9 +97,32 @@ Lists every source file `contextl` can see — useful for the agent to orient it
 
 ## Supported languages
 
-TypeScript, TSX, JavaScript, JSX — built for Next.js and React codebases first.
+**JavaScript ecosystem**: TypeScript, TSX, JavaScript, JSX.
+**Backend ecosystem**: Python (`.py`) and Java (`.java`).
+
+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.
+
+---
+
+## The Global CLI
+
+`contextl` isn't just an AI tool; it installs a global command-line interface on your system so you can access all the intelligence features natively:
+
+```bash
+# 1. Search the codebase
+contextl search ./my-repo "fix the auth flow"
+
+# 2. Analyze impact of changing a file
+contextl impact ./my-repo src/api.ts
+
+# 3. Find dead unused files
+contextl dead-code ./my-repo
+
+# 4. Generate an Obsidian vault
+contextl obsidian ./my-repo ./my_vault
+```
 
-Python, Go, and Rust support are on the roadmap.
+*(Note: If you omit the sub-command, `contextl ./my-repo "query"` will automatically default to `search` for backwards compatibility).*
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "contextl",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "contextl — finds the most relevant files in your codebase for any change request. MCP server for AI coding agents.",
   "keywords": [
     "mcp",

package/python/dead_code.py

@@ -0,0 +1,65 @@
+"""
+Repository Intelligence Engine
+Step 7: Dead Code 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 
+out standard entry points and test files.
+"""
+
+from graph_builder import RepoGraph
+from impact_analysis import _is_test_file
+
+# Common entry points that shouldn't be flagged as dead code
+# even if nothing explicitly imports them
+ENTRY_POINT_MARKERS = {
+    "page.tsx", "page.ts", "page.js", "page.jsx",
+    "layout.tsx", "layout.ts", "layout.js", "layout.jsx",
+    "route.ts", "route.js",
+    "globals.css", "global.css", "tailwind.css",
+    "index.ts", "index.js", "index.tsx", "index.jsx",
+    "main.ts", "main.js", "main.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()
+    for marker in ENTRY_POINT_MARKERS:
+        if marker in lowered:
+            return True
+    return False
+
+def find_dead_files(repo_graph: RepoGraph) -> list[str]:
+    """
+    Find files with in-degree 0, excluding entry points and tests.
+    """
+    dead_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)
+                
+    return sorted(dead_files)
+
+if __name__ == "__main__":
+    import sys
+    from scanner import scan_repo
+    from import_parser import parse_imports
+    from graph_builder import build_graph
+
+    if len(sys.argv) < 2:
+        print("Usage: python dead_code.py <repo_path>")
+        sys.exit(1)
+
+    repo_path = sys.argv[1]
+    scan = scan_repo(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 f in dead:
+        print(f"  - {f}")

package/python/import_parser.py

@@ -37,6 +37,13 @@ IMPORT_PATTERN = re.compile(
 # Also catch: import("./foo")  — dynamic imports
 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)
+
+# Java
+JAVA_IMPORT_PATTERN = re.compile(r"^import\s+(?:static\s+)?([\w.]+);", re.MULTILINE)
+
 
 @dataclass
 class ImportRelationship:
@@ -66,19 +73,33 @@ class ParseResult:
         return "\n".join(lines)
 
 
-def _extract_raw_imports(source_code: str) -> list[str]:
-    """Pull all import paths out of a TypeScript/JSX file."""
+def _extract_raw_imports(source_code: str, extension: str) -> list[str]:
+    """Pull all import paths out of a source file based on its extension."""
     paths = []
-    for match in IMPORT_PATTERN.finditer(source_code):
-        paths.append(match.group(1))
-    for match in DYNAMIC_IMPORT_PATTERN.finditer(source_code):
-        paths.append(match.group(1))
-    return paths
-
+    if extension in {".ts", ".tsx", ".js", ".jsx"}:
+        for match in IMPORT_PATTERN.finditer(source_code):
+            paths.append(match.group(1))
+        for match in DYNAMIC_IMPORT_PATTERN.finditer(source_code):
+            paths.append(match.group(1))
+    elif extension == ".py":
+        for match in PYTHON_FROM_IMPORT_PATTERN.finditer(source_code):
+            paths.append(match.group(1))
+        for match in PYTHON_IMPORT_PATTERN.finditer(source_code):
+            paths.append(match.group(1))
+    elif extension == ".java":
+        for match in JAVA_IMPORT_PATTERN.finditer(source_code):
+            paths.append(match.group(1))
+    return list(set(paths))
+
+
+def _is_external(import_path: str, extension: str) -> bool:
+    """Return True if this is an external package rather than a local file."""
+    if extension in {".py", ".java"}:
+        # For Python and Java, it's hard to tell without resolving, 
+        # so assume it's local and let the resolver fail if it's external.
+        return False
 
-def _is_external(import_path: str) -> bool:
-    """Return True if this is an npm package rather than a local file."""
-    # Local files start with . (relative) or @ followed by / (alias like @/)
+    # Node.js: Local files start with . (relative) or @ followed by / (alias like @/)
     # but NOT @scope/package style from npm — those don't contain our alias prefix
     if import_path.startswith("./") or import_path.startswith("../"):
         return False
@@ -119,6 +140,7 @@ def _find_file_in_repo(
     candidate: str,
     file_index: dict[str, str],
     root: str,
+    extension: str = "",
 ) -> str | None:
     """
     Given a candidate path (without extension), find the matching file
@@ -142,13 +164,38 @@ def _find_file_in_repo(
     if candidate_str in file_index:
         return candidate_str
 
-    # Try adding each supported extension
+    if extension == ".java":
+        # Java candidate is like 'com/example/Config'
+        # We search for any file ending in this candidate + .java
+        suffix = candidate_str + ".java"
+        for path in file_index:
+            if path.endswith(suffix):
+                return path
+        return None
+
+    if extension == ".py":
+        # Python: try exact candidate + .py
+        py_ext = candidate_str + ".py"
+        if py_ext in file_index:
+            return py_ext
+        # Try python package index
+        py_idx = candidate_str + "/__init__.py"
+        if py_idx in file_index:
+            return py_idx
+        # Fallback: search for any file ending in candidate + .py (handles src/ prefix omit)
+        suffix = "/" + py_ext
+        for path in file_index:
+            if path.endswith(suffix) or path == py_ext:
+                return path
+        return None
+
+    # Node.js: Try adding each supported extension
     for ext in [".tsx", ".ts", ".jsx", ".js"]:
         with_ext = candidate_str + ext
         if with_ext in file_index:
             return with_ext
 
-    # Try as a directory index file (e.g. components/Button/index.tsx)
+    # Node.js: Try as a directory index file
     for ext in [".tsx", ".ts", ".jsx", ".js"]:
         index_path = candidate_str + "/index" + ext
         if index_path in file_index:
@@ -225,26 +272,43 @@ def parse_imports(scan_result: ScanResult) -> ParseResult:
         except Exception:
             continue
 
-        raw_imports = _extract_raw_imports(source_code)
+        raw_imports = _extract_raw_imports(source_code, scanned_file.extension)
 
         for raw in raw_imports:
-            if _is_external(raw):
+            if _is_external(raw, scanned_file.extension):
                 result.unresolved.append((scanned_file.path, raw))
                 continue
 
             # Resolve to a candidate path string
-            if raw.startswith("@/"):
-                resolved_alias = _resolve_alias(raw, alias_map)
-                if resolved_alias is None:
-                    result.unresolved.append((scanned_file.path, raw))
-                    continue
-                candidate = resolved_alias
+            if scanned_file.extension == ".java":
+                candidate = raw.replace(".", "/")
+            elif scanned_file.extension == ".py":
+                if raw.startswith("."):
+                    # Relative python import: from .utils import foo
+                    # Count leading dots
+                    dots = len(raw) - len(raw.lstrip("."))
+                    base_dir = Path(scanned_file.path).parent
+                    # For every dot beyond the first, go up one directory
+                    for _ in range(dots - 1):
+                        base_dir = base_dir.parent
+                    mod_path = raw.lstrip(".").replace(".", "/")
+                    candidate = str(base_dir / mod_path) if mod_path else str(base_dir)
+                else:
+                    # Absolute python import from root
+                    candidate = raw.replace(".", "/")
             else:
-                # Relative import
-                candidate = _resolve_relative(raw, scanned_file.path)
+                # Node.js
+                if raw.startswith("@/"):
+                    resolved_alias = _resolve_alias(raw, alias_map)
+                    if resolved_alias is None:
+                        result.unresolved.append((scanned_file.path, raw))
+                        continue
+                    candidate = resolved_alias
+                else:
+                    candidate = _resolve_relative(raw, scanned_file.path)
 
             # Find the actual file in the repo
-            matched = _find_file_in_repo(candidate, file_index, scan_result.root)
+            matched = _find_file_in_repo(candidate, file_index, scan_result.root, scanned_file.extension)
 
             if matched:
                 result.relationships.append(

package/python/main.py

@@ -184,53 +184,97 @@ def run_engine(repo_path: str, query_str: str, top_n: int):
 # ---------------------------------------------------------------------------
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
-        prog="prune",
-        description=(
-            "Repository Intelligence Engine — find the most relevant files "
-            "for a given change request without LLMs or embeddings."
-        ),
+        prog="contextl",
+        description="Repository Intelligence Engine",
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-    parser.add_argument("repo_path", help="Path to the repository root")
-    parser.add_argument("query", help="Natural-language query (e.g. 'fix the upload error handler')")
-    parser.add_argument(
-        "--top", "-n",
-        type=int,
-        default=5,
-        metavar="N",
-        help="Number of results to return (default: 5)",
-    )
-    parser.add_argument(
-        "--json",
-        action="store_true",
-        default=False,
-        help="Output clean JSON instead of human-readable text",
     )
+    
+    subparsers = parser.add_subparsers(dest="command", required=True, help="Available commands")
+
+    # 1. Search
+    search_parser = subparsers.add_parser("search", help="Search the codebase using natural language")
+    search_parser.add_argument("repo_path", help="Path to the repository root")
+    search_parser.add_argument("query", help="Natural-language query (e.g. 'fix the upload error handler')")
+    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")
+
+    # 3. Impact Analysis
+    impact_parser = subparsers.add_parser("impact", help="Analyze the impact of changing a file")
+    impact_parser.add_argument("repo_path", help="Path to the repository root")
+    impact_parser.add_argument("target_file", help="Relative path to the file being changed")
+
+    # 4. Obsidian Export
+    obsidian_parser = subparsers.add_parser("obsidian", help="Export the repository graph to an Obsidian Vault")
+    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")
+
     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", "dead-code", "impact", "obsidian", "-h", "--help"]:
+        sys.argv.insert(1, "search")
+
     parser = build_parser()
     args = parser.parse_args()
 
-    results, repo_graph, elapsed = run_engine(args.repo_path, args.query, args.top)
+    if args.command == "search":
+        results, repo_graph, elapsed = run_engine(args.repo_path, args.query, args.top)
+
+        if not results:
+            if args.json:
+                print(json.dumps({
+                    "query": args.query,
+                    "repo": str(Path(args.repo_path).resolve()),
+                    "results": [],
+                }, indent=2))
+            else:
+                print(f"\nNo relevant files found for: '{args.query}'")
+            sys.exit(0)
 
-    if not results:
         if args.json:
-            print(json.dumps({
-                "query": args.query,
-                "repo": str(Path(args.repo_path).resolve()),
-                "results": [],
-            }, indent=2))
+            print(_format_json(args.query, args.repo_path, results, repo_graph))
         else:
-            print(f"\nNo relevant files found for: '{args.query}'")
-        sys.exit(0)
-
-    if args.json:
-        print(_format_json(args.query, args.repo_path, results, repo_graph))
-    else:
-        print(_format_human(args.query, args.repo_path, results, repo_graph, elapsed))
+            print(_format_human(args.query, args.repo_path, results, repo_graph, elapsed))
+
+    elif args.command == "dead-code":
+        from dead_code import find_dead_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):
+            print(f"  {d}")
+
+    elif args.command == "impact":
+        from impact_analysis import analyze_impact
+        scan = scan_repo(args.repo_path)
+        parse = parse_imports(scan)
+        repo_graph = build_graph(scan, parse)
+        try:
+            report = analyze_impact(args.target_file, repo_graph)
+            print(report.summary())
+            print("\nDependency tree:")
+            print(report.to_tree_string())
+        except ValueError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    elif args.command == "obsidian":
+        from obsidian_export import export_obsidian_vault
+        scan = scan_repo(args.repo_path)
+        parse = parse_imports(scan)
+        repo_graph = build_graph(scan, parse)
+        vault_path = export_obsidian_vault(repo_graph, args.output_dir)
+        print(f"Obsidian Vault successfully generated at: {vault_path}")
+        print("Open this folder in Obsidian to view your codebase graph!")
 
 
 if __name__ == "__main__":

package/python/mcp_server.py

@@ -35,6 +35,8 @@ 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 obsidian_export import export_obsidian_vault
 
 
 # ---------------------------------------------------------------------------
@@ -139,6 +141,47 @@ async def list_tools() -> list[types.Tool]:
                 "required": ["repo_path", "target_file"],
             },
         ),
+        types.Tool(
+            name="find_dead_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 "
+                "and unused files that can potentially be deleted."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the repository root.",
+                    },
+                },
+                "required": ["repo_path"],
+            },
+        ),
+        types.Tool(
+            name="export_obsidian_vault",
+            description=(
+                "Generates an Obsidian Vault from the repository graph. "
+                "Creates a folder of interconnected Markdown files using wikilinks "
+                "so the codebase can be visualized in Obsidian's 3D graph view."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "repo_path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the repository root.",
+                    },
+                    "output_dir": {
+                        "type": "string",
+                        "description": "Absolute path to a folder where the vault should be created.",
+                    },
+                },
+                "required": ["repo_path", "output_dir"],
+            },
+        ),
     ]
 
 
@@ -157,6 +200,12 @@ 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 == "export_obsidian_vault":
+        return await _handle_export_obsidian(arguments)
+
     return [types.TextContent(
         type="text",
         text=json.dumps({"error": f"Unknown tool: {name}"}),
@@ -269,6 +318,62 @@ 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)
+    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:
+    """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)
+
+    return {
+        "repo": scan.root,
+        "total_files_scanned": scan.total_files,
+        "total_dead_files": len(dead_files),
+        "dead_files": dead_files
+    }
+
+
+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)
+    except Exception as e:
+        result = {"error": str(e), "repo": repo_path, "output_dir": output_dir}
+
+    return [types.TextContent(type="text", text=json.dumps(result, indent=2))]
+
+
+def _run_export_obsidian(repo_path: str, output_dir: str) -> dict:
+    """Synchronous pipeline — called from a thread executor."""
+    scan = scan_repo(repo_path)
+    parse = parse_imports(scan)
+    repo_graph = build_graph(scan, parse)
+    
+    vault_path = export_obsidian_vault(repo_graph, output_dir)
+    
+    return {
+        "repo": scan.root,
+        "vault_path": vault_path,
+        "total_files_exported": scan.total_files,
+        "success": True
+    }
+
+
 # ---------------------------------------------------------------------------
 # Entry point
 # ---------------------------------------------------------------------------
@@ -283,33 +388,11 @@ async def main():
 
 if __name__ == "__main__":
     if len(sys.argv) > 1:
-        parser = argparse.ArgumentParser(description="ContextL — Repository Intelligence Engine")
-        parser.add_argument("repo_path", help="Path to the repository to query")
-        parser.add_argument("query", help="Natural language query")
-        parser.add_argument("--top", type=int, default=5, help="Maximum number of files to return")
-        parser.add_argument("--json", action="store_true", help="Output results in JSON format")
-        
-        args = parser.parse_args()
-        
+        # Fallback for CLI users: route all arguments to the main.py CLI engine
+        from main import main as cli_main
         try:
-            result = _run_query(args.repo_path, args.query, args.top)
-            
-            if args.json:
-                print(json.dumps(result, indent=2))
-            else:
-                print(f"\n> Query: {args.query}")
-                print(f"> Repository: {args.repo_path}\n")
-                
-                for res in result["results"]:
-                    print(f"[{res['rank']}] {res['path']}")
-                    print(f"    Score:      {res['score']} ({res['confidence']})")
-                    print(f"    Terms:      {', '.join(res['matched_terms'])}")
-                    print(f"    Reasoning:  {res['reasoning']}\n")
-        except Exception as e:
-            if args.json:
-                print(json.dumps({"error": str(e)}, indent=2))
-            else:
-                print(f"Error: {str(e)}", file=sys.stderr)
-            sys.exit(1)
+            cli_main()
+        except KeyboardInterrupt:
+            sys.exit(0)
     else:
         asyncio.run(main())

package/python/obsidian_export.py

@@ -0,0 +1,120 @@
+"""
+Repository Intelligence Engine
+Step 7: Obsidian Exporter
+
+Exports the RepoGraph into a folder of interconnected Markdown files.
+By opening the folder as an Obsidian Vault, users get an instant 3D interactive
+visualization of their entire codebase.
+"""
+
+import os
+import shutil
+import re
+from pathlib import Path
+
+from scanner import scan_repo
+from import_parser import parse_imports
+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)
+
+def _extract_explanation(file_path: str, extension: str, root_dir: str) -> str:
+    """Reads the top-level docstring or JSDoc block from the file."""
+    try:
+        content = (Path(root_dir) / file_path).read_text(encoding="utf-8")
+        if extension == ".py":
+            match = PYTHON_DOCSTRING_PATTERN.search(content)
+            if match:
+                return 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()
+    except Exception:
+        pass
+    return "*No explanation provided in source code.*"
+
+
+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.
+    """
+    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"
+        
+        dependencies = repo_graph.get_dependencies(path)
+        dependents = repo_graph.get_dependents(path)
+        
+        explanation = _extract_explanation(path, node.extension, repo_graph.root)
+        
+        content = [
+            f"# {path}",
+            "",
+            "## Explanation",
+            explanation,
+            "",
+            "## Metrics",
+            f"**Extension:** `{node.extension}`",
+            f"**Size:** {node.size_bytes} bytes",
+            f"**Centrality Score:** {node.centrality:.4f}",
+            "",
+            "## Imports (Dependencies)",
+        ]
+        
+        if dependencies:
+            for dep in sorted(dependencies):
+                dep_safe = dep.replace("/", "-").replace("\\", "-")
+                content.append(f"- [[{dep_safe}]]")
+        else:
+            content.append("*No internal imports*")
+            
+        content.extend([
+            "",
+            "## Imported By (Dependents)"
+        ])
+        
+        if dependents:
+            for dep in sorted(dependents):
+                dep_safe = dep.replace("/", "-").replace("\\", "-")
+                content.append(f"- [[{dep_safe}]]")
+        else:
+            content.append("*Not imported by any file*")
+            
+        md_file.write_text("\n".join(content), encoding="utf-8")
+        
+    return str(out_path)
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 3:
+        print("Usage: python obsidian_export.py <repo_path> <output_dir>")
+        sys.exit(1)
+
+    repo_path = sys.argv[1]
+    output_dir = sys.argv[2]
+
+    scan = scan_repo(repo_path)
+    parse = parse_imports(scan)
+    repo_graph = build_graph(scan, parse)
+
+    vault_path = export_obsidian_vault(repo_graph, output_dir)
+    print(f"Obsidian Vault successfully generated at: {vault_path}")
+    print("Open this folder in Obsidian to view your codebase graph!")

package/python/scanner.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from dataclasses import dataclass, field
 
 
-SUPPORTED_EXTENSIONS = {".tsx", ".ts", ".jsx", ".js"}
+SUPPORTED_EXTENSIONS = {".tsx", ".ts", ".jsx", ".js", ".py", ".java"}
 
 IGNORED_DIRS = {
     "node_modules",