@j0hanz/memdb 1.0.11 → 1.1.1

package/dist/worker/db-worker-client.js

@@ -0,0 +1,93 @@
+import { Worker } from 'node:worker_threads';
+import { isWorkerResponse } from './protocol.js';
+const resolveWorkerUrl = () => {
+    const extension = import.meta.url.endsWith('.ts') ? 'ts' : 'js';
+    return new URL(`./db-worker.${extension}`, import.meta.url);
+};
+const WORKER_REQUEST_TIMEOUT_MS = 30000;
+const createWorker = () => {
+    const options = { type: 'module' };
+    return new Worker(resolveWorkerUrl(), options);
+};
+const rejectAll = (pending, error) => {
+    for (const entry of pending.values()) {
+        clearTimeout(entry.timeout);
+        entry.reject(error);
+    }
+    pending.clear();
+};
+const onWorkerMessage = (pending, value) => {
+    if (!isWorkerResponse(value))
+        return;
+    const entry = pending.get(value.id);
+    if (!entry)
+        return;
+    pending.delete(value.id);
+    clearTimeout(entry.timeout);
+    if (!value.ok) {
+        entry.reject(new Error(value.error ?? 'Worker error'));
+        return;
+    }
+    entry.resolve(value.result);
+};
+const createRequest = (worker, pending, action, params, id) => {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            pending.delete(id);
+            reject(new Error('Worker request timed out'));
+        }, WORKER_REQUEST_TIMEOUT_MS);
+        pending.set(id, { resolve, reject, timeout });
+        try {
+            worker.postMessage({ id, action, params });
+        }
+        catch (error) {
+            pending.delete(id);
+            clearTimeout(timeout);
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+};
+export const createDbWorkerClient = () => {
+    const worker = createWorker();
+    let nextId = 1;
+    const pending = new Map();
+    worker.on('message', (value) => {
+        onWorkerMessage(pending, value);
+    });
+    worker.on('error', (error) => {
+        const resolved = error instanceof Error ? error : new Error(String(error));
+        rejectAll(pending, resolved);
+    });
+    worker.on('exit', (code) => {
+        if (code !== 0) {
+            rejectAll(pending, new Error(`Worker exited with code ${String(code)}`));
+        }
+    });
+    const request = async (action, params) => {
+        const id = nextId;
+        nextId += 1;
+        const result = await createRequest(worker, pending, action, params, id);
+        return result;
+    };
+    const close = async () => {
+        rejectAll(pending, new Error('Worker closed'));
+        await worker.terminate();
+    };
+    return { request, close };
+};
+export const createWorkerToolDependencies = (client) => {
+    return {
+        createMemory: (input) => client.request('store_memory', input),
+        updateMemory: (hash, options) => client.request('update_memory', [hash, options]),
+        getMemory: (hash) => client.request('get_memory', hash),
+        deleteMemory: (hash) => client.request('delete_memory', hash),
+        searchMemories: (input) => client.request('search_memories', input),
+        linkMemories: (fromHash, toHash, relationType) => client.request('link_memories', {
+            fromHash,
+            toHash,
+            relationType,
+        }),
+        getRelated: (input) => client.request('get_related', input),
+        getStats: () => client.request('memory_stats', null),
+    };
+};

package/dist/worker/db-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker/db-worker.js

@@ -0,0 +1,174 @@
+import { parentPort } from 'node:worker_threads';
+import { closeDb } from '../core/db.js';
+import { deleteMemory, getMemory, getStats } from '../core/memory-read.js';
+import { createMemory, updateMemory } from '../core/memory-write.js';
+import { getRelated, linkMemories } from '../core/relations.js';
+import { searchMemories } from '../core/search.js';
+import { GetMemoryInputSchema, GetRelatedInputSchema, LinkMemoriesInputSchema, MemoryStatsInputSchema, SearchMemoriesInputSchema, StoreMemoryInputSchema, UpdateMemoryInputSchema, } from '../schemas.js';
+const port = parentPort;
+if (!port) {
+    throw new Error('Missing parentPort');
+}
+const toErrorMessage = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string' && error.length > 0)
+        return error;
+    return 'Unknown error';
+};
+const isRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const isTwoItemArray = (value) => {
+    return Array.isArray(value) && value.length === 2;
+};
+const parseStoreMemoryInput = (params) => {
+    const parsed = StoreMemoryInputSchema.safeParse(params);
+    if (!parsed.success) {
+        throw new Error(parsed.error.message);
+    }
+    const { content, tags, importance, memoryType } = parsed.data;
+    const result = { content };
+    if (tags !== undefined)
+        result.tags = tags;
+    if (importance !== undefined)
+        result.importance = importance;
+    if (memoryType !== undefined)
+        result.memoryType = memoryType;
+    return result;
+};
+const parseHashParam = (params, action) => {
+    const parsed = GetMemoryInputSchema.safeParse({ hash: params });
+    if (!parsed.success) {
+        throw new Error(`${action}: ${parsed.error.message}`);
+    }
+    return parsed.data.hash;
+};
+const parseSearchInput = (params) => {
+    const parsed = SearchMemoriesInputSchema.safeParse(params);
+    if (!parsed.success) {
+        throw new Error(parsed.error.message);
+    }
+    return parsed.data;
+};
+const parseUpdateMemoryArgs = (params) => {
+    if (!isTwoItemArray(params)) {
+        throw new Error('update_memory: expected [hash, options]');
+    }
+    const hash = params[0];
+    const options = params[1];
+    if (typeof hash !== 'string') {
+        throw new Error('update_memory: hash must be a string');
+    }
+    if (!isRecord(options)) {
+        throw new Error('update_memory: options must be an object');
+    }
+    const parsed = UpdateMemoryInputSchema.safeParse({ hash, ...options });
+    if (!parsed.success) {
+        throw new Error(parsed.error.message);
+    }
+    const { hash: parsedHash, ...parsedOptions } = parsed.data;
+    return [parsedHash, parsedOptions];
+};
+const parseLinkParams = (params) => {
+    const parsed = LinkMemoriesInputSchema.safeParse(params);
+    if (!parsed.success) {
+        throw new Error(parsed.error.message);
+    }
+    return parsed.data;
+};
+const parseGetRelatedInput = (params) => {
+    const parsed = GetRelatedInputSchema.safeParse(params);
+    if (!parsed.success) {
+        throw new Error(parsed.error.message);
+    }
+    const { hash, relationType, depth, direction } = parsed.data;
+    const result = { hash };
+    if (relationType !== undefined)
+        result.relationType = relationType;
+    if (depth !== undefined)
+        result.depth = depth;
+    if (direction !== undefined)
+        result.direction = direction;
+    return result;
+};
+const parseStatsParams = (params) => {
+    if (params == null)
+        return;
+    const parsed = MemoryStatsInputSchema.safeParse(params);
+    if (!parsed.success) {
+        throw new Error(parsed.error.message);
+    }
+};
+const handlers = new Map([
+    ['store_memory', (params) => createMemory(parseStoreMemoryInput(params))],
+    ['get_memory', (params) => getMemory(parseHashParam(params, 'get_memory'))],
+    [
+        'delete_memory',
+        (params) => deleteMemory(parseHashParam(params, 'delete_memory')),
+    ],
+    [
+        'update_memory',
+        (params) => {
+            const [hash, options] = parseUpdateMemoryArgs(params);
+            return updateMemory(hash, options);
+        },
+    ],
+    ['search_memories', (params) => searchMemories(parseSearchInput(params))],
+    [
+        'link_memories',
+        (params) => {
+            const input = parseLinkParams(params);
+            return linkMemories(input.fromHash, input.toHash, input.relationType);
+        },
+    ],
+    ['get_related', (params) => getRelated(parseGetRelatedInput(params))],
+    [
+        'memory_stats',
+        (params) => {
+            parseStatsParams(params);
+            return getStats();
+        },
+    ],
+]);
+const isWorkerAction = (value) => {
+    if (typeof value !== 'string')
+        return false;
+    return handlers.has(value);
+};
+const isWorkerRequest = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'number')
+        return false;
+    if (!isWorkerAction(value.action))
+        return false;
+    return 'params' in value;
+};
+const getHandler = (action) => {
+    const handler = handlers.get(action);
+    if (!handler) {
+        throw new Error(`Unsupported action: ${action}`);
+    }
+    return handler;
+};
+const handleRequest = (request) => {
+    try {
+        const handler = getHandler(request.action);
+        const result = handler(request.params);
+        return { id: request.id, ok: true, result };
+    }
+    catch (error) {
+        return { id: request.id, ok: false, error: toErrorMessage(error) };
+    }
+};
+const onMessage = (value) => {
+    if (!isWorkerRequest(value))
+        return;
+    const response = handleRequest(value);
+    port.postMessage(response);
+};
+port.on('message', onMessage);
+process.on('exit', () => {
+    closeDb();
+});

package/dist/worker/protocol.d.ts

@@ -0,0 +1,9 @@
+export type WorkerAction = 'store_memory' | 'get_memory' | 'delete_memory' | 'update_memory' | 'search_memories' | 'link_memories' | 'get_related' | 'memory_stats';
+interface WorkerResponse {
+    id: number;
+    ok: boolean;
+    result?: unknown;
+    error?: string;
+}
+export declare const isWorkerResponse: (value: unknown) => value is WorkerResponse;
+export {};

package/dist/worker/protocol.js

@@ -0,0 +1,14 @@
+const isRecord = (value) => {
+    return typeof value === 'object' && value !== null;
+};
+export const isWorkerResponse = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== 'number')
+        return false;
+    if (typeof value.ok !== 'boolean')
+        return false;
+    if (!value.ok && typeof value.error !== 'string')
+        return false;
+    return true;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/memdb",
-  "version": "1.0.11",
+  "version": "1.1.1",
   "mcpName": "io.github.j0hanz/memdb",
   "description": "A memory-based MCP server using SQLite in-memory database.",
   "type": "module",
@@ -19,7 +19,8 @@
   ],
   "scripts": {
     "clean": "node -e \"require('fs').rmSync('dist', {recursive: true, force: true})\"",
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json && node -e \"require('fs').chmodSync('dist/index.js', '755')\"",
+    "prepare": "npm run build",
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
     "test": "node --import tsx/esm --test tests/*.test.ts",
@@ -48,15 +49,17 @@
   "homepage": "https://github.com/j0hanz/memdb-mcp-server#readme",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "zod": "^4.3.5"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@trivago/prettier-plugin-sort-imports": "^6.0.1",
-    "@types/node": "^22.19.3",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
+    "@types/node": "^25.0.6",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-de-morgan": "^2.0.0",
+    "eslint-plugin-depend": "^1.4.0",
     "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unused-imports": "^4.3.0",
     "prettier": "^3.7.4",