@j0hanz/memory-mcp 1.4.0 → 1.6.0

package/dist/tools/update-memory.js

@@ -1,7 +1,8 @@
-import { E_CONFLICT, E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
+import { E_CONFLICT, E_NOT_FOUND } from '../lib/errors.js';
 import { computeMemoryHash } from '../lib/hash.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { SELECT_MEMORY_BY_HASH_SQL, SELECT_MEMORY_HASH_SQL, } from '../lib/sql.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
 import { parseTags } from '../lib/types.js';
 import { UpdateMemoryInputSchema } from '../schemas/inputs.js';
@@ -19,57 +20,51 @@ async function notifyUpdatedMemoryResources(server, oldHash, newHash) {
     await Promise.allSettled(notifications);
 }
 export function registerUpdateMemory(server, db) {
-    registerToolWithContract(server, 'update_memory', UpdateMemoryInputSchema, UpdateResultSchema, wrapToolHandler(async (params) => {
-        try {
-            // All reads and the write are inside a single IMMEDIATE transaction
-            // to prevent TOCTOU between existence/collision checks and UPDATE.
-            const txResult = db.transaction(() => {
-                const existing = db
-                    .prepareOnce(SELECT_MEMORY_BY_HASH_SQL)
-                    .get(params.hash);
-                if (!existing) {
+    registerToolWithContract(server, 'update_memory', UpdateMemoryInputSchema, UpdateResultSchema, wrapToolHandler(async (params) => executeToolSafely(async () => {
+        // All reads and the write are inside a single IMMEDIATE transaction
+        // to prevent TOCTOU between existence/collision checks and UPDATE.
+        const txResult = db.transaction(() => {
+            const existing = db
+                .prepareOnce(SELECT_MEMORY_BY_HASH_SQL)
+                .get(params.hash);
+            if (!existing) {
+                return {
+                    ok: false,
+                    code: E_NOT_FOUND,
+                    message: `Memory not found: ${params.hash}`,
+                };
+            }
+            const newTags = params.tags ?? parseTags(existing.tags);
+            const newHash = computeMemoryHash(params.content, newTags);
+            if (newHash !== params.hash) {
+                const collision = db
+                    .prepareOnce(SELECT_MEMORY_HASH_SQL)
+                    .get(newHash);
+                if (collision) {
                     return {
                         ok: false,
-                        code: E_NOT_FOUND,
-                        message: `Memory not found: ${params.hash}`,
+                        code: E_CONFLICT,
+                        message: `Memory already exists for target content/tags: ${newHash}`,
                     };
                 }
-                const newTags = params.tags ?? parseTags(existing.tags);
-                const newHash = computeMemoryHash(params.content, newTags);
-                if (newHash !== params.hash) {
-                    const collision = db
-                        .prepareOnce(SELECT_MEMORY_HASH_SQL)
-                        .get(newHash);
-                    if (collision) {
-                        return {
-                            ok: false,
-                            code: E_CONFLICT,
-                            message: `Memory already exists for target content/tags: ${newHash}`,
-                        };
-                    }
-                }
-                const now = new Date().toISOString();
-                db.prepareOnce(UPDATE_MEMORY_SQL).run(newHash, params.content, JSON.stringify(newTags), now, params.hash);
-                return { ok: true, oldHash: params.hash, newHash };
-            });
-            if (!txResult.ok) {
-                return createErrorResponse(txResult.code, txResult.message);
             }
-            await logToolEvent(server, 'update', {
-                oldHash: txResult.oldHash,
-                newHash: txResult.newHash,
-            });
-            await notifyUpdatedMemoryResources(server, txResult.oldHash, txResult.newHash);
-            return createToolResponse({
-                old_hash: txResult.oldHash,
-                new_hash: txResult.newHash,
-            });
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
+            const now = new Date().toISOString();
+            db.prepareOnce(UPDATE_MEMORY_SQL).run(newHash, params.content, JSON.stringify(newTags), now, params.hash);
+            return { ok: true, oldHash: params.hash, newHash };
+        });
+        if (!txResult.ok) {
+            return createErrorResponse(txResult.code, txResult.message);
         }
-    }, {
+        await logToolEvent(server, 'update', {
+            oldHash: txResult.oldHash,
+            newHash: txResult.newHash,
+        });
+        await notifyUpdatedMemoryResources(server, txResult.oldHash, txResult.newHash);
+        return createToolResponse({
+            old_hash: txResult.oldHash,
+            new_hash: txResult.newHash,
+        });
+    }), {
         progressMessage: (params) => `⊜ update_memory: ${params.hash.slice(0, 12)}... [replace content]`,
     }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/memory-mcp",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "mcpName": "io.github.j0hanz/memory-mcp",
   "author": "Johanz",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "url": "https://github.com/j0hanz/memory-mcp.git"
   },
   "homepage": "https://github.com/j0hanz/memory-mcp#readme",
-  "description": "A memory-based implementation of the Model Context Protocol (MCP) for storing and retrieving contextual information.",
+  "description": "SQLite-backed MCP server for persistent memory, full-text retrieval, and graph traversal.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",