@jcyamacho/agent-memory 0.1.0 → 0.2.0

package/README.md

@@ -10,7 +10,7 @@ It exposes four tools:
 
 - `remember` -> save facts, decisions, preferences, and project context
 - `review` -> load workspace and global memories sorted by most recently updated
-- `revise` -> update an existing memory when it becomes outdated
+- `revise` -> update an existing memory when its content changes or when it should become global
 - `forget` -> delete a memory that is no longer relevant
 
 ## Quick Start
@@ -55,6 +55,11 @@ targets the habits models most commonly miss:
   `memory_forget` to keep memories accurate.
 - Pass `workspace` on `memory_remember` for project-scoped memory. Omit it
   only for facts that apply across projects.
+- Remember preferences, confirmed approaches, and decisions with reasoning
+  that would be lost after the session.
+- Revise content when a fact changes, promote a project-scoped memory to
+  global only when it truly applies across projects, and forget it when it is
+  no longer relevant.
 - Do not store secrets, temporary task state, or facts obvious from current
   code or git history.
 ```
@@ -75,6 +80,13 @@ npx -y @jcyamacho/agent-memory@latest --ui --port 9090
 
 The web UI uses the same database as the MCP server.
 
+## Mutating Tool Output
+
+`remember`, `revise`, and `forget` return the full affected memory
+as XML with `updated_at` and scope information so clients that hide tool-call
+arguments can still see what changed.
+`forget` includes `deleted="true"` on the returned `<memory>` element.
+
 ## How Review Works
 
 `review` requires a `workspace` and returns memories saved in that workspace

package/dist/index.js

@@ -11543,7 +11543,7 @@ var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || t
 var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
 var TaskCreationParamsSchema = looseObject({
-  ttl: union([number2(), _null3()]).optional(),
+  ttl: number2().optional(),
   pollInterval: number2().optional()
 });
 var TaskMetadataSchema = object({
@@ -11697,7 +11697,8 @@ var ClientCapabilitiesSchema = object({
   roots: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ClientTasksCapabilitySchema.optional()
+  tasks: ClientTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   protocolVersion: string2(),
@@ -11722,7 +11723,8 @@ var ServerCapabilitiesSchema = object({
   tools: object({
     listChanged: boolean2().optional()
   }).optional(),
-  tasks: ServerTasksCapabilitySchema.optional()
+  tasks: ServerTasksCapabilitySchema.optional(),
+  extensions: record(string2(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: string2(),
@@ -11837,6 +11839,7 @@ var ResourceSchema = object({
   uri: string2(),
   description: optional(string2()),
   mimeType: optional(string2()),
+  size: optional(number2()),
   annotations: AnnotationsSchema.optional(),
   _meta: optional(looseObject({}))
 });
@@ -12464,7 +12467,7 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.1.0";
+var version2 = "0.2.0";
 
 // src/config.ts
 import { homedir } from "node:os";
@@ -17974,6 +17977,10 @@ class Protocol {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
+    }
+    this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
       controller.abort();
     }
@@ -18104,7 +18111,9 @@ class Protocol {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
-      this._requestHandlerAbortControllers.delete(request.id);
+      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request.id);
+      }
     });
   }
   _onprogress(notification) {
@@ -19762,6 +19771,9 @@ class McpServer {
           annotations = rest.shift();
         }
       } else if (typeof firstArg === "object" && firstArg !== null) {
+        if (Object.values(firstArg).some((v) => typeof v === "object" && v !== null)) {
+          throw new Error(`Tool ${name} expected a Zod schema or ToolAnnotations, but received an unrecognized object`);
+        }
         annotations = rest.shift();
       }
     }
@@ -19854,6 +19866,9 @@ function getZodSchemaObject(schema) {
   if (isZodRawShapeCompat(schema)) {
     return objectFromShape(schema);
   }
+  if (!isZodSchemaInstance(schema)) {
+    throw new Error("inputSchema must be a Zod schema or raw shape, received an unrecognized object");
+  }
   return schema;
 }
 function promptArgumentsFromSchema(schema) {
@@ -19944,6 +19959,27 @@ function toMcpError(error2) {
   return new McpError(ErrorCode.InternalError, message);
 }
 var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function toMemoryXml(record3, options) {
+  const scopeAttribute = getMemoryScopeAttribute(record3, options?.skipWorkspaceIfEquals);
+  const attributes = [
+    `id="${escapeXml(record3.id)}"`,
+    `updated_at="${record3.updatedAt.toISOString()}"`,
+    scopeAttribute,
+    options?.deleted ? 'deleted="true"' : undefined
+  ].filter((value) => value).join(" ");
+  return `<memory ${attributes}>
+${escapeXml(record3.content)}
+</memory>`;
+}
+function getMemoryScopeAttribute(record3, skipWorkspaceIfEquals) {
+  if (record3.workspace === undefined) {
+    return 'global="true"';
+  }
+  if (record3.workspace === skipWorkspaceIfEquals) {
+    return;
+  }
+  return `workspace="${escapeXml(record3.workspace)}"`;
+}
 
 // src/mcp/tools/forget.ts
 var forgetInputSchema = {
@@ -19957,13 +19993,13 @@ function registerForgetTool(server, memory) {
       idempotentHint: true,
       openWorldHint: false
     },
-    description: 'Delete a memory that is wrong or obsolete. Use after `review` when you have the memory id. Use `revise` instead if the fact should remain with corrected wording. Returns `<memory id="..." deleted="true" />`.',
+    description: 'Delete a memory that is wrong or obsolete. Use after `review` when you have the memory id. Use `revise` instead if the fact should remain with corrected wording. Returns the deleted memory as `<memory ... deleted="true">...</memory>`.',
     inputSchema: forgetInputSchema
   }, async ({ id }) => {
     try {
-      await memory.delete({ id });
+      const deletedMemory = await memory.delete({ id });
       return {
-        content: [{ type: "text", text: `<memory id="${id.trim()}" deleted="true" />` }]
+        content: [{ type: "text", text: toMemoryXml(deletedMemory, { deleted: true }) }]
       };
     } catch (error2) {
       throw toMcpError(error2);
@@ -19984,7 +20020,7 @@ function registerRememberTool(server, memory) {
       idempotentHint: false,
       openWorldHint: false
     },
-    description: 'Save one new durable fact. Use for stable preferences, reusable decisions, and project context not obvious from code or git history. If the fact already exists, use `revise` instead. Returns `<memory id="..." />`.',
+    description: "Save one new durable fact. Use for stable preferences, reusable decisions, and project context not obvious from code or git history. If the fact already exists, use `revise` instead. Returns the saved memory as `<memory ...>...</memory>`.",
     inputSchema: rememberInputSchema
   }, async ({ content, workspace }) => {
     try {
@@ -19993,7 +20029,7 @@ function registerRememberTool(server, memory) {
         workspace
       });
       return {
-        content: [{ type: "text", text: `<memory id="${savedMemory.id}" />` }]
+        content: [{ type: "text", text: toMemoryXml(savedMemory) }]
       };
     } catch (error2) {
       throw toMcpError(error2);
@@ -20007,13 +20043,6 @@ 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 toMemoryXml(record3, workspace) {
-  const global2 = record3.workspace !== workspace ? ' global="true"' : "";
-  const content = escapeXml(record3.content);
-  return `<memory id="${record3.id}"${global2} updated_at="${record3.updatedAt.toISOString()}">
-${content}
-</memory>`;
-}
 function registerReviewTool(server, memory) {
   server.registerTool("review", {
     annotations: {
@@ -20038,7 +20067,7 @@ function registerReviewTool(server, memory) {
         };
       }
       const escapedWorkspace = escapeXml(workspace);
-      const memories = result.items.map((item) => toMemoryXml(item, workspace)).join(`
+      const memories = result.items.map((item) => toMemoryXml(item, { skipWorkspaceIfEquals: workspace })).join(`
 `);
       const text = `<memories workspace="${escapedWorkspace}" has_more="${result.hasMore}">
 ${memories}
@@ -20055,7 +20084,8 @@ ${memories}
 // src/mcp/tools/revise.ts
 var reviseInputSchema = {
   id: string2().describe("Memory id to update. Use an id returned by `review`."),
-  content: string2().describe("Corrected replacement text for that memory.")
+  content: string2().optional().describe("Corrected replacement text for that memory. Omit to keep the current content."),
+  global: boolean2().optional().describe("Set to true to move a project-scoped memory to global scope.")
 };
 function registerReviseTool(server, memory) {
   server.registerTool("revise", {
@@ -20065,16 +20095,23 @@ function registerReviseTool(server, memory) {
       idempotentHint: false,
       openWorldHint: false
     },
-    description: 'Update one existing memory when the same fact still applies but its wording or details changed. Use after `review` when you already have the memory id. Returns `<memory id="..." updated_at="..." />`.',
+    description: "Update one existing memory when the same fact still applies but its wording changed, or when a project-scoped memory should become global. Use after `review` when you already have the memory id. Omit fields you do not want to change. Returns the revised memory as `<memory ...>...</memory>`.",
     inputSchema: reviseInputSchema
-  }, async ({ id, content }) => {
+  }, async ({ id, content, global: global2 }) => {
     try {
-      const revisedMemory = await memory.update({ id, content });
+      if (content === undefined && global2 !== true) {
+        throw new ValidationError("Provide at least one field to revise.");
+      }
+      const revisedMemory = await memory.update({
+        id,
+        content,
+        workspace: global2 === true ? null : undefined
+      });
       return {
         content: [
           {
             type: "text",
-            text: `<memory id="${revisedMemory.id}" updated_at="${revisedMemory.updatedAt.toISOString()}" />`
+            text: toMemoryXml(revisedMemory)
           }
         ]
       };
@@ -20088,7 +20125,7 @@ function registerReviseTool(server, memory) {
 var SERVER_INSTRUCTIONS = [
   "Durable memory for stable preferences, corrections, reusable decisions, and project context not obvious from code or git history.",
   "Workflow: (1) Call `review` with the current workspace at conversation start -- this loads workspace and global memories into context.",
-  "(2) During the session, call `remember` to save a new fact, `revise` to correct an existing one, or `forget` to remove one that is wrong or obsolete.",
+  "(2) During the session, call `remember` to save a new fact, `revise` to correct content or promote a project-scoped memory to global scope, and call `forget` to remove one that is wrong or obsolete.",
   "Always check loaded memories before calling `remember` to avoid duplicates -- use `revise` instead when the fact already exists.",
   "Pass workspace on `remember` for project-scoped memory. Omit it only for facts that apply across all projects.",
   "Never store secrets, temporary task state, or facts obvious from current code or git history."
@@ -20123,27 +20160,31 @@ class MemoryService {
     if (!content) {
       throw new ValidationError("Memory content is required.");
     }
-    const workspace = await this.workspaceResolver.resolve(input.workspace);
+    const workspace = await this.normalizeWorkspaceInput(input.workspace);
     return this.repository.create({ content, workspace });
   }
   async update(input) {
-    const content = input.content.trim();
-    if (!content)
-      throw new ValidationError("Memory content is required.");
-    return this.repository.update({ id: input.id, content });
+    const content = this.normalizeUpdateContent(input.content);
+    const workspace = await this.normalizeUpdateWorkspace(input.workspace);
+    return this.repository.update({ id: input.id, content, workspace });
   }
   async delete(input) {
     const id = input.id.trim();
     if (!id)
       throw new ValidationError("Memory id is required.");
-    return this.repository.delete({ id });
+    const existingMemory = await this.repository.get(id);
+    if (!existingMemory) {
+      throw new NotFoundError(`Memory not found: ${id}`);
+    }
+    await this.repository.delete({ id });
+    return existingMemory;
   }
   async get(id) {
     return this.repository.get(id);
   }
   async list(input) {
-    const queryWorkspace = normalizeOptionalString(input.workspace);
-    const workspace = await this.workspaceResolver.resolve(input.workspace);
+    const queryWorkspace = input.workspace?.trim() || undefined;
+    const workspace = queryWorkspace ? await this.workspaceResolver.resolve(queryWorkspace) : undefined;
     const page = await this.repository.list({
       workspace,
       global: input.global,
@@ -20158,6 +20199,32 @@ class MemoryService {
   async listWorkspaces() {
     return this.repository.listWorkspaces();
   }
+  normalizeUpdateContent(value) {
+    if (value === undefined) {
+      return;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new ValidationError("Memory content is required.");
+    }
+    return trimmed;
+  }
+  async normalizeUpdateWorkspace(value) {
+    if (value === undefined || value === null) {
+      return value;
+    }
+    return this.normalizeWorkspaceInput(value);
+  }
+  async normalizeWorkspaceInput(value) {
+    if (value === undefined) {
+      return;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new ValidationError("Workspace is required.");
+    }
+    return this.workspaceResolver.resolve(trimmed);
+  }
 }
 function normalizeOffset(value) {
   return Number.isInteger(value) && value && value > 0 ? value : 0;
@@ -20168,10 +20235,6 @@ function normalizeListLimit(value) {
   }
   return Math.min(Math.max(value, 1), MAX_LIST_LIMIT);
 }
-function normalizeOptionalString(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
 function remapWorkspace(record3, canonicalWorkspace, queryWorkspace) {
   if (record3.workspace !== canonicalWorkspace) {
     return record3;
@@ -20425,7 +20488,7 @@ class SqliteMemoryRepository {
       VALUES (?, ?, ?, ?, ?)
     `);
     this.getStatement = database.prepare("SELECT id, content, workspace, created_at, updated_at FROM memories WHERE id = ?");
-    this.updateStatement = database.prepare("UPDATE memories SET content = ?, updated_at = ? WHERE id = ?");
+    this.updateStatement = database.prepare("UPDATE memories SET content = ?, workspace = ?, updated_at = ? WHERE id = ?");
     this.deleteStatement = database.prepare("DELETE FROM memories WHERE id = ?");
     this.listWorkspacesStatement = database.prepare("SELECT DISTINCT workspace FROM memories WHERE workspace IS NOT NULL ORDER BY workspace");
   }
@@ -20488,10 +20551,18 @@ class SqliteMemoryRepository {
     }
   }
   async update(input) {
+    const existingMemory = await this.get(input.id);
+    if (!existingMemory) {
+      throw new NotFoundError(`Memory not found: ${input.id}`);
+    }
+    const patch = applyMemoryPatch(existingMemory, input);
+    if (!hasMemoryChanges(existingMemory, patch)) {
+      return existingMemory;
+    }
     let result;
     try {
       const now = Date.now();
-      result = this.updateStatement.run(input.content, now, input.id);
+      result = this.updateStatement.run(patch.content, patch.workspace, now, input.id);
     } catch (error2) {
       throw new PersistenceError("Failed to update memory.", { cause: error2 });
     }
@@ -20531,9 +20602,21 @@ var toMemoryRecord = (row) => ({
   createdAt: new Date(row.created_at),
   updatedAt: new Date(row.updated_at)
 });
+function applyMemoryPatch(memory, input) {
+  return {
+    content: input.content ?? memory.content,
+    workspace: input.workspace === undefined ? toStoredWorkspace(memory.workspace) : input.workspace
+  };
+}
+function hasMemoryChanges(memory, patch) {
+  return patch.content !== memory.content || patch.workspace !== toStoredWorkspace(memory.workspace);
+}
+function toStoredWorkspace(workspace) {
+  return workspace ?? null;
+}
 // node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
-import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+import { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from "http2";
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
 import crypto from "crypto";
@@ -20843,6 +20926,48 @@ if (typeof global.crypto === "undefined") {
   global.crypto = crypto;
 }
 var outgoingEnded = Symbol("outgoingEnded");
+var incomingDraining = Symbol("incomingDraining");
+var DRAIN_TIMEOUT_MS = 500;
+var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+var drainIncoming = (incoming) => {
+  const incomingWithDrainState = incoming;
+  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+    return;
+  }
+  incomingWithDrainState[incomingDraining] = true;
+  if (incoming instanceof Http2ServerRequest2) {
+    try {
+      incoming.stream?.close?.(h2constants.NGHTTP2_NO_ERROR);
+    } catch {}
+    return;
+  }
+  let bytesRead = 0;
+  const cleanup = () => {
+    clearTimeout(timer);
+    incoming.off("data", onData);
+    incoming.off("end", cleanup);
+    incoming.off("error", cleanup);
+  };
+  const forceClose = () => {
+    cleanup();
+    const socket = incoming.socket;
+    if (socket && !socket.destroyed) {
+      socket.destroySoon();
+    }
+  };
+  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+  timer.unref?.();
+  const onData = (chunk) => {
+    bytesRead += chunk.length;
+    if (bytesRead > MAX_DRAIN_BYTES) {
+      forceClose();
+    }
+  };
+  incoming.on("data", onData);
+  incoming.on("end", cleanup);
+  incoming.on("error", cleanup);
+  incoming.resume();
+};
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -21006,14 +21131,18 @@ var getRequestListener = (fetchCallback, options = {}) => {
               setTimeout(() => {
                 if (!incomingEnded) {
                   setTimeout(() => {
-                    incoming.destroy();
-                    outgoing.destroy();
+                    drainIncoming(incoming);
                   });
                 }
               });
             }
           };
         }
+        outgoing.on("finish", () => {
+          if (!incomingEnded) {
+            drainIncoming(incoming);
+          }
+        });
       }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
@@ -21028,7 +21157,7 @@ var getRequestListener = (fetchCallback, options = {}) => {
           setTimeout(() => {
             if (!incomingEnded) {
               setTimeout(() => {
-                incoming.destroy();
+                drainIncoming(incoming);
               });
             }
           });
@@ -21453,7 +21582,7 @@ var HonoRequest = class {
     return headerData;
   }
   async parseBody(options) {
-    return this.bodyCache.parsedBody ??= await parseBody(this, options);
+    return parseBody(this, options);
   }
   #cachedBody = (key) => {
     const { bodyCache, raw } = this;
@@ -23929,9 +24058,9 @@ function createGitWorkspaceResolver(options = {}) {
   const cache = new Map;
   return {
     async resolve(workspace) {
-      const trimmed = normalizeOptionalString2(workspace);
+      const trimmed = workspace.trim();
       if (!trimmed) {
-        return;
+        throw new ValidationError("Workspace is required.");
       }
       const cached2 = cache.get(trimmed);
       if (cached2) {
@@ -23960,10 +24089,6 @@ async function defaultGetGitCommonDir(cwd) {
   });
   return stdout.trim();
 }
-function normalizeOptionalString2(value) {
-  const trimmed = value?.trim();
-  return trimmed ? trimmed : undefined;
-}
 
 // src/index.ts
 var config2 = resolveConfig();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jcyamacho/agent-memory",
   "main": "dist/index.js",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "bin": {
     "agent-memory": "dist/index.js"
   },
@@ -29,18 +29,18 @@
     "release:major": "npm version major && git push origin main --follow-tags"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.6",
+    "@biomejs/biome": "2.4.11",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@hono/node-server": "^1.19.11",
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "better-sqlite3": "^12.6.2",
-    "hono": "^4.12.8",
+    "@hono/node-server": "^1.19.13",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-sqlite3": "^12.8.0",
+    "hono": "^4.12.12",
     "zod": "^4.3.6"
   }
 }