@danielsimonjr/memory-mcp 12.5.2 → 12.7.0

package/dist/workers/levenshteinWorker.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Levenshtein Worker
+ *
+ * Worker thread for calculating Levenshtein distances in parallel.
+ * Uses workerpool for worker management.
+ *
+ * @module workers/levenshteinWorker
+ */
+/**
+ * Input data structure for the worker.
+ */
+export interface WorkerInput {
+    /** Search query string */
+    query: string;
+    /** Array of entities to search */
+    entities: Array<{
+        name: string;
+        nameLower: string;
+        observations: string[];
+    }>;
+    /** Similarity threshold (0.0 to 1.0) */
+    threshold: number;
+}
+/**
+ * Match result returned by the worker.
+ */
+export interface MatchResult {
+    /** Entity name that matched */
+    name: string;
+    /** Similarity score (0.0 to 1.0) */
+    score: number;
+    /** Where the match occurred */
+    matchedIn: 'name' | 'observation';
+}
+/**
+ * Calculate Levenshtein distance between two strings.
+ *
+ * Uses dynamic programming matrix for efficient computation.
+ *
+ * @param s1 - First string
+ * @param s2 - Second string
+ * @returns Levenshtein distance (number of edits)
+ */
+export declare function levenshteinDistance(s1: string, s2: string): number;
+/**
+ * Calculate similarity score between two strings.
+ *
+ * @param s1 - First string
+ * @param s2 - Second string
+ * @returns Similarity score (0.0 to 1.0, where 1.0 is identical)
+ */
+export declare function similarity(s1: string, s2: string): number;
+/**
+ * Search entities for fuzzy matches.
+ *
+ * @param data - Worker input containing query, entities, and threshold
+ * @returns Array of match results
+ */
+export declare function searchEntities(data: WorkerInput): MatchResult[];
+//# sourceMappingURL=levenshteinWorker.d.ts.map

package/dist/workers/levenshteinWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levenshteinWorker.d.ts","sourceRoot":"","sources":["../../src/workers/levenshteinWorker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,QAAQ,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC,CAAC;IACH,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,SAAS,EAAE,MAAM,GAAG,aAAa,CAAC;CACnC;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAgClE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAWzD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,EAAE,CAwB/D"}

package/dist/workers/levenshteinWorker.js

@@ -0,0 +1,98 @@
+/**
+ * Levenshtein Worker
+ *
+ * Worker thread for calculating Levenshtein distances in parallel.
+ * Uses workerpool for worker management.
+ *
+ * @module workers/levenshteinWorker
+ */
+import workerpool from '@danielsimonjr/workerpool/modern';
+/**
+ * Calculate Levenshtein distance between two strings.
+ *
+ * Uses dynamic programming matrix for efficient computation.
+ *
+ * @param s1 - First string
+ * @param s2 - Second string
+ * @returns Levenshtein distance (number of edits)
+ */
+export function levenshteinDistance(s1, s2) {
+    const len1 = s1.length;
+    const len2 = s2.length;
+    if (len1 === 0)
+        return len2;
+    if (len2 === 0)
+        return len1;
+    const matrix = [];
+    // Initialize first column
+    for (let i = 0; i <= len1; i++) {
+        matrix[i] = [i];
+    }
+    // Initialize first row
+    for (let j = 0; j <= len2; j++) {
+        matrix[0][j] = j;
+    }
+    // Fill matrix
+    for (let i = 1; i <= len1; i++) {
+        for (let j = 1; j <= len2; j++) {
+            const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, // deletion
+            matrix[i][j - 1] + 1, // insertion
+            matrix[i - 1][j - 1] + cost // substitution
+            );
+        }
+    }
+    return matrix[len1][len2];
+}
+/**
+ * Calculate similarity score between two strings.
+ *
+ * @param s1 - First string
+ * @param s2 - Second string
+ * @returns Similarity score (0.0 to 1.0, where 1.0 is identical)
+ */
+export function similarity(s1, s2) {
+    // Exact match
+    if (s1 === s2)
+        return 1.0;
+    // One contains the other
+    if (s1.includes(s2) || s2.includes(s1))
+        return 1.0;
+    // Calculate Levenshtein-based similarity
+    const distance = levenshteinDistance(s1, s2);
+    const maxLength = Math.max(s1.length, s2.length);
+    return 1 - distance / maxLength;
+}
+/**
+ * Search entities for fuzzy matches.
+ *
+ * @param data - Worker input containing query, entities, and threshold
+ * @returns Array of match results
+ */
+export function searchEntities(data) {
+    const { query, entities, threshold } = data;
+    const queryLower = query.toLowerCase();
+    const results = [];
+    for (const entity of entities) {
+        // Check name similarity
+        const nameScore = similarity(queryLower, entity.nameLower);
+        if (nameScore >= threshold) {
+            results.push({ name: entity.name, score: nameScore, matchedIn: 'name' });
+            continue;
+        }
+        // Check observations
+        for (const obs of entity.observations) {
+            const obsScore = similarity(queryLower, obs);
+            if (obsScore >= threshold) {
+                results.push({ name: entity.name, score: obsScore, matchedIn: 'observation' });
+                break;
+            }
+        }
+    }
+    return results;
+}
+// Register worker methods with workerpool
+// Cast to satisfy workerpool's generic type signature
+workerpool.worker({
+    searchEntities: searchEntities,
+});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@danielsimonjr/memory-mcp",
-  "version": "12.5.2",
-  "description": "Enhanced MCP memory server with hierarchies, compression, archiving, graph algorithms, semantic search, temporal KG, RBAC, bitemporal validity, OCC, procedural memory, causal reasoning, world model, do_not_remember exclusions, decision rationale, project context, heuristic guidelines, tool affordance + observer, observation dedup, spell correction, and 213 advanced tools",
+  "version": "12.7.0",
+  "description": "Enhanced MCP memory server with hierarchies, compression, archiving, graph algorithms, semantic search, temporal KG, RBAC, bitemporal validity, OCC, procedural memory, causal reasoning, world model, do_not_remember exclusions, decision rationale, project context, heuristic guidelines, tool affordance + observer, observation dedup, spell correction, event memory, reconstructive memory, relation consolidation, agent reflection, and 241 advanced tools",
   "license": "MIT",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0"
   },
   "author": "Daniel Simon Jr. (https://github.com/danielsimonjr)",
   "homepage": "https://github.com/danielsimonjr/memory-mcp",
@@ -58,7 +58,7 @@
     "tools:build": "cd tools/chunking-for-files && npm run build && cd ../compress-for-context && npm run build && cd ../create-dependency-graph && npm run build && cd ../migrate-from-jsonl-to-sqlite && npm run build"
   },
   "dependencies": {
-    "@danielsimonjr/memoryjs": "^2.8.1",
+    "@danielsimonjr/memoryjs": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.21.1",
     "zod": "^4.4.3"
   },
@@ -66,10 +66,10 @@
     "better-sqlite3": "^12.10.1"
   },
   "devDependencies": {
-    "@types/node": "^22",
-    "@vitest/coverage-v8": "^4.1.5",
+    "@types/node": "^26",
+    "@vitest/coverage-v8": "^4.1.10",
     "shx": "^0.4.0",
-    "typescript": "^5.6.2",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.5"
   }
 }