opencode-semantic-memory 0.8.4__tar.gz → 0.8.5__tar.gz

opencode_semantic_memory-0.8.5/.cache/pip/selfcheck/fe300af6f7d708c14827daac3afc81fbb8306b73de8dd6e3f1f8ea3b

@@ -0,0 +1 @@
+{"key":"/usr/local","last_check":"2026-06-05T08:40:22.432139+00:00","pypi_version":"26.1.2"}

{opencode_semantic_memory-0.8.4 → opencode_semantic_memory-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-semantic-memory
-Version: 0.8.4
+Version: 0.8.5
 Summary: Persistent semantic memory system for OpenCode sessions
 Author-email: Gregory Havenga <ghavenga@gitlab.com>
 License-Expression: MIT
@@ -29,6 +29,8 @@ Requires-Dist: watchdog>=3.0.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.1.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Description-Content-Type: text/markdown

{opencode_semantic_memory-0.8.4 → opencode_semantic_memory-0.8.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencode-semantic-memory"
-version = "0.8.4"
+version = "0.8.5"
 description = "Persistent semantic memory system for OpenCode sessions"
 readme = "README.md"
 license = "MIT"
@@ -43,6 +43,8 @@ dependencies = [
 dev = [
     "pytest>=7.0.0",
     "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.1.0",
+    "pytest-timeout>=2.1.0",
     "ruff>=0.1.0",
     "mypy>=1.0.0",
 ]
@@ -51,9 +53,11 @@ dev = [
 opencode-memory = "opencode_memory.cli:main"
 opencode-memory-server = "opencode_memory.http_server:main"
 opencode-memory-daemon = "opencode_memory.daemon:main"
-opencode-memory-worker = "opencode_memory.background_worker:main"
-# New job-based worker (Sidekiq-like)
+# Canonical worker is the job-based (Sidekiq-like) system.
+opencode-memory-worker = "opencode_memory.jobs.worker:main"
 opencode-memory-job-worker = "opencode_memory.jobs.worker:main"
+# Deprecated monolithic worker, kept for back-compat until v0.10.0.
+opencode-memory-legacy-worker = "opencode_memory.background_worker:main"
 # Bulk ingestion commands
 opencode-memory-bulk-ingest = "opencode_memory.bulk_ingest.cli:main"
 opencode-memory-bulk-ingest-daemon = "opencode_memory.bulk_ingest.daemon:main"
@@ -78,3 +82,30 @@ strict = true
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]
+addopts = "--cov=opencode_memory --cov-report=term-missing --cov-report=xml --cov-fail-under=90 --timeout=120"
+
+[tool.coverage.run]
+branch = false
+source = ["src/opencode_memory"]
+omit = [
+    # Deprecated modules, superseded by the jobs/ system. Kept only for
+    # back-compat imports; will be removed in a future major release.
+    "*/background_worker.py",
+    "*/enrichment_worker.py",
+    # One-shot maintenance scripts (run manually, not part of the service).
+    "*/historical_ingest.py",
+    "*/backfill_introspection.py",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if __name__ == .__main__.:",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+    "@(abc\\.)?abstractmethod",
+    "logger\\.debug",
+]

{opencode_semantic_memory-0.8.4 → opencode_semantic_memory-0.8.5}/src/opencode_memory/server.py

@@ -36,6 +36,7 @@ from opencode_memory.query.hybrid import HybridSearchEngine
 from opencode_memory.session.registry import SessionRegistry
 from opencode_memory.storage.sqlite import SQLiteStorage
 from opencode_memory.storage.vectors import VectorStorage
+from opencode_memory.workflow.dispatch import build_workflow_tool, handle_workflow
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -291,7 +292,7 @@ _background_tasks = BackgroundTaskRegistry()
 _update_cache: dict[str, Any] = {"result": None, "checked_at": None}
 _update_cache_lock = threading.Lock()
 _UPDATE_CACHE_TTL_SECONDS = 3600  # 1 hour
-_CURRENT_VERSION = "0.8.4"  # Keep in sync with pyproject.toml
+_CURRENT_VERSION = "0.8.5"  # Keep in sync with pyproject.toml
 
 # audit #75: Named constants for magic numbers
 _RECALL_FETCH_BUFFER = 20  # Extra results to fetch for pagination info
@@ -527,7 +528,12 @@ class MemoryServer:
         self.sqlite = SQLiteStorage(self.config.db_path)
         self.embeddings = EmbeddingEngine()
         self.vectors = VectorStorage(self.config.vectors_path, self.embeddings.dimension)
-        self.search_engine = HybridSearchEngine(self.sqlite, self.vectors, self.embeddings)
+        self.search_engine = HybridSearchEngine(
+            self.sqlite,
+            self.vectors,
+            self.embeddings,
+            include_bulk_ingest=self.config.bulk_ingest.enabled,
+        )
         self.session_registry = SessionRegistry(self.sqlite)
         self.parser = MarkdownParser()
         self.memory_cache = MemoryCache(self.sqlite)  # Uses defaults: 50k entries, 24h TTL
@@ -2204,6 +2210,7 @@ class MemoryServer:
                         "required": ["items"],
                     },
                 ),
+                build_workflow_tool(),
             ]
 
         @self.server.call_tool()
@@ -2643,6 +2650,11 @@ class MemoryServer:
                 False,
                 lambda a: (a["items"], a.get("refresh_id"), a.get("working_directory")),
             ),
+            "workflow": (
+                self._workflow,
+                True,
+                lambda a: (a.get("action"), a),
+            ),
         }
 
         if name not in dispatch:
@@ -2667,6 +2679,25 @@ class MemoryServer:
         else:
             return handler(*extracted_args)
 
+    async def _workflow(self, action: str | None, args: dict[str, Any]) -> Any:
+        """Dispatch a unified ``workflow(action=...)`` tool call.
+
+        Delegates to the merged workflow package (formerly opencode-workflow-mcp).
+        Returns a JSON string of the serialized result.
+        """
+        import json
+
+        if not action:
+            return json.dumps({"error": "Missing 'action'. Provide action=<workflow_tool_name>."})
+        try:
+            result = await handle_workflow(action, args)
+        except ValueError as e:
+            return json.dumps({"error": str(e)})
+        # invoke_subagent returns raw text; everything else returns serializable data.
+        if isinstance(result, str):
+            return result
+        return json.dumps(result, indent=2)
+
     def _log_recall_events_async(
         self,
         memories: list[tuple[int, float | None]],
@@ -3600,6 +3631,8 @@ class MemoryServer:
         Does NOT alert for:
         - Pending destructive migrations (expected, require manual action)
 
+        Also creates/updates blocker memories for destructive migrations with blockers.
+
         Returns None if everything is healthy.
         """
         try:
@@ -3611,6 +3644,11 @@ class MemoryServer:
         if not pending:
             return None
 
+        # Check destructive migrations for blockers and create blocker memories
+        for migration_info in pending:
+            if migration_info.get("destructive"):
+                self._ensure_migration_blocker_memory(migration_info["name"])
+
         # Only non-destructive pending migrations are issues (should have auto-run)
         # Destructive migrations are expected to be pending until manually run
         non_destructive = [m for m in pending if not m.get("destructive")]
@@ -3628,9 +3666,79 @@ class MemoryServer:
                 }
             ],
             "current_version": status.get("current_version", 0),
-            "hint": "Use sqlite.run_migration('name') to run a specific migration",
+            "hint": "Use workflow(action='migration_status') to see details",
         }
 
+    def _ensure_migration_blocker_memory(self, migration_name: str) -> None:
+        """Create or update blocker memory for a blocked migration.
+
+        Creates a blocker memory with structured information about why a
+        destructive migration cannot run and how to resolve it.
+        """
+        from opencode_memory.storage.migrations import get_migration_by_name
+
+        migration = get_migration_by_name(migration_name)
+        if not migration:
+            return
+
+        try:
+            with self.sqlite._get_conn() as conn:
+                blockers = migration.get_blockers(conn)
+
+            # Only create blocker if there are actual blocking issues
+            # (not just the "requires acknowledgment" one)
+            real_blockers = [b for b in blockers if b.blocking and "requires explicit acknowledgment" not in b.reason]
+
+            if not real_blockers:
+                return
+
+            # Build blocker content
+            content = f"Migration {migration_name} blocked:\n\n"
+            for b in real_blockers:
+                content += f"- {b.reason}\n"
+                content += f"  Remediation: {b.remediation}\n"
+                if b.command:
+                    content += f"  Command: {b.command}\n"
+                content += "\n"
+
+            content += f"Description: {migration.description}\n"
+            content += "\nTo resolve, use: workflow(action='migration_prep', migration_name='"
+            content += f"{migration_name}')"
+
+            # Search for existing blocker memory by pattern using FTS
+            existing = self.sqlite.search_fts(
+                f"Migration {migration_name} blocked",
+                limit=5,
+            )
+
+            # Filter to only blocker category
+            existing = [m for m in existing if m.category == MemoryCategory.BLOCKER]
+
+            # Find exact match
+            exact_match = None
+            for m in existing:
+                if f"Migration {migration_name} blocked" in m.content:
+                    exact_match = m
+                    break
+
+            if exact_match:
+                # Update existing if content changed
+                if exact_match.content != content:
+                    self.sqlite.update_memory(exact_match.id, content=content)
+            else:
+                # Create new blocker memory
+                memory = Memory(
+                    category=MemoryCategory.BLOCKER,
+                    content=content,
+                    what=f"Migration {migration_name} blocked",
+                    why="Preconditions not met for destructive migration",
+                    learned=f"Run migration_prep to resolve blockers for {migration_name}",
+                )
+                self.sqlite.insert_memory(memory)
+
+        except Exception as e:
+            logger.warning(f"Failed to create migration blocker memory: {e}")
+
     def _get_recent_session_summaries(self, limit: int = 3) -> list[dict[str, Any]]:
         """Get summaries of recent conversation sessions."""
         recent = self.sqlite.get_memories_by_category(MemoryCategory.CONVERSATION, limit=limit)
@@ -5716,7 +5824,7 @@ Actions:
             stats = await extract_concepts_batch(
                 sqlite=self.sqlite,
                 vectors=self.vectors,
-                embeddings=self.embedding_engine,
+                embeddings=self.embeddings,
                 batch_size=batch_size,
                 working_directory=working_dir,
                 config=self.config,