db-git 0.1.0__py3-none-any.whl

git_db/cli/init.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import sys
+from enum import StrEnum
+from typing import Annotated
+
+import typer
+from rich.panel import Panel
+
+from git_db.backends import get_backend
+from git_db.backends.postgresql.backend import PgPermissions
+from git_db.config import (
+    ensure_config_ignored,
+    find_project_root,
+    load_config,
+    load_dotfile_config,
+    write_config,
+)
+from git_db.db import parse_database_url
+from git_db.errors import DatabaseError, GitDbError
+from git_db.git import get_git_dir, install_hook
+from git_db.storage import ensure_snapshot_dir
+
+from ._common import debug_enabled
+from ._console import app, console
+from ._prompts import (
+    detect_default_branch,
+    resolve_choice,
+    resolve_with_prompt,
+)
+
+
+class ModeChoice(StrEnum):
+    shared = "shared"
+    per_branch = "per-branch"
+
+
+class StrategyChoice(StrEnum):
+    template = "template"
+    pgdump = "pgdump"
+
+
+class ConnectionPolicyChoice(StrEnum):
+    terminate = "terminate"
+    fail = "fail"
+
+
+@app.command()
+def init(
+    database_url: Annotated[
+        str | None, typer.Option("--database-url", envvar="DATABASE_URL")
+    ] = None,
+    mode: Annotated[ModeChoice | None, typer.Option("--mode")] = None,
+    strategy: Annotated[StrategyChoice | None, typer.Option("--strategy")] = None,
+    on_active_connections: Annotated[
+        ConnectionPolicyChoice | None, typer.Option("--on-active-connections")
+    ] = None,
+    no_hook: Annotated[bool, typer.Option("--no-hook")] = False,
+) -> None:
+    """
+    Initialize git-db in the current repo.
+    """
+    git_dir = get_git_dir()
+    if git_dir is None:
+        console.print(
+            "[red]Error:[/] Not inside a git repository. "
+            "Run this from a git project root."
+        )
+        raise typer.Exit(1)
+
+    try:
+        project_root = find_project_root()
+        if project_root is None:
+            console.print("[red]Error:[/] Could not find project root.")
+            raise typer.Exit(1)
+
+        existing_config = load_dotfile_config(project_root)
+        is_reinit = (project_root / ".git-db.toml").exists()
+        if is_reinit:
+            console.print("[dim]Updating existing configuration.[/]\n")
+
+        resolved_url = resolve_with_prompt(
+            flag_value=database_url,
+            existing=existing_config.get("database_url"),
+            prompt_text="Database URL",
+            required=True,
+        )
+        if not resolved_url:
+            console.print(
+                "[red]Error:[/] No database URL configured. "
+                "Pass --database-url or set DATABASE_URL."
+            )
+            raise typer.Exit(1)
+
+        backend = get_backend(resolved_url)
+        params = backend.apply_url_defaults(parse_database_url(resolved_url))
+        permissions: PgPermissions | None = None
+        version: int | None = None
+
+        try:
+            version = backend.get_engine_version(resolved_url)
+        except DatabaseError as e:
+            console.print(
+                f"[red]Error:[/] Could not connect to database: {e}\n"
+                "  Fix the database URL or database server, then rerun "
+                "[cyan]git-db init[/].\n"
+            )
+            raise typer.Exit(1) from e
+
+        console.print(
+            f"  Detected: [cyan]PostgreSQL {version}[/] "
+            f"at {params['host']}:{params['port']}"
+        )
+        console.print(f"  Database:  [cyan]{params['dbname']}[/]")
+        console.print(f"  User:      [cyan]{params['user']}[/]")
+
+        result = backend.check_permissions(resolved_url)
+        assert isinstance(result, PgPermissions)
+        permissions = result
+        console.print("\n  Checking permissions...")
+        console.print(
+            f"    CREATEDB:          "
+            f"{'[green]Yes[/]' if permissions.can_createdb else '[red]No[/]'}"
+        )
+        console.print(
+            f"    Superuser:         "
+            f"{'[green]Yes[/]' if permissions.is_superuser else '[red]No[/]'}"
+        )
+        sig_label = (
+            "[green]Yes[/]" if permissions.has_pg_signal_backend else "[red]No[/]"
+        )
+        console.print(f"    pg_signal_backend: {sig_label}")
+        console.print()
+
+        resolved_mode = resolve_choice(
+            flag_value=mode.value if mode is not None else None,
+            existing=existing_config.get("mode"),
+            prompt_text="How should git-db manage database state across branches?",
+            choices={"1": "shared", "2": "per-branch"},
+            labels={
+                "1": "Single database: snapshot/restore on switch",
+                "2": "Per-branch databases: each branch gets its own DB",
+            },
+            default="1",
+        )
+
+        resolved_default_branch = existing_config.get("default_branch", "")
+        if resolved_mode == "per-branch" and not resolved_default_branch:
+            resolved_default_branch = detect_default_branch()
+
+        strategy_labels = {
+            "1": "template: fast, uses CREATE DATABASE ... TEMPLATE",
+            "2": "pgdump: uses pg_dump/pg_restore",
+        }
+        strategy_default = "1"
+
+        if permissions and not permissions.can_createdb:
+            strategy_labels["1"] += " [red](requires CREATEDB)[/]"
+
+        resolved_strategy = resolve_choice(
+            flag_value=strategy.value if strategy is not None else None,
+            existing=existing_config.get("strategy"),
+            prompt_text="Snapshot strategy",
+            choices={"1": "template", "2": "pgdump"},
+            labels=strategy_labels,
+            default=strategy_default,
+        )
+
+        if (
+            resolved_strategy == "template"
+            and permissions
+            and not permissions.can_createdb
+        ):
+            console.print(
+                "[yellow]Warning:[/] Your user lacks CREATEDB privilege. "
+                "Template strategy will fail.\n"
+                "  Grant it with: ALTER ROLE {user} CREATEDB;\n"
+                "  Or switch to pgdump strategy.\n"
+            )
+
+        policy_labels = {
+            "1": "terminate: kill connections and proceed",
+            "2": "fail: stop with an error",
+        }
+        resolved_policy = resolve_choice(
+            flag_value=(
+                on_active_connections.value
+                if on_active_connections is not None
+                else None
+            ),
+            existing=existing_config.get("on_active_connections"),
+            prompt_text="When active connections prevent database operations",
+            choices={"1": "terminate", "2": "fail"},
+            labels=policy_labels,
+            default="1",
+        )
+
+        if (
+            resolved_policy == "terminate"
+            and permissions
+            and not permissions.is_superuser
+            and not permissions.has_pg_signal_backend
+        ):
+            console.print(
+                "[yellow]Warning:[/] Your user lacks superuser and "
+                "pg_signal_backend privileges.\n"
+                "  Terminate may fail silently on connections owned "
+                "by other users.\n"
+            )
+
+        install_hook_flag = not no_hook
+        if not no_hook and mode is None and sys.stdin.isatty():
+            install_hook_flag = typer.confirm(
+                "Install git post-checkout hook?", default=True
+            )
+
+        config_updates: dict[str, object] = {
+            "database_url": resolved_url,
+            "mode": resolved_mode,
+            "strategy": resolved_strategy,
+            "on_active_connections": resolved_policy,
+        }
+        if resolved_mode == "per-branch":
+            config_updates["default_branch"] = resolved_default_branch
+
+        write_config(project_root, config_updates)
+        console.print("[dim]Configuration saved to .git-db.toml[/]\n")
+        if ensure_config_ignored(project_root):
+            console.print("[dim]Added .git-db.toml to .gitignore[/]\n")
+
+        hook_status = "[dim]skipped[/]"
+        if install_hook_flag:
+            install_hook(git_dir)
+            ensure_snapshot_dir(
+                load_config(
+                    cli_overrides={"database_url": resolved_url},
+                    project_root=project_root,
+                ).snapshot_dir
+            )
+            hook_status = "[green]installed[/]"
+
+        summary = (
+            f"  Engine:     [cyan]{backend.engine}[/]\n"
+            f"  Version:    [cyan]{version or 'unknown'}[/]\n"
+            f"  Mode:       [green]{resolved_mode}[/]\n"
+            f"  Strategy:   [green]{resolved_strategy}[/]\n"
+            f"  Policy:     [green]{resolved_policy}[/]\n"
+            f"  Hook:       {hook_status}"
+        )
+        if resolved_mode == "per-branch":
+            summary += f"\n  Default:    [cyan]{resolved_default_branch}[/]"
+
+        console.print(Panel(summary, title="git-db initialized", border_style="green"))
+
+    except GitDbError as e:
+        console.print(f"[red]Error:[/] {e}")
+        raise typer.Exit(1) from e
+    except typer.Exit:
+        raise
+    except Exception as e:
+        if debug_enabled():
+            raise
+        console.print(
+            f"[red]Error:[/] Unexpected error: {e}\n"
+            "[dim]Set GIT_DB_DEBUG=1 to see the full traceback.[/]"
+        )
+        raise typer.Exit(1) from e

git_db/cli/inspect.py

@@ -0,0 +1,414 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.panel import Panel
+from rich.table import Table
+
+from git_db.backends import DatabaseBackend, SnapshotStrategy, get_backend
+from git_db.config import GitDbConfig, load_config
+from git_db.db import parse_database_url
+from git_db.errors import GitDbError
+from git_db.git import get_current_branch, get_git_dir, list_branches
+from git_db.state import load_state
+from git_db.storage import (
+    branch_db_name,
+    has_snapshot,
+    identify_stale_snapshots,
+    list_snapshots,
+    snapshot_db_name,
+    snapshot_dump_path,
+)
+
+from ._common import check_enabled, debug_enabled, require_init
+from ._console import app, console
+from ._format import format_age, format_size, mask_url
+from ._prompts import confirm_prune
+
+
+@app.command("list")
+def list_cmd(
+    database_url: Annotated[
+        str | None, typer.Option("--database-url", envvar="DATABASE_URL")
+    ] = None,
+) -> None:
+    """
+    Show all stored snapshots or branch databases.
+    """
+    require_init()
+    try:
+        config = load_config(cli_overrides={"database_url": database_url})
+    except GitDbError as e:
+        console.print(f"[red]Error:[/] {e}")
+        raise typer.Exit(1) from e
+
+    if config.mode == "per-branch":
+        _list_per_branch(config)
+        return
+
+    snapshots = list_snapshots(config.snapshot_dir)
+    if not snapshots:
+        console.print("No snapshots found.")
+        return
+
+    table = Table(title="Snapshots")
+    table.add_column("Branch", style="cyan", no_wrap=True)
+    table.add_column("Strategy", style="green")
+    table.add_column("Size", justify="right", style="magenta")
+    table.add_column("Status", justify="center")
+    table.add_column("Age", justify="right")
+    table.add_column("Database", style="dim")
+
+    backend = get_backend(config.database_url)
+
+    for s in snapshots:
+        table.add_row(
+            s.branch,
+            s.strategy,
+            format_size(s.file_size_bytes),
+            _shared_snapshot_status(config, backend, s.branch, s.strategy),
+            format_age(s.created_at),
+            s.database,
+        )
+
+    console.print(table)
+
+
+@app.command()
+def prune(
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    yes: Annotated[
+        bool, typer.Option("--yes", "-y", help="Skip confirmation prompt.")
+    ] = False,
+    database_url: Annotated[
+        str | None, typer.Option("--database-url", envvar="DATABASE_URL")
+    ] = None,
+) -> None:
+    """
+    Remove snapshots or branch databases for deleted branches.
+
+    Snapshots are pruned in shared mode; branch databases in per-branch mode.
+    """
+    require_init()
+    try:
+        config = load_config(cli_overrides={"database_url": database_url})
+
+        if config.mode == "per-branch":
+            _prune_per_branch(config, dry_run, yes)
+            return
+
+        existing = list_branches()
+        stale = identify_stale_snapshots(
+            config.snapshot_dir,
+            config.max_snapshots,
+            existing,
+        )
+
+        if not stale:
+            console.print("Nothing to prune.")
+            return
+
+        if dry_run:
+            for meta in stale:
+                console.print(f"  [dim]Would remove:[/] {meta.branch}")
+            return
+
+        if not confirm_prune(
+            "The following snapshots will be removed:",
+            [(m.branch, None) for m in stale],
+            yes,
+        ):
+            return
+
+        backend = get_backend(config.database_url)
+        strategy = backend.detect_strategy(config)
+        pruned = 0
+
+        for meta in stale:
+            try:
+                strategy.cleanup(meta.branch, config.snapshot_dir, config)
+                console.print(f"  Pruned: {meta.branch}")
+                pruned += 1
+            except Exception as e:
+                console.print(f"  [yellow]Failed to prune {meta.branch}:[/] {e}")
+
+        if pruned:
+            console.print(f"\nRemoved {pruned} snapshot(s).")
+    except GitDbError as e:
+        console.print(f"[red]Error:[/] {e}")
+        raise typer.Exit(1) from e
+    except typer.Exit:
+        raise
+    except Exception as e:
+        if debug_enabled():
+            raise
+        console.print(
+            f"[red]Error:[/] Unexpected error: {e}\n"
+            "[dim]Set GIT_DB_DEBUG=1 to see the full traceback.[/]"
+        )
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def status(
+    database_url: Annotated[
+        str | None, typer.Option("--database-url", envvar="DATABASE_URL")
+    ] = None,
+) -> None:
+    """
+    Show current strategy, database, branch, and snapshot info.
+    """
+    require_init()
+    try:
+        config = load_config(cli_overrides={"database_url": database_url})
+
+        current_branch = get_current_branch() or "(detached)"
+        backend = get_backend(config.database_url)
+        version = backend.get_engine_version(config.database_url)
+        detected = backend.detect_strategy(config)
+
+        if config.mode == "per-branch":
+            _status_per_branch(config, current_branch, backend, version, detected)
+            return
+
+        snapshots = list_snapshots(config.snapshot_dir)
+        current_status = _shared_current_status(config, backend, current_branch)
+        enabled_status = check_enabled()
+        summary = (
+            f"  Branch:     [cyan]{current_branch}[/]\n"
+            f"  Database:   {mask_url(config.database_url)}\n"
+            f"  Engine:     [cyan]{backend.engine} {version}[/]\n"
+            f"  Strategy:   [green]{detected.name}[/]\n"
+            f"  Snapshots:  {len(snapshots)}\n"
+            f"  Current:    {current_status}\n"
+            f"  Enabled:    {enabled_status}"
+        )
+        console.print(Panel(summary, title="git-db status", border_style="blue"))
+    except GitDbError as e:
+        console.print(f"[red]Error:[/] {e}")
+        raise typer.Exit(1) from e
+    except typer.Exit:
+        raise
+    except Exception as e:
+        if debug_enabled():
+            raise
+        console.print(
+            f"[red]Error:[/] Unexpected error: {e}\n"
+            "[dim]Set GIT_DB_DEBUG=1 to see the full traceback.[/]"
+        )
+        raise typer.Exit(1) from e
+
+
+def _list_per_branch(config: GitDbConfig) -> None:
+    """
+    List branch databases in per-branch mode.
+    """
+    git_dir = get_git_dir()
+    if git_dir is None:
+        console.print("[red]Error:[/] Not inside a git repository.")
+        raise typer.Exit(1)
+
+    backend = get_backend(config.database_url)
+    manager = backend.branch_db_manager(config)
+    entries = manager.list(git_dir)
+
+    if not entries:
+        console.print("No branch databases found.")
+        return
+
+    table = Table(title="Branch Databases")
+    table.add_column("Branch", style="cyan", no_wrap=True)
+    table.add_column("Database", style="green")
+    table.add_column("Status", justify="center")
+    table.add_column("Created From", style="dim")
+    table.add_column("Age", justify="right")
+
+    for branch_name, entry, exists in entries:
+        status_str = "[green]exists[/]" if exists else "[red]missing[/]"
+        table.add_row(
+            branch_name,
+            entry.db_name,
+            status_str,
+            entry.created_from,
+            format_age(entry.created_at),
+        )
+
+    params = backend.apply_url_defaults(parse_database_url(config.database_url))
+    seed_name = str(params["dbname"])
+    table.add_row(
+        f"{config.default_branch} (seed)",
+        seed_name,
+        "[green]seed[/]",
+        "n/a",
+        "n/a",
+    )
+
+    console.print(table)
+
+
+def _prune_per_branch(config: GitDbConfig, dry_run: bool, yes: bool) -> None:
+    """
+    Prune stale branch databases in per-branch mode.
+    """
+    git_dir = get_git_dir()
+    if git_dir is None:
+        console.print("[red]Error:[/] Not inside a git repository.")
+        raise typer.Exit(1)
+
+    existing_branches = list_branches()
+    state = load_state(git_dir)
+
+    if not state.databases:
+        console.print("No branch databases to prune.")
+        return
+
+    stale = [
+        (branch, entry)
+        for branch, entry in state.databases.items()
+        if branch not in existing_branches
+    ]
+
+    if not stale:
+        console.print("Nothing to prune.")
+        return
+
+    if dry_run:
+        for branch_name, entry in stale:
+            console.print(f"  [dim]Would drop:[/] {entry.db_name} ({branch_name})")
+        return
+
+    if not confirm_prune(
+        "The following branch databases will be dropped:",
+        [
+            (entry.db_name, f"{branch_name}, created from {entry.created_from}")
+            for branch_name, entry in stale
+        ],
+        yes,
+    ):
+        return
+
+    backend = get_backend(config.database_url)
+    manager = backend.branch_db_manager(config)
+
+    pruned = 0
+    for branch_name, entry in stale:
+        try:
+            manager.drop(entry.db_name, branch_name, git_dir)
+            console.print(f"  Dropped: {entry.db_name} ({branch_name})")
+            pruned += 1
+        except GitDbError as e:
+            console.print(f"  [yellow]Failed to drop {entry.db_name}:[/] {e}")
+
+    if pruned:
+        console.print(f"\nDropped {pruned} database(s).")
+
+
+def _status_per_branch(
+    config: GitDbConfig,
+    current_branch: str,
+    backend: DatabaseBackend,
+    version: int,
+    detected: SnapshotStrategy,
+) -> None:
+    """
+    Show status in per-branch mode.
+    """
+    git_dir = get_git_dir()
+
+    params = backend.apply_url_defaults(parse_database_url(config.database_url))
+    dbname = str(params["dbname"])
+
+    if current_branch != "(detached)":
+        current_db = branch_db_name(
+            current_branch,
+            dbname,
+            config.default_branch,
+            backend.max_identifier_length,
+        )
+        db_exists = backend.branch_db_manager(config).exists(current_db)
+        db_status = "[green]exists[/]" if db_exists else "[dim]not created[/]"
+    else:
+        current_db = "(detached)"
+        db_status = "[dim]N/A[/]"
+
+    total_dbs = 0
+    if git_dir:
+        state = load_state(git_dir)
+        total_dbs = len(state.databases)
+
+    count_warning = ""
+    if total_dbs > 20:
+        count_warning = " [yellow](consider running git-db prune)[/]"
+
+    enabled_status = check_enabled()
+    summary = (
+        f"  Mode:       [green]per-branch[/]\n"
+        f"  Branch:     [cyan]{current_branch}[/]\n"
+        f"  Database:   [cyan]{current_db}[/]  {db_status}\n"
+        f"  Seed:       {dbname}\n"
+        f"  Default:    {config.default_branch}\n"
+        f"  Engine:     [cyan]{backend.engine} {version}[/]\n"
+        f"  Strategy:   [green]{detected.name}[/]\n"
+        f"  Databases:  {total_dbs}{count_warning}\n"
+        f"  Enabled:    {enabled_status}"
+    )
+    console.print(Panel(summary, title="git-db status", border_style="blue"))
+
+
+def _shared_snapshot_status(
+    config: GitDbConfig,
+    backend: DatabaseBackend,
+    branch: str,
+    strategy_name: str,
+) -> str:
+    """
+    Return whether shared-mode snapshot storage still exists.
+    """
+    if strategy_name == "pgdump":
+        return (
+            "[green]exists[/]"
+            if snapshot_dump_path(config.snapshot_dir, branch).exists()
+            else "[red]missing[/]"
+        )
+
+    if strategy_name != "template":
+        return "[dim]unknown[/]"
+
+    params = backend.apply_url_defaults(parse_database_url(config.database_url))
+    dbname = str(params["dbname"])
+    name = snapshot_db_name(branch, dbname, backend.max_identifier_length)
+    try:
+        return (
+            "[green]exists[/]"
+            if backend.database_exists(config.database_url, name)
+            else "[red]missing[/]"
+        )
+    except Exception:
+        return "[yellow]unknown[/]"
+
+
+def _shared_current_status(
+    config: GitDbConfig,
+    backend: DatabaseBackend,
+    branch: str,
+) -> str:
+    """
+    Return whether the current branch has usable shared snapshot storage.
+    """
+    if branch == "(detached)" or not has_snapshot(config.snapshot_dir, branch):
+        return "[dim]no snapshot[/]"
+
+    meta = next(
+        (s for s in list_snapshots(config.snapshot_dir) if s.branch == branch),
+        None,
+    )
+    if meta is None:
+        return "[dim]no snapshot[/]"
+
+    status = _shared_snapshot_status(config, backend, branch, meta.strategy)
+    if "exists" in status:
+        return "[green]yes[/]"
+    if "missing" in status:
+        return "[red]missing[/]"
+    return "[yellow]unknown[/]"