codegraphcontext 0.4.17__py3-none-any.whl → 0.4.18__py3-none-any.whl

codegraphcontext/api/app.py

@@ -24,6 +24,11 @@ def create_app() -> FastAPI:
 
     app.include_router(router, prefix="/api/v1")
 
+    @app.get("/health")
+    async def health():
+        """Liveness probe for load balancers and k8s."""
+        return {"status": "ok"}
+
     # MCP-over-SSE Endpoints
     app.add_api_route("/api/v1/mcp/sse", handle_sse, methods=["GET"])
     app.add_api_route("/api/v1/mcp/messages", handle_messages, methods=["POST"])

codegraphcontext/cli/cli_helpers.py

@@ -260,6 +260,10 @@ def index_helper(path: str, context: Optional[str] = None):
     """Synchronously indexes a repository in a given context."""
     time_start = time.time()
     path_obj = Path(path).resolve()
+    # Normalize to forward slashes for cross-platform DB consistency.
+    # The graph DB always stores paths via Path.resolve().as_posix(),
+    # so Cypher queries must also use forward slashes on Windows.
+    repo_path_str = path_obj.as_posix()
     index_cwd = path_obj if path_obj.is_dir() else path_obj.parent
     services = _initialize_services(context, cwd=index_cwd)
     if not all(services[:3]):
@@ -283,7 +287,7 @@ def index_helper(path: str, context: Optional[str] = None):
             with db_manager.get_driver().session() as session:
                 result = session.run(
                     "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(DISTINCT f) as file_count",
-                    path=str(path_obj)
+                    path=repo_path_str
                 )
                 record = result.single()
                 file_count = record["file_count"] if record else 0
@@ -415,6 +419,49 @@ def delete_helper(repo_path: str, context: Optional[str] = None):
     finally:
         db_manager.close_driver()
 
+def _print_query_exception(e: Exception, query: str) -> None:
+    """
+    Pretty-print a database query exception, surfacing the raw driver
+    error message so Cypher syntax problems are clearly visible.
+    """
+    import traceback
+
+    error_type = type(e).__name__
+    error_module = type(e).__module__ or ""
+
+    # Neo4j: CypherSyntaxError and other ClientError subclasses carry
+    # a .message and .code attribute with the full server-side detail.
+    if "neo4j" in error_module:
+        code = getattr(e, "code", None)
+        msg = getattr(e, "message", None) or str(e)
+        console.print(f"[bold red]Query Error ({error_type}):[/bold red]")
+        if code:
+            console.print(f"  [yellow]Code:[/yellow] {code}")
+        console.print(f"  [yellow]Message:[/yellow] {msg}")
+
+    # FalkorDB: ResponseError / exceptions in falkordb or redis packages
+    elif "falkordb" in error_module or "redis" in error_module:
+        console.print(f"[bold red]Query Error ({error_type}):[/bold red]")
+        console.print(f"  [yellow]Database message:[/yellow] {e}")
+
+    # KuzuDB: RuntimeError from the kuzu extension
+    # KuzuDB: RuntimeError from the kuzu extension or database_kuzu wrapper
+    elif "kuzu" in error_module or (
+        error_type == "RuntimeError" and "Parser exception" in str(e)
+    ):
+        console.print(f"[bold red]Query Error ({error_type}):[/bold red]")
+        console.print(f"  [yellow]Database message:[/yellow] {e}")
+
+    else:
+        # Fallback: unknown backend — print type + message + traceback
+        console.print(f"[bold red]An error occurred while executing query ({error_type}):[/bold red]")
+        console.print(f"  [yellow]Message:[/yellow] {e}")
+        console.print("[dim]--- Traceback ---[/dim]")
+        console.print(f"[dim]{traceback.format_exc()}[/dim]")
+
+    console.print(f"\n[dim]Failed query:[/dim]")
+    console.print(f"[dim]  {query}[/dim]")
+
 
 def cypher_helper(query: str, context: Optional[str] = None):
     """Executes a read-only Cypher query."""
@@ -440,7 +487,7 @@ def cypher_helper(query: str, context: Optional[str] = None):
             records = [record.data() for record in result]
             console.print(json.dumps(records, indent=2))
     except Exception as e:
-        console.print(f"[bold red]An error occurred while executing query:[/bold red] {e}")
+        _print_query_exception(e, query)
         db_manager.close_driver()
         raise typer.Exit(code=1)
     finally:
@@ -466,7 +513,7 @@ def cypher_helper_visual(query: str, context: Optional[str] = None):
     try:
         visualize_cypher_results(query)
     except Exception as e:
-        console.print(f"[bold red]An error occurred while executing query:[/bold red] {e}")
+        _print_query_exception(e, query)
         db_manager.close_driver()
         raise typer.Exit(code=1)
     finally:
@@ -844,10 +891,11 @@ def watch_helper(path: str, context: Optional[str] = None, use_polling: Optional
         
         # Add the directory to watch
         if is_indexed:
-            console.print("[green]✓[/green] Already indexed (no initial scan needed)")
+            console.print("[green]✓[/green] Already indexed. Synchronizing current files...")
             watcher.watch_directory(
                 str(path_obj),
                 perform_initial_scan=False,
+                sync_on_start=True,
                 cgcignore_path=ctx.cgcignore_path,
             )
         else:

codegraphcontext/cli/config_manager.py

@@ -160,6 +160,14 @@ CONFIG_VALIDATORS = {
     "CGC_EMBEDDING_MODEL": ["local", "openai"],
     "FUZZY_SEARCH": ["true", "false"],
 }
+
+SUPPORTED_DATABASES: List[str] = CONFIG_VALIDATORS["DEFAULT_DATABASE"]
+DATABASE_CLI_HELP = (
+    "Database backend ("
+    + "|".join(SUPPORTED_DATABASES)
+    + "). Defaults to DEFAULT_DATABASE from config."
+)
+
 DEFAULT_CGCIGNORE_PATTERNS = """\
 # Default .cgcignore patterns
 # Lines starting with # are comments; blank lines are ignored.
@@ -279,18 +287,25 @@ def load_config() -> Dict[str, str]:
 def should_apply_project_dotenv() -> bool:
     """True when cwd-local ``.codegraphcontext/.env`` should merge with global config.
 
-    Skips project env when ``HOME`` is isolated (e.g. E2E) but ``cwd`` is an unrelated
-    checkout, unless ``CGC_LOAD_PROJECT_ENV=1``. Set ``CGC_IGNORE_PROJECT_ENV=1`` to force skip.
+    Project env is loaded only in **per-repo** context mode (or when
+    ``CGC_LOAD_PROJECT_ENV=1``). In **global** / **named** mode, ``~/.codegraphcontext/.env``
+    wins so clones with a checked-in ``.codegraphcontext/.env`` do not hijack config.
+
+    Set ``CGC_IGNORE_PROJECT_ENV=1`` to force skip; ``CGC_LOAD_PROJECT_ENV=1`` to force load.
     """
     if os.getenv("CGC_IGNORE_PROJECT_ENV", "").strip().lower() in ("1", "true", "yes"):
         return False
     if os.getenv("CGC_LOAD_PROJECT_ENV", "").strip().lower() in ("1", "true", "yes"):
         return True
+    cfg = load_context_config()
+    if cfg.mode != "per-repo":
+        return False
     try:
         Path.cwd().resolve().relative_to(Path.home().resolve())
         return True
     except ValueError:
-        return False
+        # Per-repo indexing from /tmp with an isolated HOME (common in E2E/CI).
+        return True
 
 
 def find_local_env() -> Optional[Path]:
@@ -869,23 +884,33 @@ def resolve_context(
         local_cgc = cwd / ".codegraphcontext"
         local_cgc.mkdir(parents=True, exist_ok=True)
         (local_cgc / "db").mkdir(exist_ok=True)
-        
+
+        inherited_db = load_config().get("DEFAULT_DATABASE", "falkordb")
+
         # Copy global .env into local context for easy per-repo tweaking
         import shutil
         if CONFIG_FILE.exists():
             shutil.copy2(CONFIG_FILE, local_cgc / ".env")
-            
-        console.print(f"[dim]Auto-initialized per-repo context at {local_cgc}[/dim]")
+
+        local_yaml = local_cgc / "config.yaml"
+        if not local_yaml.exists():
+            with open(local_yaml, "w", encoding="utf-8") as f:
+                yaml.safe_dump({"database": inherited_db}, f)
+
+        console.print(
+            f"[dim]Auto-initialized per-repo context at {local_cgc} "
+            f"(Database: {inherited_db})[/dim]"
+        )
 
     if local_cgc is not None:
         # Read local config.yaml if present
         local_yaml = local_cgc / "config.yaml"
-        local_db = "falkordb"
+        local_db = load_config().get("DEFAULT_DATABASE", "falkordb")
         if local_yaml.exists():
             try:
                 with open(local_yaml, encoding="utf-8") as f:
                     local_raw = yaml.safe_load(f) or {}
-                local_db = local_raw.get("database", "falkordb")
+                local_db = local_raw.get("database", local_db)
             except Exception:
                 pass
         db_path = str(local_cgc / "db" / local_db)

codegraphcontext/cli/hook_manager.py

@@ -0,0 +1,220 @@
+"""Git hook management for keeping CGC indexes in sync."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import stat
+import subprocess
+
+
+MANAGED_MARKER = "# CGC_MANAGED_HOOK"
+HOOK_NAMES = ("post-commit", "post-checkout")
+GITATTRIBUTES_ENTRY = "*.cgc merge=cgc-bundle"
+
+
+class HookError(RuntimeError):
+    """Raised when hook installation cannot proceed safely."""
+
+
+@dataclass(frozen=True)
+class GitRepository:
+    root: Path
+    git_dir: Path
+
+
+@dataclass(frozen=True)
+class HookStatus:
+    repo_root: Path
+    git_dir: Path
+    installed_hooks: tuple[str, ...]
+    unmanaged_hooks: tuple[str, ...]
+    has_merge_driver: bool
+    has_gitattributes_entry: bool
+
+    @property
+    def installed(self) -> bool:
+        return (
+            bool(self.installed_hooks)
+            and self.has_merge_driver
+            and self.has_gitattributes_entry
+        )
+
+
+def find_git_repository(start: Path | str | None = None) -> GitRepository:
+    """Find the nearest Git repository root and git directory."""
+    current = Path(start or Path.cwd()).resolve()
+    if current.is_file():
+        current = current.parent
+
+    for candidate in (current, *current.parents):
+        git_path = candidate / ".git"
+        if git_path.is_dir():
+            return GitRepository(root=candidate, git_dir=git_path)
+        if git_path.is_file():
+            target = _read_worktree_gitdir(git_path)
+            return GitRepository(root=candidate, git_dir=target)
+
+    raise HookError("No Git repository found from the current directory.")
+
+
+def install_hooks(start: Path | str | None = None, *, force: bool = False) -> HookStatus:
+    repo = find_git_repository(start)
+    hooks_dir = repo.git_dir / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    script = _hook_script(repo.root)
+    for hook_name in HOOK_NAMES:
+        hook_path = hooks_dir / hook_name
+        if hook_path.exists() and not _is_managed_hook(hook_path) and not force:
+            raise HookError(
+                f"{hook_name} already exists and is not managed by CGC. "
+                "Re-run with --force to replace it."
+            )
+        hook_path.write_text(script, encoding="utf-8")
+        mode = hook_path.stat().st_mode
+        hook_path.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    _ensure_gitattributes(repo.root)
+    _configure_merge_driver(repo.root)
+    return get_hook_status(repo.root)
+
+
+def uninstall_hooks(start: Path | str | None = None) -> HookStatus:
+    repo = find_git_repository(start)
+    hooks_dir = repo.git_dir / "hooks"
+
+    for hook_name in HOOK_NAMES:
+        hook_path = hooks_dir / hook_name
+        if hook_path.exists() and _is_managed_hook(hook_path):
+            hook_path.unlink()
+
+    _remove_gitattributes_entry(repo.root)
+    _unset_git_config(repo.root, "merge.cgc-bundle.name")
+    _unset_git_config(repo.root, "merge.cgc-bundle.driver")
+    return get_hook_status(repo.root)
+
+
+def get_hook_status(start: Path | str | None = None) -> HookStatus:
+    repo = find_git_repository(start)
+    hooks_dir = repo.git_dir / "hooks"
+    installed_hooks: list[str] = []
+    unmanaged_hooks: list[str] = []
+
+    for hook_name in HOOK_NAMES:
+        hook_path = hooks_dir / hook_name
+        if not hook_path.exists():
+            continue
+        if _is_managed_hook(hook_path):
+            installed_hooks.append(hook_name)
+        else:
+            unmanaged_hooks.append(hook_name)
+
+    return HookStatus(
+        repo_root=repo.root,
+        git_dir=repo.git_dir,
+        installed_hooks=tuple(installed_hooks),
+        unmanaged_hooks=tuple(unmanaged_hooks),
+        has_merge_driver=_has_git_config(repo.root, "merge.cgc-bundle.driver"),
+        has_gitattributes_entry=_has_gitattributes_entry(repo.root),
+    )
+
+
+def _read_worktree_gitdir(git_file: Path) -> Path:
+    content = git_file.read_text(encoding="utf-8").strip()
+    prefix = "gitdir:"
+    if not content.lower().startswith(prefix):
+        raise HookError(f"Unsupported .git file format at {git_file}")
+
+    raw_path = content[len(prefix):].strip()
+    git_dir = Path(raw_path)
+    if not git_dir.is_absolute():
+        git_dir = (git_file.parent / git_dir).resolve()
+    return git_dir
+
+
+def _hook_script(repo_root: Path) -> str:
+    repo_root_value = _sh_quote(str(repo_root))
+    return (
+        "#!/bin/sh\n"
+        f"{MANAGED_MARKER}: CodeGraphContext auto-update hook\n"
+        f"CGC_REPO_ROOT={repo_root_value}\n"
+        "if command -v cgc >/dev/null 2>&1; then\n"
+        '  cgc update "$CGC_REPO_ROOT" --quiet\n'
+        "else\n"
+        '  python -m codegraphcontext update "$CGC_REPO_ROOT" --quiet\n'
+        "fi\n"
+    )
+
+
+def _sh_quote(value: str) -> str:
+    return "'" + value.replace("'", "'\"'\"'") + "'"
+
+
+def _is_managed_hook(path: Path) -> bool:
+    try:
+        return MANAGED_MARKER in path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return False
+
+
+def _ensure_gitattributes(repo_root: Path) -> None:
+    path = repo_root / ".gitattributes"
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    lines = existing.splitlines()
+    if any(line.strip() == GITATTRIBUTES_ENTRY for line in lines):
+        return
+
+    prefix = existing
+    if prefix and not prefix.endswith("\n"):
+        prefix += "\n"
+    path.write_text(f"{prefix}{GITATTRIBUTES_ENTRY}\n", encoding="utf-8")
+
+
+def _remove_gitattributes_entry(repo_root: Path) -> None:
+    path = repo_root / ".gitattributes"
+    if not path.exists():
+        return
+
+    lines = [
+        line
+        for line in path.read_text(encoding="utf-8").splitlines()
+        if line.strip() != GITATTRIBUTES_ENTRY
+    ]
+    if lines:
+        path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    else:
+        path.unlink()
+
+
+def _has_gitattributes_entry(repo_root: Path) -> bool:
+    path = repo_root / ".gitattributes"
+    if not path.exists():
+        return False
+    return any(
+        line.strip() == GITATTRIBUTES_ENTRY
+        for line in path.read_text(encoding="utf-8").splitlines()
+    )
+
+
+def _configure_merge_driver(repo_root: Path) -> None:
+    _git_config(repo_root, "merge.cgc-bundle.name", "CodeGraphContext bundle merge driver")
+    _git_config(repo_root, "merge.cgc-bundle.driver", "cgc bundle merge %O %A %B")
+
+
+def _git_config(repo_root: Path, key: str, value: str) -> None:
+    subprocess.run(["git", "-C", str(repo_root), "config", key, value], check=True)
+
+
+def _unset_git_config(repo_root: Path, key: str) -> None:
+    subprocess.run(["git", "-C", str(repo_root), "config", "--unset-all", key], check=False)
+
+
+def _has_git_config(repo_root: Path, key: str) -> bool:
+    result = subprocess.run(
+        ["git", "-C", str(repo_root), "config", "--get", key],
+        check=False,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    return result.returncode == 0

codegraphcontext/cli/main.py

@@ -9,6 +9,7 @@ Commands:
 - help: Displays help information.
 - version: Show the installed version.
 """
+import sys
 import typer
 from rich.console import Console
 from rich.table import Table
@@ -34,6 +35,7 @@ from .cli_helpers import (
     cypher_helper_visual,
     visualize_helper,
     reindex_helper,
+    update_helper,
     clean_helper,
     stats_helper,
     _initialize_services,
@@ -42,6 +44,7 @@ from .cli_helpers import (
     list_watching_helper,
     setup_scip_helper,
 )
+from .hook_manager import HookError, get_hook_status, install_hooks, uninstall_hooks
 
 # Set the log level for the noisy neo4j, asyncio, and urllib3 loggers to keep the output clean.
 # Get the log level from config, defaulting to WARNING
@@ -249,7 +252,7 @@ def context_list():
 @context_app.command("create")
 def context_create(
     name: str = typer.Argument(..., help="Name of the new context"),
-    database: str = typer.Option(None, "--database", "--db", "-db", "-d", help="Database backend (falkordb, kuzudb, neo4j). Defaults to DEFAULT_DATABASE from config."),
+    database: str = typer.Option(None, "--database", "--db", "-db", "-d", help=config_manager.DATABASE_CLI_HELP),
     db_path: str = typer.Option(None, "--db-path", help="Explicit path for the DB (defaults to ~/.codegraphcontext/contexts/<name>/db)"),
 ):
     """Create a new logical context."""
@@ -290,7 +293,7 @@ def _load_credentials(cli_context_flag: Optional[str] = None):
     Uses per-variable precedence - each variable is loaded from the highest priority source.
     Priority order (highest to lowest):
     1. Runtime environment variables (shell/CI)
-    2. Local `.codegraphcontext/.env` and `.env` in the current project directory (project-specific overrides)
+    2. Local `.codegraphcontext/.env` and `.env` in the current project directory (per-repo mode only)
     3. Global `~/.codegraphcontext/.env` (user defaults, including `cgc config set`)
     4. Local `mcp.json` env vars (project defaults)
 
@@ -653,10 +656,30 @@ def bundle_export(
     finally:
         db_manager.close_driver()
 
+def _confirm_bundle_clear(clear: bool, yes: bool) -> bool:
+    """Return True if import may proceed; False if user cancelled."""
+    if not clear:
+        return True
+    console.print("[yellow]⚠️  Warning: This will clear all existing graph data![/yellow]")
+    if yes:
+        return True
+    if not sys.stdin.isatty():
+        console.print(
+            "[bold red]Refusing to clear graph in non-interactive mode. "
+            "Pass --yes / -y to confirm.[/bold red]"
+        )
+        raise typer.Exit(code=1)
+    if not typer.confirm("Are you sure you want to continue?", default=False):
+        console.print("[yellow]Import cancelled[/yellow]")
+        return False
+    return True
+
+
 @bundle_app.command("import")
 def bundle_import(
     bundle_file: str = typer.Argument(..., help="Path to the .cgc bundle file to import"),
     clear: bool = typer.Option(False, "--clear", help="Clear existing graph data before importing"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation when using --clear"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """
@@ -667,7 +690,7 @@ def bundle_import(
     
     Examples:
         cgc bundle import numpy.cgc
-        cgc bundle import my-project.cgc --clear
+        cgc bundle import my-project.cgc --clear --yes
     """
     _load_credentials()
     from codegraphcontext.core.cgc_bundle import CGCBundle
@@ -684,11 +707,8 @@ def bundle_import(
             console.print(f"[bold red]Bundle file not found: {bundle_path}[/bold red]")
             raise typer.Exit(code=1)
         
-        if clear:
-            console.print("[yellow]⚠️  Warning: This will clear all existing graph data![/yellow]")
-            if not typer.confirm("Are you sure you want to continue?", default=False):
-                console.print("[yellow]Import cancelled[/yellow]")
-                return
+        if not _confirm_bundle_clear(clear, yes):
+            return
         
         console.print(f"[cyan]Importing bundle from {bundle_path}...[/cyan]")
         
@@ -710,7 +730,8 @@ def bundle_import(
 @bundle_app.command("load")
 def bundle_load(
     bundle_name: str = typer.Argument(..., help="Bundle name or path to load (e.g., 'numpy' or 'numpy.cgc')"),
-    clear: bool = typer.Option(False, "--clear", help="Clear existing graph data before loading")
+    clear: bool = typer.Option(False, "--clear", help="Clear existing graph data before loading"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation when using --clear"),
 ):
     """
     Load a pre-indexed bundle (download if needed, then import).
@@ -731,7 +752,7 @@ def bundle_load(
     
     # If it's an absolute path or has .cgc extension and exists, use it directly
     if bundle_path.is_absolute() or (bundle_path.suffix == '.cgc' and bundle_path.exists()):
-        bundle_import(str(bundle_path), clear=clear)
+        bundle_import(str(bundle_path), clear=clear, yes=yes)
         return
     
     # Add .cgc extension if not present
@@ -741,7 +762,7 @@ def bundle_load(
     # Check if exists locally
     if bundle_path.exists():
         console.print(f"[dim]Found local bundle: {bundle_path}[/dim]")
-        bundle_import(str(bundle_path), clear=clear)
+        bundle_import(str(bundle_path), clear=clear, yes=yes)
         return
     
     # Try to download from registry
@@ -759,7 +780,7 @@ def bundle_load(
         
         if downloaded_path:
             # Import the downloaded bundle
-            bundle_import(downloaded_path, clear=clear)
+            bundle_import(downloaded_path, clear=clear, yes=yes)
         else:
             console.print(f"[bold red]Failed to download bundle '{name}'[/bold red]")
             raise typer.Exit(code=1)
@@ -769,6 +790,71 @@ def bundle_load(
         console.print("[dim]Use 'cgc registry list' to see available bundles[/dim]")
         raise typer.Exit(code=1)
 
+# ============================================================================
+# HOOK COMMAND GROUP - Git integration
+# ============================================================================
+
+hook_app = typer.Typer(help="Install Git hooks that keep the CGC graph in sync")
+app.add_typer(hook_app, name="hook")
+
+
+@hook_app.command("install")
+def hook_install(
+    path: str = typer.Argument(".", help="Path inside the Git repository"),
+    force: bool = typer.Option(False, "--force", "-f", help="Replace existing non-CGC hook files"),
+):
+    """
+    Install CGC-managed Git hooks in the nearest repository.
+
+    The installed hooks run `cgc update <repo> --quiet` after commits and
+    checkouts. Existing non-CGC hooks are preserved unless --force is used.
+    """
+    try:
+        status = install_hooks(path, force=force)
+    except HookError as exc:
+        console.print(f"[bold red]Hook install failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]✓[/green] Installed CGC hooks in [bold]{status.repo_root}[/bold]")
+    console.print(f"[dim]Git directory: {status.git_dir}[/dim]")
+
+
+@hook_app.command("uninstall")
+def hook_uninstall(
+    path: str = typer.Argument(".", help="Path inside the Git repository"),
+):
+    """Remove CGC-managed Git hooks and local merge-driver config."""
+    try:
+        status = uninstall_hooks(path)
+    except HookError as exc:
+        console.print(f"[bold red]Hook uninstall failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]✓[/green] Removed CGC hooks from [bold]{status.repo_root}[/bold]")
+
+
+@hook_app.command("status")
+def hook_status(
+    path: str = typer.Argument(".", help="Path inside the Git repository"),
+):
+    """Show whether CGC-managed Git hooks are installed."""
+    try:
+        status = get_hook_status(path)
+    except HookError as exc:
+        console.print(f"[bold red]Hook status failed:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="CGC Git Hook Status", show_header=True, header_style="bold magenta")
+    table.add_column("Check", style="cyan")
+    table.add_column("Status")
+    table.add_row("Repository", str(status.repo_root))
+    table.add_row("Git directory", str(status.git_dir))
+    table.add_row("Managed hooks", ", ".join(status.installed_hooks) or "none")
+    table.add_row("Unmanaged hooks", ", ".join(status.unmanaged_hooks) or "none")
+    table.add_row("Merge driver", "installed" if status.has_merge_driver else "missing")
+    table.add_row(".gitattributes", "installed" if status.has_gitattributes_entry else "missing")
+    console.print(table)
+
 # Shortcut commands at root level
 @app.command("export", rich_help_panel="Bundle Shortcuts")
 def export_shortcut(
@@ -783,10 +869,11 @@ def export_shortcut(
 @app.command("load", rich_help_panel="Bundle Shortcuts")
 def load_shortcut(
     bundle_name: str = typer.Argument(..., help="Bundle name or path to load"),
-    clear: bool = typer.Option(False, "--clear", help="Clear existing graph data before loading")
+    clear: bool = typer.Option(False, "--clear", help="Clear existing graph data before loading"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation when using --clear"),
 ):
     """Shortcut for 'cgc bundle load'"""
-    bundle_load(bundle_name, clear)
+    bundle_load(bundle_name, clear, yes=yes)
 
 # ============================================================================
 # REGISTRY COMMAND GROUP - Browse and Download Bundles
@@ -1173,6 +1260,23 @@ def index(
     else:
         index_helper(path, context)
 
+@app.command()
+def update(
+    path: Optional[str] = typer.Argument(None, help="Path to refresh. Defaults to current directory."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Reduce output when running from automation"),
+    context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use (overrides mode/default)"),
+):
+    """
+    Refresh an existing repository index.
+
+    This command is intentionally small and hook-friendly; Git hooks installed
+    with `cgc hook install` call it after commits and checkouts.
+    """
+    _load_credentials()
+    if path is None:
+        path = str(Path.cwd())
+    update_helper(path, context)
+
 @app.command()
 def clean(
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use")
@@ -2708,7 +2812,9 @@ def main(
         "--database", 
         "--db",
         "-db", 
-        help="[Global] Temporarily override database backend (falkordb, falkordb-remote, neo4j, or kuzudb) for any command"
+        help="[Global] Temporarily override database backend ("
+        + "|".join(config_manager.SUPPORTED_DATABASES)
+        + ") for any command"
     ),
     visual: bool = typer.Option(
         False,