codegraphcontext-rust 0.5.5__cp310-cp310-win_amd64.whl

codegraphcontext/tools/handlers/management_handlers.py

@@ -0,0 +1,339 @@
+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 ...core.bundle_registry import BundleRegistry
+    from ...core.cgc_bundle import CGCBundle
+    
+    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}")
+        
+        # Check if bundle exists locally
+        bundle_path = Path(bundle_name)
+        
+        # If it doesn't exist as-is, try with .cgc extension
+        if not bundle_path.exists() and not str(bundle_name).endswith('.cgc'):
+            bundle_path = Path(f"{bundle_name}.cgc")
+        
+        if not bundle_path.exists():
+            # Try to download from registry
+            debug_log(f"Bundle {bundle_name} not found locally, checking registry...")
+            download_url, bundle_meta, error = BundleRegistry.find_bundle_download_info(bundle_name)
+            
+            if not download_url:
+                return {"error": f"Bundle not found locally or in registry: {bundle_name}. {error}"}
+            
+            # Determine output filename from metadata
+            filename = bundle_meta.get('bundle_name', f"{bundle_name}.cgc")
+            # Save to current working directory
+            target_path = Path.cwd() / filename
+            
+            debug_log(f"Downloading bundle to {target_path}...")
+            try:
+                BundleRegistry.download_file(download_url, target_path)
+                bundle_path = target_path
+                debug_log(f"Successfully downloaded to {bundle_path}")
+            except Exception as e:
+                return {"error": f"Failed to download bundle: {str(e)}"}
+            
+            # Verify the downloaded file exists
+            if not bundle_path.exists():
+                return {"error": f"Download completed but file not found at {bundle_path}"}
+
+        # Load the bundle using CGCBundle core class
+        bundle = CGCBundle(code_finder.db_manager)
+        success, message = bundle.import_from_bundle(
+            bundle_path=bundle_path,
+            clear_existing=clear_existing
+        )
+        
+        if success:
+            stats = {}
+            # Parse simple stats from message if possible, or just return success
+            if "Nodes:" in message:
+                import re as _re
+                nodes_match = _re.search(r'Nodes:\s*(\d+)', message)
+                edges_match = _re.search(r'Edges:\s*(\d+)', message)
+                if nodes_match:
+                    stats["nodes"] = int(nodes_match.group(1))
+                if edges_match:
+                    stats["edges"] = int(edges_match.group(1))
+
+            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 ...core.bundle_registry import BundleRegistry
+    
+    query = args.get("query", "").lower()
+    unique_only = args.get("unique_only", False)
+    
+    try:
+        debug_log(f"Searching registry for: {query}")
+        
+        # Fetch directly from core registry
+        bundles = BundleRegistry.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}"
+                    }
+                
+                # 1. Files
+                file_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(f) as c"
+                file_count = session.run(file_query, path=repo_path_obj).single()["c"]
+                
+                # 2. Functions
+                func_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(func:Function) RETURN count(func) as c"
+                func_count = session.run(func_query, path=repo_path_obj).single()["c"]
+                
+                # 3. Classes
+                class_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(cls:Class) RETURN count(cls) as c"
+                class_count = session.run(class_query, path=repo_path_obj).single()["c"]
+                
+                # 4. Modules (imported)
+                module_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File)-[:IMPORTS]->(m:Module) RETURN count(DISTINCT m) as c"
+                module_count = session.run(module_query, path=repo_path_obj).single()["c"]
+                
+                return {
+                    "success": True,
+                    "repository": repo_path_obj,
+                    "stats": {
+                        "files": file_count,
+                        "functions": func_count,
+                        "classes": class_count,
+                        "modules": module_count
+                    }
+                }
+            else:
+                # Overall database stats
+                repo_count = session.run("MATCH (r:Repository) RETURN count(r) as c").single()["c"]
+                
+                if repo_count > 0:
+                    file_count = session.run("MATCH (f:File) RETURN count(f) as c").single()["c"]
+                    func_count = session.run("MATCH (func:Function) RETURN count(func) as c").single()["c"]
+                    class_count = session.run("MATCH (cls:Class) RETURN count(cls) as c").single()["c"]
+                    module_count = session.run("MATCH (m:Module) RETURN count(m) as c").single()["c"]
+                    
+                    return {
+                        "success": True,
+                        "stats": {
+                            "repositories": repo_count,
+                            "files": file_count,
+                            "functions": func_count,
+                            "classes": class_count,
+                            "modules": 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)}"}

codegraphcontext/tools/handlers/query_handlers.py

@@ -0,0 +1,83 @@
+import re
+import urllib.parse
+from typing import Any, Dict
+from neo4j.exceptions import CypherSyntaxError
+from ...utils.debug_log import debug_log
+
+def execute_cypher_query(db_manager, **args) -> Dict[str, Any]:
+    """
+    Tool implementation for executing a read-only Cypher query.
+    
+    Important: Includes a safety check to prevent any database modification
+    by disallowing keywords like CREATE, MERGE, DELETE, etc.
+    """
+    cypher_query = args.get("cypher_query")
+    if not cypher_query:
+        return {"error": "Cypher query cannot be empty."}
+
+    # Safety Check: Prevent any write operations to the database.
+    # This check first removes all string literals and then checks for forbidden keywords.
+    forbidden_keywords = ['CREATE', 'MERGE', 'DELETE', 'SET', 'REMOVE', 'DROP', 'CALL apoc']
+    
+    # Regex to match single or double quoted strings, handling escaped quotes.
+    string_literal_pattern = r'"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\''
+    
+    # Remove all string literals from the query.
+    query_without_strings = re.sub(string_literal_pattern, '', cypher_query)
+    
+    # Now, check for forbidden keywords in the query without strings.
+    for keyword in forbidden_keywords:
+        if re.search(r'\b' + keyword + r'\b', query_without_strings, re.IGNORECASE):
+            return {
+                "error": "This tool only supports read-only queries. Prohibited keywords like CREATE, MERGE, DELETE, SET, etc., are not allowed."
+            }
+
+    try:
+        debug_log(f"Executing Cypher query: {cypher_query}")
+        with db_manager.get_driver().session() as session:
+            result = session.run(cypher_query)
+            # Convert results to a list of dictionaries for clean JSON serialization.
+            records = [record.data() for record in result]
+            
+            return {
+                "success": True,
+                "query": cypher_query,
+                "record_count": len(records),
+                "results": records
+            }
+    
+    except CypherSyntaxError as e:
+        debug_log(f"Cypher syntax error: {str(e)}")
+        return {
+            "error": "Cypher syntax error.",
+            "details": str(e),
+            "query": cypher_query
+        }
+    except Exception as e:
+        debug_log(f"Error executing Cypher query: {str(e)}")
+        return {
+            "error": "An unexpected error occurred while executing the query.",
+            "details": str(e)
+        }
+
+def visualize_graph_query(db_manager, **args) -> Dict[str, Any]:
+    """Tool to generate a visualization URL for the local Playground UI."""
+    cypher_query = args.get("cypher_query")
+    if not cypher_query:
+        return {"error": "Cypher query cannot be empty."}
+
+    try:
+        # We point to the local server started by 'cgc visualize'
+        # By default it runs on port 8000
+        port = 8000
+        encoded_query = urllib.parse.quote(cypher_query)
+        visualization_url = f"http://localhost:{port}/index.html?cypher_query={encoded_query}"
+        
+        return {
+            "success": True,
+            "visualization_url": visualization_url,
+            "message": "Click the URL to visualize this specific query in the Playground UI. (Ensure 'cgc visualize' is running)"
+        }
+    except Exception as e:
+        debug_log(f"Error generating visualization URL: {str(e)}")
+        return {"error": f"Failed to generate visualization URL: {str(e)}"}

codegraphcontext/tools/handlers/watcher_handlers.py

@@ -0,0 +1,83 @@
+from typing import Any, Dict
+
+from ...utils.debug_log import error_logger
+from ...utils.repo_path import any_repo_matches_path
+
+def list_watched_paths(code_watcher, **args) -> Dict[str, Any]:
+    """Tool to list all currently watched directory paths."""
+    try:
+        paths = code_watcher.list_watched_paths()
+        return {"success": True, "watched_paths": paths}
+    except Exception as e:
+        return {"error": f"Failed to list watched paths: {str(e)}"}
+
+def unwatch_directory(code_watcher, **args) -> Dict[str, Any]:
+    """Tool to stop watching a directory."""
+    path = args.get("path")
+    if not path:
+        return {"error": "Path is a required argument."}
+    return code_watcher.unwatch_directory(path)
+
+# watch_directory is complex as it depends on other tools and handlers
+# We will keep it in server.py or implement it here passing all dependencies.
+# Let's implement it here as a pure function accepting dependencies.
+# Dependencies: code_watcher, list_repositories_func, add_code_func
+
+def watch_directory(code_watcher, list_repositories_func, add_code_func, **args) -> Dict[str, Any]:
+    """
+    Tool implementation to start watching a directory for changes.
+    It checks if the path exists, if it's already watched, or if it needs indexing.
+    """
+    path = args.get("path")
+    from pathlib import Path
+
+    if not path:
+        return {"error": "Path is a required argument."}
+
+    path_obj = Path(path).resolve()
+    path_str = str(path_obj)
+
+    # 1. Validate the path
+    if not path_obj.is_dir():
+        return {
+            "success": True,
+            "status": "path_not_found",
+            "message": f"Path '{path_str}' does not exist or is not a directory."
+        }
+    try:
+        # Check if already watching
+        if path_str in code_watcher.watched_paths:
+            return {"success": True, "message": f"Already watching directory: {path_str}"}
+
+        # 2. Check if the repository is already indexed
+        indexed_repos_result = list_repositories_func()
+        indexed_repos = indexed_repos_result.get("repositories", [])
+        is_already_indexed = any_repo_matches_path(indexed_repos, path_obj)
+
+        # 3. Decide whether to perform an initial scan
+        if is_already_indexed:
+            # If already indexed, just start the watcher without a scan
+            code_watcher.watch_directory(path_str, perform_initial_scan=False)
+            return {
+                "success": True,
+                "message": f"Path '{path_str}' is already indexed. Now watching for live changes."
+            }
+        else:
+            # If not indexed, perform the scan AND start the watcher
+            scan_job_result = add_code_func(path=path_str, is_dependency=False)
+
+            if "error" in scan_job_result:
+                return scan_job_result
+            
+            code_watcher.watch_directory(path_str, perform_initial_scan=True)
+            
+            return {
+                "success": True,
+                "message": f"Path '{path_str}' was not indexed. Started initial scan and now watching for live changes.",
+                "job_id": scan_job_result.get("job_id"),
+                "details": "Use check_job_status to monitor the initial scan."
+            }
+        
+    except Exception as e:
+        error_logger(f"Failed to start watching directory {path}: {e}")
+        return {"error": f"Failed to start watching directory: {str(e)}"}

codegraphcontext/tools/indexing/__init__.py

@@ -0,0 +1 @@
+# Indexing pipeline package (discovery, pre-scan, persistence, resolution).

codegraphcontext/tools/indexing/constants.py

@@ -0,0 +1,25 @@
+"""Shared constants for the indexing pipeline."""
+
+DEFAULT_IGNORE_PATTERNS = [
+    "node_modules/",
+    "venv/",
+    ".venv/",
+    "env/",
+    ".env/",
+    "dist/",
+    "build/",
+    "target/",
+    "out/",
+    ".git/",
+    "__pycache__/",
+    "*.png",
+    "*.jpg",
+    "*.jpeg",
+    "*.gif",
+    "*.svg",
+    "*.mp4",
+    "*.mp3",
+    "*.zip",
+    "*.tar",
+    "*.gz",
+]

codegraphcontext/tools/indexing/discovery.py

@@ -0,0 +1,64 @@
+"""Enumerate files to index with ignore rules."""
+
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from ...core.cgcignore import build_ignore_spec
+from ...utils.debug_log import debug_log, warning_logger
+from .constants import DEFAULT_IGNORE_PATTERNS
+
+
+def discover_files_to_index(
+    path: Path,
+    cgcignore_path: Optional[str] = None,
+) -> Tuple[List[Path], Path]:
+    """
+    Returns (files, ignore_root). *ignore_root* is used for .cgcignore relative matching.
+    """
+    ignore_root = path.resolve() if path.is_dir() else path.resolve().parent
+
+    spec = None
+    try:
+        spec, resolved_cgcignore = build_ignore_spec(
+            ignore_root=ignore_root,
+            default_patterns=DEFAULT_IGNORE_PATTERNS,
+            explicit_path=cgcignore_path,
+        )
+        if resolved_cgcignore:
+            debug_log(f"Using .cgcignore at {resolved_cgcignore} (filtering relative to {ignore_root})")
+    except OSError as e:
+        warning_logger(f"Could not load/create .cgcignore: {e}")
+
+    all_files = path.rglob("*") if path.is_dir() else [path]
+    files = [f for f in all_files if f.is_file()]
+
+    from ...cli.config_manager import get_config_value
+
+    ignore_dirs_str = get_config_value("IGNORE_DIRS") or ""
+    if ignore_dirs_str and path.is_dir():
+        ignore_dirs = {d.strip().lower() for d in ignore_dirs_str.split(",") if d.strip()}
+        if ignore_dirs:
+            kept_files = []
+            for f in files:
+                try:
+                    parts = set(p.lower() for p in f.relative_to(path).parent.parts)
+                    if not parts.intersection(ignore_dirs):
+                        kept_files.append(f)
+                except ValueError:
+                    kept_files.append(f)
+            files = kept_files
+
+    if spec:
+        filtered_files = []
+        for f in files:
+            try:
+                rel_path = f.relative_to(ignore_root).as_posix()
+                if not spec.match_file(rel_path):
+                    filtered_files.append(f)
+                else:
+                    debug_log(f"Ignored file based on .cgcignore: {rel_path}")
+            except ValueError:
+                filtered_files.append(f)
+        files = filtered_files
+
+    return files, ignore_root