@aeriondyseti/vector-memory-mcp 0.5.0 → 0.9.0-dev.1

package/src/services/memory.service.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "crypto";
 import type { Memory } from "../types/memory.js";
-import { DELETED_TOMBSTONE, isSuperseded } from "../types/memory.js";
+import { isDeleted } from "../types/memory.js";
 import type { MemoryRepository } from "../db/memory.repository.js";
 import type { EmbeddingsService } from "./embeddings.service.js";
 
@@ -42,33 +42,64 @@ export class MemoryService {
     return await this.repository.markDeleted(id);
   }
 
-  async search(query: string, limit: number = 10): Promise<Memory[]> {
+
+  async update(
+    id: string,
+    updates: {
+      content?: string;
+      embeddingText?: string;
+      metadata?: Record<string, unknown>;
+    }
+  ): Promise<Memory | null> {
+    const existing = await this.repository.findById(id);
+    if (!existing) {
+      return null;
+    }
+
+    const newContent = updates.content ?? existing.content;
+    const newMetadata = updates.metadata ?? existing.metadata;
+
+    // Regenerate embedding if content or embeddingText changed
+    let newEmbedding = existing.embedding;
+    if (updates.content !== undefined || updates.embeddingText !== undefined) {
+      const textToEmbed = updates.embeddingText ?? newContent;
+      newEmbedding = await this.embeddings.embed(textToEmbed);
+    }
+
+    const updatedMemory: Memory = {
+      ...existing,
+      content: newContent,
+      embedding: newEmbedding,
+      metadata: newMetadata,
+      updatedAt: new Date(),
+    };
+
+    await this.repository.upsert(updatedMemory);
+    return updatedMemory;
+  }
+
+  async search(
+    query: string,
+    limit: number = 10,
+    includeDeleted: boolean = false
+  ): Promise<Memory[]> {
     const queryEmbedding = await this.embeddings.embed(query);
     const fetchLimit = limit * 3;
 
     const rows = await this.repository.findSimilar(queryEmbedding, fetchLimit);
 
     const results: Memory[] = [];
-    const seenIds = new Set<string>();
 
     for (const row of rows) {
-      let memory = await this.repository.findById(row.id);
+      const memory = await this.repository.findById(row.id);
 
       if (!memory) {
         continue;
       }
 
-      if (isSuperseded(memory)) {
-        memory = await this.followSupersessionChain(row.id);
-        if (!memory) {
-          continue;
-        }
-      }
-
-      if (seenIds.has(memory.id)) {
+      if (!includeDeleted && isDeleted(memory)) {
         continue;
       }
-      seenIds.add(memory.id);
 
       results.push(memory);
       if (results.length >= limit) {
@@ -79,29 +110,76 @@ export class MemoryService {
     return results;
   }
 
-  private async followSupersessionChain(memoryId: string): Promise<Memory | null> {
-    const visited = new Set<string>();
-    let currentId: string | null = memoryId;
-
-    while (currentId && !visited.has(currentId)) {
-      visited.add(currentId);
-      const memory = await this.repository.findById(currentId);
+  private static readonly UUID_ZERO =
+    "00000000-0000-0000-0000-000000000000";
+
+  async storeHandoff(args: {
+    project: string;
+    branch?: string;
+    summary: string;
+    completed?: string[];
+    in_progress_blocked?: string[];
+    key_decisions?: string[];
+    next_steps?: string[];
+    memory_ids?: string[];
+    metadata?: Record<string, unknown>;
+  }): Promise<Memory> {
+    const now = new Date();
+    const date = now.toISOString().slice(0, 10);
+    const time = now.toISOString().slice(11, 16);
 
-      if (!memory) {
-        return null;
+    const list = (items: string[] | undefined) => {
+      if (!items || items.length === 0) {
+        return "- (none)";
       }
+      return items.map((i) => `- ${i}`).join("\n");
+    };
 
-      if (memory.supersededBy === null) {
-        return memory;
-      }
+    const content = `# Handoff - ${args.project}
+**Date:** ${date} ${time} | **Branch:** ${args.branch ?? "unknown"}
 
-      if (memory.supersededBy === DELETED_TOMBSTONE) {
-        return null;
-      }
+## Summary
+${args.summary}
 
-      currentId = memory.supersededBy;
-    }
+## Completed
+${list(args.completed)}
+
+## In Progress / Blocked
+${list(args.in_progress_blocked)}
+
+## Key Decisions
+${list(args.key_decisions)}
+
+## Next Steps
+${list(args.next_steps)}
+
+## Memory IDs
+${list(args.memory_ids)}`;
+
+    const metadata: Record<string, unknown> = {
+      ...(args.metadata ?? {}),
+      type: "handoff",
+      project: args.project,
+      date,
+      branch: args.branch ?? "unknown",
+      memory_ids: args.memory_ids ?? [],
+    };
+
+    const memory: Memory = {
+      id: MemoryService.UUID_ZERO,
+      content,
+      embedding: new Array(this.embeddings.dimension).fill(0),
+      metadata,
+      createdAt: now,
+      updatedAt: now,
+      supersededBy: null,
+    };
+
+    await this.repository.upsert(memory);
+    return memory;
+  }
 
-    return null;
+  async getLatestHandoff(): Promise<Memory | null> {
+    return await this.get(MemoryService.UUID_ZERO);
   }
 }

package/src/types/memory.ts

@@ -19,10 +19,6 @@ export function isDeleted(memory: Memory): boolean {
   return memory.supersededBy === DELETED_TOMBSTONE;
 }
 
-export function isSuperseded(memory: Memory): boolean {
-  return memory.supersededBy !== null;
-}
-
 export function memoryToDict(memory: Memory): Record<string, unknown> {
   return {
     id: memory.id,