@jcyamacho/agent-memory 0.0.10 → 0.0.12

package/README.md

@@ -3,10 +3,12 @@
 Persistent memory for MCP-powered coding agents.
 
 `agent-memory` is a stdio MCP server that gives your LLM durable memory backed
-by SQLite. It exposes two tools:
+by SQLite. It exposes four tools:
 
 - `remember` -> save facts, decisions, preferences, and project context
 - `recall` -> retrieve the most relevant memories later
+- `revise` -> update an existing memory when it becomes outdated
+- `forget` -> delete a memory that is no longer relevant
 
 Use it when your agent should remember preferences, project facts, and prior
 decisions across sessions.
@@ -66,7 +68,10 @@ Optional LLM instructions to reinforce the MCP's built-in guidance:
 Use `recall` at the start of every conversation and again mid-task before
 making design choices or picking conventions. Use `remember` when the user
 corrects your approach, a key decision is established, or you learn project
-context not obvious from the code. Always pass workspace.
+context not obvious from the code. Before saving, recall to check whether a
+memory about the same fact already exists -- if so, use `revise` to update
+it instead of creating a duplicate. Use `forget` to remove memories that
+are wrong or no longer relevant. Always pass workspace.
 ```
 
 ## What It Stores
@@ -92,8 +97,7 @@ Opens at `http://localhost:6580`. Use `--port` to change:
 npx -y @jcyamacho/agent-memory --ui --port 9090
 ```
 
-The web UI uses the same database as the MCP server. LLM tools remain
-append-only; the web UI is the only way to edit or delete memories.
+The web UI uses the same database as the MCP server.
 
 ## Tools
 
@@ -127,6 +131,31 @@ Output:
 
 - `results[]` with `id`, `content`, `score`, `workspace`, and `updated_at`
 
+### `revise`
+
+Update the content of an existing memory.
+
+Inputs:
+
+- `id` -> the memory id from a previous recall result
+- `content` -> replacement content for the memory
+
+Output:
+
+- `id`, `updated_at`
+
+### `forget`
+
+Permanently delete a memory.
+
+Inputs:
+
+- `id` -> the memory id from a previous recall result
+
+Output:
+
+- `id`, `deleted`
+
 ## How Ranking Works
 
 `recall` uses a multi-signal ranking system to surface the most relevant
@@ -134,15 +163,18 @@ memories:
 
 1. **Text relevance** is the primary signal -- memories whose content best
    matches your search terms rank highest.
-2. **Workspace match** is a strong secondary signal. When you pass `workspace`,
-   memories saved with the same workspace rank above unrelated ones.
+2. **Workspace match** is a strong secondary signal. When you pass
+   `workspace`, exact matches rank highest, sibling repositories get a small
+   boost, and unrelated workspaces rank lowest.
 3. **Global memories** (saved without a workspace) are treated as relevant
-   everywhere. They rank between workspace-matching and non-matching memories.
+   everywhere. When you pass `workspace`, they rank below exact workspace
+   matches and above sibling or unrelated repositories.
 4. **Recency** is a minor tiebreaker -- newer memories rank slightly above older
    ones when other signals are equal.
 
-For best results, always pass `workspace` when calling `recall`. Save memories
-without a workspace only when they apply across all projects.
+If you omit `workspace`, recall falls back to text relevance and recency only.
+For best results, pass `workspace` whenever you have one. Save memories without
+a workspace only when they apply across all projects.
 
 ## Database location
 

package/dist/index.js

@@ -12464,7 +12464,7 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.0.10";
+var version2 = "0.0.12";
 
 // src/config.ts
 import { homedir } from "node:os";
@@ -19895,9 +19895,6 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// src/memory-service.ts
-import { randomUUID } from "node:crypto";
-
 // src/errors.ts
 class MemoryError extends Error {
   code;
@@ -19929,6 +19926,55 @@ class PersistenceError extends MemoryError {
   }
 }
 
+// src/tools/shared.ts
+var toMcpError = (error2) => {
+  if (error2 instanceof McpError) {
+    return error2;
+  }
+  if (error2 instanceof MemoryError) {
+    if (error2.code === "VALIDATION_ERROR" || error2.code === "NOT_FOUND") {
+      return new McpError(ErrorCode.InvalidParams, error2.message);
+    }
+    return new McpError(ErrorCode.InternalError, error2.message);
+  }
+  const message = error2 instanceof Error ? error2.message : "Unknown server error.";
+  return new McpError(ErrorCode.InternalError, message);
+};
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var parseOptionalDate = (value, fieldName) => {
+  if (!value) {
+    return;
+  }
+  const date4 = new Date(value);
+  if (Number.isNaN(date4.getTime())) {
+    throw new MemoryError("VALIDATION_ERROR", `${fieldName} must be a valid ISO 8601 datetime.`);
+  }
+  return date4;
+};
+
+// src/tools/forget.ts
+var forgetInputSchema = {
+  id: string2().describe("The id of the memory to delete. Use the id returned by a previous recall result.")
+};
+var registerForgetTool = (server, memoryService) => {
+  server.registerTool("forget", {
+    description: "Permanently delete a memory that is wrong, obsolete, or no longer relevant. Pass the memory id from a previous recall result.",
+    inputSchema: forgetInputSchema
+  }, async ({ id }) => {
+    try {
+      await memoryService.forget({ id });
+      return {
+        content: [{ type: "text", text: `<memory id="${id.trim()}" deleted="true" />` }]
+      };
+    } catch (error2) {
+      throw toMcpError(error2);
+    }
+  });
+};
+
+// src/memory-service.ts
+import { randomUUID } from "node:crypto";
+
 // src/memory.ts
 var toNormalizedScore = (value) => value;
 
@@ -19940,6 +19986,8 @@ var RETRIEVAL_SCORE_WEIGHT = 8;
 var WORKSPACE_MATCH_WEIGHT = 4;
 var RECENCY_WEIGHT = 1;
 var MAX_COMPOSITE_SCORE = RETRIEVAL_SCORE_WEIGHT + WORKSPACE_MATCH_WEIGHT + RECENCY_WEIGHT;
+var GLOBAL_WORKSPACE_SCORE = 0.5;
+var SIBLING_WORKSPACE_SCORE = 0.25;
 
 class MemoryService {
   repository;
@@ -19961,6 +20009,18 @@ class MemoryService {
     };
     return this.repository.save(memory);
   }
+  async revise(input) {
+    const content = input.content.trim();
+    if (!content)
+      throw new ValidationError("Memory content is required.");
+    return this.repository.update(input.id, content);
+  }
+  async forget(input) {
+    const id = input.id.trim();
+    if (!id)
+      throw new ValidationError("Memory id is required.");
+    return this.repository.delete(id);
+  }
   async search(input) {
     const terms = normalizeTerms(input.terms);
     if (terms.length === 0) {
@@ -19979,7 +20039,7 @@ class MemoryService {
     return reranked.sort((a, b) => b.score - a.score).slice(0, requestedLimit);
   }
 }
-var normalizeLimit = (value) => {
+function normalizeLimit(value) {
   if (value === undefined) {
     return DEFAULT_LIMIT;
   }
@@ -19987,32 +20047,48 @@ var normalizeLimit = (value) => {
     throw new ValidationError(`Limit must be an integer between 1 and ${MAX_LIMIT}.`);
   }
   return value;
-};
-var normalizeOptionalString = (value) => {
+}
+function normalizeOptionalString(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : undefined;
-};
-var normalizeTerms = (terms) => {
+}
+function normalizeTerms(terms) {
   const normalizedTerms = terms.map((term) => term.trim()).filter(Boolean);
   return [...new Set(normalizedTerms)];
-};
-var GLOBAL_WORKSPACE_SCORE = 0.5;
-var computeWorkspaceScore = (memoryWs, queryWs) => {
-  if (!memoryWs)
+}
+function normalizeWorkspacePath(value) {
+  return value.trim().replaceAll("\\", "/").replace(/\/+/g, "/").split("/").filter(Boolean).join("/");
+}
+function computeWorkspaceScore(memoryWs, queryWs) {
+  if (!queryWs) {
+    return 0;
+  }
+  if (!memoryWs) {
     return GLOBAL_WORKSPACE_SCORE;
-  if (queryWs && memoryWs === queryWs)
+  }
+  const normalizedMemoryWs = normalizeWorkspacePath(memoryWs);
+  if (normalizedMemoryWs === queryWs) {
     return 1;
-  return 0;
-};
-var rerankSearchResults = (results, workspace) => {
+  }
+  const queryLastSlashIndex = queryWs.lastIndexOf("/");
+  const memoryLastSlashIndex = normalizedMemoryWs.lastIndexOf("/");
+  if (queryLastSlashIndex <= 0 || memoryLastSlashIndex <= 0) {
+    return 0;
+  }
+  const queryParent = queryWs.slice(0, queryLastSlashIndex);
+  const memoryParent = normalizedMemoryWs.slice(0, memoryLastSlashIndex);
+  return memoryParent === queryParent ? SIBLING_WORKSPACE_SCORE : 0;
+}
+function rerankSearchResults(results, workspace) {
   if (results.length <= 1) {
     return results;
   }
+  const normalizedQueryWs = workspace ? normalizeWorkspacePath(workspace) : undefined;
   const updatedAtTimes = results.map((result) => result.updatedAt.getTime());
   const minUpdatedAt = Math.min(...updatedAtTimes);
   const maxUpdatedAt = Math.max(...updatedAtTimes);
-  return [...results].map((result) => {
-    const workspaceScore = computeWorkspaceScore(result.workspace, workspace);
+  return results.map((result) => {
+    const workspaceScore = computeWorkspaceScore(result.workspace, normalizedQueryWs);
     const recencyScore = maxUpdatedAt === minUpdatedAt ? 0 : (result.updatedAt.getTime() - minUpdatedAt) / (maxUpdatedAt - minUpdatedAt);
     const combinedScore = (result.score * RETRIEVAL_SCORE_WEIGHT + workspaceScore * WORKSPACE_MATCH_WEIGHT + recencyScore * RECENCY_WEIGHT) / MAX_COMPOSITE_SCORE;
     return {
@@ -20020,33 +20096,7 @@ var rerankSearchResults = (results, workspace) => {
       score: toNormalizedScore(combinedScore)
     };
   });
-};
-
-// src/tools/shared.ts
-var toMcpError = (error2) => {
-  if (error2 instanceof McpError) {
-    return error2;
-  }
-  if (error2 instanceof MemoryError) {
-    if (error2.code === "VALIDATION_ERROR") {
-      return new McpError(ErrorCode.InvalidParams, error2.message);
-    }
-    return new McpError(ErrorCode.InternalError, error2.message);
-  }
-  const message = error2 instanceof Error ? error2.message : "Unknown server error.";
-  return new McpError(ErrorCode.InternalError, message);
-};
-var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-var parseOptionalDate = (value, fieldName) => {
-  if (!value) {
-    return;
-  }
-  const date4 = new Date(value);
-  if (Number.isNaN(date4.getTime())) {
-    throw new MemoryError("VALIDATION_ERROR", `${fieldName} must be a valid ISO 8601 datetime.`);
-  }
-  return date4;
-};
+}
 
 // src/tools/recall.ts
 var recallInputSchema = {
@@ -20113,11 +20163,40 @@ var registerRememberTool = (server, memoryService) => {
   });
 };
 
+// src/tools/revise.ts
+var reviseInputSchema = {
+  id: string2().describe("The id of the memory to update. Use the id returned by a previous recall result."),
+  content: string2().describe("The replacement content for the memory. Use a single self-contained sentence or short note. One fact per memory.")
+};
+var registerReviseTool = (server, memoryService) => {
+  server.registerTool("revise", {
+    description: "Update the content of an existing memory. Use when a previously saved memory is outdated or inaccurate and needs correction rather than deletion. Pass the memory id from a previous recall result.",
+    inputSchema: reviseInputSchema
+  }, async ({ id, content }) => {
+    try {
+      const memory = await memoryService.revise({ id, content });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `<memory id="${memory.id}" updated_at="${memory.updatedAt.toISOString()}" />`
+          }
+        ]
+      };
+    } catch (error2) {
+      throw toMcpError(error2);
+    }
+  });
+};
+
 // src/mcp-server.ts
 var SERVER_INSTRUCTIONS = [
   "Stores decisions, corrections, and context that cannot be derived from code or git history.",
   "Use `recall` at the start of every conversation and again mid-task before making design choices or picking conventions the user may have guided before.",
   "Use `remember` when the user corrects your approach, states a preference, a key decision is established, or you learn project context not obvious from the code.",
+  "Before saving a new memory, recall to check whether a memory about the same fact already exists. If so, use `revise` to update it instead of creating a duplicate.",
+  "Use `revise` when a previously saved memory is outdated or inaccurate and needs correction rather than deletion.",
+  "Use `forget` to remove memories that are wrong, obsolete, or no longer relevant.",
   "Always pass workspace (the current working directory) to scope results to the active project.",
   "Omit workspace only when saving a memory that applies across all projects."
 ].join(" ");
@@ -20130,6 +20209,8 @@ var createMcpServer = (memoryService, version3) => {
   });
   registerRememberTool(server, memoryService);
   registerRecallTool(server, memoryService);
+  registerReviseTool(server, memoryService);
+  registerForgetTool(server, memoryService);
   return server;
 };
 

package/package.json

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