codegraphcontext 0.2.12__py3-none-any.whl → 0.3.1__py3-none-any.whl

codegraphcontext/cli/cli_helpers.py

@@ -4,8 +4,18 @@ 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 (
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+    TimeRemainingColumn,
+    MofNCompleteColumn,
+)
 
 from ..core import get_database_manager
 from ..core.jobs import JobManager
@@ -67,6 +77,64 @@ def _initialize_services():
     return db_manager, graph_builder, code_finder
 
 
+async def _run_index_with_progress(graph_builder: GraphBuilder, path_obj: Path, is_dependency: bool = False):
+    """Internal helper to run indexing with a Live progress bar."""
+    job_id = graph_builder.job_manager.create_job(str(path_obj), is_dependency=is_dependency)
+    
+    # Create the progress bar
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        MofNCompleteColumn(),
+        TimeRemainingColumn(),
+        TextColumn("[dim]{task.fields[filename]}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        
+        task_id = progress.add_task(
+            "Indexing...", 
+            total=None,  # Will be updated once file discovery is done
+            filename=""
+        )
+
+        indexing_task = asyncio.create_task(
+            graph_builder.build_graph_from_path_async(path_obj, is_dependency=is_dependency, job_id=job_id)
+        )
+
+        from ..core.jobs import JobStatus
+        
+        # Poll for updates
+        while not indexing_task.done():
+            job = graph_builder.job_manager.get_job(job_id)
+            if job:
+                if job.total_files > 0:
+                    progress.update(task_id, total=job.total_files, completed=job.processed_files)
+                
+                # Update the current filename in the UI
+                current_file = job.current_file or ""
+                if len(current_file) > 40:
+                    current_file = "..." + current_file[-37:]
+                progress.update(task_id, filename=current_file)
+
+                if job.status in [JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.CANCELLED]:
+                    break
+            
+            await asyncio.sleep(0.1)
+
+        # Wait for actual completion and handle final state
+        try:
+            await indexing_task
+            job = graph_builder.job_manager.get_job(job_id)
+            if job and job.status == JobStatus.FAILED:
+                error_msg = job.errors[0] if job.errors else "Unknown error"
+                raise RuntimeError(error_msg)
+        except Exception as e:
+            raise e
+
+
 def index_helper(path: str):
     """Synchronously indexes a repository."""
     time_start = time.time()
@@ -107,13 +175,9 @@ def index_helper(path: str):
             console.print(f"[yellow]Warning: Could not check file count: {e}. Proceeding with indexing...[/yellow]")
 
     console.print(f"Starting indexing for: {path_obj}")
-    console.print("[yellow]This may take a few minutes for large repositories...[/yellow]")
-
-    async def do_index():
-        await graph_builder.build_graph_from_path_async(path_obj, is_dependency=False)
 
     try:
-        asyncio.run(do_index())
+        asyncio.run(_run_index_with_progress(graph_builder, path_obj, is_dependency=False))
         time_end = time.time()
         elapsed = time_end - time_start
         console.print(f"[green]Successfully finished indexing: {path} in {elapsed:.2f} seconds[/green]")
@@ -159,13 +223,9 @@ def add_package_helper(package_name: str, language: str):
         return
 
     console.print(f"Starting indexing for package '{package_name}' at: {package_path}")
-    console.print("[yellow]This may take a few minutes...[/yellow]")
-
-    async def do_index():
-        await graph_builder.build_graph_from_path_async(package_path, is_dependency=True)
 
     try:
-        asyncio.run(do_index())
+        asyncio.run(_run_index_with_progress(graph_builder, package_path, is_dependency=True))
         console.print(f"[green]Successfully finished indexing package: {package_name}[/green]")
     except Exception as e:
         console.print(f"[bold red]An error occurred during package indexing:[/bold red] {e}")
@@ -280,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]")
@@ -587,13 +658,9 @@ def reindex_helper(path: str):
             return
     
     console.print(f"[cyan]Re-indexing: {path_obj}[/cyan]")
-    console.print("[yellow]This may take a few minutes for large repositories...[/yellow]")
-
-    async def do_index():
-        await graph_builder.build_graph_from_path_async(path_obj, is_dependency=False)
-
+    
     try:
-        asyncio.run(do_index())
+        asyncio.run(_run_index_with_progress(graph_builder, path_obj, is_dependency=False))
         time_end = time.time()
         elapsed = time_end - time_start
         console.print(f"[green]Successfully re-indexed: {path} in {elapsed:.2f} seconds[/green]")

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/__init__.py

@@ -125,7 +125,14 @@ def get_database_manager() -> Union['DatabaseManager', 'FalkorDBManager', 'Falko
         else:
             raise ValueError(f"Unknown database type: '{db_type}'. Use 'kuzudb', 'falkordb', 'falkordb-remote', or 'neo4j'.")
 
-    # 4. Implicit Default -> FalkorDB Lite (Unix Zero Config)
+    # 4. Auto-detect: Remote FalkorDB (if FALKORDB_HOST is set)
+    # This takes priority over zero-config local backends because it's an explicit signal
+    if _is_falkordb_remote_configured():
+        from .database_falkordb_remote import FalkorDBRemoteManager
+        info_logger("Using remote FalkorDB (auto-detected via FALKORDB_HOST)")
+        return FalkorDBRemoteManager()
+
+    # 5. Implicit Default -> FalkorDB Lite (Unix Zero Config)
     if _is_falkordb_available():
         from .database_falkordb import FalkorDBManager, FalkorDBUnavailableError
         try:
@@ -139,18 +146,12 @@ def get_database_manager() -> Union['DatabaseManager', 'FalkorDBManager', 'Falko
             )
             # fall through to KùzuDB below
 
-    # 5. Implicit Default -> KùzuDB (Best Zero Config)
+    # 6. Implicit Default -> KùzuDB (Best Zero Config)
     if _is_kuzudb_available():
         from .database_kuzu import KuzuDBManager
         info_logger("Using KùzuDB (default)")
         return KuzuDBManager()
 
-    # 6. Auto-detect: Remote FalkorDB (if FALKORDB_HOST is set)
-    if _is_falkordb_remote_configured():
-        from .database_falkordb_remote import FalkorDBRemoteManager
-        info_logger("Using remote FalkorDB (auto-detected via FALKORDB_HOST)")
-        return FalkorDBRemoteManager()
-
     # 7. Fallback if configured
     if _is_neo4j_configured():
         from .database import DatabaseManager

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"