@jcyamacho/agent-memory 0.0.19 → 0.0.20

package/README.md

@@ -6,10 +6,11 @@ Persistent memory for MCP-powered coding agents.
 by SQLite. It helps your agent remember preferences, project context, and prior
 decisions across sessions.
 
-It exposes four tools:
+It exposes five tools:
 
 - `remember` -> save facts, decisions, preferences, and project context
 - `recall` -> retrieve the most relevant memories later
+- `review` -> browse all memories for a workspace
 - `revise` -> update an existing memory when it becomes outdated
 - `forget` -> delete a memory that is no longer relevant
 
@@ -52,6 +53,8 @@ Optional LLM instructions to reinforce the MCP's built-in guidance:
   conventions, edge cases, or saving memory.
 - Query `memory_recall` with 2-5 short anchor-heavy terms or exact phrases,
   not full questions or sentences.
+- Use `memory_review` to browse all memories for a workspace before bulk review
+  or cleanup.
 - Pass `workspace` for project-scoped memory. Omit it only for facts that
   apply across projects.
 - Use `memory_remember` to save one durable fact when the user states a stable

package/dist/index.js

@@ -12464,7 +12464,7 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.0.19";
+var version2 = "0.0.20";
 
 // src/config.ts
 import { homedir } from "node:os";
@@ -12533,14 +12533,20 @@ class PersistenceError extends MemoryError {
 
 // src/embedding/service.ts
 var DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
+function configureModelsCache(modelsCachePath) {
+  mkdirSync(modelsCachePath, { recursive: true });
+  transformersEnv.useFSCache = true;
+  transformersEnv.cacheDir = modelsCachePath;
+}
 
 class EmbeddingService {
   options;
   extractorPromise;
-  modelsCachePath;
   constructor(options = {}) {
     this.options = options;
-    this.modelsCachePath = options.modelsCachePath ?? resolveModelsCachePath();
+  }
+  async warmup() {
+    await this.getExtractor();
   }
   async createVector(text) {
     const normalizedText = text.trim();
@@ -12553,17 +12559,11 @@ class EmbeddingService {
   }
   getExtractor() {
     if (!this.extractorPromise) {
-      configureModelsCache(this.modelsCachePath);
       this.extractorPromise = (this.options.createExtractor ?? createDefaultExtractor)();
     }
     return this.extractorPromise;
   }
 }
-function configureModelsCache(modelsCachePath) {
-  mkdirSync(modelsCachePath, { recursive: true });
-  transformersEnv.useFSCache = true;
-  transformersEnv.cacheDir = modelsCachePath;
-}
 async function createDefaultExtractor() {
   const extractor = await pipeline("feature-extraction", DEFAULT_EMBEDDING_MODEL);
   return (text) => extractor(text, {
@@ -20185,6 +20185,7 @@ class MemoryService {
     return memory ? toPublicMemoryRecord(memory) : undefined;
   }
   async list(input) {
+    const queryWorkspace = normalizeOptionalString(input.workspace);
     const workspace = await this.workspaceResolver.resolve(input.workspace);
     const page = await this.repository.list({
       workspace,
@@ -20192,7 +20193,10 @@ class MemoryService {
       offset: normalizeOffset(input.offset),
       limit: normalizeListLimit(input.limit)
     });
-    return toPublicMemoryPage(page);
+    return {
+      items: page.items.map((item) => toPublicMemoryRecord(remapWorkspace(item, workspace, queryWorkspace))),
+      hasMore: page.hasMore
+    };
   }
   async listWorkspaces() {
     return this.repository.listWorkspaces();
@@ -20215,7 +20219,7 @@ class MemoryService {
       this.repository.search(normalizedQuery),
       this.embeddingService.createVector(terms.join(" "))
     ]);
-    return rerankSearchResults(results, workspace, queryEmbedding).slice(0, requestedLimit).map((result) => toPublicSearchResult(remapSearchResultWorkspace(result, workspace, queryWorkspace)));
+    return rerankSearchResults(results, workspace, queryEmbedding).slice(0, requestedLimit).map((result) => toPublicSearchResult(remapWorkspace(result, workspace, queryWorkspace)));
   }
 }
 function toPublicMemoryRecord(memory) {
@@ -20237,12 +20241,6 @@ function toPublicSearchResult(result) {
     updatedAt: result.updatedAt
   };
 }
-function toPublicMemoryPage(page) {
-  return {
-    items: page.items.map(toPublicMemoryRecord),
-    hasMore: page.hasMore
-  };
-}
 function normalizeLimit(value) {
   if (value === undefined) {
     return DEFAULT_RECALL_LIMIT;
@@ -20269,14 +20267,11 @@ function normalizeOptionalString(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : undefined;
 }
-function remapSearchResultWorkspace(result, canonicalWorkspace, queryWorkspace) {
-  if (!queryWorkspace || !canonicalWorkspace || result.workspace !== canonicalWorkspace) {
-    return result;
+function remapWorkspace(record3, canonicalWorkspace, queryWorkspace) {
+  if (record3.workspace !== canonicalWorkspace) {
+    return record3;
   }
-  return {
-    ...result,
-    workspace: queryWorkspace
-  };
+  return { ...record3, workspace: queryWorkspace };
 }
 
 // src/mcp/tools/recall.ts
@@ -20356,6 +20351,53 @@ function registerRememberTool(server, memory) {
   });
 }
 
+// src/mcp/tools/review.ts
+var REVIEW_PAGE_SIZE = 25;
+var reviewInputSchema = {
+  workspace: string2().describe("Current working directory for project-scoped listing."),
+  page: number2().int().min(0).optional().describe("Zero-based page number. Defaults to 0.")
+};
+function toMemoryXml2(record3) {
+  const content = escapeXml(record3.content);
+  return `<memory id="${record3.id}" updated_at="${record3.updatedAt.toISOString()}">
+${content}
+</memory>`;
+}
+function registerReviewTool(server, memory) {
+  server.registerTool("review", {
+    annotations: {
+      title: "Review",
+      readOnlyHint: true,
+      openWorldHint: false
+    },
+    description: 'Browse all memories for a workspace in creation order. Use before bulk review, cleanup, or when you need to scan memories without specific search terms. For targeted retrieval by topic, use `recall` instead. Returns `<memories workspace="..." has_more="true|false">...</memories>` with pagination support.',
+    inputSchema: reviewInputSchema
+  }, async ({ workspace, page }) => {
+    try {
+      const pageIndex = page ?? 0;
+      const result = await memory.list({
+        workspace,
+        offset: pageIndex * REVIEW_PAGE_SIZE,
+        limit: REVIEW_PAGE_SIZE
+      });
+      if (result.items.length === 0) {
+        return {
+          content: [{ type: "text", text: "No memories found for this workspace." }]
+        };
+      }
+      const text = `<memories workspace="${escapeXml(workspace)}" has_more="${result.hasMore}">
+${result.items.map(toMemoryXml2).join(`
+`)}
+</memories>`;
+      return {
+        content: [{ type: "text", text }]
+      };
+    } catch (error2) {
+      throw toMcpError(error2);
+    }
+  });
+}
+
 // src/mcp/tools/revise.ts
 var reviseInputSchema = {
   id: string2().describe("Memory id to update. Use an id returned by `recall`."),
@@ -20392,6 +20434,7 @@ function registerReviseTool(server, memory) {
 var SERVER_INSTRUCTIONS = [
   "Use this server only for durable memory that should survive across turns: stable preferences, corrections, reusable decisions, and project context not obvious from code or git history.",
   "Use `recall` at conversation start, before design choices, and before saving or revising memory.",
+  "Use `review` to browse all memories for a workspace before bulk review or cleanup.",
   "Use `remember` for one new durable fact. Use `revise` when the fact already exists but needs correction.",
   "Use `forget` only when a memory is wrong or obsolete.",
   "Pass workspace for project-scoped memory. Omit it only for facts that apply across projects.",
@@ -20408,6 +20451,7 @@ function createMcpServer(memory, version3) {
   registerRecallTool(server, memory);
   registerReviseTool(server, memory);
   registerForgetTool(server, memory);
+  registerReviewTool(server, memory);
   return server;
 }
 
@@ -24288,11 +24332,13 @@ function normalizeOptionalString2(value) {
 
 // src/index.ts
 var config2 = resolveConfig();
-var embeddingService = new EmbeddingService({ modelsCachePath: config2.modelsCachePath });
+configureModelsCache(config2.modelsCachePath);
+var embeddingService = new EmbeddingService;
 var workspaceResolver = createGitWorkspaceResolver();
 var database = await openMemoryDatabase(config2.databasePath, { embeddingService, workspaceResolver });
 var repository2 = new SqliteMemoryRepository(database);
 var memoryService = new MemoryService(repository2, embeddingService, workspaceResolver);
+embeddingService.warmup();
 if (config2.uiMode) {
   let shutdown = function() {
     server.close();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jcyamacho/agent-memory",
   "main": "dist/index.js",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "bin": {
     "agent-memory": "dist/index.js"
   },