gobby 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

gobby/adapters/claude_code.py

@@ -191,11 +191,17 @@ class ClaudeCodeAdapter(BaseAdapter):
             additional_context_parts.append(response.context)
 
         # Add session identifiers from metadata
+        # Note: "session_id" in metadata is Gobby's internal platform session ID
+        #       "external_id" in metadata is the CLI's session UUID
         if response.metadata:
-            session_id = response.metadata.get("session_id")
-            if session_id:
+            gobby_session_id = response.metadata.get("session_id")
+            external_id = response.metadata.get("external_id")
+            if gobby_session_id:
                 # Build context with all available identifiers
-                context_lines = [f"session_id: {session_id}"]
+                # Use clear naming: Gobby Session ID for MCP calls, External ID for transcripts
+                context_lines = [f"Gobby Session ID: {gobby_session_id}"]
+                if external_id:
+                    context_lines.append(f"External ID: {external_id}")
                 if response.metadata.get("parent_session_id"):
                     context_lines.append(
                         f"parent_session_id: {response.metadata['parent_session_id']}"
@@ -227,7 +233,10 @@ class ClaudeCodeAdapter(BaseAdapter):
                 additional_context_parts.append("\n".join(context_lines))
 
         # Build hookSpecificOutput if we have any context to inject
-        if additional_context_parts:
+        # Only include hookSpecificOutput for hook types that Claude Code's schema accepts
+        # Valid hookEventName values: PreToolUse, UserPromptSubmit, PostToolUse
+        valid_hook_event_names = {"PreToolUse", "UserPromptSubmit", "PostToolUse"}
+        if additional_context_parts and hook_event_name in valid_hook_event_names:
             result["hookSpecificOutput"] = {
                 "hookEventName": hook_event_name,
                 "additionalContext": "\n\n".join(additional_context_parts),

gobby/adapters/codex.py

@@ -775,6 +775,28 @@ class CodexAdapter(BaseAdapter):
         "item/completed": HookEventType.AFTER_TOOL,
     }
 
+    # Tool name mapping: Codex tool names -> canonical CC-style names
+    # Codex uses different tool names - normalize to Claude Code conventions
+    # so block_tools rules work across CLIs
+    TOOL_MAP: dict[str, str] = {
+        # File operations
+        "read_file": "Read",
+        "ReadFile": "Read",
+        "write_file": "Write",
+        "WriteFile": "Write",
+        "edit_file": "Edit",
+        "EditFile": "Edit",
+        # Shell
+        "run_shell_command": "Bash",
+        "RunShellCommand": "Bash",
+        "commandExecution": "Bash",
+        # Search
+        "glob": "Glob",
+        "grep": "Grep",
+        "GlobTool": "Glob",
+        "GrepTool": "Grep",
+    }
+
     # Item types that represent tool operations
     TOOL_ITEM_TYPES = {"commandExecution", "fileChange", "mcpToolCall"}
 
@@ -814,6 +836,19 @@ class CodexAdapter(BaseAdapter):
             self._machine_id = _get_machine_id()
         return self._machine_id
 
+    def normalize_tool_name(self, codex_tool_name: str) -> str:
+        """Normalize Codex tool name to canonical CC-style format.
+
+        This ensures block_tools rules work consistently across CLIs.
+
+        Args:
+            codex_tool_name: Tool name from Codex CLI.
+
+        Returns:
+            Normalized tool name (e.g., "Bash", "Read", "Write", "Edit").
+        """
+        return self.TOOL_MAP.get(codex_tool_name, codex_tool_name)
+
     def attach_to_client(self, codex_client: CodexAppServerClient) -> None:
         """Attach to an existing CodexAppServerClient for event handling.
 
@@ -876,14 +911,17 @@ class CodexAdapter(BaseAdapter):
         thread_id = params.get("threadId", "")
         item_id = params.get("itemId", "")
 
-        # Determine tool name from method
+        # Determine tool name from method and normalize to CC-style
         if "commandExecution" in method:
-            tool_name = "Bash"
+            original_tool = "commandExecution"
+            tool_name = self.normalize_tool_name(original_tool)  # -> "Bash"
             tool_input = params.get("parsedCmd", params.get("command", ""))
         elif "fileChange" in method:
-            tool_name = "Write"
+            original_tool = "fileChange"
+            tool_name = "Write"  # File changes are writes
             tool_input = params.get("changes", [])
         else:
+            original_tool = "unknown"
             tool_name = "unknown"
             tool_input = params
 
@@ -905,6 +943,8 @@ class CodexAdapter(BaseAdapter):
                 "requires_response": True,
                 "item_id": item_id,
                 "approval_method": method,
+                "original_tool_name": original_tool,
+                "normalized_tool_name": tool_name,
             },
         )
 

gobby/agents/runner.py

@@ -607,6 +607,14 @@ class AgentRunner:
             else:
                 self._session_storage.update_status(child_session.id, "failed")
 
+            # Persist cost to session storage for budget tracking
+            if result.cost_info and result.cost_info.total_cost > 0:
+                self._session_storage.add_cost(child_session.id, result.cost_info.total_cost)
+                self.logger.debug(
+                    f"Persisted cost ${result.cost_info.total_cost:.4f} "
+                    f"for session {child_session.id}"
+                )
+
             # Remove from in-memory tracking
             self._untrack_running_agent(agent_run.id)
 

gobby/cli/__init__.py

@@ -8,6 +8,8 @@ from gobby.config.app import load_config
 
 from .agents import agents
 from .artifacts import artifacts
+from .clones import clones
+from .conductor import conductor
 from .daemon import restart, start, status, stop
 from .extensions import hooks, plugins, webhooks
 from .github import github
@@ -20,6 +22,7 @@ from .memory import memory
 from .merge import merge
 from .projects import projects
 from .sessions import sessions
+from .skills import skills
 from .tasks import tasks
 from .tui import ui
 from .workflows import workflows
@@ -52,6 +55,7 @@ cli.add_command(uninstall)
 cli.add_command(tasks)
 cli.add_command(memory)
 cli.add_command(sessions)
+cli.add_command(skills)
 cli.add_command(agents)
 cli.add_command(worktrees)
 cli.add_command(mcp_proxy)
@@ -61,6 +65,8 @@ cli.add_command(merge)
 cli.add_command(artifacts)
 cli.add_command(github)
 cli.add_command(linear)
+cli.add_command(clones)
+cli.add_command(conductor)
 cli.add_command(hooks)
 cli.add_command(plugins)
 cli.add_command(webhooks)

gobby/cli/clones.py

@@ -0,0 +1,419 @@
+"""
+Clone management CLI commands.
+
+Commands for managing git clones:
+- create: Create a new clone
+- list: List clones
+- spawn: Spawn an agent in a clone
+- sync: Sync a clone with remote
+- merge: Merge clone branch to target
+- delete: Delete a clone
+"""
+
+import json
+
+import click
+import httpx
+
+from gobby.storage.clones import LocalCloneManager
+from gobby.storage.database import LocalDatabase
+
+
+def get_clone_manager() -> LocalCloneManager:
+    """Get initialized clone manager."""
+    db = LocalDatabase()
+    return LocalCloneManager(db)
+
+
+def get_daemon_url() -> str:
+    """Get daemon URL from config."""
+    from gobby.config.app import load_config
+
+    config = load_config()
+    return f"http://localhost:{config.daemon_port}"
+
+
+@click.group()
+def clones() -> None:
+    """Manage git clones for parallel development."""
+    pass
+
+
+@clones.command("list")
+@click.option("--status", "-s", help="Filter by status (active, stale, syncing, cleanup)")
+@click.option("--project", "-p", "project_id", help="Filter by project ID")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def list_clones(
+    status: str | None,
+    project_id: str | None,
+    json_format: bool,
+) -> None:
+    """List clones."""
+    manager = get_clone_manager()
+
+    clones_list = manager.list_clones(status=status, project_id=project_id)
+
+    if json_format:
+        click.echo(json.dumps([c.to_dict() for c in clones_list], indent=2, default=str))
+        return
+
+    if not clones_list:
+        click.echo("No clones found.")
+        return
+
+    click.echo(f"Found {len(clones_list)} clone(s):\n")
+    for clone in clones_list:
+        status_icon = {
+            "active": "●",
+            "syncing": "↻",
+            "stale": "○",
+            "cleanup": "✗",
+        }.get(clone.status, "?")
+
+        session_info = f" (session: {clone.agent_session_id[:8]})" if clone.agent_session_id else ""
+        click.echo(
+            f"{status_icon} {clone.id}  {clone.branch_name:<30} {clone.status:<10}{session_info}"
+        )
+
+
+@clones.command("create")
+@click.argument("branch_name")
+@click.argument("clone_path")
+@click.option("--base", "-b", "base_branch", default="main", help="Base branch to clone from")
+@click.option("--task", "-t", "task_id", help="Link clone to a task")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def create_clone(
+    branch_name: str,
+    clone_path: str,
+    base_branch: str,
+    task_id: str | None,
+    json_format: bool,
+) -> None:
+    """Create a new clone for parallel development.
+
+    Examples:
+
+        gobby clones create feature/my-feature /path/to/clone
+
+        gobby clones create bugfix/fix-123 /tmp/fix --base develop --task #47
+    """
+    daemon_url = get_daemon_url()
+
+    arguments = {
+        "branch_name": branch_name,
+        "clone_path": clone_path,
+        "base_branch": base_branch,
+    }
+
+    if task_id:
+        arguments["task_id"] = task_id
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/create_clone",
+            json=arguments,
+            timeout=300.0,  # Clone can take a while
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        clone_info = result.get("clone", {})
+        click.echo(f"Created clone: {clone_info.get('id', 'unknown')}")
+        click.echo(f"  Branch: {clone_info.get('branch_name', 'unknown')}")
+    else:
+        click.echo(f"Failed to create clone: {result.get('error')}", err=True)
+
+
+@clones.command("spawn")
+@click.argument("clone_ref")
+@click.argument("prompt")
+@click.option(
+    "--parent-session-id",
+    "-p",
+    "parent_session_id",
+    required=True,
+    help="Parent session ID (required)",
+)
+@click.option("--mode", "-m", default="terminal", help="Agent mode (terminal, embedded, headless)")
+@click.option("--workflow", "-w", help="Workflow to activate")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def spawn_agent(
+    clone_ref: str,
+    prompt: str,
+    parent_session_id: str,
+    mode: str,
+    workflow: str | None,
+    json_format: bool,
+) -> None:
+    """Spawn an agent to work in a clone.
+
+    Examples:
+
+        gobby clones spawn clone-123 "Fix the authentication bug"
+
+        gobby clones spawn clone-123 "Implement feature" --mode headless
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    daemon_url = get_daemon_url()
+
+    arguments = {
+        "clone_id": clone_id,
+        "prompt": prompt,
+        "parent_session_id": parent_session_id,
+        "mode": mode,
+    }
+
+    if workflow:
+        arguments["workflow"] = workflow
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/spawn_agent_in_clone",
+            json=arguments,
+            timeout=60.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        session_id = result.get("session_id", "unknown")
+        click.echo(f"Spawned agent in clone {clone_id}")
+        click.echo(f"  Session: {session_id}")
+    else:
+        click.echo(f"Failed to spawn agent: {result.get('error')}", err=True)
+
+
+@clones.command("sync")
+@click.argument("clone_ref")
+@click.option("--direction", "-d", default="pull", help="Sync direction (pull, push, both)")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def sync_clone(clone_ref: str, direction: str, json_format: bool) -> None:
+    """Sync clone with remote.
+
+    Examples:
+
+        gobby clones sync clone-123
+
+        gobby clones sync clone-123 --direction push
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/sync_clone",
+            json={"clone_id": clone_id, "direction": direction},
+            timeout=120.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(f"Synced clone {clone_id}")
+    else:
+        click.echo(f"Failed to sync clone: {result.get('error')}", err=True)
+
+
+@clones.command("merge")
+@click.argument("clone_ref")
+@click.option("--target", "-t", "target_branch", default="main", help="Target branch to merge into")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def merge_clone(clone_ref: str, target_branch: str, json_format: bool) -> None:
+    """Merge clone branch to target branch.
+
+    Examples:
+
+        gobby clones merge clone-123
+
+        gobby clones merge clone-123 --target develop
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/merge_clone_to_target",
+            json={"clone_id": clone_id, "target_branch": target_branch},
+            timeout=120.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(f"Merged clone {clone_id} to {target_branch}")
+    else:
+        # Check for merge conflicts
+        if result.get("has_conflicts"):
+            conflicted = result.get("conflicted_files", [])
+            click.echo(f"Merge conflict in {len(conflicted)} file(s):", err=True)
+            for f in conflicted:
+                click.echo(f"  {f}", err=True)
+        else:
+            click.echo(f"Failed to merge clone: {result.get('error')}", err=True)
+
+
+@clones.command("delete")
+@click.argument("clone_ref")
+@click.option("--force", "-f", is_flag=True, help="Force delete even if active")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def delete_clone(clone_ref: str, force: bool, yes: bool, json_format: bool) -> None:
+    """Delete a clone.
+
+    Examples:
+
+        gobby clones delete clone-123 --yes
+
+        gobby clones delete clone-123 --force --yes
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        if json_format:
+            click.echo(json.dumps({"success": False, "error": f"Clone not found: {clone_ref}"}))
+        else:
+            click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    if not yes and not json_format:
+        click.confirm("Are you sure you want to delete this clone?", abort=True)
+
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/delete_clone",
+            json={"clone_id": clone_id, "force": force},
+            timeout=60.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        if json_format:
+            click.echo(json.dumps({"success": False, "error": "Cannot connect to Gobby daemon"}))
+        else:
+            click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        if json_format:
+            click.echo(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": f"HTTP Error {e.response.status_code}",
+                        "detail": e.response.text,
+                    }
+                )
+            )
+        else:
+            click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        if json_format:
+            click.echo(json.dumps({"success": False, "error": str(e)}))
+        else:
+            click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(f"Deleted clone: {clone_id}")
+    else:
+        click.echo(f"Failed to delete clone: {result.get('error')}", err=True)
+
+
+def resolve_clone_id(manager: LocalCloneManager, clone_ref: str) -> str | None:
+    """Resolve clone reference (UUID or prefix) to full ID."""
+    # Check for exact match first
+    if manager.get(clone_ref):
+        return clone_ref
+
+    # Try prefix match
+    all_clones = manager.list_clones()
+    matches = [c for c in all_clones if c.id.startswith(clone_ref)]
+
+    if not matches:
+        return None
+
+    if len(matches) > 1:
+        click.echo(f"Ambiguous clone reference '{clone_ref}' matches:", err=True)
+        for c in matches:
+            click.echo(f"  {c.id[:8]} ({c.branch_name})", err=True)
+        return None
+
+    return matches[0].id