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

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

@@ -50,14 +50,14 @@ def build_memory_context(memories: list[Memory]) -> str:
 
     # 1. Project Context
     if context_memories:
-        parts.append("## Project Context\n")
+        parts.append("## Project Context")
         for mem in context_memories:
-            parts.append(f"{mem.content}\n")
+            parts.append(mem.content)
         parts.append("")
 
     # 2. Preferences
     if pref_memories:
-        parts.append("## Preferences\n")
+        parts.append("## Preferences")
         for mem in pref_memories:
             content = _strip_leading_bullet(mem.content)
             if content:  # Skip empty content
@@ -66,7 +66,7 @@ def build_memory_context(memories: list[Memory]) -> str:
 
     # 3. Patterns
     if pattern_memories:
-        parts.append("## Patterns\n")
+        parts.append("## Patterns")
         for mem in pattern_memories:
             content = _strip_leading_bullet(mem.content)
             if content:  # Skip empty content
@@ -75,7 +75,7 @@ def build_memory_context(memories: list[Memory]) -> str:
 
     # 4. Facts/Other
     if fact_memories:
-        parts.append("## Facts\n")
+        parts.append("## Facts")
         for mem in fact_memories:
             content = _strip_leading_bullet(mem.content)
             if content:  # Skip empty content

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)