codegraphcontext 0.3.0__tar.gz → 0.3.1__tar.gz

codegraphcontext-0.3.1/MANIFEST.in

@@ -0,0 +1,5 @@
+prune website
+prune images
+prune vscode-extension
+prune playground
+recursive-include src/codegraphcontext/viz/dist *

{codegraphcontext-0.3.0/src/codegraphcontext.egg-info → codegraphcontext-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.3.0
+Version: 0.3.1
 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
@@ -52,6 +52,8 @@ 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 +65,17 @@ Dynamic: license-file
 
 # 🏗️ CodeGraphContext (CGC)
 
+**Turn code repositories into a queryable graph for AI agents.**
+
+🌐 **Languages:**
+- 🇬🇧 [English](README.md)
+- 🇨🇳 [中文](README.zh-CN.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.1
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.3.0 → codegraphcontext-0.3.1}/README.md

@@ -1,5 +1,16 @@
 # 🏗️ CodeGraphContext (CGC)
 
+**Turn code repositories into a queryable graph for AI agents.**
+
+🌐 **Languages:**
+- 🇬🇧 [English](README.md)
+- 🇨🇳 [中文](README.zh-CN.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>
@@ -84,7 +95,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.3.0
+- **Version:** 0.3.1
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.3.0 → codegraphcontext-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.3.0"
+version = "0.3.1"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"
@@ -30,7 +30,9 @@ dependencies = [
     "nbconvert>=7.16.6",
     "pathspec>=0.12.1",
     "falkordb>=0.1.0",
-    "falkordblite>=0.1.0; sys_platform != 'win32' and python_version >= '3.12'"
+    "falkordblite>=0.1.0; sys_platform != 'win32' and python_version >= '3.12'",
+    "fastapi>=0.100.0",
+    "uvicorn>=0.22.0"
 ]
 
 [project.optional-dependencies]
@@ -54,6 +56,10 @@ codegraphcontext = "codegraphcontext.cli.main:app"
 
 [tool.setuptools]
 package-dir = { "" = "src" }
+include-package-data = true
+
+[tool.setuptools.package-data]
+codegraphcontext = ["viz/dist/**/*"]
 
 [tool.setuptools.packages.find]
 where = ["src"]

{codegraphcontext-0.3.0 → codegraphcontext-0.3.1}/src/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-0.3.0 → codegraphcontext-0.3.1}/src/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-0.3.0 → codegraphcontext-0.3.1}/src/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"