gobby 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

gobby/agents/spawn_executor.py

@@ -10,7 +10,11 @@ import logging
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Literal, cast
 
-from gobby.agents.sandbox import SandboxConfig
+from gobby.agents.sandbox import (
+    GeminiSandboxResolver,
+    SandboxConfig,
+    compute_sandbox_paths,
+)
 
 if TYPE_CHECKING:
     from gobby.agents.session import ChildSessionManager
@@ -63,7 +67,7 @@ class SpawnResult:
 
     success: bool
     run_id: str
-    child_session_id: str
+    child_session_id: str | None
     status: str
 
     # Optional result fields
@@ -219,16 +223,19 @@ async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
     """
     Spawn Gemini agent in terminal with preflight session capture.
 
-    Gemini CLI in interactive mode can't introspect its session_id, so we:
-    1. Launch preflight to capture session_id from stream-json output
-    2. Create Gobby session with external_id = gemini's session_id
-    3. Launch interactive with -r {session_id} to resume
+    Uses preflight to capture Gemini's session_id before launching interactive mode:
+    1. Run `gemini --output-format stream-json` to capture Gemini's session_id
+    2. Pre-create Gobby session with parent_session_id linked and external_id set
+    3. Resume Gemini session with `-r {session_id}` flag
+
+    This approach ensures session linkage works without relying on env vars,
+    which don't pass through macOS's `open` command.
     """
     if request.session_manager is None:
         return SpawnResult(
             success=False,
             run_id=request.run_id,
-            child_session_id=request.session_id,
+            child_session_id=None,
             status="failed",
             error="session_manager is required for Gemini preflight",
         )
@@ -242,21 +249,31 @@ async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
             machine_id=request.machine_id or "unknown",
             workflow_name=request.workflow,
             git_branch=None,  # Will be detected by hook
+            prompt=request.prompt,
+            max_agent_depth=request.max_agent_depth,
         )
     except FileNotFoundError as e:
+        logger.error(
+            f"Gemini spawn failed - command not found: {e}",
+            extra={"project_id": request.project_id, "run_id": request.run_id},
+        )
         return SpawnResult(
             success=False,
             run_id=request.run_id,
-            child_session_id=request.session_id,
+            child_session_id=None,
             status="failed",
             error=str(e),
         )
     except Exception as e:
-        logger.error(f"Gemini preflight capture failed: {e}", exc_info=True)
+        logger.error(
+            f"Gemini preflight capture failed: {e}",
+            extra={"project_id": request.project_id, "run_id": request.run_id},
+            exc_info=True,
+        )
         return SpawnResult(
             success=False,
             run_id=request.run_id,
-            child_session_id=request.session_id,
+            child_session_id=None,
             status="failed",
             error=f"Gemini preflight capture failed: {e}",
         )
@@ -265,20 +282,33 @@ async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
     gobby_session_id = spawn_context.session_id
     gemini_session_id = spawn_context.env_vars["GOBBY_GEMINI_EXTERNAL_ID"]
 
-    # Build command with session context injected into prompt
+    # Build command with resume (no env vars needed - session already linked)
     cmd = build_gemini_command_with_resume(
         gemini_external_id=gemini_session_id,
         prompt=request.prompt,
-        auto_approve=True,  # Subagents need to work autonomously
+        auto_approve=True,
         gobby_session_id=gobby_session_id,
     )
 
+    # Resolve sandbox config if provided
+    sandbox_env: dict[str, str] = {}
+    if request.sandbox_config and request.sandbox_config.enabled:
+        resolver = GeminiSandboxResolver()
+        paths = compute_sandbox_paths(
+            config=request.sandbox_config,
+            workspace_path=request.cwd,
+        )
+        sandbox_args, sandbox_env = resolver.resolve(request.sandbox_config, paths)
+        # Append sandbox args to command (e.g., -s flag)
+        cmd.extend(sandbox_args)
+
     # Spawn in terminal
     terminal_spawner = TerminalSpawner()
     terminal_result = terminal_spawner.spawn(
         command=cmd,
         cwd=request.cwd,
         terminal=request.terminal,
+        env=sandbox_env if sandbox_env else None,
     )
 
     if not terminal_result.success:
@@ -293,7 +323,7 @@ async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
     return SpawnResult(
         success=True,
         run_id=f"gemini-{gemini_session_id[:8]}",
-        child_session_id=gobby_session_id,
+        child_session_id=gobby_session_id,  # Now properly set!
         status="pending",
         pid=terminal_result.pid,
         gemini_session_id=gemini_session_id,

gobby/agents/spawners/macos.py

@@ -31,6 +31,24 @@ class GhosttySpawner(TerminalSpawnerBase):
     def terminal_type(self) -> TerminalType:
         return TerminalType.GHOSTTY
 
+    def _is_ghostty_running(self) -> bool:
+        """Check if Ghostty is currently running on macOS."""
+        try:
+            result = subprocess.run(  # nosec B603, B607 - osascript is safe
+                [
+                    "/usr/bin/osascript",
+                    "-e",
+                    'tell application "System Events" to (name of processes) contains "Ghostty"',
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return result.stdout.strip().lower() == "true"
+        except Exception:
+            # If we can't determine, assume running to use safer -n behavior
+            return True
+
     def is_available(self) -> bool:
         config = get_tty_config().get_terminal_config("ghostty")
         if not config.enabled:
@@ -66,7 +84,14 @@ class GhosttySpawner(TerminalSpawnerBase):
                 ghostty_args.extend(tty_config.options)
                 ghostty_args.extend(["-e"] + command)
 
-                args = ["open", "-na", app_path, "--args"] + ghostty_args
+                # Check if Ghostty is already running
+                # If running: use -n to open a new window
+                # If not running: omit -n to avoid double window on first launch
+                ghostty_running = self._is_ghostty_running()
+                if ghostty_running:
+                    args = ["open", "-na", app_path, "--args"] + ghostty_args
+                else:
+                    args = ["open", "-a", app_path, "--args"] + ghostty_args
             else:
                 # On Linux/other platforms, use ghostty CLI directly
                 cli_command = tty_config.command or "ghostty"

gobby/app_context.py

@@ -0,0 +1,59 @@
+"""
+Service container for dependency injection in Gobby daemon.
+
+Holds references to singleton services to avoid prop-drilling in HTTPServer
+and other components.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from gobby.config.app import DaemonConfig
+from gobby.llm import LLMService
+from gobby.memory.manager import MemoryManager
+from gobby.storage.clones import LocalCloneManager
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.sessions import LocalSessionManager
+from gobby.storage.tasks import LocalTaskManager
+from gobby.storage.worktrees import LocalWorktreeManager
+from gobby.sync.memories import MemorySyncManager
+from gobby.sync.tasks import TaskSyncManager
+
+
+@dataclass
+class ServiceContainer:
+    """Container for daemon services."""
+
+    # Core Infrastructure
+    config: DaemonConfig
+    database: DatabaseProtocol
+
+    # Core Managers
+    session_manager: LocalSessionManager
+    task_manager: LocalTaskManager
+
+    # Sync Managers
+    task_sync_manager: TaskSyncManager | None = None
+    memory_sync_manager: MemorySyncManager | None = None
+
+    # Advanced Features
+    memory_manager: MemoryManager | None = None
+    llm_service: LLMService | None = None
+
+    # MCP & Agents
+    mcp_manager: Any | None = None  # MCPClientManager
+    mcp_db_manager: Any | None = None  # LocalMCPManager
+    metrics_manager: Any | None = None  # ToolMetricsManager
+    agent_runner: Any | None = None  # AgentRunner
+    message_processor: Any | None = None  # SessionMessageProcessor
+    message_manager: Any | None = None  # LocalSessionMessageManager
+
+    # Validation & Git
+    task_validator: Any | None = None  # TaskValidator
+    worktree_storage: LocalWorktreeManager | None = None
+    clone_storage: LocalCloneManager | None = None
+    git_manager: Any | None = None  # WorktreeGitManager
+
+    # Context
+    project_id: str | None = None
+    websocket_server: Any | None = None

gobby/cli/__init__.py

@@ -24,7 +24,6 @@ from .projects import projects
 from .sessions import sessions
 from .skills import skills
 from .tasks import tasks
-from .tui import ui
 from .workflows import workflows
 from .worktrees import worktrees
 
@@ -70,4 +69,3 @@ cli.add_command(conductor)
 cli.add_command(hooks)
 cli.add_command(plugins)
 cli.add_command(webhooks)
-cli.add_command(ui)

gobby/cli/memory.py

@@ -282,6 +282,191 @@ def export_memories(
         click.echo(markdown)
 
 
+@memory.command("dedupe")
+@click.option("--dry-run", is_flag=True, help="Show duplicates without deleting")
+@click.pass_context
+def dedupe_memories(ctx: click.Context, dry_run: bool) -> None:
+    """Remove duplicate memories (same content, different IDs).
+
+    Identifies memories with identical content but different IDs (caused by
+    project_id variations) and removes duplicates, keeping the earliest one.
+
+    Examples:
+
+        gobby memory dedupe --dry-run   # Preview duplicates
+
+        gobby memory dedupe             # Remove duplicates
+    """
+    manager = get_memory_manager(ctx)
+
+    # Get all memories
+    memories = manager.list_memories(limit=10000)
+
+    if not memories:
+        click.echo("No memories found.")
+        return
+
+    # Group by normalized content
+    content_groups: dict[str, list[tuple[str, str, str | None]]] = {}
+    for m in memories:
+        normalized = m.content.strip()
+        if normalized not in content_groups:
+            content_groups[normalized] = []
+        content_groups[normalized].append((m.id, m.created_at, m.project_id))
+
+    # Find duplicates
+    duplicates_to_delete: list[str] = []
+    duplicate_count = 0
+
+    for content, entries in content_groups.items():
+        if len(entries) > 1:
+            duplicate_count += len(entries) - 1
+            # Sort by created_at to keep earliest
+            entries.sort(key=lambda x: x[1])
+            keeper = entries[0]
+            to_delete = entries[1:]
+
+            if dry_run:
+                click.echo(f"\nDuplicate content ({len(entries)} copies):")
+                click.echo(f"  Content: {content[:80]}{'...' if len(content) > 80 else ''}")
+                click.echo(f"  Keep: {keeper[0][:12]} (created: {keeper[1][:19]})")
+                for d in to_delete:
+                    click.echo(f"  Delete: {d[0][:12]} (created: {d[1][:19]}, project: {d[2]})")
+            else:
+                for d in to_delete:
+                    duplicates_to_delete.append(d[0])
+
+    if dry_run:
+        click.echo(f"\nFound {duplicate_count} duplicate memories.")
+        click.echo("Run without --dry-run to delete them.")
+    else:
+        # Delete duplicates
+        deleted = 0
+        for memory_id in duplicates_to_delete:
+            if manager.forget(memory_id):
+                deleted += 1
+
+        click.echo(f"Deleted {deleted} duplicate memories.")
+
+
+@memory.command("fix-null-project")
+@click.option("--dry-run", is_flag=True, help="Show affected memories without updating")
+@click.pass_context
+def fix_null_project(ctx: click.Context, dry_run: bool) -> None:
+    """Fix memories with NULL project_id from their source session.
+
+    Finds memories with source_type='session' and NULL project_id, then
+    looks up the source session to get the correct project_id.
+
+    Examples:
+
+        gobby memory fix-null-project --dry-run   # Preview changes
+
+        gobby memory fix-null-project             # Apply fixes
+    """
+    from gobby.storage.sessions import LocalSessionManager
+
+    db = LocalDatabase()
+    session_mgr = LocalSessionManager(db)
+
+    # Find memories with NULL project_id and session source
+    rows = db.fetchall(
+        """
+        SELECT id, content, source_session_id
+        FROM memories
+        WHERE project_id IS NULL AND source_type = 'session' AND source_session_id IS NOT NULL
+        """,
+        (),
+    )
+
+    if not rows:
+        click.echo("No memories with NULL project_id from sessions found.")
+        return
+
+    click.echo(f"Found {len(rows)} memories with NULL project_id from sessions.")
+
+    fixed = 0
+    for row in rows:
+        memory_id = row["id"]
+        session_id = row["source_session_id"]
+        content_preview = row["content"][:50] if row["content"] else ""
+
+        # Look up session to get project_id
+        session = session_mgr.get(session_id)
+        if session and session.project_id:
+            if dry_run:
+                click.echo(
+                    f"  Would fix {memory_id[:12]}: set project_id={session.project_id[:12]}"
+                )
+                click.echo(f"    Content: {content_preview}...")
+            else:
+                # Update the memory's project_id
+                with db.transaction() as conn:
+                    conn.execute(
+                        "UPDATE memories SET project_id = ? WHERE id = ?",
+                        (session.project_id, memory_id),
+                    )
+                fixed += 1
+        else:
+            if dry_run:
+                click.echo(
+                    f"  Cannot fix {memory_id[:12]}: session {session_id} not found or has no project_id"
+                )
+
+    if dry_run:
+        click.echo(f"\nWould fix {fixed} memories. Run without --dry-run to apply.")
+    else:
+        click.echo(f"Fixed {fixed} memories with project_id from their source sessions.")
+
+
+@memory.command("backup")
+@click.option(
+    "--output",
+    "-o",
+    "output_path",
+    type=click.Path(),
+    help="Output file path (default: .gobby/memories.jsonl)",
+)
+@click.pass_context
+def backup_memories(ctx: click.Context, output_path: str | None) -> None:
+    """Backup memories to JSONL file.
+
+    Exports all memories to a JSONL file for backup/disaster recovery.
+    This runs synchronously and can be used even when the daemon is not running.
+
+    Examples:
+
+        gobby memory backup                           # Export to .gobby/memories.jsonl
+
+        gobby memory backup -o ~/backups/mem.jsonl   # Export to custom path
+    """
+    from pathlib import Path
+
+    from gobby.config.persistence import MemorySyncConfig
+    from gobby.sync.memories import MemoryBackupManager
+
+    manager = get_memory_manager(ctx)
+
+    # Create a backup manager with custom or default path
+    if output_path:
+        export_path = Path(output_path)
+    else:
+        export_path = Path(".gobby/memories.jsonl")
+
+    config = MemorySyncConfig(enabled=True, export_path=export_path)
+    backup_mgr = MemoryBackupManager(
+        db=manager.db,
+        memory_manager=manager,
+        config=config,
+    )
+
+    count = backup_mgr.backup_sync()
+    if count > 0:
+        click.echo(f"Backed up {count} memories to {export_path}")
+    else:
+        click.echo("No memories to backup.")
+
+
 def resolve_memory_id(manager: MemoryManager, memory_ref: str) -> str:
     """Resolve memory reference (UUID or prefix) to full ID."""
     # Try exact match first

gobby/cli/utils.py

@@ -394,23 +394,10 @@ def get_install_dir() -> Path:
     Returns:
         Path to the install directory
     """
-    import gobby
+    # Import from centralized paths module to avoid duplication
+    from gobby.paths import get_install_dir as _get_install_dir
 
-    package_install_dir = Path(gobby.__file__).parent / "install"
-
-    # Try to find source directory (project root)
-    current = Path(gobby.__file__).resolve()
-    source_install_dir = None
-
-    for parent in current.parents:
-        potential_source = parent / "src" / "gobby" / "install"
-        if potential_source.exists():
-            source_install_dir = potential_source
-            break
-
-    if source_install_dir and source_install_dir.exists():
-        return source_install_dir
-    return package_install_dir
+    return _get_install_dir()
 
 
 def _is_process_alive(pid: int) -> bool:
@@ -472,7 +459,8 @@ def stop_daemon(quiet: bool = False) -> bool:
             click.echo(f"Sent shutdown signal to Gobby daemon (PID {pid})")
 
         # Wait for graceful shutdown
-        max_wait = 5
+        # Match daemon's uvicorn timeout_graceful_shutdown (15s) + buffer
+        max_wait = 20
         for _ in range(max_wait * 10):
             time.sleep(0.1)
             if not _is_process_alive(pid):

gobby/clones/git.py

@@ -231,6 +231,89 @@ class CloneGitManager:
                 error=str(e),
             )
 
+    def full_clone(
+        self,
+        remote_url: str,
+        clone_path: str | Path,
+        branch: str = "main",
+    ) -> GitOperationResult:
+        """
+        Create a full (non-shallow) clone of a repository.
+
+        Args:
+            remote_url: URL of the remote repository (HTTPS or SSH)
+            clone_path: Path where clone will be created
+            branch: Branch to clone
+
+        Returns:
+            GitOperationResult with success status and message
+        """
+        clone_path = Path(clone_path)
+
+        # Check if path already exists
+        if clone_path.exists():
+            return GitOperationResult(
+                success=False,
+                message=f"Path already exists: {clone_path}",
+            )
+
+        # Ensure parent directory exists
+        clone_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            # Build clone command without --depth (full clone)
+            cmd = [
+                "git",
+                "clone",
+                "-b",
+                branch,
+                remote_url,
+                str(clone_path),
+            ]
+
+            # Sanitize URL in command before logging to avoid exposing credentials
+            safe_cmd = cmd.copy()
+            safe_cmd[safe_cmd.index(remote_url)] = _sanitize_url(remote_url)
+            logger.debug(f"Running: {' '.join(safe_cmd)}")
+
+            result = subprocess.run(  # nosec B603 B607 - cmd built from hardcoded git arguments
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=600,  # 10 minutes for full clone
+            )
+
+            if result.returncode == 0:
+                return GitOperationResult(
+                    success=True,
+                    message=f"Successfully cloned to {clone_path}",
+                    output=result.stdout,
+                )
+            else:
+                return GitOperationResult(
+                    success=False,
+                    message=f"Clone failed: {result.stderr}",
+                    error=result.stderr,
+                )
+
+        except subprocess.TimeoutExpired:
+            # Clean up partial clone
+            if clone_path.exists():
+                shutil.rmtree(clone_path, ignore_errors=True)
+            return GitOperationResult(
+                success=False,
+                message="Git clone timed out",
+            )
+        except Exception as e:
+            # Clean up partial clone
+            if clone_path.exists():
+                shutil.rmtree(clone_path, ignore_errors=True)
+            return GitOperationResult(
+                success=False,
+                message=f"Error cloning repository: {e}",
+                error=str(e),
+            )
+
     def sync_clone(
         self,
         clone_path: str | Path,
@@ -422,6 +505,100 @@ class CloneGitManager:
             logger.error(f"Error getting clone status: {e}")
             return None
 
+    def create_clone(
+        self,
+        clone_path: str | Path,
+        branch_name: str,
+        base_branch: str = "main",
+        shallow: bool = True,
+    ) -> GitOperationResult:
+        """
+        Create a clone for isolated work.
+
+        This is the high-level API used by CloneIsolationHandler.
+        It gets the remote URL from the current repository and creates
+        either a shallow or full clone at the specified path.
+
+        Args:
+            clone_path: Path where clone will be created
+            branch_name: Branch to create/checkout in the clone
+            base_branch: Base branch to clone from (default: main)
+            shallow: Whether to create a shallow clone (default: True)
+
+        Returns:
+            GitOperationResult with success status and message
+        """
+        # Get remote URL from current repo
+        remote_url = self.get_remote_url()
+        if not remote_url:
+            return GitOperationResult(
+                success=False,
+                message="Could not get remote URL from repository",
+                error="no_remote_url",
+            )
+
+        # Create clone (shallow or full based on parameter)
+        if shallow:
+            result = self.shallow_clone(
+                remote_url=remote_url,
+                clone_path=clone_path,
+                branch=base_branch,
+                depth=1,
+            )
+        else:
+            result = self.full_clone(
+                remote_url=remote_url,
+                clone_path=clone_path,
+                branch=base_branch,
+            )
+
+        if not result.success:
+            return result
+
+        # If branch_name differs from base_branch, create and checkout the new branch
+        if branch_name != base_branch:
+            try:
+                # Create new branch from base
+                create_result = self._run_git(
+                    ["checkout", "-b", branch_name],
+                    cwd=clone_path,
+                    timeout=30,
+                )
+                if create_result.returncode != 0:
+                    # Clean up the clone on branch creation failure
+                    try:
+                        if Path(clone_path).exists():
+                            shutil.rmtree(clone_path)
+                    except Exception as cleanup_err:
+                        logger.warning(
+                            f"Failed to clean up clone after branch creation failure: {cleanup_err}"
+                        )
+                    return GitOperationResult(
+                        success=False,
+                        message=f"Failed to create branch {branch_name}: {create_result.stderr}",
+                        error=create_result.stderr,
+                    )
+            except Exception as e:
+                # Clean up the clone on exception
+                try:
+                    if Path(clone_path).exists():
+                        shutil.rmtree(clone_path)
+                except Exception as cleanup_err:
+                    logger.warning(
+                        f"Failed to clean up clone after branch creation error: {cleanup_err}"
+                    )
+                return GitOperationResult(
+                    success=False,
+                    message=f"Error creating branch: {e}",
+                    error=str(e),
+                )
+
+        return GitOperationResult(
+            success=True,
+            message=f"Successfully created clone at {clone_path} on branch {branch_name}",
+            output=result.output,
+        )
+
     def merge_branch(
         self,
         source_branch: str,

gobby/config/features.py

@@ -23,7 +23,6 @@ __all__ = [
     "HookStageConfig",
     "HooksConfig",
     "TaskDescriptionConfig",
-    "DEFAULT_IMPORT_MCP_SERVER_PROMPT",
 ]
 
 
@@ -139,25 +138,6 @@ class RecommendToolsConfig(BaseModel):
     )
 
 
-DEFAULT_IMPORT_MCP_SERVER_PROMPT = """You are an MCP server configuration extractor. Given documentation for an MCP server, extract the configuration needed to connect to it.
-
-Return ONLY a valid JSON object (no markdown, no code blocks) with these fields:
-- name: Server name (lowercase, no spaces, use hyphens)
-- transport: "http", "stdio", or "websocket"
-- url: Server URL (required for http/websocket transports)
-- command: Command to run (required for stdio, e.g., "npx", "uv", "node")
-- args: Array of command arguments (for stdio)
-- env: Object of environment variables needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- headers: Object of HTTP headers needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- instructions: How to obtain any required API keys or setup steps
-
-Example stdio server:
-{"name": "filesystem", "transport": "stdio", "command": "npx", "args": ["-y", "@anthropic-ai/filesystem-mcp"], "env": {}, "instructions": "No setup required"}
-
-Example http server with API key:
-{"name": "exa", "transport": "http", "url": "https://mcp.exa.ai/mcp", "headers": {"EXA_API_KEY": "<YOUR_EXA_API_KEY>"}, "instructions": "Get your API key from https://exa.ai/dashboard"}"""
-
-
 class ImportMCPServerConfig(BaseModel):
     """MCP server import configuration."""