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

gobby/mcp_proxy/tools/workflows/_resolution.py

@@ -0,0 +1,78 @@
+"""
+Resolution utilities for workflow tools.
+
+Provides functions to resolve session and task references from various
+formats (#N, N, UUID, prefix) to canonical UUIDs.
+"""
+
+import logging
+from typing import Any
+
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.sessions import LocalSessionManager
+from gobby.storage.tasks._id import resolve_task_reference
+from gobby.storage.tasks._models import TaskNotFoundError
+from gobby.utils.project_context import get_project_context
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_session_id(session_manager: LocalSessionManager, ref: str) -> str:
+    """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+    project_ctx = get_project_context()
+    project_id = project_ctx.get("id") if project_ctx else None
+    return session_manager.resolve_session_reference(ref, project_id)
+
+
+def resolve_session_task_value(
+    value: Any,
+    session_id: str | None,
+    session_manager: LocalSessionManager,
+    db: DatabaseProtocol,
+) -> Any:
+    """
+    Resolve a session_task value from seq_num reference (#N or N) to UUID.
+
+    This prevents repeated resolution failures in condition evaluation when
+    task_tree_complete() is called with a seq_num that requires project_id.
+
+    Args:
+        value: The value to potentially resolve (e.g., "#4424", "47", or a UUID)
+        session_id: Session ID to look up project_id
+        session_manager: Session manager for lookups
+        db: Database for task resolution
+
+    Returns:
+        Resolved UUID if value was a seq_num reference, otherwise original value
+    """
+    # Only process string values that look like seq_num references
+    if not isinstance(value, str):
+        return value
+
+    # Check if it's a seq_num reference (#N or plain N)
+    is_seq_ref = value.startswith("#") or value.isdigit()
+    if not is_seq_ref:
+        return value
+
+    # Need session to get project_id
+    if not session_id:
+        logger.warning(f"Cannot resolve task reference '{value}': no session_id provided")
+        return value
+
+    # Get project_id from session
+    session = session_manager.get(session_id)
+    if not session or not session.project_id:
+        logger.warning(f"Cannot resolve task reference '{value}': session has no project_id")
+        return value
+
+    # Resolve the reference
+    try:
+        resolved = resolve_task_reference(db, value, session.project_id)
+        logger.debug(f"Resolved session_task '{value}' to UUID '{resolved}'")
+        return resolved
+    except TaskNotFoundError as e:
+        logger.warning(f"Could not resolve task reference '{value}': {e}")
+        return value
+    except Exception as e:
+        logger.warning(f"Unexpected error resolving task reference '{value}': {e}")
+        return value

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/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/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

gobby/prompts/loader.py

@@ -12,7 +12,6 @@ Implements prompt loading with precedence:
 
 import logging
 import re
-from collections.abc import Callable
 from functools import lru_cache
 from pathlib import Path
 from typing import Any
@@ -66,21 +65,6 @@ class PromptLoader:
         # Template cache
         self._cache: dict[str, PromptTemplate] = {}
 
-        # Fallback registry for strangler fig pattern
-        self._fallbacks: dict[str, Callable[[], str]] = {}
-
-    def register_fallback(self, path: str, getter: Callable[[], str]) -> None:
-        """Register a Python constant fallback for a template path.
-
-        Used for strangler fig pattern - if template file doesn't exist,
-        fall back to the original Python constant.
-
-        Args:
-            path: Template path (e.g., "expansion/system")
-            getter: Callable that returns the fallback string
-        """
-        self._fallbacks[path] = getter
-
     def clear_cache(self) -> None:
         """Clear the template cache."""
         self._cache.clear()
@@ -162,19 +146,6 @@ class PromptLoader:
             logger.debug(f"Loaded prompt template '{path}' from {template_file}")
             return template
 
-        # Fall back to registered Python constant
-        if path in self._fallbacks:
-            fallback_content = self._fallbacks[path]()
-            template = PromptTemplate(
-                name=path,
-                description=f"Fallback for {path}",
-                content=fallback_content,
-                source_path=None,
-            )
-            self._cache[path] = template
-            logger.debug(f"Using fallback for prompt template '{path}'")
-            return template
-
         raise FileNotFoundError(f"Prompt template not found: {path}")
 
     def render(
@@ -280,7 +251,7 @@ class PromptLoader:
         Returns:
             True if template exists (file or fallback)
         """
-        return self._find_template_file(path) is not None or path in self._fallbacks
+        return self._find_template_file(path) is not None
 
     def list_templates(self, category: str | None = None) -> list[str]:
         """List available template paths.
@@ -305,11 +276,6 @@ class PromptLoader:
                 if category is None or template_path.startswith(f"{category}/"):
                     templates.add(template_path)
 
-        # Add registered fallbacks
-        for fallback_path in self._fallbacks:
-            if category is None or fallback_path.startswith(f"{category}/"):
-                templates.add(fallback_path)
-
         return sorted(templates)