codegraphcontext 0.3.9__py3-none-any.whl → 0.4.1__py3-none-any.whl

codegraphcontext/cli/cli_helpers.py

@@ -24,6 +24,7 @@ from ..tools.code_finder import CodeFinder
 from ..tools.graph_builder import GraphBuilder
 from ..tools.package_resolver import get_local_package_path
 from ..utils.debug_log import info_logger, warning_logger
+from ..utils.repo_path import any_repo_matches_path
 from .config_manager import resolve_context, ResolvedContext, register_repo_in_context, ensure_first_run_bootstrap
 
 console = Console()
@@ -175,8 +176,8 @@ def index_helper(path: str, context: Optional[str] = None):
         return
 
     indexed_repos = code_finder.list_indexed_repositories()
-    repo_exists = any(Path(repo["path"]).resolve() == path_obj for repo in indexed_repos)
-    
+    repo_exists = any_repo_matches_path(indexed_repos, path_obj)
+
     if repo_exists:
         # Check if the repository actually has files (not just an empty node from interrupted indexing)
         # Use variable-length path to handle both flat (Repository->File) and
@@ -184,7 +185,7 @@ def index_helper(path: str, context: Optional[str] = None):
         try:
             with db_manager.get_driver().session() as session:
                 result = session.run(
-                    "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(f) as file_count",
+                    "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(DISTINCT f) as file_count",
                     path=str(path_obj)
                 )
                 record = result.single()
@@ -284,7 +285,7 @@ def list_repos_helper(context: Optional[str] = None):
 
         for repo in repos:
             repo_type = "Dependency" if repo.get("is_dependency") else "Project"
-            table.add_row(repo["name"], repo["path"], repo_type)
+            table.add_row(repo.get("name") or "", str(repo.get("path") or ""), repo_type)
         
         console.print(table)
     except Exception as e:
@@ -377,7 +378,7 @@ import urllib.parse
 from ..viz.server import run_server, set_db_manager
 
 def visualize_helper(repo_path: Optional[str] = None, port: int = 8000, context: Optional[str] = None):
-    """"Generates an interactive visualization using the Playground UI."""
+    """Generates an interactive visualization using the Playground UI."""
     services = _initialize_services(context)
     if not all(services[:3]):
         return
@@ -415,15 +416,33 @@ def visualize_helper(repo_path: Optional[str] = None, port: int = 8000, context:
             if cwd_static_dir.exists():
                 static_dir = cwd_static_dir
             else:
-                console.print(f"[yellow]Warning: Visualization assets not found.[/yellow]")
-                console.print(f"[dim]Checked paths:[/dim]")
-                console.print(f"  [dim]- {static_dir}[/dim]")
+                console.print("[bold red]Visualization assets not found.[/bold red]")
+                console.print("[dim]Checked paths:[/dim]")
+                console.print(f"  [dim]- {package_root / 'viz' / 'dist'}[/dim]")
                 console.print(f"  [dim]- {dev_static_dir}[/dim]")
                 console.print(f"  [dim]- {alt_dev_dir}[/dim]")
                 console.print(f"  [dim]- {cwd_static_dir}[/dim]")
-                console.print("[dim]Please run 'cd website && npm run build' first.[/dim]")
-                # We continue anyway to let the server start (helpful for dev)
-    
+                console.print(
+                    "[dim]If you installed from PyPI, upgrade after the next release "
+                    "(wheels must bundle viz/dist). If you are developing from source, run:[/dim]"
+                )
+                console.print("  [cyan]./scripts/sync_viz_dist.sh[/cyan]")
+                console.print(
+                    "[dim]or[/dim] [cyan]cd website && npm ci && npm run build[/cyan] "
+                    "[dim]then sync[/dim] [cyan]website/dist[/cyan] [dim]→[/dim] "
+                    "[cyan]src/codegraphcontext/viz/dist[/cyan][dim].[/dim]"
+                )
+                db_manager.close_driver()
+                raise SystemExit(1)
+
+    index_html = static_dir / "index.html"
+    if not index_html.is_file():
+        console.print(
+            f"[bold red]Invalid visualization bundle:[/bold red] missing {index_html}"
+        )
+        db_manager.close_driver()
+        raise SystemExit(1)
+
     # Construct the URL
     backend_url = f"http://localhost:{port}"
     params = {"backend": backend_url}
@@ -471,8 +490,8 @@ def reindex_helper(path: str, context: Optional[str] = None):
 
     # Check if already indexed
     indexed_repos = code_finder.list_indexed_repositories()
-    repo_exists = any(Path(repo["path"]).resolve() == path_obj for repo in indexed_repos)
-    
+    repo_exists = any_repo_matches_path(indexed_repos, path_obj)
+
     if repo_exists:
         console.print(f"[yellow]Deleting existing index for: {path_obj}[/yellow]")
         try:
@@ -671,7 +690,7 @@ def watch_helper(path: str, context: Optional[str] = None):
     # transient empty result from list_indexed_repositories never triggers a
     # destructive full rescan of an already-populated graph.
     indexed_repos = code_finder.list_indexed_repositories()
-    is_indexed = any(Path(repo["path"]).resolve() == path_obj for repo in indexed_repos)
+    is_indexed = any_repo_matches_path(indexed_repos, path_obj)
     if not is_indexed:
         # Fallback: count File nodes whose path starts with this repo's path.
         # If > 100 exist, the repo is clearly already indexed — skip the scan.

codegraphcontext/cli/config_manager.py

@@ -78,7 +78,7 @@ CONFIG_DESCRIPTIONS = {
 
 # Valid values for each config key
 CONFIG_VALIDATORS = {
-    "DEFAULT_DATABASE": ["neo4j", "falkordb", "kuzudb"],
+    "DEFAULT_DATABASE": ["neo4j", "falkordb", "falkordb-remote", "kuzudb"],
     "INDEX_VARIABLES": ["true", "false"],
     "ALLOW_DB_DELETION": ["true", "false"],
     "DEBUG_LOGS": ["true", "false"],
@@ -219,6 +219,18 @@ def find_local_env() -> Optional[Path]:
     return None
 
 
+def codegraphcontext_dotenv_at_cwd(cwd: Optional[Path] = None) -> Optional[Path]:
+    """
+    Return ``<cwd>/.codegraphcontext/.env`` if that file exists, else None.
+
+    *cwd* defaults to ``Path.cwd()``. Parent directories are **not** searched—same rule as
+    local context resolution (``find_local_cgc_dir``).
+    """
+    root = (cwd or Path.cwd()).resolve()
+    candidate = root / ".codegraphcontext" / ".env"
+    return candidate if candidate.exists() else None
+
+
 def save_config(config: Dict[str, str], preserve_db_credentials: bool = True):
     """
     Save configuration to file.

codegraphcontext/cli/main.py

@@ -19,7 +19,6 @@ import logging
 import json
 import os
 from pathlib import Path
-from dotenv import load_dotenv, find_dotenv, set_key
 from importlib.metadata import version as pkg_version, PackageNotFoundError
 
 from codegraphcontext.server import MCPServer
@@ -111,6 +110,7 @@ def mcp_setup():
     - VS Code, Cursor, Windsurf
     - Claude Desktop, Gemini CLI
     - Cline, RooCode, Amazon Q Developer
+    - OpenCode (prints stdio config + link to vendor docs)
     
     Works with FalkorDB by default (no database setup needed).
     """
@@ -290,19 +290,18 @@ def _load_credentials():
     Uses per-variable precedence - each variable is loaded from the highest priority source.
     Priority order (highest to lowest):
     1. Local `mcp.json` env vars (highest - explicit MCP server config)
-    2. Local `.env` in project directory (high - project-specific overrides)
+    2. ``<cwd>/.codegraphcontext/.env`` only (no parent-directory walk)
     3. Global `~/.codegraphcontext/.env` (lowest - user defaults)
+
+    Step 2 skips duplicate loading when that file is the same path as the global file.
+    Arbitrary repo-root `.env` files are not loaded—only CodeGraphContext config paths.
     """
     from dotenv import dotenv_values
-    from codegraphcontext.cli.config_manager import ensure_config_dir
+    from codegraphcontext.cli.config_manager import (
+        ensure_config_dir,
+        codegraphcontext_dotenv_at_cwd,
+    )
     
-    # Capture DATABASE_TYPE from actual shell env BEFORE we load .env files.
-    # If the user ran `DATABASE_TYPE=falkordb cgc …` we must not let
-    # DEFAULT_DATABASE=neo4j in .env steal priority later.
-    shell_db_type = os.environ.get('DATABASE_TYPE')
-    if shell_db_type and not os.environ.get('CGC_RUNTIME_DB_TYPE'):
-        os.environ['CGC_RUNTIME_DB_TYPE'] = shell_db_type
-
     # Ensure config directory exists (lazy initialization)
     ensure_config_dir()
     
@@ -319,14 +318,16 @@ def _load_credentials():
         except Exception as e:
             console.print(f"[yellow]Warning: Could not load global .env: {e}[/yellow]")
     
-    # 2. Local project .env (higher priority - project-specific overrides)
+    # 2. <cwd>/.codegraphcontext/.env only (overrides global when distinct)
     try:
-        dotenv_path = find_dotenv(usecwd=True, raise_error_if_not_found=False)
-        if dotenv_path:
-            config_sources.append(dotenv_values(dotenv_path))
-            config_source_names.append(str(dotenv_path))
+        local_cgc_env = codegraphcontext_dotenv_at_cwd(Path.cwd())
+        if local_cgc_env and local_cgc_env.resolve() != global_env_path.resolve():
+            config_sources.append(dotenv_values(str(local_cgc_env)))
+            config_source_names.append(str(local_cgc_env))
     except Exception as e:
-        console.print(f"[yellow]Warning: Could not load .env from current directory: {e}[/yellow]")
+        console.print(
+            f"[yellow]Warning: Could not load .codegraphcontext/.env at cwd: {e}[/yellow]"
+        )
     
     # 1. Local mcp.json (highest priority - explicit MCP server config)
     mcp_file_path = Path.cwd() / "mcp.json"
@@ -348,9 +349,9 @@ def _load_credentials():
     
     # Apply merged config to environment.
     # IMPORTANT: DB-selection keys set in the shell must win over .env defaults.
-    # E.g. `DATABASE_TYPE=falkordb cgc index …` must not be overridden by
+    # E.g. `DEFAULT_DATABASE=falkordb cgc index …` must not be overridden by
     # DEFAULT_DATABASE=neo4j sitting in ~/.codegraphcontext/.env
-    DB_OVERRIDE_KEYS = {"DATABASE_TYPE", "CGC_RUNTIME_DB_TYPE", "DEFAULT_DATABASE"}
+    DB_OVERRIDE_KEYS = {"CGC_RUNTIME_DB_TYPE", "DEFAULT_DATABASE"}
     for key, value in merged_config.items():
         if value is not None:  # Only set non-None values
             # Never let .env clobber a DB-type key that the user already set in the shell
@@ -369,16 +370,10 @@ def _load_credentials():
     
     
     # Show which database is actually being used.
-    # When DATABASE_TYPE is explicitly set, trust it.  When it's left to auto-
-    # detect, call get_database_manager() so the banner can never lie: e.g. if
-    # falkordblite is installed but its native .so is missing (frozen bundle),
-    # the factory falls back to KùzuDB and we display that correctly.
+    # When CGC_RUNTIME_DB_TYPE or DEFAULT_DATABASE is set, trust it. Otherwise
+    # call get_database_manager() so the banner matches factory fallbacks.
     runtime_db = os.environ.get("CGC_RUNTIME_DB_TYPE")
-    explicit_db = (
-        runtime_db
-        or os.environ.get("DEFAULT_DATABASE")
-        or os.environ.get("DATABASE_TYPE")
-    )
+    explicit_db = runtime_db or os.environ.get("DEFAULT_DATABASE")
 
     if explicit_db:
         default_db = explicit_db.lower()
@@ -416,12 +411,9 @@ def _load_credentials():
         if host:
             console.print(f"[cyan]Using database: FalkorDB Remote ({host})[/cyan]")
         else:
-            console.print("[yellow]⚠ DATABASE_TYPE=falkordb-remote but FALKORDB_HOST not set.[/yellow]")
-    elif default_db == "falkordb":
-        if os.environ.get("FALKORDB_HOST"):
-            console.print(f"[cyan]Using database: FalkorDB Remote ({os.environ.get('FALKORDB_HOST')})[/cyan]")
-        else:
-            console.print("[cyan]Using database: FalkorDB[/cyan]")
+            console.print(
+                "[yellow]⚠ DEFAULT_DATABASE=falkordb-remote but FALKORDB_HOST not set.[/yellow]"
+            )
     else:
         console.print(f"[cyan]Using database: {default_db}[/cyan]")
 
@@ -474,7 +466,7 @@ def config_reset():
         console.print("[yellow]Reset cancelled[/yellow]")
 
 @config_app.command("db")
-def config_db(backend: str = typer.Argument(..., help="Database backend: 'neo4j' or 'falkordb'")):
+def config_db(backend: str = typer.Argument(..., help="Database backend: 'neo4j', 'falkordb', 'falkordb-remote', or 'kuzudb'")):
     """
     Quickly switch the default database backend.
     
@@ -483,14 +475,19 @@ def config_db(backend: str = typer.Argument(..., help="Database backend: 'neo4j'
     Examples:
         cgc config db neo4j
         cgc config db falkordb
+        cgc config db kuzudb
     """
     backend = backend.lower()
-    if backend not in ['falkordb', 'falkordb-remote', 'neo4j']:
+    if backend not in ['falkordb', 'falkordb-remote', 'neo4j', 'kuzudb']:
         console.print(f"[bold red]Invalid backend: {backend}[/bold red]")
-        console.print("Must be 'falkordb', 'falkordb-remote', or 'neo4j'")
+        console.print("Must be 'falkordb', 'falkordb-remote', 'neo4j', or 'kuzudb'")
         raise typer.Exit(code=1)
     
-    config_manager.set_config_value("DEFAULT_DATABASE", backend)
+    updated = config_manager.set_config_value("DEFAULT_DATABASE", backend)
+    if not updated:
+        console.print(f"[bold red]Failed to switch default database to {backend}[/bold red]")
+        raise typer.Exit(code=1)
+
     console.print(f"[green]✔ Default database switched to {backend}[/green]")
 
 # ============================================================================
@@ -672,10 +669,12 @@ def bundle_load(
 @app.command("export", rich_help_panel="Bundle Shortcuts")
 def export_shortcut(
     output: str = typer.Argument(..., help="Output path for the .cgc bundle file"),
-    repo: Optional[str] = typer.Option(None, "--repo", "-r", help="Specific repository path to export")
+    repo: Optional[str] = typer.Option(None, "--repo", "-r", help="Specific repository path to export"),
+    no_stats: bool = typer.Option(False, "--no-stats", help="Skip generating statistics in the bundle"),
+    context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """Shortcut for 'cgc bundle export'"""
-    bundle_export(output, repo, False)
+    bundle_export(output, repo, no_stats, context)
 
 @app.command("load", rich_help_panel="Bundle Shortcuts")
 def load_shortcut(
@@ -796,6 +795,7 @@ def doctor():
     
     # 1. Check configuration
     console.print("[bold]1. Checking Configuration...[/bold]")
+    config = {}
     try:
         config = config_manager.load_config()
         
@@ -851,6 +851,15 @@ def doctor():
                     all_checks_passed = False
             else:
                 console.print(f"   [yellow]⚠[/yellow] Neo4j credentials not set. Run 'cgc neo4j setup'")
+        elif default_db == "kuzudb":
+            from importlib.util import find_spec
+
+            if find_spec("kuzu") is not None:
+                console.print(f"   [green]✓[/green] KuzuDB is installed")
+            else:
+                console.print(f"   [red]✗[/red] KuzuDB is not installed")
+                console.print(f"       Run: pip install kuzu")
+                all_checks_passed = False
         else:
             # FalkorDB
             try:
@@ -2313,7 +2322,7 @@ def main(
         None, 
         "--database", 
         "-db", 
-        help="[Global] Temporarily override database backend (falkordb or neo4j) for any command"
+        help="[Global] Temporarily override database backend (falkordb, falkordb-remote, neo4j, or kuzudb) for any command"
     ),
     visual: bool = typer.Option(
         False,

codegraphcontext/cli/registry_commands.py

@@ -17,93 +17,12 @@ console = Console()
 
 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"
 
 
 def fetch_available_bundles() -> List[Dict[str, Any]]:
-    """
-    Fetch all available bundles from GitHub Releases.
-    Returns a list of bundle dictionaries with metadata.
-    Preserves all versions - no deduplication.
-    """
-    all_bundles = []
-    
-    try:
-        # 1. Fetch on-demand bundles from manifest
-        try:
-            response = requests.get(MANIFEST_URL, 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:
-            console.print(f"[dim]Note: Could not fetch on-demand bundles: {e}[/dim]")
-        
-        # 2. Fetch weekly pre-indexed bundles
-        try:
-            response = requests.get(REGISTRY_API_URL, 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': 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:
-            console.print(f"[dim]Note: Could not fetch weekly bundles: {e}[/dim]")
-        
-        # 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', '')
-        
-        # NO DEDUPLICATION - Keep all versions
-        return all_bundles
-    
-    except Exception as e:
-        console.print(f"[bold red]Error fetching bundles: {e}[/bold red]")
-        return []
+    """Fetch all available bundles from GitHub Releases (delegates to core BundleRegistry)."""
+    from ..core.bundle_registry import BundleRegistry
+    return BundleRegistry.fetch_available_bundles()
 
 
 def _get_base_package_name(bundle_name: str) -> str:
@@ -213,6 +132,7 @@ def search_bundles(query: str):
     matching_bundles = [
         b for b in bundles
         if query_lower in b.get('name', '').lower() or
+           query_lower in b.get('full_name', '').lower() or
            query_lower in b.get('repo', '').lower() or
            query_lower in b.get('description', '').lower()
     ]

codegraphcontext/cli/setup_wizard.py

@@ -135,12 +135,26 @@ def convert_mcp_json_to_yaml():
             yaml.dump(mcp_config, yaml_file, default_flow_style=False)
         console.print(f"[green]Generated devfile.yaml for Amazon Q Developer at {yaml_path}[/green]")
 
+def _print_opencode_mcp_instructions(mcp_config: dict) -> None:
+    """OpenCode manages MCP in its own UI; we only print the stdio snippet + doc link."""
+    console.print("\n[bold cyan]OpenCode[/bold cyan]")
+    console.print(
+        "Register a stdio MCP server in OpenCode using the same command, args, and env as below "
+        "(mirror your generated mcp.json so OpenCode and the CLI share one database)."
+    )
+    console.print(
+        "\n[dim]Vendor guide:[/dim] https://opencode.ai/docs/ko/mcp-servers/#_top"
+    )
+    console.print("\n[bold]Suggested MCP server JSON:[/bold]")
+    console.print(json.dumps(mcp_config, indent=2))
+
+
 def _configure_ide(mcp_config):
     """Asks user for their IDE and configures it automatically."""
     questions = [
         {
             "type": "confirm",
-            "message": "Automatically configure your IDE/CLI (VS Code, Cursor, Windsurf, Claude, Gemini, Cline, RooCode, ChatGPT Codex, Amazon Q Developer, Aider, Kiro, Antigravity)?",
+            "message": "Automatically configure your IDE/CLI (VS Code, Cursor, Windsurf, Claude, Gemini, Cline, RooCode, ChatGPT Codex, Amazon Q Developer, Aider, Kiro, Antigravity, OpenCode)?",
             "name": "configure_ide",
             "default": True,
         }
@@ -154,7 +168,7 @@ def _configure_ide(mcp_config):
         {
             "type": "list",
             "message": "Choose your IDE/CLI to configure:",
-            "choices": ["VS Code", "Cursor", "Windsurf", "Claude code", "Gemini CLI", "ChatGPT Codex", "Cline", "RooCode", "Amazon Q Developer", "JetBrainsAI", "Aider", "Kiro", "Antigravity", "None of the above"],
+            "choices": ["VS Code", "Cursor", "Windsurf", "Claude code", "Gemini CLI", "ChatGPT Codex", "Cline", "RooCode", "Amazon Q Developer", "JetBrainsAI", "Aider", "Kiro", "Antigravity", "OpenCode", "None of the above"],
             "name": "ide_choice",
         }
     ]
@@ -165,6 +179,13 @@ def _configure_ide(mcp_config):
         console.print("\n[cyan]You can add the MCP server manually to your IDE/CLI.[/cyan]")
         return
 
+    if ide_choice == "OpenCode":
+        _print_opencode_mcp_instructions(mcp_config)
+        console.print(
+            "\n[green]When you have pasted this into OpenCode, reload MCP and run "
+            "`cgc mcp start` from a terminal to verify the server starts cleanly.[/green]"
+        )
+        return
 
     if ide_choice in ["VS Code", "Cursor", "Claude code", "Gemini CLI", "ChatGPT Codex", "Cline", "Windsurf", "RooCode", "Amazon Q Developer", "JetBrainsAI", "Aider", "Kiro", "Antigravity"]:
         console.print(f"\n[bold cyan]Configuring for {ide_choice}...[/bold cyan]")

codegraphcontext/core/__init__.py

@@ -3,18 +3,16 @@
 Core database management module.
 
 Supports Neo4j, FalkorDB Lite, remote FalkorDB, and KùzuDB backends.
-Use DATABASE_TYPE environment variable to switch:
-- DATABASE_TYPE=kuzudb - Uses embedded KùzuDB (Recommended for cross-platform zero-config)
-- DATABASE_TYPE=falkordb - Uses embedded FalkorDB Lite (Unix-only)
-- DATABASE_TYPE=falkordb-remote - Uses a remote/hosted FalkorDB server over TCP
-- DATABASE_TYPE=neo4j - Uses Neo4j server
-- If not set, auto-detects based on what's available
-
- Priority (no DATABASE_TYPE set):
-  1. FalkorDB Lite  (Unix + Python 3.12+ + falkordblite installed)
-  2. KùzuDB         (cross-platform fallback)
-  3. Remote FalkorDB (if FALKORDB_HOST is set)
-  4. Neo4j           (if credentials are configured)
+
+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
@@ -59,22 +57,14 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
     Factory function to get the appropriate database manager based on configuration.
 
     Selection logic:
-    1. Runtime Override: 'CGC_RUNTIME_DB_TYPE' (set via --database flag)
-    2. Configured Default: 'DEFAULT_DATABASE' (set via 'cgc default database')
-    3. Legacy Env Var: 'DATABASE_TYPE'
-    4. Implicit Default: KùzuDB (Best cross-platform zero-config)
-    5. Auto-detect: Remote FalkorDB (if FALKORDB_HOST is set)
-    6. Fallback Default: FalkorDB Lite (if Unix and available)
-    7. Fallback: Neo4j (if configured)
+    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
 
-    # 1. Runtime Override (CLI flag) or Config/Env
-    db_type = os.getenv('CGC_RUNTIME_DB_TYPE')
-    if not db_type:
-        db_type = os.getenv('DEFAULT_DATABASE')
-    if not db_type:
-        db_type = os.getenv('DATABASE_TYPE')
+    db_type = os.getenv("CGC_RUNTIME_DB_TYPE") or os.getenv("DEFAULT_DATABASE")
 
     if db_type:
         db_type = db_type.lower()
@@ -124,14 +114,13 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
         else:
             raise ValueError(f"Unknown database type: '{db_type}'. Use 'kuzudb', 'falkordb', 'falkordb-remote', or 'neo4j'.")
 
-    # 4. Auto-detect: Remote FalkorDB (if FALKORDB_HOST is set)
-    # This takes priority over zero-config local backends because it's an explicit signal
+    # 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()
 
-    # 5. Implicit Default -> FalkorDB Lite (Unix Zero Config)
+    # Implicit: FalkorDB Lite on Unix when available (typical embedded default there)
     if _is_falkordb_available():
         from .database_falkordb import FalkorDBManager, FalkorDBUnavailableError
         try:
@@ -145,13 +134,13 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
             )
             # fall through to KùzuDB below
 
-    # 6. Implicit Default -> KùzuDB (Best Zero Config)
+    # 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)
 
-    # 7. Fallback if configured
+    # Implicit: Neo4j when configured
     if _is_neo4j_configured():
         from .database import DatabaseManager
         info_logger("Using Neo4j Server (auto-detected)")

codegraphcontext/core/bundle_registry.py

@@ -5,6 +5,16 @@ 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"
@@ -27,7 +37,7 @@ class BundleRegistry:
         
         # 1. Fetch on-demand bundles from manifest
         try:
-            response = requests.get(MANIFEST_URL, timeout=10)
+            response = requests.get(MANIFEST_URL, headers=_github_headers(), timeout=10)
             if response.status_code == 200:
                 manifest = response.json()
                 if manifest.get('bundles'):
@@ -43,7 +53,7 @@ class BundleRegistry:
         
         # 2. Fetch weekly pre-indexed bundles
         try:
-            response = requests.get(REGISTRY_API_URL, timeout=10)
+            response = requests.get(REGISTRY_API_URL, headers=_github_headers(), timeout=10)
             if response.status_code == 200:
                 releases = response.json()
                 

codegraphcontext/core/cgc_bundle.py

@@ -384,7 +384,7 @@ class CGCBundle:
             if repo_path:
                 query = """
                     MATCH (n)
-                    WHERE n.path STARTS WITH $repo_path OR n.path STARTS WITH $repo_path
+                    WHERE n.path STARTS WITH $repo_path
                     RETURN n, labels(n) as labels
                 """
                 params = {"repo_path": str(repo_path.resolve())}
@@ -437,8 +437,8 @@ class CGCBundle:
             if repo_path:
                 query = """
                     MATCH (n)-[r]->(m)
-                    WHERE (n.path STARTS WITH $repo_path OR n.path STARTS WITH $repo_path)
-                       OR (m.path STARTS WITH $repo_path OR m.path STARTS WITH $repo_path)
+                    WHERE (n.path STARTS WITH $repo_path)
+                       OR (m.path STARTS WITH $repo_path)
                     RETURN n, r, m, type(r) as rel_type
                 """
                 params = {"repo_path": str(repo_path.resolve())}