codegraphcontext 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

codegraphcontext/cli/cli_helpers.py

@@ -4,6 +4,7 @@ import uuid
 import urllib.parse
 from pathlib import Path
 import time
+from typing import Optional
 from rich.console import Console
 from rich.table import Table
 from rich.progress import (
@@ -339,44 +340,55 @@ def cypher_helper_visual(query: str):
         console.print(f"[bold red]An error occurred while executing query:[/bold red] {e}")
     finally:
         db_manager.close_driver()
-
-
 import webbrowser
+import urllib.parse
+from ..viz.server import run_server, set_db_manager
 
-def visualize_helper(query: str):
-    """"Generates a visualization."""
+def visualize_helper(repo_path: Optional[str] = None, port: int = 8000):
+    """"Generates an interactive visualization using the Playground UI."""
     services = _initialize_services()
     if not all(services):
         return
 
     db_manager, _, _ = services
     
-    # Check Backend Type
-    backend = getattr(db_manager, "name", "").lower()
-    if not backend:
-        # Fallback check
-        if "FalkorDB" in db_manager.__class__.__name__:
-            backend = "falkordb"
-        elif "Kuzu" in db_manager.__class__.__name__:
-            backend = "kuzudb"
-        else:
-            backend = "neo4j"
-
-    if backend == "falkordb":
-        _visualize_falkordb(db_manager)
-    elif backend == "kuzudb":
-        _visualize_kuzudb(db_manager)
-    else:
-        try:
-            encoded_query = urllib.parse.quote(query)
-            visualization_url = f"http://localhost:7474/browser/?cmd=edit&arg={encoded_query}"
-            console.print("[green]Graph visualization URL:[/green]")
-            console.print(visualization_url)
-            console.print("Open the URL in your browser to see the graph.")
-        except Exception as e:
-            console.print(f"[bold red]An error occurred while generating URL:[/bold red] {e}")
-        finally:
-            db_manager.close_driver()
+    # Set the DB manager for the server
+    set_db_manager(db_manager)
+    
+    # Determine the static directory (built React app)
+    static_dir = Path(__file__).parent.parent / "viz" / "dist"
+    if not static_dir.exists():
+        console.print("[yellow]Warning: Visualizer UI assets not found in package. Using fallback static dir.[/yellow]")
+        # Fallback for development
+        static_dir = Path.cwd() / "website" / "dist"
+
+    # Construct the URL
+    backend_url = f"http://localhost:{port}"
+    params = {"backend": backend_url}
+    if repo_path:
+        params["repo_path"] = str(Path(repo_path).resolve())
+    
+    query_string = urllib.parse.urlencode(params)
+    visualization_url = f"{backend_url}/playground?{query_string}"
+    
+    console.print(f"[green]Starting visualizer server on {backend_url}...[/green]")
+    console.print(f"[cyan]Opening Playground UI:[/cyan] {visualization_url}")
+    
+    # Open browser in a separate thread/process if possible, or just before starting server
+    def open_browser():
+        import time
+        time.sleep(1.5) # Give the server a moment to start
+        webbrowser.open(visualization_url)
+    
+    import threading
+    threading.Thread(target=open_browser, daemon=True).start()
+    
+    try:
+        run_server(host="127.0.0.1", port=port, static_dir=str(static_dir))
+    except Exception as e:
+        console.print(f"[bold red]An error occurred while running the server:[/bold red] {e}")
+    finally:
+        db_manager.close_driver()
 
 def _visualize_falkordb(db_manager):
     console.print("[dim]Generating FalkorDB visualization (showing up to 500 relationships)...[/dim]")

codegraphcontext/cli/main.py

@@ -994,15 +994,15 @@ def delete(
         delete_helper(path)
 
 @app.command()
-def visualize(query: Optional[str] = typer.Argument(None, help="The Cypher query to visualize.")):
+def visualize(
+    repo: Optional[str] = typer.Option(None, "--repo", "-r", help="Path to the repository to visualize."),
+    port: int = typer.Option(8000, "--port", "-p", help="Port to run the visualizer server on.")
+):
     """
-    Generates a URL to visualize a Cypher query in the Neo4j Browser.
-    If no query is provided, a default query will be used.
+    Launches the interactive Playground UI to visualize the code graph.
     """
-    if query is None:
-        query = "MATCH p=()-->() RETURN p"
     _load_credentials()
-    visualize_helper(query)
+    visualize_helper(repo, port)
 
 @app.command("list")
 def list_repositories():
@@ -2145,9 +2145,13 @@ def delete_abbrev(
     delete(path, all_repos)
 
 @app.command("v", rich_help_panel="Shortcuts")
-def visualize_abbrev(query: Optional[str] = typer.Argument(None, help="Cypher query")):
+def visualize_abbrev(
+    repo: Optional[str] = typer.Argument(None, help="Path to the repository to visualize."),
+    port: int = typer.Option(8000, "--port", "-p", help="Port to run the visualizer server on.")
+):
     """Shortcut for 'cgc visualize'"""
-    visualize(query)
+    _load_credentials()
+    visualize_helper(repo, port)
 
 @app.command("w", rich_help_panel="Shortcuts")
 def watch_abbrev(path: str = typer.Argument(".", help="Path to watch")):

codegraphcontext/core/cgc_bundle.py

@@ -161,9 +161,13 @@ class CGCBundle:
             with tempfile.TemporaryDirectory() as temp_dir:
                 temp_path = Path(temp_dir)
                 
-                # Step 1: Extract ZIP
+                # Step 1: Extract ZIP (with Zip Slip protection)
                 info_logger("Extracting bundle...")
                 with zipfile.ZipFile(bundle_path, 'r') as zip_ref:
+                    for entry in zip_ref.namelist():
+                        resolved = (temp_path / entry).resolve()
+                        if not str(resolved).startswith(str(temp_path.resolve())):
+                            return False, f"Zip Slip detected: entry '{entry}' escapes target directory"
                     zip_ref.extractall(temp_path)
                 
                 # Step 2: Validate bundle

codegraphcontext/tools/code_finder.py

@@ -1,6 +1,6 @@
 # src/codegraphcontext/tools/code_finder.py
 import logging
-import re
+
 from typing import Any, Dict, List, Literal, Optional
 from pathlib import Path
 
@@ -348,7 +348,6 @@ class CodeFinder:
     def what_does_function_call(self, function_name: str, path: Optional[str] = None, repo_path: Optional[str] = None) -> List[Dict]:
         """Find what functions a specific function calls using CALLS relationships"""
         with self.driver.session() as session:
-            repo_filter = "AND called.path STARTS WITH $repo_path" if repo_path else ""
             if path:
                 # Convert path to absolute path
                 absolute_file_path = str(Path(path).resolve())
@@ -450,16 +449,16 @@ class CodeFinder:
     def find_class_hierarchy(self, class_name: str, path: Optional[str] = None, repo_path: Optional[str] = None) -> Dict[str, Any]:
         """Find class inheritance relationships using INHERITS relationships"""
         with self.driver.session() as session:
-            repo_filter = "WHERE 1=1 AND parent.path STARTS WITH $repo_path" if repo_path else ""
+            repo_filter = "AND parent.path STARTS WITH $repo_path" if repo_path else ""
             if path:
                 match_clause = "MATCH (child:Class {name: $class_name, path: $path})"
             else:
                 match_clause = "MATCH (child:Class {name: $class_name})"
 
             parents_query = f"""
-                {{match_clause}}
+                {match_clause}
                 MATCH (child)-[:INHERITS]->(parent:Class)
-                WHERE 1=1 {{repo_filter}}
+                WHERE 1=1 {repo_filter}
                 OPTIONAL MATCH (parent_file:File)-[:CONTAINS]->(parent)
                 RETURN DISTINCT
                     parent.name as parent_class,
@@ -471,11 +470,11 @@ class CodeFinder:
             """
             parents_result = session.run(parents_query, class_name=class_name, path=path, repo_path=repo_path)
             
-            repo_filter_child = "WHERE 1=1 AND grandchild.path STARTS WITH $repo_path" if repo_path else ""
+            repo_filter_child = "AND grandchild.path STARTS WITH $repo_path" if repo_path else ""
             children_query = f"""
-                {{match_clause}}
+                {match_clause}
                 MATCH (grandchild:Class)-[:INHERITS]->(child)
-                WHERE 1=1 {{repo_filter_child}}
+                WHERE 1=1 {repo_filter_child}
                 OPTIONAL MATCH (child_file:File)-[:CONTAINS]->(grandchild)
                 RETURN DISTINCT
                     grandchild.name as child_class,
@@ -513,10 +512,10 @@ class CodeFinder:
     def find_function_overrides(self, function_name: str, repo_path: Optional[str] = None) -> List[Dict]:
         """Find all implementations of a function across different classes"""
         with self.driver.session() as session:
-            repo_filter = "WHERE 1=1 AND class.path STARTS WITH $repo_path" if repo_path else ""
+            repo_filter = "AND class.path STARTS WITH $repo_path" if repo_path else ""
             result = session.run(f"""
                 MATCH (class:Class)-[:CONTAINS]->(func:Function {{name: $function_name}})
-                WHERE 1=1 {{repo_filter}}
+                WHERE 1=1 {repo_filter}
                 OPTIONAL MATCH (file:File)-[:CONTAINS]->(class)
                 RETURN DISTINCT
                     class.name as class_name,
@@ -821,69 +820,69 @@ class CodeFinder:
                 "instances": variable_instances.data()
             }
     
-    def analyze_code_relationships(self, query_type: str, target: str, context: Optional[str] = None) -> Dict[str, Any]:
+    def analyze_code_relationships(self, query_type: str, target: str, context: Optional[str] = None, repo_path: Optional[str] = None) -> Dict[str, Any]:
         """Main method to analyze different types of code relationships with fixed return types"""
         query_type = query_type.lower().strip()
         
         try:
             if query_type == "find_callers":
-                results = self.who_calls_function(target, context)
+                results = self.who_calls_function(target, context, repo_path=repo_path)
                 return {
                     "query_type": "find_callers", "target": target, "context": context, "results": results,
                     "summary": f"Found {len(results)} functions that call '{target}'"
                 }
             
             elif query_type == "find_callees":
-                results = self.what_does_function_call(target, context)
+                results = self.what_does_function_call(target, context, repo_path=repo_path)
                 return {
                     "query_type": "find_callees", "target": target, "context": context, "results": results,
                     "summary": f"Function '{target}' calls {len(results)} other functions"
                 }
                 
             elif query_type == "find_importers":
-                results = self.who_imports_module(target)
+                results = self.who_imports_module(target, repo_path=repo_path)
                 return {
                     "query_type": "find_importers", "target": target, "results": results,
                     "summary": f"Found {len(results)} files that import '{target}'"
                 }
                 
             elif query_type == "find_functions_by_argument":
-                results = self.find_functions_by_argument(target, context)
+                results = self.find_functions_by_argument(target, context, repo_path=repo_path)
                 return {
                     "query_type": "find_functions_by_argument", "target": target, "context": context, "results": results,
                     "summary": f"Found {len(results)} functions that take '{target}' as an argument"
                 }
             
             elif query_type == "find_functions_by_decorator":
-                results = self.find_functions_by_decorator(target, context)
+                results = self.find_functions_by_decorator(target, context, repo_path=repo_path)
                 return {
                     "query_type": "find_functions_by_decorator", "target": target, "context": context, "results": results,
                     "summary": f"Found {len(results)} functions decorated with '{target}'"
                 }
                 
             elif query_type in ["who_modifies", "modifies", "mutations", "changes", "variable_usage"]:
-                results = self.who_modifies_variable(target)
+                results = self.who_modifies_variable(target, repo_path=repo_path)
                 return {
                     "query_type": "who_modifies", "target": target, "results": results,
                     "summary": f"Found {len(results)} containers that hold variable '{target}'"
                 }
             
             elif query_type in ["class_hierarchy", "inheritance", "extends"]:
-                results = self.find_class_hierarchy(target, context)
+                results = self.find_class_hierarchy(target, context, repo_path=repo_path)
                 return {
                     "query_type": "class_hierarchy", "target": target, "results": results,
                     "summary": f"Class '{target}' has {len(results['parent_classes'])} parents, {len(results['child_classes'])} children, and {len(results['methods'])} methods"
                 }
             
             elif query_type in ["overrides", "implementations", "polymorphism"]:
-                results = self.find_function_overrides(target)
+                results = self.find_function_overrides(target, repo_path=repo_path)
                 return {
                     "query_type": "overrides", "target": target, "results": results,
                     "summary": f"Found {len(results)} implementations of function '{target}'"
                 }
             
             elif query_type in ["dead_code", "unused", "unreachable"]:
-                results = self.find_dead_code()
+                results = self.find_dead_code(repo_path=repo_path)
                 return {
                     "query_type": "dead_code", "results": results,
                     "summary": f"Found {len(results['potentially_unused_functions'])} potentially unused functions"
@@ -891,21 +890,21 @@ class CodeFinder:
             
             elif query_type == "find_complexity":
                 limit = int(context) if context and context.isdigit() else 10
-                results = self.find_most_complex_functions(limit)
+                results = self.find_most_complex_functions(limit, repo_path=repo_path)
                 return {
                     "query_type": "find_complexity", "limit": limit, "results": results,
                     "summary": f"Found the top {len(results)} most complex functions"
                 }
             
             elif query_type == "find_all_callers":
-                results = self.find_all_callers(target, context)
+                results = self.find_all_callers(target, context, repo_path=repo_path)
                 return {
                     "query_type": "find_all_callers", "target": target, "context": context, "results": results,
                     "summary": f"Found {len(results)} direct and indirect callers of '{target}'"
                 }
 
             elif query_type == "find_all_callees":
-                results = self.find_all_callees(target, context)
+                results = self.find_all_callees(target, context, repo_path=repo_path)
                 return {
                     "query_type": "find_all_callees", "target": target, "context": context, "results": results,
                     "summary": f"Found {len(results)} direct and indirect callees of '{target}'"
@@ -916,7 +915,7 @@ class CodeFinder:
                     start_func, end_func = target.split('->', 1)
                     # max_depth can be passed as context, default to 5 if not provided or invalid
                     max_depth = int(context) if context and context.isdigit() else 5
-                    results = self.find_function_call_chain(start_func.strip(), end_func.strip(), max_depth)
+                    results = self.find_function_call_chain(start_func.strip(), end_func.strip(), max_depth, repo_path=repo_path)
                     return {
                         "query_type": "call_chain", "target": target, "results": results,
                         "summary": f"Found {len(results)} call chains from '{start_func.strip()}' to '{end_func.strip()}' (max depth: {max_depth})"
@@ -928,14 +927,14 @@ class CodeFinder:
                     }
             
             elif query_type in ["module_deps", "module_dependencies", "module_usage"]:
-                results = self.find_module_dependencies(target)
+                results = self.find_module_dependencies(target, repo_path=repo_path)
                 return {
                     "query_type": "module_dependencies", "target": target, "results": results,
                     "summary": f"Module '{target}' is imported by {len(results['imported_by_files'])} files"
                 }
             
             elif query_type in ["variable_scope", "var_scope", "variable_usage_scope"]:
-                results = self.find_variable_usage_scope(target)
+                results = self.find_variable_usage_scope(target, repo_path=repo_path)
                 return {
                     "query_type": "variable_scope", "target": target, "results": results,
                     "summary": f"Variable '{target}' has {len(results['instances'])} instances across different scopes"

codegraphcontext/tools/graph_builder.py

@@ -14,7 +14,20 @@ from ..utils.debug_log import debug_log, info_logger, error_logger, warning_logg
 from tree_sitter import Language, Parser
 from ..utils.tree_sitter_manager import get_tree_sitter_manager
 from ..cli.config_manager import get_config_value
-
+import fnmatch
+ 
+DEFAULT_IGNORE_PATTERNS = [
+    "*.png",
+    "*.jpg",
+    "*.jpeg",
+    "*.gif",
+    "*.svg",
+    "*.mp4",
+    "*.mp3",
+    "*.zip",
+    "*.tar",
+    "*.gz",
+]
 
 class TreeSitterParser:
     """A generic parser wrapper for a specific language using tree-sitter."""
@@ -181,6 +194,38 @@ class GraphBuilder:
             except Exception as e:
                 warning_logger(f"Schema creation warning: {e}")
 
+    @staticmethod
+    def _sanitize_props(props: Dict) -> Dict:
+        """Return a copy of *props* with all values coerced to database-safe types.
+
+        FalkorDB and KùzuDB only accept node properties that are primitives
+        (str, int, float, bool, None) or flat lists of primitives.  Complex
+        values such as tuples, dicts, or lists-of-dicts that come from language
+        parsers (e.g. C's ``detailed_args`` or Scala's tuple ``class_context``)
+        are serialized to a JSON string so the data is preserved rather than
+        being silently dropped.
+        """
+        import json
+
+        def _is_primitive(v):
+            return isinstance(v, (str, int, float, bool)) or v is None
+
+        def _is_flat_list(v):
+            return isinstance(v, list) and all(_is_primitive(item) for item in v)
+
+        def _coerce(v):
+            if _is_primitive(v):
+                return v
+            if _is_flat_list(v):
+                return v
+            # Tuples, dicts, lists-of-dicts, nested structures → JSON string
+            try:
+                return json.dumps(v, default=str)
+            except Exception:
+                return str(v)
+
+        return {k: _coerce(v) for k, v in props.items()}
+
 
     def _pre_scan_for_imports(self, files: list[Path]) -> dict:
         """Dispatches pre-scan to the correct language-specific implementation."""
@@ -381,7 +426,12 @@ class GraphBuilder:
                         MERGE (f)-[:CONTAINS]->(n)
                     """
 
-                    session.run(query, path=file_path_str, name=item['name'], line_number=item['line_number'], props=item)
+                    # Strip non-primitive fields (dicts, tuples, lists-of-dicts)
+                    # before writing to the database to avoid runtime errors such as
+                    # "Property values can only be of primitive types or arrays of
+                    # primitive types" raised by FalkorDB / KùzuDB.
+                    safe_props = self._sanitize_props(item)
+                    session.run(query, path=file_path_str, name=item['name'], line_number=item['line_number'], props=safe_props)
                     
                     if label == 'Function':
                         for arg_name in item.get('args', []):
@@ -1231,16 +1281,35 @@ class GraphBuilder:
                     break
                 curr = curr.parent
 
+            spec = None
             if cgcignore_path:
                 with open(cgcignore_path) as f:
-                    ignore_patterns = f.read().splitlines()
+                    user_patterns = [line.strip() for line in f.read().splitlines() if line.strip() and not line.strip().startswith('#')]
+                ignore_patterns = DEFAULT_IGNORE_PATTERNS + user_patterns
                 spec = pathspec.PathSpec.from_lines('gitwildmatch', ignore_patterns)
             else:
-                spec = None
+                # No .cgcignore found — create one in the project root with default patterns
+                # so the user can see and customize what's being ignored
+                project_root = path.resolve() if path.is_dir() else path.resolve().parent
+                new_cgcignore = project_root / ".cgcignore"
+                try:
+                    cgcignore_content = "# Auto-generated by CodeGraphContext\n"
+                    cgcignore_content += "# Default ignore patterns for binary/media files\n"
+                    cgcignore_content += "# Add your own patterns below\n\n"
+                    cgcignore_content += "\n".join(DEFAULT_IGNORE_PATTERNS) + "\n"
+                    new_cgcignore.write_text(cgcignore_content)
+                    info_logger(f"Created default .cgcignore at {new_cgcignore}")
+                except OSError as e:
+                    warning_logger(f"Could not create .cgcignore at {new_cgcignore}: {e}")
+                spec = pathspec.PathSpec.from_lines('gitwildmatch', DEFAULT_IGNORE_PATTERNS)
 
             supported_extensions = self.parsers.keys()
             all_files = path.rglob("*") if path.is_dir() else [path]
-            files = [f for f in all_files if f.is_file() and f.suffix in supported_extensions]
+
+            # Previously only files with supported extensions were indexed.
+            # Updated to include all files so that unsupported file types
+            # can still be represented as minimal File nodes in the graph.
+            files = [f for f in all_files if f.is_file()]
 
             # Filter default ignored directories
             ignore_dirs_str = get_config_value("IGNORE_DIRS") or ""
@@ -1291,10 +1360,28 @@ class GraphBuilder:
                         self.job_manager.update_job(job_id, current_file=str(file))
                     repo_path = path.resolve() if path.is_dir() else file.parent.resolve()
                     file_data = self.parse_file(repo_path, file, is_dependency)
+                    # Previously only files with supported extensions were indexed.
+                    # Updated to include all files so that unsupported file types
+                    # can still be represented as minimal File nodes in the graph.
                     if "error" not in file_data:
-                        self.add_file_to_graph(file_data, repo_name, imports_map)
+                        try:
+                            self.add_file_to_graph(file_data, repo_name, imports_map)
+                        except Exception as file_err:
+                            # Re-raise with the offending file path so the user
+                            # can identify which source file triggered the error.
+                            raise RuntimeError(
+                                f"{file_err} (while indexing file: {file})"
+                            ) from file_err
                         all_file_data.append(file_data)
+
+                    # Previously only files with supported extensions were indexed.
+                    # Updated to include all files so that unsupported file types
+                    # can still be represented as minimal File nodes in the graph.
+                    else:
+                        # create minimal node if parser not available
+                        self.add_minimal_file_node(file, repo_path, is_dependency)
                     processed_count += 1
+
                     if job_id:
                         self.job_manager.update_job(job_id, processed_files=processed_count)
                     await asyncio.sleep(0.01)
@@ -1318,3 +1405,67 @@ class GraphBuilder:
                 self.job_manager.update_job(
                     job_id, status=status, end_time=datetime.now(), errors=[str(e)]
                 )
+
+    # Create a minimal File node for unsupported file types.
+    # These files do not contain parsed entities but should still
+    # appear in the repository graph as requested in issue #707.
+    def add_minimal_file_node(self, file_path: Path, repo_path: Path, is_dependency: bool = False):
+
+        file_path_str = str(file_path.resolve())
+        file_name = file_path.name
+        repo_name = repo_path.name
+        repo_path_str = str(repo_path.resolve())
+
+        with self.driver.session() as session:
+
+            session.run(
+                """
+                MERGE (r:Repository {path: $repo_path})
+                SET r.name = $repo_name
+                """,
+                repo_path=repo_path_str,
+                repo_name=repo_name
+            )
+
+            session.run(
+                """
+                MERGE (f:File {path: $file_path})
+                SET f.name = $file_name,
+                    f.is_dependency = $is_dependency
+                """,
+                file_path=file_path_str,
+                file_name=file_name,
+                is_dependency=is_dependency
+            )
+
+            # Establish directory structure
+            file_path_obj = Path(file_path_str)
+            repo_path_obj = Path(repo_path_str)
+            try:
+                relative_path_to_file = file_path_obj.relative_to(repo_path_obj)
+            except ValueError:
+                # Fallback if not relative
+                relative_path_to_file = Path(file_path_obj.name)
+            
+            parent_path = repo_path_str
+            parent_label = 'Repository'
+
+            for part in relative_path_to_file.parts[:-1]:
+                current_path = Path(parent_path) / part
+                current_path_str = str(current_path)
+                
+                session.run(f"""
+                    MATCH (p:{parent_label} {{path: $parent_path}})
+                    MERGE (d:Directory {{path: $current_path}})
+                    SET d.name = $part
+                    MERGE (p)-[:CONTAINS]->(d)
+                """, parent_path=parent_path, current_path=current_path_str, part=part)
+
+                parent_path = current_path_str
+                parent_label = 'Directory'
+
+            session.run(f"""
+                MATCH (p:{parent_label} {{path: $parent_path}})
+                MATCH (f:File {{path: $file_path}})
+                MERGE (p)-[:CONTAINS]->(f)
+            """, parent_path=parent_path, file_path=file_path_str)

codegraphcontext/tools/package_resolver.py

@@ -1,5 +1,5 @@
 # src/codegraphcontext/tools/package_resolver.py
-import importlib
+import importlib.util
 import stdlibs
 from pathlib import Path
 import subprocess
@@ -10,25 +10,27 @@ from ..utils.debug_log import debug_log
 def _get_python_package_path(package_name: str) -> Optional[str]:
     """
     Finds the local installation path of a Python package.
+    Uses importlib.util.find_spec() to locate the module without executing its code.
     """
     try:
         debug_log(f"Getting local path for Python package: {package_name}")
-        module = importlib.import_module(package_name)
-        if hasattr(module, '__file__') and module.__file__:
-            module_file = Path(module.__file__)
+        spec = importlib.util.find_spec(package_name)
+        if spec is None:
+            return None
+        if spec.origin and spec.origin != "frozen":
+            module_file = Path(spec.origin)
             if module_file.name == '__init__.py':
                 return str(module_file.parent)
             elif package_name in stdlibs.module_names:
                 return str(module_file)
             else:
                 return str(module_file.parent)
-        elif hasattr(module, '__path__'):
-            if isinstance(module.__path__, list) and module.__path__:
-                return str(Path(module.__path__[0]))
-            else:
-                return str(Path(str(module.__path__)))
+        elif spec.submodule_search_locations:
+            locations = list(spec.submodule_search_locations)
+            if locations:
+                return str(Path(locations[0]))
         return None
-    except ImportError:
+    except (ModuleNotFoundError, ValueError):
         return None
     except Exception as e:
         debug_log(f"Error getting local path for {package_name}: {e}")

codegraphcontext/viz/server.py

@@ -0,0 +1,178 @@
+
+from fastapi import FastAPI, HTTPException, Query, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, FileResponse
+from pathlib import Path
+import uvicorn
+import json
+import os
+from typing import Optional, List, Dict, Any
+
+from ..core.database import DatabaseManager
+from ..utils.debug_log import debug_log
+
+app = FastAPI()
+
+# Enable CORS for development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global database manager (will be initialized when server starts)
+db_manager: Optional[DatabaseManager] = None
+# Path to static directory
+_static_dir: Optional[str] = None
+
+def set_db_manager(manager: DatabaseManager):
+    global db_manager
+    db_manager = manager
+
+@app.get("/api/graph")
+async def get_graph(repo_path: Optional[str] = None):
+    if not db_manager:
+        raise HTTPException(status_code=500, detail="Database not initialized")
+    
+    def get_eid(element):
+        if not element: return None
+        if isinstance(element, (int, str)):
+            return str(element)
+        # Try various ways to get ID (Neo4j, FalkorDB, etc.)
+        for attr in ['element_id', 'id', '_id']:
+            if hasattr(element, attr):
+                val = getattr(element, attr)
+                if val is not None: return str(val)
+        return str(id(element))
+
+    try:
+        nodes_dict = {}
+        edges = []
+
+        with db_manager.get_driver().session() as session:
+            if repo_path:
+                repo_path = str(Path(repo_path).resolve())
+                # Optimized subgraph query
+                query = """
+                MATCH (r:Repository {path: $repo_path})
+                OPTIONAL MATCH (r)-[:CONTAINS*0..]->(n)
+                WITH DISTINCT n
+                WHERE n IS NOT NULL
+                OPTIONAL MATCH (n)-[rel]->(m)
+                RETURN n, rel, m
+                """
+                result = session.run(query, repo_path=repo_path)
+            else:
+                query = "MATCH (n) OPTIONAL MATCH (n)-[rel]->(m) RETURN n, rel, m LIMIT 5000"
+                result = session.run(query)
+
+            for record in result:
+                for key in ['n', 'm']:
+                    node = record[key]
+                    if node:
+                        eid = get_eid(node)
+                        if eid not in nodes_dict:
+                            # FalkorDB / Neo4j labels compatibility
+                            labels = []
+                            if hasattr(node, 'labels'):
+                                labels = list(node.labels)
+                            
+                            # FalkorDB / Neo4j properties compatibility
+                            props = {}
+                            if hasattr(node, 'properties'):
+                                props = node.properties
+                            elif hasattr(node, 'items'):
+                                props = dict(node.items())
+                                
+                            nodes_dict[eid] = {
+                                "id": eid,
+                                "label": props.get('name', props.get('label', 'Unknown')),
+                                "type": labels[0].lower() if labels else "default",
+                                "file": props.get('path', ''),
+                                "properties": props
+                            }
+                
+                rel = record['rel']
+                if rel:
+                    rid = get_eid(rel)
+                    
+                    # FalkorDB / Neo4j compatibility for source/target nodes
+                    start_node = getattr(rel, 'start_node', getattr(rel, 'src_node', None))
+                    end_node = getattr(rel, 'end_node', getattr(rel, 'dest_node', None))
+                    
+                    source = get_eid(start_node)
+                    target = get_eid(end_node)
+                    
+                    if source and target:
+                        # relationship type/relation
+                        rel_type = "related"
+                        if hasattr(rel, 'type'):
+                            rel_type = rel.type
+                        elif hasattr(rel, 'relation'):
+                            rel_type = rel.relation
+                            
+                        edges.append({
+                            "id": rid,
+                            "source": source,
+                            "target": target,
+                            "type": str(rel_type).lower()
+                        })
+
+        return {
+            "nodes": list(nodes_dict.values()), 
+            "edges": edges,
+            "files": {}
+        }
+
+    except Exception as e:
+        debug_log(f"Error fetching graph: {str(e)}")
+        # Print stack trace for debugging if possible
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/file")
+async def get_file(path: str):
+    file_path = Path(path)
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return {"content": f.read()}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# SPA fallback handler
+@app.get("/{full_path:path}")
+async def spa_fallback(request: Request, full_path: str):
+    global _static_dir
+    if not _static_dir:
+        return HTMLResponse("Static directory not configured", status_code=500)
+    
+    # Filesystem path
+    file_path = Path(_static_dir) / full_path
+    
+    # If the file exists and is a file, serve it normally (handled by StaticFiles usually, 
+    # but we need this for routes that don't match StaticFiles mount)
+    if file_path.exists() and file_path.is_file():
+        return FileResponse(file_path)
+    
+    # Otherwise serve index.html
+    index_path = Path(_static_dir) / "index.html"
+    if index_path.exists():
+        return FileResponse(index_path)
+    
+    return HTMLResponse("Not Found", status_code=404)
+
+def run_server(host: str = "127.0.0.1", port: int = 8000, static_dir: Optional[str] = None):
+    global _static_dir
+    _static_dir = static_dir
+    if static_dir:
+        # Mount API first
+        # We don't mount "/" with StaticFiles because we use spa_fallback for all routes
+        pass
+    
+    uvicorn.run(app, host=host, port=port)

{codegraphcontext-0.3.0.dist-info → codegraphcontext-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.3.0
+Version: 0.3.2
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -46,12 +46,13 @@ Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: tree-sitter>=0.21.0
 Requires-Dist: tree-sitter-language-pack>=0.6.0
 Requires-Dist: pyyaml
-Requires-Dist: pytest
 Requires-Dist: nbformat
 Requires-Dist: nbconvert>=7.16.6
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: falkordb>=0.1.0
 Requires-Dist: falkordblite>=0.1.0; sys_platform != "win32" and python_version >= "3.12"
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.22.0
 Provides-Extra: parsing
 Requires-Dist: tree-sitter>=0.21.0; extra == "parsing"
 Requires-Dist: tree-sitter-language-pack>=0.6.0; extra == "parsing"
@@ -63,6 +64,18 @@ Dynamic: license-file
 
 # 🏗️ CodeGraphContext (CGC)
 
+**Turn code repositories into a queryable graph for AI agents.**
+
+🌐 **Languages:**
+- 🇬🇧 [English](README.md)
+- 🇨🇳 [中文](README.zh-CN.md)
+- 🇰🇷 [한국어](README.kor.md)
+- 🇯🇵 日本語 (Soon)
+- 🇷🇺 Русский (Soon)
+- 🇪🇸 Español (Soon)
+
+🌍 **Help translate CodeGraphContext to your language by raising an issue & PR on https://github.com/Shashankss1205/CodeGraphContext/issues!**
+
 <p align="center">
   <br>
   <b>Bridge the gap between deep code graphs and AI context.</b>
@@ -147,7 +160,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.3.0
+- **Version:** 0.3.2
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)
@@ -352,7 +365,7 @@ cgc watch .
 cgc help
 ```
 
-**See the full [CLI Commands Guide](CLI_Commands.md) for all available commands and usage scenarios.**
+  **See the full [CLI Commands Guide](docs/CLI_COMPLETE_REFERENCE.md) for all available commands and usage scenarios.**
 
 ### 🎨 Premium Interactive Visualization
 CodeGraphContext can generate stunning, interactive knowledge graphs of your code. Unlike static diagrams, these are premium web-based explorers:

{codegraphcontext-0.3.0.dist-info → codegraphcontext-0.3.2.dist-info}/RECORD

@@ -4,16 +4,16 @@ codegraphcontext/prompts.py,sha256=E5P55paM0oHfBcNVfxkxpXRGZnya1kr_mKDg9i49FwM,6
 codegraphcontext/server.py,sha256=gcb6V4x0Oh8haBOCm2WBjTCO9FDukrSalAMMApL-oc8,12806
 codegraphcontext/tool_definitions.py,sha256=_0ahezQSURX_ewWydT2sFcvC6OFGdMoPA7KwgWNVcks,11482
 codegraphcontext/cli/__init__.py,sha256=v6CMDVKM5d_sXn3S5nZNf0phXn0IdrnhLazUoen9k9w,38
-codegraphcontext/cli/cli_helpers.py,sha256=2T8eP1RmM_p2Z1XfZDv44wx3Hf01jF_b3KGoWVBG0lk,35945
+codegraphcontext/cli/cli_helpers.py,sha256=zlcPv0cReflgTpTM2Nj0jCB3pHvVRCqfvyAM-hCEm6c,36598
 codegraphcontext/cli/config_manager.py,sha256=MK7GMGZ4hd8-ZOShXBd_KDtNqHQ3ngdbef5KM_naPrQ,15899
-codegraphcontext/cli/main.py,sha256=PSJ5BxQhbdNdCWWyYvW9-6COCiw852iVi-zhP43nYPA,86328
+codegraphcontext/cli/main.py,sha256=D-nlcT90ah3rHQ_h7TIq451EA4WN_HxOmXKm9EY2Hnw,86497
 codegraphcontext/cli/registry_commands.py,sha256=30rJm4SeS0n1jax4JVuhuv4zYLzyMmlHcCSnsDDhgc8,19964
 codegraphcontext/cli/setup_macos.py,sha256=Xjlv_9jk9qv8Gh7stpH1pvlalzC0Fg176y7jc5G1zh0,3575
 codegraphcontext/cli/setup_wizard.py,sha256=yVXKqvAtUM0UC4tUreiS6C5utJbBO5Et2MiPUPWit9s,41393
 codegraphcontext/cli/visualizer.py,sha256=rZOLPx44wlaxVXGLR6uOaiL2GaQvxEnpyDQ4tjRDVC8,45750
 codegraphcontext/core/__init__.py,sha256=r-dC2b8hn5e4ZBVfWnCcBYMTQVcayxG5-eA5Do6uSM4,7278
 codegraphcontext/core/bundle_registry.py,sha256=kLvTLEl99QwfyAw8a7-4hqconLCtS64G9ECPVdfVBsM,7476
-codegraphcontext/core/cgc_bundle.py,sha256=YHL_uamATXYVweh5qbg9TQjT1lKlt69gXyF-xKKk67c,31353
+codegraphcontext/core/cgc_bundle.py,sha256=lxaImBnEJMiscrGssLTgLaeEa7tY33xztjbxOhr6O5U,31686
 codegraphcontext/core/database.py,sha256=2UL8AyE6vX5mVHg1zcD74TYEREmddhKzN7Bjy2THQwM,11435
 codegraphcontext/core/database_falkordb.py,sha256=IKRcUwqdCR92ymX9rNAQSs49RWPxug_78utwePEcliQ,18842
 codegraphcontext/core/database_falkordb_remote.py,sha256=aMiuJTB_-2rBUpbAmX8ElZiZrYZbOXK-On3ncgMCyhY,7118
@@ -23,9 +23,9 @@ codegraphcontext/core/jobs.py,sha256=d6v_IERdEcDlIsz3CW3p0QMp3N-6dgQICs3FZRPgPgU
 codegraphcontext/core/watcher.py,sha256=42AWDv7LUE5v_HlY_Rvvlk8deDdlUBvM3hI-DMDWAOk,9813
 codegraphcontext/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codegraphcontext/tools/advanced_language_query_tool.py,sha256=APtC-KSkXXSrVLwiw3kgi6Q-xaqXl6skLWHPyuNh358,3670
-codegraphcontext/tools/code_finder.py,sha256=KFBBRaWfviix2myDl9qJfNxfeBl5amG5QNsKYmqCjog,55343
-codegraphcontext/tools/graph_builder.py,sha256=7wFLzW6S0Ria7oSfpma9KKHA-uEGjuCMz3lnq7MCTR0,72017
-codegraphcontext/tools/package_resolver.py,sha256=b8ksgCxR-rHcVCPTkzmjOYNuJvZGGsCDQtUqMuVKhzo,18613
+codegraphcontext/tools/code_finder.py,sha256=2wd05dMrPW8xZDBUixS4BaipNbrE4rttqSD6JYEeQM4,55552
+codegraphcontext/tools/graph_builder.py,sha256=dUIJKRZRlC0WHINNOqHLmw20I28cf_ePti-NcGEEcnE,78728
+codegraphcontext/tools/package_resolver.py,sha256=KtbdMReTezszjdsqYniL-Xb-QUsrAJWtf1NSiyIPkLI,18704
 codegraphcontext/tools/scip_indexer.py,sha256=gxe5-f090wonHEWYDT1CV6b3SpSTQtwng6A1SfPX_LA,19970
 codegraphcontext/tools/scip_pb2.py,sha256=dwOMNKlu6VyLq5h8kTPZRDqxrwfVL8yw7I7ziokFG48,98229
 codegraphcontext/tools/system.py,sha256=DGeavZoPxzV78wwApV4f7fdBFQRa8oeOSv5wprHSjRE,5733
@@ -71,9 +71,10 @@ codegraphcontext/tools/query_tool_languages/typescript_toolkit.py,sha256=3S4hpmO
 codegraphcontext/utils/debug_log.py,sha256=Qg7jwyeg7x2h3Ur_2S34bdMCkHdlk_ngHfPwa97A9vE,2836
 codegraphcontext/utils/tree_sitter_manager.py,sha256=bIuKYN1aj1Zi6BnksGjZSLZzgBwuFRselZzyUpbToAU,9180
 codegraphcontext/utils/visualize_graph.py,sha256=Ntq8l8SvAOvsOp19QKByjEwU7-5rPa_XfcGLOrUehq4,5003
-codegraphcontext-0.3.0.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-codegraphcontext-0.3.0.dist-info/METADATA,sha256=FH-FTUU-gexxDfZePS6rqliF6540hUmv3ARwXJ_qO-I,21093
-codegraphcontext-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-codegraphcontext-0.3.0.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
-codegraphcontext-0.3.0.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
-codegraphcontext-0.3.0.dist-info/RECORD,,
+codegraphcontext/viz/server.py,sha256=KiB6UARhVHGJ3ANi1R8i5RKnDVwqOULS8kKng-L-6GI,6530
+codegraphcontext-0.3.2.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+codegraphcontext-0.3.2.dist-info/METADATA,sha256=Bc0OVmQ-9RaxbL4YYE5bIGuqSDcRUbHMwtsrbxjjziY,21579
+codegraphcontext-0.3.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codegraphcontext-0.3.2.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
+codegraphcontext-0.3.2.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.3.2.dist-info/RECORD,,