codegraphcontext-rust 0.5.5__cp310-cp310-win_amd64.whl

codegraphcontext/cli/visualizer.py

@@ -0,0 +1,50 @@
+import urllib.parse
+from typing import Optional, List, Dict, Any, Set
+from pathlib import Path
+from .cli_helpers import visualize_helper
+
+def check_visual_flag(ctx, visual: bool, cypher_query: str = None):
+    """
+    Helper to check the --visual flag and launch the visualizer.
+    This is called from within analyze/find commands.
+    """
+    if visual and cypher_query:
+        # We start the visualizer on port 8000
+        # Passing empty repo handles showing just the query results
+        port = 8000
+        encoded_query = urllib.parse.quote(cypher_query)
+        visualization_url = f"http://localhost:{port}/explore?cypher_query={encoded_query}"
+        
+        from rich.console import Console
+        console = Console(stderr=True)
+        console.print(f"[green]Starting visualizer...[/green]")
+        console.print(f"[cyan]Visualizing results at:[/cyan] {visualization_url}")
+        
+        # Start the backend server and open the browser
+        visualize_helper(repo_path=None, port=port)
+        return True
+    return False
+
+def visualize_call_graph(cypher_query: str):
+    """Visualize a call graph result."""
+    visualize_helper(repo_path=None, port=8000)
+
+def visualize_call_chain(cypher_query: str):
+    """Visualize a call chain result."""
+    visualize_helper(repo_path=None, port=8000)
+
+def visualize_dependencies(cypher_query: str):
+    """Visualize code dependencies."""
+    visualize_helper(repo_path=None, port=8000)
+
+def visualize_inheritance_tree(cypher_query: str):
+    """Visualize class inheritance tree."""
+    visualize_helper(repo_path=None, port=8000)
+
+def visualize_overrides(cypher_query: str):
+    """Visualize method overrides."""
+    visualize_helper(repo_path=None, port=8000)
+
+def visualize_search_results(cypher_query: str):
+    """Visualize search results."""
+    visualize_helper(repo_path=None, port=8000)

codegraphcontext/core/__init__.py

@@ -0,0 +1,165 @@
+# src/codegraphcontext/core/__init__.py
+"""
+Core database management module.
+
+Supports Neo4j, FalkorDB Lite, remote FalkorDB, and KùzuDB backends.
+
+Explicit backend selection (see ``get_database_manager``):
+- ``CGC_RUNTIME_DB_TYPE`` — per-invocation override (CLI ``--database`` / MCP resolved context).
+- ``DEFAULT_DATABASE`` — configured default from ``cgc config db …`` / CodeGraphContext ``.env``.
+
+When neither is set, implicit selection:
+- Remote FalkorDB if ``FALKORDB_HOST`` is set (explicit remote signal).
+- Else **Unix**: FalkorDB Lite when Python 3.12+ and ``falkordblite`` work; else KùzuDB if
+  installed; else Neo4j if credentials exist.
+- Else **Windows**: KùzuDB if installed; else Neo4j if credentials exist.
+"""
+import os
+import platform
+from typing import Union, Optional
+import importlib.util
+
+def _is_kuzudb_available() -> bool:
+    """Check if KùzuDB is installed."""
+    try:
+        return importlib.util.find_spec("kuzu") is not None
+    except ImportError:
+        return False
+
+def _is_falkordb_available() -> bool:
+    """Check if FalkorDB Lite is installed (Unix only)."""
+    if platform.system() == "Windows":
+        return False
+
+    import sys
+    if sys.version_info < (3, 12):
+        return False
+    try:
+        import redislite
+        return hasattr(redislite, 'falkordb_client')
+    except ImportError:
+        return False
+
+def _is_falkordb_remote_configured() -> bool:
+    """Check if a remote FalkorDB host is configured."""
+    return bool(os.getenv('FALKORDB_HOST'))
+
+def _is_neo4j_configured() -> bool:
+    """Check if Neo4j is configured with credentials."""
+    return all([
+        os.getenv('NEO4J_URI'),
+        os.getenv('NEO4J_USERNAME'),
+        os.getenv('NEO4J_PASSWORD')
+    ])
+
+def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager']:
+    """
+    Factory function to get the appropriate database manager based on configuration.
+
+    Selection logic:
+    1. Runtime override: ``CGC_RUNTIME_DB_TYPE`` (CLI ``--database``, MCP context).
+    2. Configured default: ``DEFAULT_DATABASE`` (``cgc config db …``, CodeGraphContext ``.env``).
+    3. Implicit: ``FALKORDB_HOST`` → remote FalkorDB; else Unix → FalkorDB Lite when available,
+       then KùzuDB; Windows → KùzuDB first; Neo4j if configured.
+    """
+    from codegraphcontext.utils.debug_log import info_logger
+
+    db_type = os.getenv("CGC_RUNTIME_DB_TYPE") or os.getenv("DEFAULT_DATABASE")
+
+    if db_type:
+        db_type = db_type.lower()
+        if db_type == 'kuzudb':
+            if not _is_kuzudb_available():
+                raise ValueError("Database set to 'kuzudb' but Kùzu is not installed.\nRun 'pip install kuzu'")
+            from .database_kuzu import KuzuDBManager
+            info_logger(f"Using KùzuDB (explicit) at {db_path or 'default path'}")
+            return KuzuDBManager(db_path=db_path)
+
+        elif db_type == 'falkordb':
+            if not _is_falkordb_available():
+                info_logger("FalkorDB Lite is not supported or not installed. Falling back to KùzuDB.")
+                if _is_kuzudb_available():
+                    from .database_kuzu import KuzuDBManager
+                    return KuzuDBManager()
+                raise ValueError("Database set to 'falkordb' but FalkorDB Lite is not installed or not supported on this OS.\nRun 'pip install falkordblite'")
+            
+            from .database_falkordb import FalkorDBManager, FalkorDBUnavailableError
+            try:
+                mgr = FalkorDBManager(db_path=db_path)
+                info_logger(f"Using FalkorDB Lite (explicit) at {db_path or 'default path'}")
+                return mgr
+            except FalkorDBUnavailableError as falkor_err:
+                info_logger(f"FalkorDB Lite not functional ({falkor_err}). Falling back to KùzuDB.")
+                if _is_kuzudb_available():
+                    from .database_kuzu import KuzuDBManager
+                    return KuzuDBManager(db_path=db_path)
+                raise
+
+        elif db_type == 'falkordb-remote':
+            if not _is_falkordb_remote_configured():
+                raise ValueError(
+                    "Database set to 'falkordb-remote' but FALKORDB_HOST is not set.\n"
+                    "Set the FALKORDB_HOST environment variable to your remote FalkorDB host."
+                )
+            from .database_falkordb_remote import FalkorDBRemoteManager
+            info_logger("Using remote FalkorDB (explicit)")
+            return FalkorDBRemoteManager()
+
+        elif db_type == 'neo4j':
+            if not _is_neo4j_configured():
+                raise ValueError("Database set to 'neo4j' but it is not configured.\nRun 'cgc neo4j setup' to configure Neo4j.")
+            from .database import DatabaseManager
+            info_logger("Using Neo4j Server (explicit)")
+            return DatabaseManager()
+        else:
+            raise ValueError(f"Unknown database type: '{db_type}'. Use 'kuzudb', 'falkordb', 'falkordb-remote', or 'neo4j'.")
+
+    # Implicit: remote FalkorDB when FALKORDB_HOST is set (explicit infra signal)
+    if _is_falkordb_remote_configured():
+        from .database_falkordb_remote import FalkorDBRemoteManager
+        info_logger("Using remote FalkorDB (auto-detected via FALKORDB_HOST)")
+        return FalkorDBRemoteManager()
+
+    # Implicit: FalkorDB Lite on Unix when available (typical embedded default there)
+    if _is_falkordb_available():
+        from .database_falkordb import FalkorDBManager, FalkorDBUnavailableError
+        try:
+            mgr = FalkorDBManager(db_path=db_path)
+            info_logger(f"Using FalkorDB Lite (default) at {db_path or 'default path'}")
+            return mgr
+        except FalkorDBUnavailableError as falkor_err:
+            info_logger(
+                f"FalkorDB Lite not functional in this environment ({falkor_err}). "
+                "Falling back to KùzuDB."
+            )
+            # fall through to KùzuDB below
+
+    # Implicit: KùzuDB (typical on Windows; Unix fallback when Falkor Lite unavailable)
+    if _is_kuzudb_available():
+        from .database_kuzu import KuzuDBManager
+        info_logger(f"Using KùzuDB (default) at {db_path or 'default path'}")
+        return KuzuDBManager(db_path=db_path)
+
+    # Implicit: Neo4j when configured
+    if _is_neo4j_configured():
+        from .database import DatabaseManager
+        info_logger("Using Neo4j Server (auto-detected)")
+        return DatabaseManager()
+
+    error_msg = "No database backend available.\n"
+    error_msg += "Recommended: Install KùzuDB for zero-config ('pip install kuzu')\n"
+
+    if platform.system() != "Windows":
+        error_msg += "Alternative: Install FalkorDB Lite ('pip install falkordblite')\n"
+
+    error_msg += "Alternative: Run 'cgc neo4j setup' to configure Neo4j."
+
+    raise ValueError(error_msg)
+
+# For backward compatibility, export managers
+from .database import DatabaseManager
+from .database_falkordb import FalkorDBManager
+from .database_falkordb_remote import FalkorDBRemoteManager
+from .database_kuzu import KuzuDBManager
+
+__all__ = ['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager', 'get_database_manager']

codegraphcontext/core/bundle_registry.py

@@ -0,0 +1,181 @@
+import requests
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def _github_headers() -> dict:
+    """Return GitHub API headers, including auth token if available."""
+    import os
+    headers = {"Accept": "application/vnd.github.v3+json"}
+    token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"token {token}"
+    return headers
+
+GITHUB_ORG = "CodeGraphContext"
+GITHUB_REPO = "CodeGraphContext"
+REGISTRY_API_URL = f"https://api.github.com/repos/{GITHUB_ORG}/{GITHUB_REPO}/releases"
+MANIFEST_URL = f"https://github.com/{GITHUB_ORG}/{GITHUB_REPO}/releases/download/on-demand-bundles/manifest.json"
+
+class BundleRegistry:
+    """
+    Core logic for interacting with the CodeGraphContext bundle registry.
+    Handles fetching metadata, searching, and downloading bundles without CLI dependencies.
+    """
+
+    @staticmethod
+    def fetch_available_bundles() -> List[Dict[str, Any]]:
+        """
+        Fetch all available bundles from GitHub Releases and the on-demand manifest.
+        Returns a list of bundle dictionaries with metadata.
+        Preserves all versions - no deduplication.
+        """
+        all_bundles = []
+        
+        # 1. Fetch on-demand bundles from manifest
+        try:
+            response = requests.get(MANIFEST_URL, headers=_github_headers(), timeout=10)
+            if response.status_code == 200:
+                manifest = response.json()
+                if manifest.get('bundles'):
+                    for bundle in manifest['bundles']:
+                        bundle['source'] = 'on-demand'
+                        # Ensure bundle has a full_name field (with version info)
+                        if 'bundle_name' in bundle:
+                            # Extract full name without .cgc extension
+                            bundle['full_name'] = bundle['bundle_name'].replace('.cgc', '')
+                        all_bundles.append(bundle)
+        except Exception as e:
+            logger.warning(f"Could not fetch on-demand bundles from manifest: {e}")
+        
+        # 2. Fetch weekly pre-indexed bundles
+        try:
+            response = requests.get(REGISTRY_API_URL, headers=_github_headers(), timeout=10)
+            if response.status_code == 200:
+                releases = response.json()
+                
+                # Find weekly releases (bundles-YYYYMMDD pattern)
+                weekly_releases = [r for r in releases if r['tag_name'].startswith('bundles-') and r['tag_name'] != 'bundles-latest']
+                
+                if weekly_releases:
+                    # Get the most recent weekly release
+                    latest_weekly = weekly_releases[0]
+                    
+                    for asset in latest_weekly.get('assets', []):
+                        if asset['name'].endswith('.cgc'):
+                            # Full bundle name without extension
+                            full_name = asset['name'].replace('.cgc', '')
+                            
+                            # Parse bundle name
+                            name_parts = full_name.split('-')
+                            bundle = {
+                                'name': name_parts[0],  # Base package name
+                                'full_name': full_name,  # Complete name with version
+                                'repo': f"{name_parts[0]}/{name_parts[0]}",  # Simplified
+                                'bundle_name': asset['name'],
+                                'version': name_parts[1] if len(name_parts) > 1 else 'latest',
+                                'commit': name_parts[2] if len(name_parts) > 2 else 'unknown',
+                                'size_bytes': asset.get('size', 0),
+                                'size': f"{asset['size'] / 1024 / 1024:.1f}MB",
+                                'download_url': asset['browser_download_url'],
+                                'generated_at': asset['updated_at'],
+                                'source': 'weekly'
+                            }
+                            all_bundles.append(bundle)
+        except Exception as e:
+            logger.warning(f"Could not fetch weekly bundles from GitHub API: {e}")
+        
+        # Normalize all bundles to have required fields
+        for bundle in all_bundles:
+            # Ensure 'name' field exists (base package name)
+            if 'name' not in bundle:
+                repo = bundle.get('repo', '')
+                if '/' in repo:
+                    bundle['name'] = repo.split('/')[-1]
+                else:
+                    # Extract from full_name or bundle_name
+                    full_name = bundle.get('full_name', bundle.get('bundle_name', 'unknown'))
+                    bundle['name'] = full_name.split('-')[0]
+            
+            # Ensure 'full_name' exists
+            if 'full_name' not in bundle:
+                bundle['full_name'] = bundle.get('bundle_name', bundle.get('name', 'unknown')).replace('.cgc', '')
+        
+        return all_bundles
+
+    @staticmethod
+    def find_bundle_download_info(name: str) -> Tuple[Optional[str], Optional[Dict[str, Any]], str]:
+        """
+        Find a download URL and metadata for a bundle by name.
+        
+        Strategies:
+        1. Exact match on full_name (e.g., 'flask-main-abc123')
+        2. Match on base name (e.g., 'flask') - returns most recent version
+        
+        Returns:
+            (download_url, bundle_metadata, error_message)
+        """
+        bundles = BundleRegistry.fetch_available_bundles()
+        
+        if not bundles:
+            return None, None, "Could not fetch bundle registry."
+        
+        name_lower = name.lower()
+        
+        # Strategy 1: Exact match on full_name
+        for b in bundles:
+            if b.get('full_name', '').lower() == name_lower:
+                url = b.get('download_url')
+                if url:
+                    return url, b, ""
+                return None, b, f"No download URL found for bundle '{name}'"
+        
+        # Strategy 2: Match base package name (most recent)
+        matching_bundles = []
+        for b in bundles:
+            if b.get('name', '').lower() == name_lower:
+                matching_bundles.append(b)
+        
+        if matching_bundles:
+            # Sort by timestamp (newest first)
+            matching_bundles.sort(key=lambda x: x.get('generated_at', ''), reverse=True)
+            bundle = matching_bundles[0]
+            url = bundle.get('download_url')
+            if url:
+                return url, bundle, ""
+            return None, bundle, f"No download URL found for bundle '{name}'"
+            
+        return None, None, f"Bundle '{name}' not found in registry."
+
+    @staticmethod
+    def download_file(url: str, output_path: Path, progress_callback=None) -> bool:
+        """
+        Download a file from a URL to a local path.
+        
+        Args:
+            url: The URL to download from
+            output_path: Local path to save the file
+            progress_callback: Optional callable(chunk_size) to report progress
+            
+        Returns:
+            True if successful, raises exception otherwise
+        """
+        try:
+            response = requests.get(url, stream=True, timeout=30)
+            response.raise_for_status()
+            
+            with open(output_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        if progress_callback:
+                            progress_callback(len(chunk))
+            return True
+        except Exception as e:
+            # Clean up partial file
+            if output_path.exists():
+                output_path.unlink()
+            raise e