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

gobby/mcp_proxy/tools/tasks/_lifecycle_validation.py

@@ -53,7 +53,7 @@ def validate_commit_requirements(
             can_close=False,
             error_type="no_commits_linked",
             message=(
-                "A commit is required before closing this task.\n\n"
+                "\nA commit is required before closing this task.\n\n"
                 "**Normal flow:**\n"
                 '1. Commit your changes: git commit -m "[#N] description"\n'
                 '2. Close with commit_sha: close_task(task_id="#N", commit_sha="<sha>")\n\n'

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,6 @@ def create_worktrees_registry(
     worktree_storage: LocalWorktreeManager,
     git_manager: WorktreeGitManager | None = None,
     project_id: str | None = None,
-    agent_runner: AgentRunner | None = None,
 ) -> InternalToolRegistry:
     """
     Create a worktree tool registry with all worktree-related tools.
@@ -300,7 +295,6 @@ 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.
 
     Returns:
         InternalToolRegistry with all worktree tools registered.
@@ -929,341 +923,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/ingestion/__init__.py

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

gobby/memory/ingestion/multimodal.py

@@ -0,0 +1,221 @@
+"""Multimodal content ingestion for memory system."""
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from gobby.memory.protocol import MediaAttachment
+from gobby.storage.memories import Memory
+
+if TYPE_CHECKING:
+    from gobby.llm.service import LLMService
+    from gobby.memory.protocol import MemoryBackendProtocol
+    from gobby.storage.memories import LocalMemoryManager
+
+logger = logging.getLogger(__name__)
+
+
+class MultimodalIngestor:
+    """
+    Handles ingestion of multimodal content (images, screenshots) into memory.
+
+    Extracts image handling from MemoryManager to provide focused
+    multimodal processing capabilities.
+    """
+
+    def __init__(
+        self,
+        storage: LocalMemoryManager,
+        backend: MemoryBackendProtocol,
+        llm_service: LLMService | None = None,
+    ):
+        """
+        Initialize the multimodal ingestor.
+
+        Args:
+            storage: Memory storage manager for persistence
+            backend: Memory backend protocol for creating records
+            llm_service: LLM service for image description
+        """
+        self._storage = storage
+        self._backend = backend
+        self._llm_service = llm_service
+
+    @property
+    def llm_service(self) -> LLMService | None:
+        """Get the LLM service for image description."""
+        return self._llm_service
+
+    @llm_service.setter
+    def llm_service(self, service: LLMService | None) -> None:
+        """Set the LLM service for image description."""
+        self._llm_service = service
+
+    async def remember_with_image(
+        self,
+        image_path: str,
+        context: str | None = None,
+        memory_type: str = "fact",
+        importance: float = 0.5,
+        project_id: str | None = None,
+        source_type: str = "user",
+        source_session_id: str | None = None,
+        tags: list[str] | None = None,
+    ) -> Memory:
+        """
+        Store a memory with an image attachment.
+
+        Uses the configured LLM provider to generate a description of the image,
+        then stores the memory with the description as content and the image
+        as a media attachment.
+
+        Args:
+            image_path: Path to the image file
+            context: Optional context to guide the image description
+            memory_type: Type of memory (fact, preference, etc)
+            importance: 0.0-1.0 importance score
+            project_id: Optional project context
+            source_type: Origin of memory
+            source_session_id: Origin session
+            tags: Optional tags
+
+        Returns:
+            The created Memory object
+
+        Raises:
+            ValueError: If LLM service is not configured or image not found
+        """
+        path = Path(image_path)
+        if not path.exists():
+            raise ValueError(f"Image not found: {image_path}")
+
+        # Get LLM provider for image description
+        if not self._llm_service:
+            raise ValueError(
+                "LLM service not configured. Pass llm_service to MemoryManager "
+                "to enable remember_with_image."
+            )
+
+        provider = self._llm_service.get_default_provider()
+
+        # Generate image description
+        description = await provider.describe_image(image_path, context=context)
+
+        # Determine MIME type
+        mime_type, _ = mimetypes.guess_type(str(path))
+        if not mime_type:
+            mime_type = "application/octet-stream"
+
+        # Create media attachment
+        media = MediaAttachment(
+            media_type="image",
+            content_path=str(path.absolute()),
+            mime_type=mime_type,
+            description=description,
+            description_model=provider.provider_name,
+        )
+
+        # Store memory with media attachment via backend
+        record = await self._backend.create(
+            content=description,
+            memory_type=memory_type,
+            importance=importance,
+            project_id=project_id,
+            source_type=source_type,
+            source_session_id=source_session_id,
+            tags=tags,
+            media=[media],
+        )
+
+        # Return as Memory object for backward compatibility
+        # Note: The backend returns MemoryRecord, but we need Memory
+        memory = self._storage.get_memory(record.id)
+        if memory is not None:
+            return memory
+
+        # Fallback: construct Memory from MemoryRecord if storage lookup fails
+        # This can happen with synthetic records from failed backend calls
+        return Memory(
+            id=record.id,
+            content=record.content,
+            memory_type=record.memory_type,
+            created_at=record.created_at.isoformat(),
+            updated_at=record.updated_at.isoformat()
+            if record.updated_at
+            else record.created_at.isoformat(),
+            project_id=record.project_id,
+            source_type=record.source_type,
+            source_session_id=record.source_session_id,
+            importance=record.importance,
+            tags=record.tags,
+        )
+
+    async def remember_screenshot(
+        self,
+        screenshot_bytes: bytes,
+        context: str | None = None,
+        memory_type: str = "observation",
+        importance: float = 0.5,
+        project_id: str | None = None,
+        source_type: str = "user",
+        source_session_id: str | None = None,
+        tags: list[str] | None = None,
+    ) -> Memory:
+        """
+        Store a memory from raw screenshot bytes.
+
+        Saves the screenshot to .gobby/resources/ with a timestamp-based filename,
+        then delegates to remember_with_image() for LLM description and storage.
+
+        Args:
+            screenshot_bytes: Raw PNG screenshot bytes (from Playwright/Puppeteer)
+            context: Optional context to guide the image description
+            memory_type: Type of memory (default: "observation")
+            importance: 0.0-1.0 importance score
+            project_id: Optional project context
+            source_type: Origin of memory
+            source_session_id: Origin session
+            tags: Optional tags
+
+        Returns:
+            The created Memory object
+
+        Raises:
+            ValueError: If LLM service is not configured or screenshot bytes are empty
+        """
+        if not screenshot_bytes:
+            raise ValueError("Screenshot bytes cannot be empty")
+
+        # Determine resources directory using centralized utility
+        from datetime import datetime as dt
+
+        from gobby.cli.utils import get_resources_dir
+        from gobby.utils.project_context import get_project_context
+
+        ctx = get_project_context()
+        project_path = ctx.get("path") if ctx else None
+        resources_dir = get_resources_dir(project_path)
+
+        # Generate timestamp-based filename
+        timestamp = dt.now().strftime("%Y%m%d_%H%M%S_%f")
+        filename = f"screenshot_{timestamp}.png"
+        filepath = resources_dir / filename
+
+        # Write screenshot to file
+        filepath.write_bytes(screenshot_bytes)
+        logger.debug(f"Saved screenshot to {filepath}")
+
+        # Delegate to remember_with_image
+        return await self.remember_with_image(
+            image_path=str(filepath),
+            context=context,
+            memory_type=memory_type,
+            importance=importance,
+            project_id=project_id,
+            source_type=source_type,
+            source_session_id=source_session_id,
+            tags=tags,
+        )