gobby 0.2.5__py3-none-any.whl

gobby/cli/artifacts.py

@@ -0,0 +1,266 @@
+"""CLI commands for session artifacts."""
+
+import json
+from typing import Any
+
+import click
+
+from gobby.storage.artifacts import Artifact, LocalArtifactManager
+from gobby.storage.database import LocalDatabase
+
+
+def get_artifact_manager() -> LocalArtifactManager:
+    """Get the artifact manager."""
+    db = LocalDatabase()
+    return LocalArtifactManager(db)
+
+
+@click.group()
+def artifacts() -> None:
+    """Manage session artifacts (code, diffs, errors)."""
+    pass
+
+
+@artifacts.command()
+@click.argument("query")
+@click.option("--session", "-s", "session_id", help="Filter by session ID")
+@click.option("--type", "-t", "artifact_type", help="Filter by artifact type (code, diff, error)")
+@click.option("--limit", "-n", default=50, help="Maximum results")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def search(
+    query: str,
+    session_id: str | None,
+    artifact_type: str | None,
+    limit: int,
+    output_json: bool,
+) -> None:
+    """Search artifacts by content.
+
+    Uses full-text search to find matching artifacts.
+    """
+    manager = get_artifact_manager()
+    artifacts_list = manager.search_artifacts(
+        query_text=query,
+        session_id=session_id,
+        artifact_type=artifact_type,
+        limit=limit,
+    )
+
+    if not artifacts_list:
+        if output_json:
+            click.echo(json.dumps({"artifacts": [], "count": 0}))
+        else:
+            click.echo("No artifacts found")
+        return
+
+    if output_json:
+        click.echo(
+            json.dumps(
+                {
+                    "artifacts": [a.to_dict() for a in artifacts_list],
+                    "count": len(artifacts_list),
+                },
+                indent=2,
+            )
+        )
+    else:
+        _display_artifact_list(artifacts_list)
+
+
+@artifacts.command("list")
+@click.option("--session", "-s", "session_id", help="Filter by session ID")
+@click.option("--type", "-t", "artifact_type", help="Filter by artifact type (code, diff, error)")
+@click.option("--limit", "-n", default=100, help="Maximum results")
+@click.option("--offset", "-o", default=0, help="Offset for pagination")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def list_artifacts(
+    session_id: str | None,
+    artifact_type: str | None,
+    limit: int,
+    offset: int,
+    output_json: bool,
+) -> None:
+    """List artifacts with optional filters."""
+    manager = get_artifact_manager()
+    artifacts_list = manager.list_artifacts(
+        session_id=session_id,
+        artifact_type=artifact_type,
+        limit=limit,
+        offset=offset,
+    )
+
+    if output_json:
+        click.echo(
+            json.dumps(
+                {
+                    "artifacts": [a.to_dict() for a in artifacts_list],
+                    "count": len(artifacts_list),
+                },
+                indent=2,
+            )
+        )
+    else:
+        if not artifacts_list:
+            click.echo("No artifacts found")
+            return
+        _display_artifact_list(artifacts_list)
+
+
+@artifacts.command()
+@click.argument("artifact_id")
+@click.option("--verbose", "-v", is_flag=True, help="Show full metadata")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def show(artifact_id: str, verbose: bool, output_json: bool) -> None:
+    """Display a single artifact by ID."""
+    manager = get_artifact_manager()
+    artifact = manager.get_artifact(artifact_id)
+
+    if artifact is None:
+        if output_json:
+            click.echo(json.dumps({"error": f"Artifact '{artifact_id}' not found"}))
+        else:
+            click.echo(f"Artifact not found: {artifact_id}", err=True)
+        raise SystemExit(1)
+
+    if output_json:
+        click.echo(json.dumps(artifact.to_dict(), indent=2))
+    else:
+        _display_artifact_detail(artifact, verbose)
+
+
+@artifacts.command()
+@click.argument("session_id")
+@click.option("--type", "-t", "artifact_type", help="Filter by artifact type")
+@click.option("--limit", "-n", default=100, help="Maximum results")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def timeline(
+    session_id: str,
+    artifact_type: str | None,
+    limit: int,
+    output_json: bool,
+) -> None:
+    """Show artifacts for a session in chronological order.
+
+    Displays artifacts from oldest to newest.
+    """
+    manager = get_artifact_manager()
+    artifacts_list = manager.list_artifacts(
+        session_id=session_id,
+        artifact_type=artifact_type,
+        limit=limit,
+        offset=0,
+    )
+
+    # Reverse to get chronological order (oldest first)
+    artifacts_list = list(reversed(artifacts_list))
+
+    if output_json:
+        click.echo(
+            json.dumps(
+                {
+                    "session_id": session_id,
+                    "artifacts": [a.to_dict() for a in artifacts_list],
+                    "count": len(artifacts_list),
+                },
+                indent=2,
+            )
+        )
+    else:
+        if not artifacts_list:
+            click.echo(f"No artifacts found for session: {session_id}")
+            return
+        click.echo(f"Timeline for session: {session_id}")
+        click.echo("-" * 60)
+        for artifact in artifacts_list:
+            _display_timeline_entry(artifact)
+
+
+def _display_artifact_list(artifacts_list: list[Any]) -> None:
+    """Display a list of artifacts in table format."""
+    # Header
+    click.echo(f"{'ID':<12} {'Type':<8} {'Source':<20} {'Created':<20}")
+    click.echo("-" * 60)
+
+    for artifact in artifacts_list:
+        artifact_id = artifact.id[:12] if len(artifact.id) > 12 else artifact.id
+        source = artifact.source_file or "-"
+        if len(source) > 18:
+            source = "..." + source[-15:]
+        created = artifact.created_at[:19] if artifact.created_at else "-"
+        click.echo(f"{artifact_id:<12} {artifact.artifact_type:<8} {source:<20} {created:<20}")
+
+
+def _display_artifact_detail(artifact: Artifact, verbose: bool) -> None:
+    """Display a single artifact with optional verbosity."""
+    click.echo(f"ID: {artifact.id}")
+    click.echo(f"Type: {artifact.artifact_type}")
+    click.echo(f"Session: {artifact.session_id}")
+
+    if artifact.source_file:
+        location = artifact.source_file
+        if artifact.line_start:
+            location += f":{artifact.line_start}"
+            if artifact.line_end and artifact.line_end != artifact.line_start:
+                location += f"-{artifact.line_end}"
+        click.echo(f"Source: {location}")
+
+    click.echo(f"Created: {artifact.created_at}")
+
+    if verbose and artifact.metadata:
+        click.echo(f"Metadata: {json.dumps(artifact.metadata, indent=2)}")
+
+    click.echo("")
+    click.echo("-" * 60)
+
+    # Display content with syntax highlighting for code
+    _display_content(artifact.content, artifact.artifact_type, artifact.metadata)
+
+
+def _display_content(content: str, artifact_type: str, metadata: dict[str, Any] | None) -> None:
+    """Display content with appropriate formatting."""
+    # Try to use rich for syntax highlighting if available
+    try:
+        from rich.console import Console
+        from rich.syntax import Syntax
+
+        console = Console()
+
+        # Determine language for syntax highlighting
+        language = None
+        if metadata and "language" in metadata:
+            language = metadata["language"]
+        elif artifact_type == "code":
+            # Default to python if no language specified
+            language = "python"
+        elif artifact_type == "diff":
+            language = "diff"
+        elif artifact_type == "error":
+            language = "text"
+
+        if language:
+            syntax = Syntax(content, language, theme="monokai", line_numbers=True)
+            console.print(syntax)
+        else:
+            click.echo(content)
+
+    except ImportError:
+        # Fall back to plain text
+        click.echo(content)
+
+
+def _display_timeline_entry(artifact: Artifact) -> None:
+    """Display a single timeline entry."""
+    click.echo(f"[{artifact.created_at[:19]}] {artifact.artifact_type.upper()}: {artifact.id}")
+    if artifact.source_file:
+        click.echo(f"  Source: {artifact.source_file}")
+
+    # Show a preview of the content (first 2 lines)
+    lines = artifact.content.split("\n")[:2]
+    for line in lines:
+        if len(line) > 60:
+            line = line[:57] + "..."
+        click.echo(f"  | {line}")
+
+    if len(artifact.content.split("\n")) > 2:
+        click.echo(f"  | ... ({len(artifact.content.split(chr(10)))} lines total)")
+    click.echo("")

gobby/cli/daemon.py

@@ -0,0 +1,329 @@
+"""
+Daemon management commands.
+"""
+
+import logging
+import os
+import subprocess  # nosec B404 - subprocess needed for daemon management
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import click
+import httpx
+import psutil
+
+from gobby.utils.status import fetch_rich_status, format_status_message
+
+from .utils import (
+    format_uptime,
+    get_gobby_home,
+    init_local_storage,
+    is_port_available,
+    kill_all_gobby_daemons,
+    setup_logging,
+    wait_for_port_available,
+)
+from .utils import (
+    stop_daemon as stop_daemon_util,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Enable verbose debug output",
+)
+@click.pass_context
+def start(ctx: click.Context, verbose: bool) -> None:
+    """Start the Gobby daemon."""
+    # Get config object
+    config = ctx.obj["config"]
+
+    # Get paths from config (respects GOBBY_HOME env var)
+    gobby_dir = get_gobby_home()
+    pid_file = gobby_dir / "gobby.pid"
+    log_file = Path(config.logging.client).expanduser()
+    error_log_file = Path(config.logging.client_error).expanduser()
+
+    gobby_dir.mkdir(parents=True, exist_ok=True)
+    log_file.parent.mkdir(parents=True, exist_ok=True)
+    error_log_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Initialize local storage before starting daemon
+    click.echo("Initializing local storage...")
+    init_local_storage()
+
+    # Check if already running
+    if pid_file.exists():
+        try:
+            with open(pid_file) as f:
+                pid = int(f.read().strip())
+
+            # Check if process is actually running
+            try:
+                os.kill(pid, 0)
+                click.echo(f"Gobby daemon is already running (PID: {pid})", err=True)
+                sys.exit(1)
+            except ProcessLookupError:
+                # Stale PID file
+                click.echo(f"Removing stale PID file (PID: {pid})")
+                pid_file.unlink()
+        except Exception:
+            pid_file.unlink()
+
+    # Kill any existing gobby processes
+    click.echo("Checking for existing gobby processes...")
+    killed_count = kill_all_gobby_daemons()
+    if killed_count > 0:
+        click.echo(f"Stopped {killed_count} existing process(es)")
+        time.sleep(2.0)  # Wait for ports to be released
+    else:
+        click.echo("No existing processes found")
+
+    # Check ports
+    http_port = config.daemon_port
+    ws_port = config.websocket.port
+
+    if not is_port_available(http_port):
+        click.echo(f"Waiting for HTTP port {http_port} to become available...", err=True)
+        if not wait_for_port_available(http_port, timeout=5.0):
+            click.echo(f"Error: Port {http_port} is still in use", err=True)
+            sys.exit(1)
+
+    if not is_port_available(ws_port):
+        click.echo(f"Waiting for WebSocket port {ws_port} to become available...", err=True)
+        if not wait_for_port_available(ws_port, timeout=5.0):
+            click.echo(f"Error: Port {ws_port} is still in use", err=True)
+            sys.exit(1)
+
+    click.echo(f"Ports available (HTTP: {http_port}, WebSocket: {ws_port})")
+
+    # Start the runner as a subprocess
+    click.echo("Starting Gobby daemon...")
+
+    # Build command
+    cmd = [sys.executable, "-m", "gobby.runner"]
+    if verbose:
+        cmd.append("--verbose")
+
+    # Open log files
+    log_f = open(log_file, "a")
+    error_log_f = open(error_log_file, "a")
+
+    try:
+        # Start detached subprocess
+        process = subprocess.Popen(  # nosec B603 - cmd built from sys.executable and module path
+            cmd,
+            stdout=log_f,
+            stderr=error_log_f,
+            stdin=subprocess.DEVNULL,
+            start_new_session=True,  # Detach from terminal
+            env=os.environ.copy(),  # Inherit parent's environment (including PATH)
+        )
+
+        # Write PID file
+        with open(pid_file, "w") as f:
+            f.write(str(process.pid))
+
+        # Give it a moment to start
+        time.sleep(1.0)
+
+        # Check if still running
+        if process.poll() is not None:
+            click.echo("Process exited immediately", err=True)
+            click.echo(f"  Check logs: {error_log_file}", err=True)
+            sys.exit(1)
+
+        # Give server time to fully start
+        time.sleep(2.0)
+
+        # Display formatted status
+        # Try to verify daemon is responding
+        daemon_healthy = False
+        start_time = time.time()
+        max_wait = 15.0
+
+        while (time.time() - start_time) < max_wait:
+            try:
+                response = httpx.get(f"http://localhost:{http_port}/admin/status", timeout=1.0)
+                if response.status_code == 200:
+                    daemon_healthy = True
+                    break
+            except (httpx.ConnectError, httpx.TimeoutException):
+                time.sleep(0.5)
+                continue
+
+        # Format and display status
+        status_kwargs = {
+            "running": daemon_healthy,
+            "pid": process.pid,
+            "pid_file": str(pid_file),
+            "log_files": str(log_file.parent),
+            "http_port": http_port,
+            "websocket_port": ws_port,
+        }
+
+        # Fetch rich status if daemon is healthy
+        # Brief delay to allow stats to be computed
+        if daemon_healthy:
+            time.sleep(1.0)
+            rich_status = fetch_rich_status(http_port, timeout=2.0)
+            status_kwargs.update(rich_status)
+
+        message = format_status_message(**status_kwargs)
+        click.echo("")
+        click.echo(message)
+        click.echo("")
+
+        if not daemon_healthy:
+            click.echo("Warning: Daemon started but health check failed")
+            click.echo(f"  Check logs: {error_log_file}")
+
+    except Exception as e:
+        click.echo(f"Error starting daemon: {e}", err=True)
+        sys.exit(1)
+    finally:
+        log_f.close()
+        error_log_f.close()
+
+
+@click.command()
+@click.pass_context
+def stop(ctx: click.Context) -> None:
+    """Stop the Gobby daemon."""
+    success = stop_daemon_util(quiet=False)
+    sys.exit(0 if success else 1)
+
+
+@click.command()
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Enable verbose debug output",
+)
+@click.pass_context
+def restart(ctx: click.Context, verbose: bool) -> None:
+    """Restart the Gobby daemon (stop then start)."""
+    setup_logging(verbose)
+
+    click.echo("Restarting Gobby daemon...")
+
+    # Stop daemon using helper function (doesn't call sys.exit)
+    if not stop_daemon_util(quiet=False):
+        click.echo("Failed to stop daemon, aborting restart", err=True)
+        sys.exit(1)
+
+    # Wait for cleanup and port release (TIME_WAIT state)
+    time.sleep(3)
+
+    # Call start command
+    ctx.invoke(start, verbose=verbose)
+
+
+@click.command()
+@click.pass_context
+def status(ctx: click.Context) -> None:
+    """Show Gobby daemon status and information."""
+    config = ctx.obj["config"]
+    pid_file = get_gobby_home() / "gobby.pid"
+    log_dir = Path(config.logging.client).expanduser().parent
+
+    # Read PID from file
+    if not pid_file.exists():
+        message = format_status_message(running=False)
+        click.echo(message)
+        sys.exit(0)
+
+    try:
+        with open(pid_file) as f:
+            pid = int(f.read().strip())
+    except Exception:
+        message = format_status_message(running=False)
+        click.echo(message)
+        sys.exit(0)
+
+    # Check if process is actually running
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        message = format_status_message(running=False)
+        click.echo(message)
+        click.echo(f"Note: Stale PID file found (PID {pid})")
+        sys.exit(0)
+
+    # Get process info for uptime (fallback)
+    try:
+        process = psutil.Process(pid)
+        uptime_seconds = time.time() - process.create_time()
+        uptime_str = format_uptime(uptime_seconds)
+    except Exception:
+        uptime_str = None
+
+    http_port = config.daemon_port
+    websocket_port = config.websocket.port
+
+    # Build status kwargs
+    status_kwargs: dict[str, Any] = {
+        "running": True,
+        "pid": pid,
+        "pid_file": str(pid_file),
+        "log_files": str(log_dir),
+        "uptime": uptime_str,
+        "http_port": http_port,
+        "websocket_port": websocket_port,
+    }
+
+    # Fetch rich status from daemon API
+    rich_status = fetch_rich_status(http_port, timeout=2.0)
+    status_kwargs.update(rich_status)
+
+    # Format and display status
+    message = format_status_message(**status_kwargs)
+    click.echo(message)
+    sys.exit(0)
+
+
+def get_merge_status() -> dict[str, Any]:
+    """
+    Get the current merge status for status output.
+
+    Returns:
+        Dict with merge status info:
+        - active: bool - Whether there's an active merge
+        - resolution_id: str | None - ID of active resolution
+        - source_branch: str | None - Source branch being merged
+        - target_branch: str | None - Target branch
+        - pending_conflicts: int - Number of unresolved conflicts
+    """
+    try:
+        from gobby.storage.database import LocalDatabase
+        from gobby.storage.merge_resolutions import MergeResolutionManager
+
+        db = LocalDatabase()
+        manager = MergeResolutionManager(db)
+
+        resolution = manager.get_active_resolution()
+        if not resolution:
+            return {"active": False}
+
+        conflicts = manager.list_conflicts(resolution_id=resolution.id)
+        pending_count = sum(1 for c in conflicts if c.status == "pending")
+
+        return {
+            "active": True,
+            "resolution_id": resolution.id,
+            "source_branch": resolution.source_branch,
+            "target_branch": resolution.target_branch,
+            "pending_conflicts": pending_count,
+            "total_conflicts": len(conflicts),
+        }
+    except Exception as e:
+        logger.debug(f"Error getting merge status: {e}")
+        return {"active": False, "error": str(e)}