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

{opencode_semantic_memory-0.8.3 → opencode_semantic_memory-0.8.4}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.4] - 2026-06-03
+
+### Added
+
+- **`get_by_id` tool** - Retrieve a single memory by its ID, returning the full record
+  (content, category, what/why/learned, project, entities, timestamps) plus a link summary.
+  Lets static procedures and directives be fetched directly instead of via search, which is
+  unreliable for exact retrieval. Closes #83.
+
+### Fixed
+
+- **Recall relevance** - Bulk-ingested GitLab entities could drown out genuinely relevant
+  procedures and directives. The keyword-overlap boost was unbounded
+  (`overlap_count * 0.1`), so a verbose issue/MR sharing many keywords could add an
+  arbitrarily large score. The boost is now capped at `0.2`, and the bulk-ingest
+  `relevance_weight` default is lowered `0.8` -> `0.6` to discount bulk results further
+  versus personal memories.
+
 ## [0.8.3] - 2026-06-03
 
 ### Fixed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-semantic-memory
-Version: 0.8.3
+Version: 0.8.4
 Summary: Persistent semantic memory system for OpenCode sessions
 Author-email: Gregory Havenga <ghavenga@gitlab.com>
 License-Expression: MIT

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencode-semantic-memory"
-version = "0.8.3"
+version = "0.8.4"
 description = "Persistent semantic memory system for OpenCode sessions"
 readme = "README.md"
 license = "MIT"

{opencode_semantic_memory-0.8.3 → opencode_semantic_memory-0.8.4}/src/opencode_memory/bulk_ingest/config.py

@@ -47,7 +47,10 @@ class QueryConfig(BaseModel):
     """Query integration configuration."""
 
     enabled: bool = True  # Include in memory_recall searches
-    relevance_weight: float = 0.8  # Discount vs personal memories
+    # Discount bulk-ingested GitLab entities vs personal memories. Kept well
+    # below 1.0 so that procedures, directives, and decisions are not drowned
+    # out by weakly-matching bulk issues/MRs in recall results.
+    relevance_weight: float = 0.6
 
 
 class BulkIngestConfig(BaseModel):

{opencode_semantic_memory-0.8.3 → opencode_semantic_memory-0.8.4}/src/opencode_memory/bulk_ingest/keywords.py

@@ -274,6 +274,14 @@ def compute_keyword_overlap(keywords1: list[str], keywords2: list[str]) -> int:
     return len(set(keywords1) & set(keywords2))
 
 
+# Maximum additive keyword-overlap boost. Without a cap the boost is
+# unbounded (overlap_count * boost_factor), so a verbose bulk-ingested GitLab
+# entity sharing many keywords with the query could outscore a genuinely
+# relevant personal procedure/directive. Cap it so the boost only nudges
+# ranking rather than dominating it.
+MAX_KEYWORD_BOOST = 0.2
+
+
 def keyword_boost(query_keywords: list[str], entity_keywords: list[str], boost_factor: float = 0.1) -> float:
     """Calculate keyword overlap boost for search scoring.
 
@@ -283,7 +291,7 @@ def keyword_boost(query_keywords: list[str], entity_keywords: list[str], boost_f
         boost_factor: Multiplier per overlapping keyword
 
     Returns:
-        Boost value to add to search score
+        Boost value to add to search score, capped at MAX_KEYWORD_BOOST.
     """
     overlap = compute_keyword_overlap(query_keywords, entity_keywords)
-    return overlap * boost_factor
+    return min(overlap * boost_factor, MAX_KEYWORD_BOOST)

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

@@ -291,7 +291,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.3"  # Keep in sync with pyproject.toml
+_CURRENT_VERSION = "0.8.4"  # Keep in sync with pyproject.toml
 
 # audit #75: Named constants for magic numbers
 _RECALL_FETCH_BUFFER = 20  # Extra results to fetch for pagination info
@@ -1188,6 +1188,27 @@ class MemoryServer:
                         "required": ["memory_id"],
                     },
                 ),
+                Tool(
+                    name="get_by_id",
+                    description=(
+                        "Retrieve a single memory by its ID. Returns the full record "
+                        "(content, category, what/why/learned, project, entities, timestamps) "
+                        "plus a summary of its links. Use this to fetch an exact memory when "
+                        "you know its ID, e.g. a static procedure or directive referenced "
+                        "elsewhere, a linked memory shown in recall, or an ID from logs. "
+                        "More reliable than search for retrieving a known memory."
+                    ),
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "memory_id": {
+                                "type": "integer",
+                                "description": "ID of the memory to retrieve",
+                            },
+                        },
+                        "required": ["memory_id"],
+                    },
+                ),
                 Tool(
                     name="export_memories",
                     description=(
@@ -2356,6 +2377,11 @@ class MemoryServer:
                 False,
                 lambda a: (a["memory_id"], a.get("link_types")),
             ),
+            "get_by_id": (
+                self._get_by_id,
+                False,
+                lambda a: (a["memory_id"],),
+            ),
             "export_memories": (
                 self._export_memories,
                 True,
@@ -3474,6 +3500,7 @@ class MemoryServer:
             else None,
             "queue": self._get_queue_summary_for_boot(),
             "job_health": self._get_job_health_for_boot(),
+            "migration_health": self._get_migration_health_for_boot(),
             "update_available": update_available,
             # Convenience field: all memory IDs shown in boot context for exclusion from proactive injection
             "_memory_ids_shown": [m.id for m in boot.unresolved_blockers]
@@ -3564,6 +3591,46 @@ class MemoryServer:
             "hint": "Use JobQueue.list_dead_jobs() to inspect, retry_dead_job(id) to retry",
         }
 
+    def _get_migration_health_for_boot(self) -> dict[str, Any] | None:
+        """Get migration health for boot context.
+
+        Only returns info if there's an actual issue:
+        - Non-destructive migrations that failed to auto-run (warning)
+
+        Does NOT alert for:
+        - Pending destructive migrations (expected, require manual action)
+
+        Returns None if everything is healthy.
+        """
+        try:
+            status = self.sqlite.get_migration_status()
+        except Exception:
+            return None
+
+        pending = status.get("pending", [])
+        if not pending:
+            return None
+
+        # 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")]
+
+        if not non_destructive:
+            return None
+
+        return {
+            "alerts": [
+                {
+                    "type": "pending_migrations",
+                    "severity": "warning",
+                    "message": f"{len(non_destructive)} migration(s) failed to auto-run",
+                    "migrations": [m["name"] for m in non_destructive],
+                }
+            ],
+            "current_version": status.get("current_version", 0),
+            "hint": "Use sqlite.run_migration('name') to run a specific migration",
+        }
+
     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)
@@ -4049,6 +4116,28 @@ Actions:
         except Exception:
             pass
 
+        # Add migration status
+        try:
+            migration_status = self.sqlite.get_migration_status()
+            pending_migrations = migration_status.get("pending", [])
+            result["migrations"] = {
+                "schema_version": migration_status.get("current_version", 0),
+                "applied_count": len(migration_status.get("applied", [])),
+                "pending_count": len(pending_migrations),
+                "pending": [
+                    {
+                        "name": m["name"],
+                        "description": m["description"],
+                        "destructive": m["destructive"],
+                    }
+                    for m in pending_migrations
+                ]
+                if pending_migrations
+                else None,
+            }
+        except Exception:
+            pass
+
         return result
 
     def _tool_metrics(
@@ -4395,6 +4484,59 @@ Actions:
 
         return result
 
+    def _get_by_id(self, memory_id: int) -> dict[str, Any]:
+        """Retrieve a single memory by ID with its full record and link summary."""
+        validated_id = _validate_memory_id(memory_id)  # audit #31
+        if validated_id is None:
+            return {"error": f"Invalid memory_id: {memory_id}"}
+        memory_id = validated_id
+
+        # Cache first, then database.
+        memory = self.memory_cache.get(memory_id)
+        if not memory:
+            memory = self.sqlite.get_memory_by_id(memory_id)
+            if memory:
+                self.memory_cache.put(memory)
+        if not memory:
+            return {"error": f"Memory {memory_id} not found"}
+
+        def _iso(dt: Any) -> str | None:
+            return dt.isoformat() if dt is not None else None
+
+        # Summarize links (id + type) without fetching full linked content;
+        # callers can follow up with get_linked_memories for the details.
+        links = self.sqlite.get_all_links_for_memory(memory_id)
+        link_summary = [
+            {
+                "linked_memory_id": (
+                    lnk.target_memory_id if lnk.source_memory_id == memory_id else lnk.source_memory_id
+                ),
+                "link_type": lnk.link_type.value if hasattr(lnk.link_type, "value") else str(lnk.link_type),
+            }
+            for lnk in links
+        ]
+
+        return {
+            "id": memory.id,
+            "category": memory.category.value if hasattr(memory.category, "value") else str(memory.category),
+            "content": memory.content,
+            "what": memory.what,
+            "why": memory.why,
+            "learned": memory.learned,
+            "project": memory.project,
+            "entities": memory.entities,
+            "source_file": memory.source_file,
+            "created_at": _iso(memory.created_at),
+            "expires_at": _iso(memory.expires_at),
+            "resolved_at": _iso(memory.resolved_at),
+            "reminder_at": _iso(memory.reminder_at),
+            "recurrence": memory.recurrence,
+            "last_reviewed_at": _iso(memory.last_reviewed_at),
+            "review_interval_days": memory.review_interval_days,
+            "links": link_summary,
+            "link_count": len(link_summary),
+        }
+
     def _get_linked_memories(self, memory_id: int, link_types: list[str] | None = None) -> dict[str, Any]:
         """Get all memories linked to a specific memory.