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

gobby/mcp_proxy/tools/clones.py

@@ -13,13 +13,11 @@ via the downstream proxy pattern (call_tool, list_tools, get_tool_schema).
 from __future__ import annotations
 
 import logging
-from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 
 if TYPE_CHECKING:
-    from gobby.agents.runner import AgentRunner
     from gobby.clones.git import CloneGitManager
     from gobby.storage.clones import LocalCloneManager
 
@@ -30,7 +28,6 @@ def create_clones_registry(
     clone_storage: LocalCloneManager,
     git_manager: CloneGitManager,
     project_id: str,
-    agent_runner: AgentRunner | None = None,
 ) -> InternalToolRegistry:
     """
     Create the gobby-clones MCP server registry.
@@ -39,7 +36,6 @@ def create_clones_registry(
         clone_storage: Clone storage manager for CRUD operations
         git_manager: Git manager for clone operations
         project_id: Default project ID for new clones
-        agent_runner: Optional agent runner for spawning agents in clones
 
     Returns:
         InternalToolRegistry with clone management tools
@@ -519,385 +515,4 @@ def create_clones_registry(
         func=merge_clone_to_target,
     )
 
-    # ===== spawn_agent_in_clone =====
-    async def spawn_agent_in_clone(
-        prompt: str,
-        branch_name: str,
-        parent_session_id: str | None = None,
-        task_id: str | None = None,
-        base_branch: str = "main",
-        clone_path: str | None = None,
-        mode: str = "terminal",
-        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,
-    ) -> dict[str, Any]:
-        """
-        Create a clone (if needed) and spawn an agent in it.
-
-        This combines clone creation with agent spawning for isolated development.
-        Unlike worktrees, clones are full repository copies that can be worked on
-        independently without affecting the main repository.
-
-        Args:
-            prompt: The task/prompt for the agent.
-            branch_name: Name for the branch in the clone.
-            parent_session_id: Parent session ID for context (required).
-            task_id: Optional task ID to link to this clone.
-            base_branch: Branch to clone from (default: main).
-            clone_path: Optional custom path for the clone.
-            mode: Execution mode (terminal, embedded, headless).
-            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).
-
-        Returns:
-            Dict with clone_id, run_id, and status.
-        """
-        if agent_runner is None:
-            return {
-                "success": False,
-                "error": "Agent runner not configured. Cannot spawn agent.",
-            }
-
-        if parent_session_id is None:
-            return {
-                "success": False,
-                "error": "parent_session_id is required for agent spawning.",
-            }
-
-        # Handle mode aliases and validation
-        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)}. "
-                    f"Note: 'in_process' mode is not supported for spawn_agent_in_clone."
-                ),
-            }
-
-        # Normalize terminal parameter to lowercase
-        if isinstance(terminal, str):
-            terminal = terminal.lower()
-
-        # Check spawn depth limit
-        can_spawn, reason, _depth = agent_runner.can_spawn(parent_session_id)
-        if not can_spawn:
-            return {
-                "success": False,
-                "error": reason,
-            }
-
-        # Check if clone already exists for this branch
-        existing = clone_storage.get_by_branch(project_id, branch_name)
-        if existing:
-            clone = existing
-            logger.info(f"Using existing clone for branch '{branch_name}'")
-        else:
-            # Get remote URL
-            remote_url = git_manager.get_remote_url() if git_manager else None
-            if not remote_url:
-                return {
-                    "success": False,
-                    "error": "No remote URL available. Cannot create clone.",
-                }
-
-            # Generate clone path if not provided
-            if clone_path is None:
-                import platform
-                import tempfile
-
-                if platform.system() == "Windows":
-                    base = Path(tempfile.gettempdir()) / "gobby-clones"
-                else:
-                    # nosec B108: /tmp is intentional for clones - they're temporary
-                    base = Path("/tmp").resolve() / "gobby-clones"  # nosec B108
-                base.mkdir(parents=True, exist_ok=True)
-                safe_branch = branch_name.replace("/", "-")
-                clone_path = str(base / f"{project_id}-{safe_branch}")
-
-            # Create the clone
-            result = git_manager.shallow_clone(
-                remote_url=remote_url,
-                clone_path=clone_path,
-                branch=base_branch,
-                depth=1,
-            )
-
-            if not result.success:
-                return {
-                    "success": False,
-                    "error": f"Clone failed: {result.error or result.message}",
-                }
-
-            # Store clone record
-            clone = clone_storage.create(
-                project_id=project_id,
-                branch_name=branch_name,
-                clone_path=clone_path,
-                base_branch=base_branch,
-                task_id=task_id,
-                remote_url=remote_url,
-            )
-
-        # Import AgentConfig and get machine_id
-        from gobby.agents.runner import AgentConfig
-        from gobby.utils.machine_id import get_machine_id
-
-        machine_id = get_machine_id()
-
-        # Create agent config
-        config = AgentConfig(
-            prompt=prompt,
-            parent_session_id=parent_session_id,
-            project_id=project_id,
-            machine_id=machine_id,
-            source=provider,
-            workflow=workflow,
-            task=task_id,
-            session_context="summary_markdown",
-            mode=mode,
-            terminal=terminal,
-            provider=provider,
-            model=model,
-            max_turns=max_turns,
-            timeout=timeout,
-            project_path=clone.clone_path,
-        )
-
-        # Prepare the run
-        from gobby.llm.executor import AgentResult
-
-        prepare_result = agent_runner.prepare_run(config)
-        if isinstance(prepare_result, AgentResult):
-            return {
-                "success": False,
-                "clone_id": clone.id,
-                "clone_path": clone.clone_path,
-                "branch_name": clone.branch_name,
-                "error": prepare_result.error,
-            }
-
-        context = prepare_result
-        if context.session is None or context.run is None:
-            return {
-                "success": False,
-                "clone_id": clone.id,
-                "error": "Internal error: context missing session or run",
-            }
-
-        child_session = context.session
-        agent_run = context.run
-
-        # Claim clone for the child session
-        clone_storage.claim(clone.id, child_session.id)
-
-        # Build enhanced prompt with clone context
-        context_lines = [
-            "## CRITICAL: Clone Context",
-            "You are working in an ISOLATED git clone, NOT the main repository.",
-            "",
-            f"**Your workspace:** {clone.clone_path}",
-            f"**Your branch:** {clone.branch_name}",
-        ]
-        if task_id:
-            context_lines.append(f"**Your task:** {task_id}")
-        context_lines.extend(
-            [
-                "",
-                "**IMPORTANT RULES:**",
-                f"1. ALL file operations must be within {clone.clone_path}",
-                "2. Do NOT access the main repository",
-                "3. Run `pwd` to verify your location before any file operations",
-                f"4. Commit to YOUR branch ({clone.branch_name})",
-                "5. When your assigned task is complete, STOP - do not claim other tasks",
-                "",
-                "---",
-                "",
-            ]
-        )
-        enhanced_prompt = "\n".join(context_lines) + prompt
-
-        # Spawn based on mode
-        if mode == "terminal":
-            from gobby.agents.spawn import TerminalSpawner
-
-            terminal_spawner = TerminalSpawner()
-            terminal_result = terminal_spawner.spawn_agent(
-                cli=provider,
-                cwd=clone.clone_path,
-                session_id=child_session.id,
-                parent_session_id=parent_session_id,
-                agent_run_id=agent_run.id,
-                project_id=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,
-                    "clone_id": clone.id,
-                    "clone_path": clone.clone_path,
-                    "branch_name": clone.branch_name,
-                    "run_id": agent_run.id,
-                    "child_session_id": child_session.id,
-                    "error": terminal_result.error or terminal_result.message,
-                }
-
-            return {
-                "success": True,
-                "clone_id": clone.id,
-                "clone_path": clone.clone_path,
-                "branch_name": clone.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=clone.clone_path,
-                session_id=child_session.id,
-                parent_session_id=parent_session_id,
-                agent_run_id=agent_run.id,
-                project_id=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,
-                "clone_id": clone.id,
-                "clone_path": clone.clone_path,
-                "branch_name": clone.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=clone.clone_path,
-                session_id=child_session.id,
-                parent_session_id=parent_session_id,
-                agent_run_id=agent_run.id,
-                project_id=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,
-                "clone_id": clone.id,
-                "clone_path": clone.clone_path,
-                "branch_name": clone.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,
-            }
-
-    registry.register(
-        name="spawn_agent_in_clone",
-        description="Create a clone and spawn an agent to work in it",
-        input_schema={
-            "type": "object",
-            "properties": {
-                "prompt": {
-                    "type": "string",
-                    "description": "The task/prompt for the agent",
-                },
-                "branch_name": {
-                    "type": "string",
-                    "description": "Name for the branch in the clone",
-                },
-                "parent_session_id": {
-                    "type": "string",
-                    "description": "Parent session ID for context (required)",
-                },
-                "task_id": {
-                    "type": "string",
-                    "description": "Optional task ID to link to this clone",
-                },
-                "base_branch": {
-                    "type": "string",
-                    "description": "Branch to clone from",
-                    "default": "main",
-                },
-                "clone_path": {
-                    "type": "string",
-                    "description": "Optional custom path for the clone",
-                },
-                "mode": {
-                    "type": "string",
-                    "description": "Execution mode",
-                    "enum": ["terminal", "embedded", "headless"],
-                    "default": "terminal",
-                },
-                "terminal": {
-                    "type": "string",
-                    "description": "Terminal type for terminal/embedded modes",
-                    "default": "auto",
-                },
-                "provider": {
-                    "type": "string",
-                    "description": "LLM provider",
-                    "enum": ["claude", "gemini", "codex", "antigravity"],
-                    "default": "claude",
-                },
-                "model": {
-                    "type": "string",
-                    "description": "Optional model override",
-                },
-                "workflow": {
-                    "type": "string",
-                    "description": "Workflow name to execute",
-                },
-                "timeout": {
-                    "type": "number",
-                    "description": "Execution timeout in seconds",
-                    "default": 120.0,
-                },
-                "max_turns": {
-                    "type": "integer",
-                    "description": "Maximum turns",
-                    "default": 10,
-                },
-            },
-            "required": ["prompt", "branch_name", "parent_session_id"],
-        },
-        func=spawn_agent_in_clone,
-    )
-
     return registry

gobby/mcp_proxy/tools/memory.py

@@ -255,7 +255,7 @@ def create_memory_registry(
         name="get_related_memories",
         description="Get memories related to a specific memory via cross-references.",
     )
-    def get_related_memories(
+    async def get_related_memories(
         memory_id: str,
         limit: int = 5,
         min_similarity: float = 0.0,
@@ -272,7 +272,7 @@ def create_memory_registry(
             min_similarity: Minimum similarity threshold (0.0-1.0)
         """
         try:
-            memories = memory_manager.get_related(
+            memories = await memory_manager.get_related(
                 memory_id=memory_id,
                 limit=limit,
                 min_similarity=min_similarity,

gobby/mcp_proxy/tools/sessions/__init__.py

@@ -0,0 +1,14 @@
+"""Session tools package.
+
+This package provides MCP tools for session management. Re-exports maintain
+backwards compatibility with the original session_messages.py module.
+
+Public API:
+    - create_session_messages_registry: Factory function to create the session tool registry
+"""
+
+from gobby.mcp_proxy.tools.sessions._factory import create_session_messages_registry
+
+__all__ = [
+    "create_session_messages_registry",
+]

gobby/mcp_proxy/tools/sessions/_commits.py

@@ -0,0 +1,232 @@
+"""Commits and workflow tools for session management.
+
+This module contains MCP tools for:
+- Getting session commits (get_session_commits)
+- Marking autonomous loop complete (mark_loop_complete)
+"""
+
+from __future__ import annotations
+
+from datetime import UTC
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+    from gobby.storage.sessions import LocalSessionManager
+
+
+def register_commits_tools(
+    registry: InternalToolRegistry,
+    session_manager: LocalSessionManager,
+) -> None:
+    """
+    Register commits and workflow tools with a registry.
+
+    Args:
+        registry: The InternalToolRegistry to register tools with
+        session_manager: LocalSessionManager instance for session operations
+    """
+
+    @registry.tool(
+        name="get_session_commits",
+        description="Get git commits made during a session timeframe.",
+    )
+    def get_session_commits(
+        session_id: str,
+        max_commits: int = 20,
+    ) -> dict[str, Any]:
+        """
+        Get git commits made during a session's active timeframe.
+
+        Uses session.created_at and session.updated_at to filter
+        git log within that timeframe.
+
+        Args:
+            session_id: Session ID
+            max_commits: Maximum commits to return (default 20)
+
+        Returns:
+            Session ID, list of commits, and count
+        """
+        import subprocess  # nosec B404 - subprocess needed for git commands
+        from datetime import datetime
+        from pathlib import Path
+
+        if session_manager is None:
+            return {"error": "Session manager not available"}
+
+        # Get session
+        session = session_manager.get(session_id)
+        if not session:
+            # Try prefix match
+            sessions = session_manager.list(limit=100)
+            matches = [s for s in sessions if s.id.startswith(session_id)]
+            if len(matches) == 1:
+                session = matches[0]
+            elif len(matches) > 1:
+                return {
+                    "error": f"Ambiguous session ID prefix '{session_id}'",
+                    "matches": [s.id for s in matches[:5]],
+                }
+            else:
+                return {"error": f"Session {session_id} not found"}
+
+        # Get working directory from transcript path or project
+        cwd = None
+        if session.jsonl_path:
+            cwd = str(Path(session.jsonl_path).parent)
+
+        # Format timestamps for git --since/--until
+        # Git expects ISO format or relative dates
+        # Session timestamps may be ISO strings or datetime objects
+        if isinstance(session.created_at, str):
+            since_time = datetime.fromisoformat(session.created_at.replace("Z", "+00:00"))
+        else:
+            since_time = session.created_at
+
+        if session.updated_at:
+            if isinstance(session.updated_at, str):
+                until_time = datetime.fromisoformat(session.updated_at.replace("Z", "+00:00"))
+            else:
+                until_time = session.updated_at
+        else:
+            until_time = datetime.now(UTC)
+
+        # Format as ISO 8601 for git
+        since_str = since_time.strftime("%Y-%m-%dT%H:%M:%S")
+        until_str = until_time.strftime("%Y-%m-%dT%H:%M:%S")
+
+        try:
+            # Get commits within timeframe
+            cmd = [
+                "git",
+                "log",
+                f"--since={since_str}",
+                f"--until={until_str}",
+                f"-{max_commits}",
+                "--format=%H|%s|%aI",  # hash|subject|author-date-iso
+            ]
+
+            result = subprocess.run(  # nosec B603 - cmd built from hardcoded git arguments
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=10,
+                cwd=cwd,
+            )
+
+            if result.returncode != 0:
+                return {
+                    "session_id": session.id,
+                    "error": "Git command failed",
+                    "stderr": result.stderr.strip(),
+                }
+
+            commits = []
+            for line in result.stdout.strip().split("\n"):
+                if "|" in line:
+                    parts = line.split("|", 2)
+                    if len(parts) >= 2:
+                        commit = {
+                            "hash": parts[0],
+                            "message": parts[1],
+                        }
+                        if len(parts) >= 3:
+                            commit["timestamp"] = parts[2]
+                        commits.append(commit)
+
+            return {
+                "session_id": session.id,
+                "commits": commits,
+                "count": len(commits),
+                "timeframe": {
+                    "since": since_str,
+                    "until": until_str,
+                },
+            }
+
+        except subprocess.TimeoutExpired:
+            return {
+                "session_id": session.id,
+                "error": "Git command timed out",
+            }
+        except FileNotFoundError:
+            return {
+                "session_id": session.id,
+                "error": "Git not found or not a git repository",
+            }
+        except Exception as e:
+            return {
+                "session_id": session.id,
+                "error": f"Failed to get commits: {e!s}",
+            }
+
+    @registry.tool(
+        name="mark_loop_complete",
+        description="""Mark the autonomous loop as complete, preventing session chaining.
+
+Args:
+    session_id: (REQUIRED) Your session ID. Get it from:
+        1. Your injected context (look for 'session_id: xxx')
+        2. Or call get_current(external_id, source) first""",
+    )
+    def mark_loop_complete(session_id: str) -> dict[str, Any]:
+        """
+        Mark the autonomous loop as complete for a session.
+
+        This sets stop_reason='completed' in the workflow state, which
+        signals the auto-loop workflow to NOT chain a new session
+        when this session ends.
+
+        Use this when:
+        - A task is fully complete and no more work is needed
+        - You want to exit the autonomous loop gracefully
+        - The user has explicitly asked to stop
+
+        Args:
+            session_id: Session ID (REQUIRED)
+
+        Returns:
+            Success status and session details
+        """
+        if not session_manager:
+            raise RuntimeError("Session manager not available")
+
+        # Find session - session_id is now required
+        session = session_manager.get(session_id)
+
+        if not session:
+            return {"error": f"Session {session_id} not found", "session_id": session_id}
+
+        # Load and update workflow state
+        from gobby.storage.database import LocalDatabase
+        from gobby.workflows.definitions import WorkflowState
+        from gobby.workflows.state_manager import WorkflowStateManager
+
+        db = LocalDatabase()
+        state_manager = WorkflowStateManager(db)
+
+        # Get or create state for session
+        state = state_manager.get_state(session.id)
+        if not state:
+            # Create minimal state just to hold the variable
+            state = WorkflowState(
+                session_id=session.id,
+                workflow_name="auto-loop",
+                step="active",
+            )
+
+        # Mark loop complete using the action function
+        from gobby.workflows.state_actions import mark_loop_complete as action_mark_complete
+
+        action_mark_complete(state)
+
+        # Save updated state
+        state_manager.save_state(state)
+
+        return {
+            "success": True,
+            "session_id": session.id,
+            "stop_reason": "completed",
+            "message": "Autonomous loop marked complete - session will not chain",
+        }