codegraphcontext 0.1.35__tar.gz → 0.1.36__tar.gz

{codegraphcontext-0.1.35/src/codegraphcontext.egg-info → codegraphcontext-0.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.1.35
+Version: 0.1.36
 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
@@ -91,7 +91,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/CodeGraphContext/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.35
+- **Version:** 0.1.36
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.1.35 → codegraphcontext-0.1.36}/README.md

@@ -29,7 +29,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ![Using the MCP server](https://github.com/CodeGraphContext/CodeGraphContext/blob/main/images/Usecase.gif)
 
 ## Project Details
-- **Version:** 0.1.35
+- **Version:** 0.1.36
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.1.35 → codegraphcontext-0.1.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.1.35"
+version = "0.1.36"
 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"

{codegraphcontext-0.1.35 → codegraphcontext-0.1.36}/src/codegraphcontext/cli/registry_commands.py

@@ -408,3 +408,77 @@ def request_bundle(repo_url: str, wait: bool = False):
     if wait:
         console.print("\n[yellow]Note: Automatic waiting not yet implemented.[/yellow]")
         console.print("[dim]Please check back in 5-10 minutes and use 'cgc registry download <name>'[/dim]")
+
+
+def load_bundle_command(bundle_name: str, clear_existing: bool = False):
+    """
+    Load a bundle (for MCP tool integration).
+    
+    This is a wrapper around download_bundle that returns structured data
+    instead of using console output and typer.Exit.
+    
+    Args:
+        bundle_name: Name of the bundle to load
+        clear_existing: Whether to clear existing data before loading
+        
+    Returns:
+        Tuple of (success: bool, message: str, stats: dict)
+    """
+    from pathlib import Path
+    from .cli_helpers import _initialize_services
+    from ..core.cgc_bundle import CGCBundle
+    
+    try:
+        # Initialize services
+        services = _initialize_services()
+        if not all(services):
+            return (False, "Failed to initialize database services", {})
+        
+        db_manager, _, _ = services
+        
+        # Check if bundle exists locally
+        bundle_path = Path(bundle_name)
+        if not bundle_path.exists():
+            # Try to download from registry
+            try:
+                download_bundle(bundle_name, output_dir=None, auto_load=False)
+                # After download, the file should exist
+                if not bundle_path.exists():
+                    # Try with .cgc extension
+                    bundle_path = Path(f"{bundle_name}.cgc")
+                    if not bundle_path.exists():
+                        return (False, f"Bundle not found: {bundle_name}", {})
+            except Exception as e:
+                return (False, f"Failed to download bundle: {str(e)}", {})
+        
+        # Load the bundle
+        bundle = CGCBundle(db_manager)
+        success, message = bundle.import_from_bundle(
+            bundle_path=bundle_path,
+            clear_existing=clear_existing
+        )
+        
+        if success:
+            # Extract stats from message if available
+            stats = {}
+            if "Nodes:" in message and "Edges:" in message:
+                try:
+                    parts = message.split("|")
+                    for part in parts:
+                        if "Nodes:" in part:
+                            stats["nodes"] = int(part.split(":")[1].strip().replace(",", ""))
+                        elif "Edges:" in part:
+                            stats["edges"] = int(part.split(":")[1].strip().replace(",", ""))
+                except:
+                    pass
+            
+            return (True, message, stats)
+        else:
+            return (False, message, {})
+    
+    except Exception as e:
+        return (False, f"Error loading bundle: {str(e)}", {})
+    finally:
+        if 'db_manager' in locals():
+            db_manager.close_driver()
+

{codegraphcontext-0.1.35 → codegraphcontext-0.1.36}/src/codegraphcontext/server.py

@@ -164,6 +164,16 @@ class MCPServer:
             **args
         )
 
+    def load_bundle_tool(self, **args) -> Dict[str, Any]:
+        return management_handlers.load_bundle(self.code_finder, **args)
+    
+    def search_registry_bundles_tool(self, **args) -> Dict[str, Any]:
+        return management_handlers.search_registry_bundles(self.code_finder, **args)
+    
+    def get_repository_stats_tool(self, **args) -> Dict[str, Any]:
+        return management_handlers.get_repository_stats(self.code_finder, **args)
+
+
     async def handle_tool_call(self, tool_name: str, args: Dict[str, Any]) -> Dict[str, Any]:
         """
         Routes a tool call from the AI assistant to the appropriate handler function. 
@@ -184,7 +194,10 @@ class MCPServer:
             "delete_repository": self.delete_repository_tool,
             "visualize_graph_query": self.visualize_graph_query_tool,
             "list_watched_paths": self.list_watched_paths_tool,
-            "unwatch_directory": self.unwatch_directory_tool
+            "unwatch_directory": self.unwatch_directory_tool,
+            "load_bundle": self.load_bundle_tool,
+            "search_registry_bundles": self.search_registry_bundles_tool,
+            "get_repository_stats": self.get_repository_stats_tool
         }
         handler = tool_map.get(tool_name)
         if handler:

{codegraphcontext-0.1.35 → codegraphcontext-0.1.36}/src/codegraphcontext/tool_definitions.py

@@ -156,5 +156,38 @@ TOOLS = {
             },
             "required": ["path"]
         }
+    },
+    "load_bundle": {
+        "name": "load_bundle",
+        "description": "Load a pre-indexed .cgc bundle into the database. Can load from local file or automatically download from registry if not found locally. Bundles are portable snapshots of indexed code that load instantly without re-indexing.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "bundle_name": {"type": "string", "description": "Name of the bundle to load (e.g., 'flask', 'pandas', 'flask-main-2579ce9.cgc'). Can be a full filename or just the package name."},
+                "clear_existing": {"type": "boolean", "description": "Whether to clear existing data before loading. Use with caution.", "default": False}
+            },
+            "required": ["bundle_name"]
+        }
+    },
+    "search_registry_bundles": {
+        "name": "search_registry_bundles",
+        "description": "Search for available pre-indexed bundles in the registry. Returns bundles matching the search query with details like repository, version, size, and download information.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Search query to find bundles (searches in name, repository, and description). Leave empty to list all bundles."},
+                "unique_only": {"type": "boolean", "description": "If true, show only the most recent version of each package. If false, show all versions.", "default": False}
+            }
+        }
+    },
+    "get_repository_stats": {
+        "name": "get_repository_stats",
+        "description": "Get statistics about indexed repositories, including counts of files, functions, classes, and modules. Can show overall database statistics or stats for a specific repository.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "repo_path": {"type": "string", "description": "Optional: Path to a specific repository. If not provided, returns overall database statistics."}
+            }
+        }
     }
 }

{codegraphcontext-0.1.35 → codegraphcontext-0.1.36}/src/codegraphcontext/tools/graph_builder.py

@@ -70,6 +70,9 @@ class TreeSitterParser:
         elif self.language_name == 'swift':
             from .languages.swift import SwiftTreeSitterParser
             self.language_specific_parser = SwiftTreeSitterParser(self)
+        elif self.language_name == 'haskell':
+            from .languages.haskell import HaskellTreeSitterParser
+            self.language_specific_parser = HaskellTreeSitterParser(self)
 
 
 
@@ -114,6 +117,7 @@ class GraphBuilder:
             '.scala': TreeSitterParser('scala'),
             '.sc': TreeSitterParser('scala'),
             '.swift': TreeSitterParser('swift'),
+            '.hs': TreeSitterParser('haskell'),
         }
         self.create_schema()
 

codegraphcontext-0.1.36/src/codegraphcontext/tools/handlers/management_handlers.py

@@ -0,0 +1,304 @@
+from typing import Any, Dict
+from dataclasses import asdict
+from datetime import datetime
+from ...core.jobs import JobManager, JobStatus
+from ...utils.debug_log import debug_log
+from ..code_finder import CodeFinder
+from ..graph_builder import GraphBuilder
+
+def list_indexed_repositories(code_finder: CodeFinder, **args) -> Dict[str, Any]:
+    """Tool to list indexed repositories."""
+    try:
+        debug_log("Listing indexed repositories.")
+        results = code_finder.list_indexed_repositories()
+        return {
+            "success": True,
+            "repositories": results
+        }
+    except Exception as e:
+        debug_log(f"Error listing indexed repositories: {str(e)}")
+        return {"error": f"Failed to list indexed repositories: {str(e)}"}
+
+def delete_repository(graph_builder: GraphBuilder, **args) -> Dict[str, Any]:
+    """Tool to delete a repository from the graph."""
+    repo_path = args.get("repo_path")
+    try:
+        debug_log(f"Deleting repository: {repo_path}")
+        if graph_builder.delete_repository_from_graph(repo_path):
+            return {
+                "success": True,
+                "message": f"Repository '{repo_path}' deleted successfully."
+            }
+        else:
+                return {
+                "success": False,
+                "message": f"Repository '{repo_path}' not found in the graph."
+            }
+    except Exception as e:
+        debug_log(f"Error deleting repository: {str(e)}")
+        return {"error": f"Failed to delete repository: {str(e)}"}
+
+def check_job_status(job_manager: JobManager, **args) -> Dict[str, Any]:
+    """Tool to check job status"""
+    job_id = args.get("job_id")
+    if not job_id:
+        return {"error": "Job ID is a required argument."}
+            
+    try:
+        job = job_manager.get_job(job_id)
+        
+        if not job:
+            return {
+                "success": True, # Return success to avoid generic error wrapper
+                "status": "not_found",
+                "message": f"Job with ID '{job_id}' not found. The ID may be incorrect or the job may have been cleared after a server restart."
+            }
+        
+        job_dict = asdict(job)
+        
+        if job.status == JobStatus.RUNNING:
+            if job.estimated_time_remaining:
+                remaining = job.estimated_time_remaining
+                job_dict["estimated_time_remaining_human"] = (
+                    f"{int(remaining // 60)}m {int(remaining % 60)}s" 
+                    if remaining >= 60 else f"{int(remaining)}s"
+                )
+            
+            if job.start_time:
+                elapsed = (datetime.now() - job.start_time).total_seconds()
+                job_dict["elapsed_time_human"] = (
+                    f"{int(elapsed // 60)}m {int(elapsed % 60)}s" 
+                    if elapsed >= 60 else f"{int(elapsed)}s"
+                )
+        
+        elif job.status == JobStatus.COMPLETED and job.start_time and job.end_time:
+            duration = (job.end_time - job.start_time).total_seconds()
+            job_dict["actual_duration_human"] = (
+                f"{int(duration // 60)}m {int(duration % 60)}s" 
+                if duration >= 60 else f"{int(duration)}s"
+            )
+        
+        job_dict["start_time"] = job.start_time.strftime("%Y-%m-%d %H:%M:%S")
+        if job.end_time:
+            job_dict["end_time"] = job.end_time.strftime("%Y-%m-%d %H:%M:%S")
+        
+        job_dict["status"] = job.status.value
+        
+        return {"success": True, "job": job_dict}
+    
+    except Exception as e:
+        debug_log(f"Error checking job status: {str(e)}")
+        return {"error": f"Failed to check job status: {str(e)}"}
+
+def list_jobs(job_manager: JobManager) -> Dict[str, Any]:
+    """Tool to list all jobs"""
+    try:
+        jobs = job_manager.list_jobs()
+        
+        jobs_data = []
+        for job in jobs:
+            job_dict = asdict(job)
+            job_dict["status"] = job.status.value
+            job_dict["start_time"] = job.start_time.strftime("%Y-%m-%d %H:%M:%S")
+            if job.end_time:
+                job_dict["end_time"] = job.end_time.strftime("%Y-%m-%d %H:%M:%S")
+            jobs_data.append(job_dict)
+        
+        jobs_data.sort(key=lambda x: x["start_time"], reverse=True)
+        
+        return {"success": True, "jobs": jobs_data, "total_jobs": len(jobs_data)}
+    
+    except Exception as e:
+        debug_log(f"Error listing jobs: {str(e)}")
+        return {"error": f"Failed to list jobs: {str(e)}"}
+
+
+def load_bundle(code_finder: CodeFinder, **args) -> Dict[str, Any]:
+    """Tool to load a .cgc bundle into the database."""
+    from pathlib import Path
+    from ...cli.registry_commands import load_bundle_command
+    
+    bundle_name = args.get("bundle_name")
+    clear_existing = args.get("clear_existing", False)
+    
+    if not bundle_name:
+        return {"error": "bundle_name is required"}
+    
+    try:
+        debug_log(f"Loading bundle: {bundle_name}")
+        
+        # Use the existing load_bundle_command from CLI
+        # This handles both local files and auto-download from registry
+        success, message, stats = load_bundle_command(
+            bundle_name=bundle_name,
+            clear_existing=clear_existing
+        )
+        
+        if success:
+            return {
+                "success": True,
+                "message": message,
+                "stats": stats
+            }
+        else:
+            return {"error": message}
+    
+    except Exception as e:
+        debug_log(f"Error loading bundle: {str(e)}")
+        return {"error": f"Failed to load bundle: {str(e)}"}
+
+
+def search_registry_bundles(code_finder: CodeFinder, **args) -> Dict[str, Any]:
+    """Tool to search for bundles in the registry."""
+    from ...cli.registry_commands import fetch_available_bundles
+    
+    query = args.get("query", "").lower()
+    unique_only = args.get("unique_only", False)
+    
+    try:
+        debug_log(f"Searching registry for: {query}")
+        
+        # Fetch all bundles from registry
+        bundles = fetch_available_bundles()
+        
+        if not bundles:
+            return {
+                "success": True,
+                "bundles": [],
+                "total": 0,
+                "message": "No bundles found in registry"
+            }
+        
+        # Filter by query if provided
+        if query:
+            filtered_bundles = []
+            for bundle in bundles:
+                name = bundle.get('name', '').lower()
+                repo = bundle.get('repo', '').lower()
+                full_name = bundle.get('full_name', '').lower()
+                
+                if query in name or query in repo or query in full_name:
+                    filtered_bundles.append(bundle)
+            bundles = filtered_bundles
+        
+        # If unique_only, keep only most recent version per package
+        if unique_only:
+            unique_bundles = {}
+            for bundle in bundles:
+                base_name = bundle.get('name', 'unknown')
+                if base_name not in unique_bundles:
+                    unique_bundles[base_name] = bundle
+                else:
+                    current_time = bundle.get('generated_at', '')
+                    existing_time = unique_bundles[base_name].get('generated_at', '')
+                    if current_time > existing_time:
+                        unique_bundles[base_name] = bundle
+            bundles = list(unique_bundles.values())
+        
+        # Sort by name
+        bundles.sort(key=lambda b: (b.get('name', ''), b.get('full_name', '')))
+        
+        return {
+            "success": True,
+            "bundles": bundles,
+            "total": len(bundles),
+            "query": query if query else "all",
+            "unique_only": unique_only
+        }
+    
+    except Exception as e:
+        debug_log(f"Error searching registry: {str(e)}")
+        return {"error": f"Failed to search registry: {str(e)}"}
+
+
+def get_repository_stats(code_finder: CodeFinder, **args) -> Dict[str, Any]:
+    """Tool to get statistics about indexed repositories."""
+    from pathlib import Path
+    
+    repo_path = args.get("repo_path")
+    
+    try:
+        debug_log(f"Getting stats for: {repo_path or 'all repositories'}")
+        
+        with code_finder.db_manager.get_driver().session() as session:
+            if repo_path:
+                # Stats for specific repository
+                repo_path_obj = str(Path(repo_path).resolve())
+                
+                # Check if repository exists
+                repo_query = """
+                MATCH (r:Repository {path: $path})
+                RETURN r
+                """
+                result = session.run(repo_query, path=repo_path_obj)
+                if not result.single():
+                    return {
+                        "success": False,
+                        "error": f"Repository not found: {repo_path_obj}"
+                    }
+                
+                # Get stats for specific repo
+                stats_query = """
+                MATCH (r:Repository {path: $path})-[:CONTAINS]->(f:File)
+                WITH r, count(f) as file_count, f
+                OPTIONAL MATCH (f)-[:CONTAINS]->(func:Function)
+                OPTIONAL MATCH (f)-[:CONTAINS]->(cls:Class)
+                OPTIONAL MATCH (f)-[:IMPORTS]->(m:Module)
+                RETURN 
+                    file_count,
+                    count(DISTINCT func) as function_count,
+                    count(DISTINCT cls) as class_count,
+                    count(DISTINCT m) as module_count
+                """
+                result = session.run(stats_query, path=repo_path_obj)
+                record = result.single()
+                
+                return {
+                    "success": True,
+                    "repository": repo_path_obj,
+                    "stats": {
+                        "files": record["file_count"] if record else 0,
+                        "functions": record["function_count"] if record else 0,
+                        "classes": record["class_count"] if record else 0,
+                        "modules": record["module_count"] if record else 0
+                    }
+                }
+            else:
+                # Overall database stats
+                stats_query = """
+                MATCH (r:Repository)
+                OPTIONAL MATCH (f:File)
+                OPTIONAL MATCH (func:Function)
+                OPTIONAL MATCH (cls:Class)
+                OPTIONAL MATCH (m:Module)
+                RETURN 
+                    count(DISTINCT r) as repo_count,
+                    count(DISTINCT f) as file_count,
+                    count(DISTINCT func) as function_count,
+                    count(DISTINCT cls) as class_count,
+                    count(DISTINCT m) as module_count
+                """
+                result = session.run(stats_query)
+                record = result.single()
+                
+                if record and record["repo_count"] > 0:
+                    return {
+                        "success": True,
+                        "stats": {
+                            "repositories": record["repo_count"],
+                            "files": record["file_count"],
+                            "functions": record["function_count"],
+                            "classes": record["class_count"],
+                            "modules": record["module_count"]
+                        }
+                    }
+                else:
+                    return {
+                        "success": True,
+                        "stats": {},
+                        "message": "No data indexed yet"
+                    }
+    
+    except Exception as e:
+        debug_log(f"Error getting stats: {str(e)}")
+        return {"error": f"Failed to get stats: {str(e)}"}