gobby 0.2.7__py3-none-any.whl → 0.2.8__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/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/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/skills.py

@@ -11,6 +11,37 @@ from typing import Literal
 from pydantic import BaseModel, Field, field_validator
 
 
+class HubConfig(BaseModel):
+    """
+    Configuration for a skill hub or collection.
+    """
+
+    type: Literal["clawdhub", "skillhub", "github-collection"] = Field(
+        ...,
+        description="Type of the hub: 'clawdhub', 'skillhub', or 'github-collection'",
+    )
+
+    base_url: str | None = Field(
+        default=None,
+        description="Base URL for the hub",
+    )
+
+    repo: str | None = Field(
+        default=None,
+        description="GitHub repository (e.g. 'owner/repo')",
+    )
+
+    branch: str | None = Field(
+        default=None,
+        description="Git branch to use",
+    )
+
+    auth_key_name: str | None = Field(
+        default=None,
+        description="Environment variable name for auth key",
+    )
+
+
 class SkillsConfig(BaseModel):
     """
     Configuration for skill injection and discovery.