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

gobby/mcp_proxy/tools/artifacts.py

@@ -25,6 +25,7 @@ if TYPE_CHECKING:
 def create_artifacts_registry(
     db: LocalDatabase | None = None,
     artifact_manager: LocalArtifactManager | None = None,
+    session_manager: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create an artifacts tool registry with all artifact-related tools.
@@ -32,10 +33,21 @@ def create_artifacts_registry(
     Args:
         db: LocalDatabase instance (used to create artifact_manager if not provided)
         artifact_manager: LocalArtifactManager instance
+        session_manager: Session manager for resolving session references
 
     Returns:
         InternalToolRegistry with artifact tools registered
     """
+    from gobby.utils.project_context import get_project_context
+
+    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()
+        project_id = ctx.get("id") if ctx else None
+        return str(session_manager.resolve_session_reference(ref, project_id))
+
     # Create artifact manager if not provided
     if artifact_manager is None:
         if db is None:
@@ -55,7 +67,7 @@ def create_artifacts_registry(
 
     @registry.tool(
         name="search_artifacts",
-        description="Search artifacts by content using full-text search.",
+        description="Search artifacts by content using full-text search. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def search_artifacts(
         query: str,
@@ -68,7 +80,7 @@ def create_artifacts_registry(
 
         Args:
             query: Search query text
-            session_id: Optional session ID to filter by
+            session_id: Optional session reference (accepts #N, N, UUID, or prefix) to filter by
             artifact_type: Optional artifact type to filter by (code, diff, error, etc.)
             limit: Maximum number of results (default: 50)
 
@@ -78,10 +90,18 @@ def create_artifacts_registry(
         if not query or not query.strip():
             return {"success": True, "artifacts": [], "count": 0}
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        if session_id:
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e), "artifacts": []}
+
         try:
             artifacts = _artifact_manager.search_artifacts(
                 query_text=query,
-                session_id=session_id,
+                session_id=resolved_session_id,
                 artifact_type=artifact_type,
                 limit=limit,
             )
@@ -95,7 +115,7 @@ def create_artifacts_registry(
 
     @registry.tool(
         name="list_artifacts",
-        description="List artifacts with optional filters.",
+        description="List artifacts with optional filters. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def list_artifacts(
         session_id: str | None = None,
@@ -107,7 +127,7 @@ def create_artifacts_registry(
         List artifacts with optional filters.
 
         Args:
-            session_id: Optional session ID to filter by
+            session_id: Optional session reference (accepts #N, N, UUID, or prefix) to filter by
             artifact_type: Optional artifact type to filter by
             limit: Maximum number of results (default: 100)
             offset: Offset for pagination (default: 0)
@@ -115,9 +135,17 @@ def create_artifacts_registry(
         Returns:
             Dict with success status and list of artifacts
         """
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        if session_id:
+            try:
+                resolved_session_id = _resolve_session_id(session_id)
+            except ValueError as e:
+                return {"success": False, "error": str(e), "artifacts": []}
+
         try:
             artifacts = _artifact_manager.list_artifacts(
-                session_id=session_id,
+                session_id=resolved_session_id,
                 artifact_type=artifact_type,
                 limit=limit,
                 offset=offset,
@@ -161,7 +189,7 @@ def create_artifacts_registry(
 
     @registry.tool(
         name="get_timeline",
-        description="Get artifacts for a session in chronological order.",
+        description="Get artifacts for a session in chronological order. Accepts #N, N, UUID, or prefix for session_id.",
     )
     def get_timeline(
         session_id: str | None = None,
@@ -172,7 +200,7 @@ def create_artifacts_registry(
         Get artifacts for a session in chronological order (oldest first).
 
         Args:
-            session_id: Required session ID to get timeline for
+            session_id: Required session reference (accepts #N, N, UUID, or prefix) to get timeline for
             artifact_type: Optional artifact type to filter by
             limit: Maximum number of results (default: 100)
 
@@ -186,10 +214,16 @@ def create_artifacts_registry(
                 "artifacts": [],
             }
 
+        # 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), "artifacts": []}
+
         try:
             # Get artifacts (list_artifacts returns newest first by default)
             artifacts = _artifact_manager.list_artifacts(
-                session_id=session_id,
+                session_id=resolved_session_id,
                 artifact_type=artifact_type,
                 limit=limit,
                 offset=0,

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",
+]