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

gobby/mcp_proxy/tools/workflows/_terminal.py

@@ -0,0 +1,139 @@
+"""
+Terminal tools for workflows.
+"""
+
+import asyncio
+import logging
+import os
+import stat
+import subprocess  # nosec B404
+from pathlib import Path
+from typing import Any
+
+from gobby.paths import get_install_dir
+
+logger = logging.getLogger(__name__)
+
+
+async def close_terminal(
+    signal: str = "TERM",
+    delay_ms: int = 0,
+) -> dict[str, Any]:
+    """
+    Close the current terminal by running the agent shutdown script.
+
+    This is for agent self-termination (meeseeks-style). The agent calls
+    this to close its own terminal window when done with its workflow.
+
+    The script is located at ~/.gobby/scripts/agent_shutdown.sh and is
+    automatically rebuilt if missing. It handles different terminal types
+    (tmux, iTerm, Terminal.app, Ghostty, Kitty, WezTerm, etc.).
+
+    Args:
+        signal: Signal to use for shutdown (TERM, KILL, INT). Default: TERM.
+        delay_ms: Optional delay in milliseconds before shutdown. Default: 0.
+
+    Returns:
+        Dict with success status and message.
+    """
+    # Script location
+    gobby_dir = Path.home() / ".gobby"
+    scripts_dir = gobby_dir / "scripts"
+    script_path = scripts_dir / "agent_shutdown.sh"
+
+    # Source script from the install directory (single source of truth)
+    source_script_path = get_install_dir() / "shared" / "scripts" / "agent_shutdown.sh"
+
+    def get_script_version(script_content: str) -> str | None:
+        """Extract VERSION marker from script content."""
+        import re
+
+        match = re.search(r"^# VERSION:\s*(.+)$", script_content, re.MULTILINE)
+        return match.group(1).strip() if match else None
+
+    # Ensure directories exist and script is present/up-to-date
+    script_rebuilt = False
+    try:
+        scripts_dir.mkdir(parents=True, exist_ok=True)
+
+        # Read source script content
+        if source_script_path.exists():
+            source_content = source_script_path.read_text()
+            source_version = get_script_version(source_content)
+        else:
+            logger.warning(f"Source shutdown script not found at {source_script_path}")
+            source_content = None
+            source_version = None
+
+        # Check if installed script exists and compare versions
+        needs_rebuild = False
+        if not script_path.exists():
+            needs_rebuild = True
+        elif source_content:
+            installed_content = script_path.read_text()
+            installed_version = get_script_version(installed_content)
+            # Rebuild if versions differ or installed has no version marker
+            if installed_version != source_version:
+                needs_rebuild = True
+                logger.info(
+                    f"Shutdown script version mismatch: installed={installed_version}, source={source_version}"
+                )
+
+        if needs_rebuild:
+            if not source_content:
+                logger.error(
+                    f"Cannot rebuild shutdown script at {script_path}: "
+                    f"source script not found at {source_script_path}"
+                )
+                return {
+                    "success": False,
+                    "error": f"Source shutdown script not found at {source_script_path}",
+                }
+            script_path.write_text(source_content)
+            # Make executable
+            script_path.chmod(script_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP)
+            script_rebuilt = True
+            logger.info(f"Created/updated agent shutdown script at {script_path}")
+    except OSError as e:
+        return {
+            "success": False,
+            "error": f"Failed to create shutdown script: {e}",
+        }
+
+    # Validate signal
+    valid_signals = {"TERM", "KILL", "INT", "HUP", "QUIT"}
+    if signal.upper() not in valid_signals:
+        return {
+            "success": False,
+            "error": f"Invalid signal '{signal}'. Valid: {valid_signals}",
+        }
+
+    # Apply delay before launching script (non-blocking)
+    if delay_ms > 0:
+        await asyncio.sleep(delay_ms / 1000.0)
+
+    # Launch the script
+    try:
+        # Run in background - we don't wait for it since it kills our process
+        env = os.environ.copy()
+
+        subprocess.Popen(  # nosec B603 - script path is from gobby scripts directory
+            [str(script_path), signal.upper(), "0"],  # Delay already applied
+            env=env,
+            start_new_session=True,  # Detach from parent
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        return {
+            "success": True,
+            "message": "Shutdown script launched",
+            "script_path": str(script_path),
+            "script_rebuilt": script_rebuilt,
+            "signal": signal.upper(),
+        }
+    except OSError as e:
+        return {
+            "success": False,
+            "error": f"Failed to launch shutdown script: {e}",
+        }

gobby/mcp_proxy/tools/worktrees.py

@@ -287,6 +287,7 @@ def create_worktrees_registry(
     worktree_storage: LocalWorktreeManager,
     git_manager: WorktreeGitManager | None = None,
     project_id: str | None = None,
+    session_manager: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create a worktree tool registry with all worktree-related tools.
@@ -295,10 +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.
+        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",
@@ -435,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,
@@ -447,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,
         )
 
@@ -479,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,
@@ -490,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 {
@@ -502,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"}
 

gobby/memory/components/ingestion.py

@@ -0,0 +1,98 @@
+"""
+Component for handling Memory Manager's multimodal ingestion logic.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from gobby.memory.ingestion import MultimodalIngestor
+from gobby.memory.protocol import MemoryBackendProtocol
+from gobby.storage.memories import LocalMemoryManager, Memory
+
+if TYPE_CHECKING:
+    from gobby.llm.service import LLMService
+
+logger = logging.getLogger(__name__)
+
+
+class IngestionService:
+    """Service for handling memory ingestion, particularly multimodal content."""
+
+    def __init__(
+        self,
+        storage: LocalMemoryManager,
+        backend: MemoryBackendProtocol,
+        llm_service: LLMService | None = None,
+    ):
+        self.storage = storage
+        self._backend = backend
+        self._llm_service = llm_service
+
+        self._multimodal_ingestor = MultimodalIngestor(
+            storage=storage,
+            backend=backend,
+            llm_service=llm_service,
+        )
+
+    @property
+    def llm_service(self) -> LLMService | None:
+        """Get the LLM service."""
+        return self._llm_service
+
+    @llm_service.setter
+    def llm_service(self, service: LLMService | None) -> None:
+        """Set the LLM service and propagate to ingestor."""
+        self._llm_service = service
+        self._multimodal_ingestor.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.
+        """
+        return await self._multimodal_ingestor.remember_with_image(
+            image_path=image_path,
+            context=context,
+            memory_type=memory_type,
+            importance=importance,
+            project_id=project_id,
+            source_type=source_type,
+            source_session_id=source_session_id,
+            tags=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.
+        """
+        return await self._multimodal_ingestor.remember_screenshot(
+            screenshot_bytes=screenshot_bytes,
+            context=context,
+            memory_type=memory_type,
+            importance=importance,
+            project_id=project_id,
+            source_type=source_type,
+            source_session_id=source_session_id,
+            tags=tags,
+        )

gobby/memory/components/search.py

@@ -0,0 +1,108 @@
+"""
+Component for handling Memory Manager's search and cross-referencing logic.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from gobby.config.persistence import MemoryConfig
+from gobby.memory.search.coordinator import SearchCoordinator
+from gobby.memory.services.crossref import CrossrefService
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.memories import LocalMemoryManager, Memory
+
+logger = logging.getLogger(__name__)
+
+
+class SearchService:
+    """Service for handling memory search and cross-referencing."""
+
+    def __init__(
+        self,
+        storage: LocalMemoryManager,
+        config: MemoryConfig,
+        db: DatabaseProtocol,
+    ):
+        self.storage = storage
+        self.config = config
+
+        self._search_coordinator = SearchCoordinator(
+            storage=storage,
+            config=config,
+            db=db,
+        )
+
+        self._crossref_service = CrossrefService(
+            storage=storage,
+            config=config,
+            search_backend_getter=lambda: self._search_coordinator.search_backend,
+            ensure_fitted=self._search_coordinator.ensure_fitted,
+        )
+
+    @property
+    def backend(self) -> Any:
+        """Get the underlying search backend."""
+        return self._search_coordinator.search_backend
+
+    def ensure_fitted(self) -> None:
+        """Ensure the search backend is fitted with current memories."""
+        self._search_coordinator.ensure_fitted()
+
+    def mark_refit_needed(self) -> None:
+        """Mark that the search backend needs to be refitted."""
+        self._search_coordinator.mark_refit_needed()
+
+    def reindex(self) -> dict[str, Any]:
+        """Force rebuild of the search index."""
+        return self._search_coordinator.reindex()
+
+    def search(
+        self,
+        query: str,
+        project_id: str | None = None,
+        limit: int = 10,
+        min_importance: float | None = None,
+        search_mode: str | None = None,
+        tags_all: list[str] | None = None,
+        tags_any: list[str] | None = None,
+        tags_none: list[str] | None = None,
+    ) -> list[Memory]:
+        """Perform search using the configured search backend."""
+        return self._search_coordinator.search(
+            query=query,
+            project_id=project_id,
+            limit=limit,
+            min_importance=min_importance,
+            search_mode=search_mode,
+            tags_all=tags_all,
+            tags_any=tags_any,
+            tags_none=tags_none,
+        )
+
+    async def create_crossrefs(
+        self,
+        memory: Memory,
+        threshold: float | None = None,
+        max_links: int | None = None,
+    ) -> int:
+        """Find and link similar memories."""
+        return await self._crossref_service.create_crossrefs(
+            memory=memory,
+            threshold=threshold,
+            max_links=max_links,
+        )
+
+    async def get_related(
+        self,
+        memory_id: str,
+        limit: int = 5,
+        min_similarity: float = 0.0,
+    ) -> list[Memory]:
+        """Get memories linked to this one via cross-references."""
+        return await self._crossref_service.get_related(
+            memory_id=memory_id,
+            limit=limit,
+            min_similarity=min_similarity,
+        )

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/manager.py

@@ -6,11 +6,10 @@ from typing import TYPE_CHECKING, Any
 
 from gobby.config.persistence import MemoryConfig
 from gobby.memory.backends import get_backend
+from gobby.memory.components.ingestion import IngestionService
+from gobby.memory.components.search import SearchService
 from gobby.memory.context import build_memory_context
-from gobby.memory.ingestion import MultimodalIngestor
 from gobby.memory.protocol import MemoryBackendProtocol
-from gobby.memory.search.coordinator import SearchCoordinator
-from gobby.memory.services.crossref import CrossrefService
 from gobby.storage.database import DatabaseProtocol
 from gobby.storage.memories import LocalMemoryManager, Memory
 
@@ -46,20 +45,13 @@ class MemoryManager:
         self.storage = LocalMemoryManager(db)
 
         # Initialize extracted components
-        self._search_coordinator = SearchCoordinator(
+        self._search_service = SearchService(
             storage=self.storage,
             config=config,
             db=db,
         )
 
-        self._crossref_service = CrossrefService(
-            storage=self.storage,
-            config=config,
-            search_backend_getter=lambda: self._search_coordinator.search_backend,
-            ensure_fitted=self._search_coordinator.ensure_fitted,
-        )
-
-        self._multimodal_ingestor = MultimodalIngestor(
+        self._ingestion_service = IngestionService(
             storage=self.storage,
             backend=self._backend,
             llm_service=llm_service,
@@ -68,14 +60,13 @@ class MemoryManager:
     @property
     def llm_service(self) -> LLMService | None:
         """Get the LLM service for image description."""
-        return self._llm_service
+        return self._ingestion_service.llm_service
 
     @llm_service.setter
     def llm_service(self, service: LLMService | None) -> None:
         """Set the LLM service for image description."""
         self._llm_service = service
-        # Keep multimodal ingestor in sync
-        self._multimodal_ingestor.llm_service = service
+        self._ingestion_service.llm_service = service
 
     @property
     def search_backend(self) -> Any:
@@ -86,15 +77,15 @@ class MemoryManager:
         - "tfidf" (default): Zero-dependency TF-IDF search
         - "text": Simple text substring matching
         """
-        return self._search_coordinator.search_backend
+        return self._search_service.backend
 
     def _ensure_search_backend_fitted(self) -> None:
         """Ensure the search backend is fitted with current memories."""
-        self._search_coordinator.ensure_fitted()
+        self._search_service.ensure_fitted()
 
     def mark_search_refit_needed(self) -> None:
         """Mark that the search backend needs to be refitted."""
-        self._search_coordinator.mark_refit_needed()
+        self._search_service.mark_refit_needed()
 
     def reindex_search(self) -> dict[str, Any]:
         """
@@ -109,7 +100,7 @@ class MemoryManager:
         Returns:
             Dict with index statistics including memory_count, backend_type, etc.
         """
-        return self._search_coordinator.reindex()
+        return self._search_service.reindex()
 
     async def remember(
         self,
@@ -161,7 +152,7 @@ class MemoryManager:
         # Auto cross-reference if enabled
         if getattr(self.config, "auto_crossref", False):
             try:
-                await self._crossref_service.create_crossrefs(memory)
+                await self._search_service.create_crossrefs(memory)
             except Exception as e:
                 # Don't fail the remember if crossref fails
                 logger.warning(f"Auto-crossref failed for {memory.id}: {e}")
@@ -202,7 +193,7 @@ class MemoryManager:
         Raises:
             ValueError: If LLM service is not configured or image not found
         """
-        memory = await self._multimodal_ingestor.remember_with_image(
+        memory = await self._ingestion_service.remember_with_image(
             image_path=image_path,
             context=context,
             memory_type=memory_type,
@@ -249,7 +240,7 @@ class MemoryManager:
         Raises:
             ValueError: If LLM service is not configured or screenshot bytes are empty
         """
-        memory = await self._multimodal_ingestor.remember_screenshot(
+        memory = await self._ingestion_service.remember_screenshot(
             screenshot_bytes=screenshot_bytes,
             context=context,
             memory_type=memory_type,
@@ -283,7 +274,7 @@ class MemoryManager:
         Returns:
             Number of cross-references created
         """
-        return await self._crossref_service.create_crossrefs(
+        return await self._search_service.create_crossrefs(
             memory=memory,
             threshold=threshold,
             max_links=max_links,
@@ -306,7 +297,7 @@ class MemoryManager:
         Returns:
             List of related Memory objects, sorted by similarity
         """
-        return await self._crossref_service.get_related(
+        return await self._search_service.get_related(
             memory_id=memory_id,
             limit=limit,
             min_similarity=min_similarity,
@@ -398,7 +389,7 @@ class MemoryManager:
         if use_semantic is not None:
             logger.warning("use_semantic argument is deprecated and ignored")
 
-        return self._search_coordinator.search(
+        return self._search_service.search(
             query=query,
             project_id=project_id,
             limit=limit,

gobby/paths.py

@@ -0,0 +1,51 @@
+"""
+Core path utilities for Gobby package.
+
+This module provides stable path resolution utilities that work in both
+development (source) and installed (package) modes without CLI dependencies.
+"""
+
+from pathlib import Path
+
+__all__ = ["get_package_root", "get_install_dir"]
+
+
+def get_package_root() -> Path:
+    """Get the root directory of the gobby package.
+
+    Returns:
+        Path to src/gobby/ (the package root directory)
+    """
+    import gobby
+
+    return Path(gobby.__file__).parent
+
+
+def get_install_dir() -> Path:
+    """Get the gobby install directory.
+
+    Checks for source directory (development mode) first,
+    falls back to package directory. This handles both:
+    - Development: src/gobby/install/
+    - Installed package: <site-packages>/gobby/install/
+
+    Returns:
+        Path to the install directory
+    """
+    import gobby
+
+    package_install_dir = Path(gobby.__file__).parent / "install"
+
+    # Try to find source directory (project root) for development mode
+    current = Path(gobby.__file__).resolve()
+    source_install_dir = None
+
+    for parent in current.parents:
+        potential_source = parent / "src" / "gobby" / "install"
+        if potential_source.exists():
+            source_install_dir = potential_source
+            break
+
+    if source_install_dir and source_install_dir.exists():
+        return source_install_dir
+    return package_install_dir