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

gobby/mcp_proxy/tools/worktrees.py

@@ -22,13 +22,9 @@ from typing import TYPE_CHECKING, Any, Literal, cast
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 from gobby.utils.project_context import get_project_context
-from gobby.workflows.definitions import WorkflowState
-from gobby.workflows.loader import WorkflowLoader
-from gobby.workflows.state_manager import WorkflowStateManager
 from gobby.worktrees.git import WorktreeGitManager
 
 if TYPE_CHECKING:
-    from gobby.agents.runner import AgentRunner
     from gobby.storage.worktrees import LocalWorktreeManager
     from gobby.worktrees.git import WorktreeGitManager
 
@@ -291,7 +287,7 @@ def create_worktrees_registry(
     worktree_storage: LocalWorktreeManager,
     git_manager: WorktreeGitManager | None = None,
     project_id: str | None = None,
-    agent_runner: AgentRunner | None = None,
+    session_manager: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create a worktree tool registry with all worktree-related tools.
@@ -300,11 +296,20 @@ def create_worktrees_registry(
         worktree_storage: LocalWorktreeManager for database operations.
         git_manager: WorktreeGitManager for git operations.
         project_id: Default project ID for operations.
-        agent_runner: AgentRunner for spawning agents in worktrees.
+        session_manager: Session manager for resolving session references.
 
     Returns:
         InternalToolRegistry with all worktree tools registered.
     """
+
+    def _resolve_session_id(ref: str) -> str:
+        """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+        if session_manager is None:
+            return ref  # No resolution available, return as-is
+        ctx = get_project_context()
+        proj_id = ctx.get("id") if ctx else project_id
+        return str(session_manager.resolve_session_reference(ref, proj_id))
+
     registry = InternalToolRegistry(
         name="gobby-worktrees",
         description="Git worktree management - create, manage, and cleanup isolated development directories",
@@ -441,7 +446,7 @@ def create_worktrees_registry(
 
     @registry.tool(
         name="list_worktrees",
-        description="List worktrees with optional filters.",
+        description="List worktrees with optional filters. Accepts #N, N, UUID, or prefix for agent_session_id.",
     )
     async def list_worktrees(
         status: str | None = None,
@@ -453,16 +458,24 @@ def create_worktrees_registry(
 
         Args:
             status: Filter by status (active, stale, merged, abandoned).
-            agent_session_id: Filter by owning session.
+            agent_session_id: Session reference (accepts #N, N, UUID, or prefix) to filter by owning session.
             limit: Maximum results (default: 50).
 
         Returns:
             Dict with list of worktrees.
         """
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = agent_session_id
+        if agent_session_id:
+            try:
+                resolved_session_id = _resolve_session_id(agent_session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e)}
+
         worktrees = worktree_storage.list_worktrees(
             project_id=project_id,
             status=status,
-            agent_session_id=agent_session_id,
+            agent_session_id=resolved_session_id,
             limit=limit,
         )
 
@@ -485,7 +498,7 @@ def create_worktrees_registry(
 
     @registry.tool(
         name="claim_worktree",
-        description="Claim ownership of a worktree for an agent session.",
+        description="Claim ownership of a worktree for an agent session. Accepts #N, N, UUID, or prefix for session_id.",
     )
     async def claim_worktree(
         worktree_id: str,
@@ -496,11 +509,17 @@ def create_worktrees_registry(
 
         Args:
             worktree_id: The worktree ID to claim.
-            session_id: The session ID claiming ownership.
+            session_id: Session reference (accepts #N, N, UUID, or prefix) claiming ownership.
 
         Returns:
             Dict with success status.
         """
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = _resolve_session_id(session_id)
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
         worktree = worktree_storage.get(worktree_id)
         if not worktree:
             return {
@@ -508,13 +527,13 @@ def create_worktrees_registry(
                 "error": f"Worktree '{worktree_id}' not found",
             }
 
-        if worktree.agent_session_id and worktree.agent_session_id != session_id:
+        if worktree.agent_session_id and worktree.agent_session_id != resolved_session_id:
             return {
                 "success": False,
                 "error": f"Worktree already claimed by session '{worktree.agent_session_id}'",
             }
 
-        updated = worktree_storage.claim(worktree_id, session_id)
+        updated = worktree_storage.claim(worktree_id, resolved_session_id)
         if not updated:
             return {"error": "Failed to claim worktree"}
 
@@ -929,341 +948,4 @@ def create_worktrees_registry(
 
         return {}
 
-    @registry.tool(
-        name="spawn_agent_in_worktree",
-        description="Create a worktree and spawn an agent in it.",
-    )
-    async def spawn_agent_in_worktree(
-        prompt: str,
-        branch_name: str,
-        base_branch: str = "main",
-        task_id: str | None = None,
-        parent_session_id: str | None = None,
-        mode: str = "terminal",  # Note: in_process mode is not supported
-        terminal: str = "auto",
-        provider: Literal["claude", "gemini", "codex", "antigravity"] = "claude",
-        model: str | None = None,
-        workflow: str | None = None,
-        timeout: float = 120.0,
-        max_turns: int = 10,
-        project_path: str | None = None,
-    ) -> dict[str, Any]:
-        """
-        Create a worktree and spawn an agent to work in it.
-
-        This combines worktree creation with agent spawning for isolated development.
-
-        Args:
-            prompt: The task/prompt for the agent.
-            branch_name: Name for the new branch/worktree.
-            base_branch: Branch to base the worktree on (default: main).
-            task_id: Optional task ID to link to this worktree.
-            parent_session_id: Parent session ID for context.
-            mode: Execution mode (terminal, embedded, headless). Note: in_process is not supported.
-            terminal: Terminal for terminal/embedded modes (auto, ghostty, etc.).
-            provider: LLM provider (claude, gemini, etc.).
-            model: Optional model override.
-            workflow: Workflow name to execute.
-            timeout: Execution timeout in seconds (default: 120).
-            max_turns: Maximum turns (default: 10).
-            project_path: Path to project directory (pass cwd from CLI).
-
-        Returns:
-            Dict with worktree_id, run_id, and status.
-        """
-        if agent_runner is None:
-            return {
-                "success": False,
-                "error": "Agent runner not configured. Cannot spawn agent.",
-            }
-
-        # Resolve project context
-        resolved_git_mgr, resolved_project_id, error = _resolve_project_context(
-            project_path, git_manager, project_id
-        )
-        if error:
-            return {"success": False, "error": error}
-
-        # Type narrowing: if no error, these are guaranteed non-None
-        if resolved_git_mgr is None or resolved_project_id is None:
-            raise RuntimeError("Git manager or project ID unexpectedly None")
-
-        if parent_session_id is None:
-            return {
-                "success": False,
-                "error": "parent_session_id is required for agent spawning.",
-            }
-
-        # Handle mode aliases and validation
-        # "interactive" is an alias for "terminal" mode
-        if mode == "interactive":
-            mode = "terminal"
-
-        valid_modes = ["terminal", "embedded", "headless"]
-        if mode not in valid_modes:
-            return {
-                "success": False,
-                "error": (
-                    f"Invalid mode '{mode}'. Must be one of: {', '.join(valid_modes)} (or 'interactive' as alias for 'terminal'). "
-                    f"Note: 'in_process' mode is not supported for spawn_agent_in_worktree."
-                ),
-            }
-
-        # Normalize terminal parameter to lowercase for enum compatibility
-        # (TerminalType enum values are lowercase, e.g., "terminal.app" not "Terminal.app")
-        if isinstance(terminal, str):
-            terminal = terminal.lower()
-
-        # Default to 'worktree-agent' workflow if not specified
-        # This workflow restricts tools available to spawned agents in worktrees
-        if workflow is None:
-            workflow = "worktree-agent"
-
-        # Validate workflow (reject lifecycle workflows)
-        if workflow:
-            workflow_loader = WorkflowLoader()
-            is_valid, error_msg = workflow_loader.validate_workflow_for_agent(
-                workflow, project_path=project_path
-            )
-            if not is_valid:
-                return {
-                    "success": False,
-                    "error": error_msg,
-                }
-
-        # Check if worktree already exists for this branch
-        existing = worktree_storage.get_by_branch(resolved_project_id, branch_name)
-        if existing:
-            # Use existing worktree
-            worktree = existing
-            logger.info(f"Using existing worktree for branch '{branch_name}'")
-        else:
-            # Generate worktree path in temp directory
-            project_name = Path(resolved_git_mgr.repo_path).name
-            worktree_path = _generate_worktree_path(branch_name, project_name)
-
-            # Create git worktree
-            result = resolved_git_mgr.create_worktree(
-                worktree_path=worktree_path,
-                branch_name=branch_name,
-                base_branch=base_branch,
-                create_branch=True,
-            )
-
-            if not result.success:
-                return {
-                    "success": False,
-                    "error": result.error or "Failed to create git worktree",
-                }
-
-            # Record in database
-            worktree = worktree_storage.create(
-                project_id=resolved_project_id,
-                branch_name=branch_name,
-                worktree_path=worktree_path,
-                base_branch=base_branch,
-                task_id=task_id,
-            )
-
-        # Copy project.json and install provider hooks
-        _copy_project_json_to_worktree(resolved_git_mgr.repo_path, worktree.worktree_path)
-        _install_provider_hooks(provider, worktree.worktree_path)
-
-        # Check spawn depth limit
-        can_spawn, reason, _depth = agent_runner.can_spawn(parent_session_id)
-        if not can_spawn:
-            return {
-                "success": False,
-                "error": reason,
-                "worktree_id": worktree.id,
-            }
-
-        # Import AgentConfig and get machine_id
-        from gobby.agents.runner import AgentConfig
-        from gobby.utils.machine_id import get_machine_id
-
-        # Auto-detect machine_id if not provided
-        machine_id = get_machine_id()
-
-        # Create agent config with worktree
-        config = AgentConfig(
-            prompt=prompt,
-            parent_session_id=parent_session_id,
-            project_id=resolved_project_id,
-            machine_id=machine_id,
-            source=provider,
-            workflow=workflow,
-            task=task_id,
-            session_context="summary_markdown",
-            mode=mode,
-            terminal=terminal,
-            worktree_id=worktree.id,
-            provider=provider,
-            model=model,
-            max_turns=max_turns,
-            timeout=timeout,
-            project_path=worktree.worktree_path,
-        )
-
-        # For terminal/embedded/headless modes, use prepare_run + spawner
-        # (runner.run() is only for in_process mode)
-        from gobby.llm.executor import AgentResult
-
-        prepare_result = agent_runner.prepare_run(config)
-        if isinstance(prepare_result, AgentResult):
-            # prepare_run returns AgentResult on error
-            return {
-                "success": False,
-                "worktree_id": worktree.id,
-                "worktree_path": worktree.worktree_path,
-                "branch_name": worktree.branch_name,
-                "error": prepare_result.error,
-            }
-
-        # Successfully prepared - we have context with session and run
-        context = prepare_result
-
-        if context.session is None or context.run is None:
-            return {
-                "success": False,
-                "worktree_id": worktree.id,
-                "error": "Internal error: context missing session or run after prepare_run",
-            }
-
-        child_session = context.session
-        agent_run = context.run
-
-        # Claim worktree for the child session
-        worktree_storage.claim(worktree.id, child_session.id)
-
-        # Pre-save workflow state with session_task if task_id is provided
-        # This ensures suggest_next_task() will scope to this task's subtasks
-        if task_id and workflow:
-            try:
-                workflow_state_manager = WorkflowStateManager(worktree_storage.db)
-                initial_state = WorkflowState(
-                    session_id=child_session.id,
-                    workflow_name=workflow,
-                    step="",  # Will be set when workflow actually starts
-                    variables={"session_task": task_id},
-                )
-                workflow_state_manager.save_state(initial_state)
-                logger.debug(
-                    f"Pre-saved workflow state for session {child_session.id} "
-                    f"with session_task={task_id}"
-                )
-            except Exception as e:
-                logger.warning(f"Failed to pre-save workflow state: {e}")
-                # Continue anyway - this is an optimization, not a requirement
-
-        # Build enhanced prompt with worktree context
-        # This helps the agent understand it's in an isolated worktree, not the main repo
-        enhanced_prompt = _build_worktree_context_prompt(
-            original_prompt=prompt,
-            worktree_path=worktree.worktree_path,
-            branch_name=worktree.branch_name,
-            task_id=task_id,
-            main_repo_path=str(resolved_git_mgr.repo_path),
-        )
-
-        # Spawn in terminal using TerminalSpawner
-        if mode == "terminal":
-            from gobby.agents.spawn import TerminalSpawner
-
-            terminal_spawner = TerminalSpawner()
-            terminal_result = terminal_spawner.spawn_agent(
-                cli=provider,  # claude, gemini, codex
-                cwd=worktree.worktree_path,
-                session_id=child_session.id,
-                parent_session_id=parent_session_id,
-                agent_run_id=agent_run.id,
-                project_id=resolved_project_id,
-                workflow_name=workflow,
-                agent_depth=child_session.agent_depth,
-                max_agent_depth=agent_runner._child_session_manager.max_agent_depth,
-                terminal=terminal,
-                prompt=enhanced_prompt,
-            )
-
-            if not terminal_result.success:
-                return {
-                    "success": False,
-                    "worktree_id": worktree.id,
-                    "worktree_path": worktree.worktree_path,
-                    "branch_name": worktree.branch_name,
-                    "run_id": agent_run.id,
-                    "child_session_id": child_session.id,
-                    "error": terminal_result.error or terminal_result.message,
-                }
-
-            return {
-                "success": True,
-                "worktree_id": worktree.id,
-                "worktree_path": worktree.worktree_path,
-                "branch_name": worktree.branch_name,
-                "run_id": agent_run.id,
-                "child_session_id": child_session.id,
-                "status": "pending",
-                "message": f"Agent spawned in {terminal_result.terminal_type} (PID: {terminal_result.pid})",
-                "terminal_type": terminal_result.terminal_type,
-                "pid": terminal_result.pid,
-            }
-
-        elif mode == "embedded":
-            from gobby.agents.spawn import EmbeddedSpawner
-
-            embedded_spawner = EmbeddedSpawner()
-            embedded_result = embedded_spawner.spawn_agent(
-                cli=provider,
-                cwd=worktree.worktree_path,
-                session_id=child_session.id,
-                parent_session_id=parent_session_id,
-                agent_run_id=agent_run.id,
-                project_id=resolved_project_id,
-                workflow_name=workflow,
-                agent_depth=child_session.agent_depth,
-                max_agent_depth=agent_runner._child_session_manager.max_agent_depth,
-                prompt=enhanced_prompt,
-            )
-
-            return {
-                "success": embedded_result.success,
-                "worktree_id": worktree.id,
-                "worktree_path": worktree.worktree_path,
-                "branch_name": worktree.branch_name,
-                "run_id": agent_run.id,
-                "child_session_id": child_session.id,
-                "status": "pending" if embedded_result.success else "error",
-                "error": embedded_result.error if not embedded_result.success else None,
-            }
-
-        else:  # headless
-            from gobby.agents.spawn import HeadlessSpawner
-
-            headless_spawner = HeadlessSpawner()
-            headless_result = headless_spawner.spawn_agent(
-                cli=provider,
-                cwd=worktree.worktree_path,
-                session_id=child_session.id,
-                parent_session_id=parent_session_id,
-                agent_run_id=agent_run.id,
-                project_id=resolved_project_id,
-                workflow_name=workflow,
-                agent_depth=child_session.agent_depth,
-                max_agent_depth=agent_runner._child_session_manager.max_agent_depth,
-                prompt=enhanced_prompt,
-            )
-
-            return {
-                "success": headless_result.success,
-                "worktree_id": worktree.id,
-                "worktree_path": worktree.worktree_path,
-                "branch_name": worktree.branch_name,
-                "run_id": agent_run.id,
-                "child_session_id": child_session.id,
-                "status": "pending" if headless_result.success else "error",
-                "pid": headless_result.pid if headless_result.success else None,
-                "error": headless_result.error if not headless_result.success else None,
-            }
-
     return registry

gobby/memory/extractor.py

@@ -153,10 +153,15 @@ class SessionMemoryExtractor:
         """
         session = self.session_manager.get(session_id)
         if not session:
+            logger.warning(f"Session not found for memory extraction: {session_id}")
             return None
 
-        # Get project info
+        # Get project info - log for debugging NULL project_id issues
         project_id = session.project_id
+        logger.debug(
+            f"Memory extraction context: session={session_id}, "
+            f"project_id={project_id!r} (type={type(project_id).__name__})"
+        )
         project_name = "Unknown Project"
 
         if project_id:
@@ -461,6 +466,15 @@ class SessionMemoryExtractor:
             session_id: Source session ID
             project_id: Project ID for the memories
         """
+        # Log project_id for debugging NULL project_id issues
+        if project_id is None:
+            logger.warning(
+                f"Storing memories with NULL project_id for session {session_id}. "
+                "This may cause duplicate detection issues."
+            )
+        else:
+            logger.debug(f"Storing {len(candidates)} memories with project_id={project_id}")
+
         for candidate in candidates:
             try:
                 await self.memory_manager.remember(

gobby/memory/ingestion/__init__.py

@@ -0,0 +1,5 @@
+"""Memory ingestion components for multimodal content."""
+
+from gobby.memory.ingestion.multimodal import MultimodalIngestor
+
+__all__ = ["MultimodalIngestor"]