kynjal-cli 3.1.3 → 4.0.0

package/dist/src/mcp-tools/memory-tools.js

@@ -9,12 +9,48 @@
  *
  * @module v3/cli/mcp-tools/memory-tools
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 // Paths
-const MEMORY_DIR = '.claude-flow/memory';
-const LEGACY_MEMORY_FILE = 'store.json';
-const MIGRATION_MARKER = '.migrated-to-sqlite';
+var MEMORY_DIR = '.claude-flow/memory';
+var LEGACY_MEMORY_FILE = 'store.json';
+var MIGRATION_MARKER = '.migrated-to-sqlite';
 function getMemoryDir() {
     return resolve(MEMORY_DIR);
 }
@@ -25,17 +61,32 @@ function getMigrationMarkerPath() {
     return resolve(join(MEMORY_DIR, MIGRATION_MARKER));
 }
 function ensureMemoryDir() {
-    const dir = getMemoryDir();
+    var dir = getMemoryDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
+// D-2: Input bounds for memory parameters
+var MAX_KEY_LENGTH = 1024;
+var MAX_VALUE_SIZE = 1024 * 1024; // 1MB
+var MAX_QUERY_LENGTH = 4096;
+function validateMemoryInput(key, value, query) {
+    if (key && key.length > MAX_KEY_LENGTH) {
+        throw new Error("Key exceeds maximum length of " + MAX_KEY_LENGTH + " characters");
+    }
+    if (value && value.length > MAX_VALUE_SIZE) {
+        throw new Error("Value exceeds maximum size of " + MAX_VALUE_SIZE + " bytes");
+    }
+    if (query && query.length > MAX_QUERY_LENGTH) {
+        throw new Error("Query exceeds maximum length of " + MAX_QUERY_LENGTH + " characters");
+    }
+}
 /**
  * Check if legacy JSON store exists and needs migration
  */
 function hasLegacyStore() {
-    const legacyPath = getLegacyPath();
-    const migrationMarker = getMigrationMarkerPath();
+    var legacyPath = getLegacyPath();
+    var migrationMarker = getMigrationMarkerPath();
     return existsSync(legacyPath) && !existsSync(migrationMarker);
 }
 /**
@@ -43,13 +94,13 @@ function hasLegacyStore() {
  */
 function loadLegacyStore() {
     try {
-        const path = getLegacyPath();
+        var path = getLegacyPath();
         if (existsSync(path)) {
-            const data = readFileSync(path, 'utf-8');
+            var data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
         }
     }
-    catch {
+    catch (_a) {
         // Return null on error
     }
     return null;
@@ -61,62 +112,94 @@ function markMigrationComplete() {
     ensureMemoryDir();
     writeFileSync(getMigrationMarkerPath(), JSON.stringify({
         migratedAt: new Date().toISOString(),
-        version: '3.0.0',
+        version: '3.0.0'
     }), 'utf-8');
 }
 /**
  * Lazy-load memory initializer functions to avoid circular deps
  */
-async function getMemoryFunctions() {
-    const { storeEntry, searchEntries, listEntries, getEntry, deleteEntry, initializeMemoryDatabase, checkMemoryInitialization, } = await import('../memory/memory-initializer.js');
-    return {
-        storeEntry,
-        searchEntries,
-        listEntries,
-        getEntry,
-        deleteEntry,
-        initializeMemoryDatabase,
-        checkMemoryInitialization,
-    };
+function getMemoryFunctions() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, storeEntry, searchEntries, listEntries, getEntry, deleteEntry, initializeMemoryDatabase, checkMemoryInitialization;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 1:
+                    _a = _b.sent(), storeEntry = _a.storeEntry, searchEntries = _a.searchEntries, listEntries = _a.listEntries, getEntry = _a.getEntry, deleteEntry = _a.deleteEntry, initializeMemoryDatabase = _a.initializeMemoryDatabase, checkMemoryInitialization = _a.checkMemoryInitialization;
+                    return [2 /*return*/, {
+                            storeEntry: storeEntry,
+                            searchEntries: searchEntries,
+                            listEntries: listEntries,
+                            getEntry: getEntry,
+                            deleteEntry: deleteEntry,
+                            initializeMemoryDatabase: initializeMemoryDatabase,
+                            checkMemoryInitialization: checkMemoryInitialization
+                        }];
+            }
+        });
+    });
 }
 /**
  * Ensure memory database is initialized and migrate legacy data if needed
  */
-async function ensureInitialized() {
-    const { initializeMemoryDatabase, checkMemoryInitialization, storeEntry } = await getMemoryFunctions();
-    // Check if already initialized
-    const status = await checkMemoryInitialization();
-    if (!status.initialized) {
-        await initializeMemoryDatabase({ force: false, verbose: false });
-    }
-    // Migrate legacy JSON data if exists
-    if (hasLegacyStore()) {
-        const legacyStore = loadLegacyStore();
-        if (legacyStore && Object.keys(legacyStore.entries).length > 0) {
-            console.error('[MCP Memory] Migrating legacy JSON store to sql.js...');
-            let migrated = 0;
-            for (const [key, entry] of Object.entries(legacyStore.entries)) {
-                try {
-                    // Convert value to string for storage
-                    const value = typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value);
-                    await storeEntry({
-                        key,
-                        value,
-                        namespace: 'default',
-                        generateEmbeddingFlag: true,
-                    });
+function ensureInitialized() {
+    return __awaiter(this, void 0, Promise, function () {
+        var _a, initializeMemoryDatabase, checkMemoryInitialization, storeEntry, status, legacyStore, migrated, _i, _b, _c, key, entry, value, e_1;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, getMemoryFunctions()];
+                case 1:
+                    _a = _d.sent(), initializeMemoryDatabase = _a.initializeMemoryDatabase, checkMemoryInitialization = _a.checkMemoryInitialization, storeEntry = _a.storeEntry;
+                    return [4 /*yield*/, checkMemoryInitialization()];
+                case 2:
+                    status = _d.sent();
+                    if (!!status.initialized) return [3 /*break*/, 4];
+                    return [4 /*yield*/, initializeMemoryDatabase({ force: false, verbose: false })];
+                case 3:
+                    _d.sent();
+                    _d.label = 4;
+                case 4:
+                    if (!hasLegacyStore()) return [3 /*break*/, 11];
+                    legacyStore = loadLegacyStore();
+                    if (!(legacyStore && Object.keys(legacyStore.entries).length > 0)) return [3 /*break*/, 11];
+                    console.error('[MCP Memory] Migrating legacy JSON store to sql.js...');
+                    migrated = 0;
+                    _i = 0, _b = Object.entries(legacyStore.entries);
+                    _d.label = 5;
+                case 5:
+                    if (!(_i < _b.length)) return [3 /*break*/, 10];
+                    _c = _b[_i], key = _c[0], entry = _c[1];
+                    _d.label = 6;
+                case 6:
+                    _d.trys.push([6, 8, , 9]);
+                    value = typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value);
+                    return [4 /*yield*/, storeEntry({
+                            key: key,
+                            value: value,
+                            namespace: 'default',
+                            generateEmbeddingFlag: true
+                        })];
+                case 7:
+                    _d.sent();
                     migrated++;
-                }
-                catch (e) {
-                    console.error(`[MCP Memory] Failed to migrate key "${key}":`, e);
-                }
+                    return [3 /*break*/, 9];
+                case 8:
+                    e_1 = _d.sent();
+                    console.error("[MCP Memory] Failed to migrate key \"" + key + "\":", e_1);
+                    return [3 /*break*/, 9];
+                case 9:
+                    _i++;
+                    return [3 /*break*/, 5];
+                case 10:
+                    console.error("[MCP Memory] Migrated " + migrated + "/" + Object.keys(legacyStore.entries).length + " entries");
+                    markMigrationComplete();
+                    _d.label = 11;
+                case 11: return [2 /*return*/];
             }
-            console.error(`[MCP Memory] Migrated ${migrated}/${Object.keys(legacyStore.entries).length} entries`);
-            markMigrationComplete();
-        }
-    }
+        });
+    });
 }
-export const memoryTools = [
+export var memoryTools = [
     {
         name: 'memory_store',
         description: 'Store a value in memory with vector embedding for semantic search (sql.js + HNSW backend). Use upsert=true to update existing keys.',
@@ -130,55 +213,80 @@ export const memoryTools = [
                 tags: {
                     type: 'array',
                     items: { type: 'string' },
-                    description: 'Optional tags for filtering',
+                    description: 'Optional tags for filtering'
                 },
                 ttl: { type: 'number', description: 'Time-to-live in seconds (optional)' },
-                upsert: { type: 'boolean', description: 'If true, update existing key instead of failing (default: false)' },
+                upsert: { type: 'boolean', description: 'If true, update existing key instead of failing (default: false)' }
             },
-            required: ['key', 'value'],
-        },
-        handler: async (input) => {
-            await ensureInitialized();
-            const { storeEntry } = await getMemoryFunctions();
-            const key = input.key;
-            const namespace = input.namespace || 'default';
-            const value = typeof input.value === 'string' ? input.value : JSON.stringify(input.value);
-            const tags = input.tags || [];
-            const ttl = input.ttl;
-            const upsert = input.upsert || false;
-            const startTime = performance.now();
-            try {
-                const result = await storeEntry({
-                    key,
-                    value,
-                    namespace,
-                    generateEmbeddingFlag: true,
-                    tags,
-                    ttl,
-                    upsert,
-                });
-                const duration = performance.now() - startTime;
-                return {
-                    success: result.success,
-                    key,
-                    namespace,
-                    stored: result.success,
-                    storedAt: new Date().toISOString(),
-                    hasEmbedding: !!result.embedding,
-                    embeddingDimensions: result.embedding?.dimensions || null,
-                    backend: 'sql.js + HNSW',
-                    storeTime: `${duration.toFixed(2)}ms`,
-                    error: result.error,
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    key,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
+            required: ['key', 'value']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var storeEntry, key, namespace, rawValue, value, tags, ttl, upsert, startTime, result, duration, error_1;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, ensureInitialized()];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, getMemoryFunctions()];
+                    case 2:
+                        storeEntry = (_b.sent()).storeEntry;
+                        key = input.key;
+                        namespace = input.namespace || 'default';
+                        rawValue = input.value;
+                        value = typeof rawValue === 'string' ? rawValue : (rawValue !== undefined ? JSON.stringify(rawValue) : '');
+                        tags = input.tags || [];
+                        ttl = input.ttl;
+                        upsert = input.upsert || false;
+                        if (!value) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    key: key,
+                                    stored: false,
+                                    hasEmbedding: false,
+                                    error: 'Value is required and cannot be empty'
+                                }];
+                        }
+                        validateMemoryInput(key, value);
+                        startTime = performance.now();
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, storeEntry({
+                                key: key,
+                                value: value,
+                                namespace: namespace,
+                                generateEmbeddingFlag: true,
+                                tags: tags,
+                                ttl: ttl,
+                                upsert: upsert
+                            })];
+                    case 4:
+                        result = _b.sent();
+                        duration = performance.now() - startTime;
+                        return [2 /*return*/, {
+                                success: result.success,
+                                key: key,
+                                namespace: namespace,
+                                stored: result.success,
+                                storedAt: new Date().toISOString(),
+                                hasEmbedding: !!result.embedding,
+                                embeddingDimensions: ((_a = result.embedding) === null || _a === void 0 ? void 0 : _a.dimensions) || null,
+                                backend: 'sql.js + HNSW',
+                                storeTime: duration.toFixed(2) + "ms",
+                                error: result.error
+                            }];
+                    case 5:
+                        error_1 = _b.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                key: key,
+                                error: error_1 instanceof Error ? error_1.message : 'Unknown error'
+                            }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'memory_retrieve',
@@ -188,56 +296,69 @@ export const memoryTools = [
             type: 'object',
             properties: {
                 key: { type: 'string', description: 'Memory key' },
-                namespace: { type: 'string', description: 'Namespace (default: "default")' },
+                namespace: { type: 'string', description: 'Namespace (default: "default")' }
             },
-            required: ['key'],
+            required: ['key']
         },
-        handler: async (input) => {
-            await ensureInitialized();
-            const { getEntry } = await getMemoryFunctions();
-            const key = input.key;
-            const namespace = input.namespace || 'default';
-            try {
-                const result = await getEntry({ key, namespace });
-                if (result.found && result.entry) {
-                    // Try to parse JSON value
-                    let value = result.entry.content;
-                    try {
-                        value = JSON.parse(result.entry.content);
-                    }
-                    catch {
-                        // Keep as string
-                    }
-                    return {
-                        key,
-                        namespace,
-                        value,
-                        tags: result.entry.tags,
-                        storedAt: result.entry.createdAt,
-                        updatedAt: result.entry.updatedAt,
-                        accessCount: result.entry.accessCount,
-                        hasEmbedding: result.entry.hasEmbedding,
-                        found: true,
-                        backend: 'sql.js + HNSW',
-                    };
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var getEntry, key, namespace, result, value, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureInitialized()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, getMemoryFunctions()];
+                    case 2:
+                        getEntry = (_a.sent()).getEntry;
+                        key = input.key;
+                        namespace = input.namespace || 'default';
+                        validateMemoryInput(key);
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, getEntry({ key: key, namespace: namespace })];
+                    case 4:
+                        result = _a.sent();
+                        if (result.found && result.entry) {
+                            value = result.entry.content;
+                            try {
+                                value = JSON.parse(result.entry.content);
+                            }
+                            catch (_b) {
+                                // Keep as string
+                            }
+                            return [2 /*return*/, {
+                                    key: key,
+                                    namespace: namespace,
+                                    value: value,
+                                    tags: result.entry.tags,
+                                    storedAt: result.entry.createdAt,
+                                    updatedAt: result.entry.updatedAt,
+                                    accessCount: result.entry.accessCount,
+                                    hasEmbedding: result.entry.hasEmbedding,
+                                    found: true,
+                                    backend: 'sql.js + HNSW'
+                                }];
+                        }
+                        return [2 /*return*/, {
+                                key: key,
+                                namespace: namespace,
+                                value: null,
+                                found: false
+                            }];
+                    case 5:
+                        error_2 = _a.sent();
+                        return [2 /*return*/, {
+                                key: key,
+                                namespace: namespace,
+                                value: null,
+                                found: false,
+                                error: error_2 instanceof Error ? error_2.message : 'Unknown error'
+                            }];
+                    case 6: return [2 /*return*/];
                 }
-                return {
-                    key,
-                    namespace,
-                    value: null,
-                    found: false,
-                };
-            }
-            catch (error) {
-                return {
-                    key,
-                    namespace,
-                    value: null,
-                    found: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
-        },
+            });
+        }); }
     },
     {
         name: 'memory_search',
@@ -249,59 +370,72 @@ export const memoryTools = [
                 query: { type: 'string', description: 'Search query (semantic similarity)' },
                 namespace: { type: 'string', description: 'Namespace to search (default: "default")' },
                 limit: { type: 'number', description: 'Maximum results (default: 10)' },
-                threshold: { type: 'number', description: 'Minimum similarity threshold 0-1 (default: 0.3)' },
+                threshold: { type: 'number', description: 'Minimum similarity threshold 0-1 (default: 0.3)' }
             },
-            required: ['query'],
-        },
-        handler: async (input) => {
-            await ensureInitialized();
-            const { searchEntries } = await getMemoryFunctions();
-            const query = input.query;
-            const namespace = input.namespace || 'default';
-            const limit = input.limit || 10;
-            const threshold = input.threshold || 0.3;
-            const startTime = performance.now();
-            try {
-                const result = await searchEntries({
-                    query,
-                    namespace,
-                    limit,
-                    threshold,
-                });
-                const duration = performance.now() - startTime;
-                // Parse JSON values in results
-                const results = result.results.map(r => {
-                    let value = r.content;
-                    try {
-                        value = JSON.parse(r.content);
-                    }
-                    catch {
-                        // Keep as string
-                    }
-                    return {
-                        key: r.key,
-                        namespace: r.namespace,
-                        value,
-                        similarity: r.score,
-                    };
-                });
-                return {
-                    query,
-                    results,
-                    total: results.length,
-                    searchTime: `${duration.toFixed(2)}ms`,
-                    backend: 'HNSW + sql.js',
-                };
-            }
-            catch (error) {
-                return {
-                    query,
-                    results: [],
-                    total: 0,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
+            required: ['query']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var searchEntries, query, namespace, limit, threshold, startTime, result, duration, results, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureInitialized()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, getMemoryFunctions()];
+                    case 2:
+                        searchEntries = (_a.sent()).searchEntries;
+                        query = input.query;
+                        namespace = input.namespace || 'default';
+                        limit = input.limit || 10;
+                        threshold = input.threshold || 0.3;
+                        validateMemoryInput(undefined, undefined, query);
+                        startTime = performance.now();
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, searchEntries({
+                                query: query,
+                                namespace: namespace,
+                                limit: limit,
+                                threshold: threshold
+                            })];
+                    case 4:
+                        result = _a.sent();
+                        duration = performance.now() - startTime;
+                        results = result.results.map(function (r) {
+                            var value = r.content;
+                            try {
+                                value = JSON.parse(r.content);
+                            }
+                            catch (_a) {
+                                // Keep as string
+                            }
+                            return {
+                                key: r.key,
+                                namespace: r.namespace,
+                                value: value,
+                                similarity: r.score
+                            };
+                        });
+                        return [2 /*return*/, {
+                                query: query,
+                                results: results,
+                                total: results.length,
+                                searchTime: duration.toFixed(2) + "ms",
+                                backend: 'HNSW + sql.js'
+                            }];
+                    case 5:
+                        error_3 = _a.sent();
+                        return [2 /*return*/, {
+                                query: query,
+                                results: [],
+                                total: 0,
+                                error: error_3 instanceof Error ? error_3.message : 'Unknown error'
+                            }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'memory_delete',
@@ -311,35 +445,50 @@ export const memoryTools = [
             type: 'object',
             properties: {
                 key: { type: 'string', description: 'Memory key' },
-                namespace: { type: 'string', description: 'Namespace (default: "default")' },
+                namespace: { type: 'string', description: 'Namespace (default: "default")' }
             },
-            required: ['key'],
-        },
-        handler: async (input) => {
-            await ensureInitialized();
-            const { deleteEntry } = await getMemoryFunctions();
-            const key = input.key;
-            const namespace = input.namespace || 'default';
-            try {
-                const result = await deleteEntry({ key, namespace });
-                return {
-                    success: result.deleted,
-                    key,
-                    namespace,
-                    deleted: result.deleted,
-                    backend: 'sql.js + HNSW',
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    key,
-                    namespace,
-                    deleted: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
+            required: ['key']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var deleteEntry, key, namespace, result, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureInitialized()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, getMemoryFunctions()];
+                    case 2:
+                        deleteEntry = (_a.sent()).deleteEntry;
+                        key = input.key;
+                        namespace = input.namespace || 'default';
+                        validateMemoryInput(key);
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, deleteEntry({ key: key, namespace: namespace })];
+                    case 4:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                success: result.deleted,
+                                key: key,
+                                namespace: namespace,
+                                deleted: result.deleted,
+                                hnswIndexInvalidated: result.deleted,
+                                backend: 'sql.js + HNSW'
+                            }];
+                    case 5:
+                        error_4 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                key: key,
+                                namespace: namespace,
+                                deleted: false,
+                                error: error_4 instanceof Error ? error_4.message : 'Unknown error'
+                            }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'memory_list',
@@ -350,48 +499,61 @@ export const memoryTools = [
             properties: {
                 namespace: { type: 'string', description: 'Filter by namespace' },
                 limit: { type: 'number', description: 'Maximum results (default: 50)' },
-                offset: { type: 'number', description: 'Offset for pagination (default: 0)' },
-            },
-        },
-        handler: async (input) => {
-            await ensureInitialized();
-            const { listEntries } = await getMemoryFunctions();
-            const namespace = input.namespace;
-            const limit = input.limit || 50;
-            const offset = input.offset || 0;
-            try {
-                const result = await listEntries({
-                    namespace,
-                    limit,
-                    offset,
-                });
-                const entries = result.entries.map(e => ({
-                    key: e.key,
-                    namespace: e.namespace,
-                    storedAt: e.createdAt,
-                    updatedAt: e.updatedAt,
-                    accessCount: e.accessCount,
-                    hasEmbedding: e.hasEmbedding,
-                    size: e.size,
-                }));
-                return {
-                    entries,
-                    total: result.total,
-                    limit,
-                    offset,
-                    backend: 'sql.js + HNSW',
-                };
-            }
-            catch (error) {
-                return {
-                    entries: [],
-                    total: 0,
-                    limit,
-                    offset,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
+                offset: { type: 'number', description: 'Offset for pagination (default: 0)' }
             }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var listEntries, namespace, limit, offset, result, entries, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureInitialized()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, getMemoryFunctions()];
+                    case 2:
+                        listEntries = (_a.sent()).listEntries;
+                        namespace = input.namespace;
+                        limit = input.limit || 50;
+                        offset = input.offset || 0;
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, listEntries({
+                                namespace: namespace,
+                                limit: limit,
+                                offset: offset
+                            })];
+                    case 4:
+                        result = _a.sent();
+                        entries = result.entries.map(function (e) { return ({
+                            key: e.key,
+                            namespace: e.namespace,
+                            storedAt: e.createdAt,
+                            updatedAt: e.updatedAt,
+                            accessCount: e.accessCount,
+                            hasEmbedding: e.hasEmbedding,
+                            size: e.size
+                        }); });
+                        return [2 /*return*/, {
+                                entries: entries,
+                                total: result.total,
+                                limit: limit,
+                                offset: offset,
+                                backend: 'sql.js + HNSW'
+                            }];
+                    case 5:
+                        error_5 = _a.sent();
+                        return [2 /*return*/, {
+                                entries: [],
+                                total: 0,
+                                limit: limit,
+                                offset: offset,
+                                error: error_5 instanceof Error ? error_5.message : 'Unknown error'
+                            }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'memory_stats',
@@ -399,46 +561,61 @@ export const memoryTools = [
         category: 'memory',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {}
         },
-        handler: async () => {
-            await ensureInitialized();
-            const { checkMemoryInitialization, listEntries } = await getMemoryFunctions();
-            try {
-                const status = await checkMemoryInitialization();
-                const allEntries = await listEntries({ limit: 100000 });
-                // Count by namespace
-                const namespaces = {};
-                let withEmbeddings = 0;
-                for (const entry of allEntries.entries) {
-                    namespaces[entry.namespace] = (namespaces[entry.namespace] || 0) + 1;
-                    if (entry.hasEmbedding)
-                        withEmbeddings++;
+        handler: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, checkMemoryInitialization, listEntries, status, allEntries, namespaces, withEmbeddings, _i, _b, entry, error_6;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, ensureInitialized()];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, getMemoryFunctions()];
+                    case 2:
+                        _a = _c.sent(), checkMemoryInitialization = _a.checkMemoryInitialization, listEntries = _a.listEntries;
+                        _c.label = 3;
+                    case 3:
+                        _c.trys.push([3, 6, , 7]);
+                        return [4 /*yield*/, checkMemoryInitialization()];
+                    case 4:
+                        status = _c.sent();
+                        return [4 /*yield*/, listEntries({ limit: 100000 })];
+                    case 5:
+                        allEntries = _c.sent();
+                        namespaces = {};
+                        withEmbeddings = 0;
+                        for (_i = 0, _b = allEntries.entries; _i < _b.length; _i++) {
+                            entry = _b[_i];
+                            namespaces[entry.namespace] = (namespaces[entry.namespace] || 0) + 1;
+                            if (entry.hasEmbedding)
+                                withEmbeddings++;
+                        }
+                        return [2 /*return*/, {
+                                initialized: status.initialized,
+                                totalEntries: allEntries.total,
+                                entriesWithEmbeddings: withEmbeddings,
+                                embeddingCoverage: allEntries.total > 0
+                                    ? ((withEmbeddings / allEntries.total) * 100).toFixed(1) + "%"
+                                    : '0%',
+                                namespaces: namespaces,
+                                backend: 'sql.js + HNSW',
+                                version: status.version || '3.0.0',
+                                features: status.features || {
+                                    vectorEmbeddings: true,
+                                    hnswIndex: true,
+                                    semanticSearch: true
+                                }
+                            }];
+                    case 6:
+                        error_6 = _c.sent();
+                        return [2 /*return*/, {
+                                initialized: false,
+                                error: error_6 instanceof Error ? error_6.message : 'Unknown error'
+                            }];
+                    case 7: return [2 /*return*/];
                 }
-                return {
-                    initialized: status.initialized,
-                    totalEntries: allEntries.total,
-                    entriesWithEmbeddings: withEmbeddings,
-                    embeddingCoverage: allEntries.total > 0
-                        ? `${((withEmbeddings / allEntries.total) * 100).toFixed(1)}%`
-                        : '0%',
-                    namespaces,
-                    backend: 'sql.js + HNSW',
-                    version: status.version || '3.0.0',
-                    features: status.features || {
-                        vectorEmbeddings: true,
-                        hnswIndex: true,
-                        semanticSearch: true,
-                    },
-                };
-            }
-            catch (error) {
-                return {
-                    initialized: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                };
-            }
-        },
+            });
+        }); }
     },
     {
         name: 'memory_migrate',
@@ -447,36 +624,44 @@ export const memoryTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                force: { type: 'boolean', description: 'Force re-migration even if already done' },
-            },
-        },
-        handler: async (input) => {
-            const force = input.force;
-            // Remove migration marker if forcing
-            if (force) {
-                const markerPath = getMigrationMarkerPath();
-                if (existsSync(markerPath)) {
-                    unlinkSync(markerPath);
-                }
+                force: { type: 'boolean', description: 'Force re-migration even if already done' }
             }
-            // Check for legacy data
-            const legacyStore = loadLegacyStore();
-            if (!legacyStore || Object.keys(legacyStore.entries).length === 0) {
-                return {
-                    success: true,
-                    message: 'No legacy data to migrate',
-                    migrated: 0,
-                };
-            }
-            // Run migration via ensureInitialized
-            await ensureInitialized();
-            return {
-                success: true,
-                message: 'Migration completed',
-                migrated: Object.keys(legacyStore.entries).length,
-                backend: 'sql.js + HNSW',
-            };
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var force, markerPath, legacyStore;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        force = input.force;
+                        // Remove migration marker if forcing
+                        if (force) {
+                            markerPath = getMigrationMarkerPath();
+                            if (existsSync(markerPath)) {
+                                unlinkSync(markerPath);
+                            }
+                        }
+                        legacyStore = loadLegacyStore();
+                        if (!legacyStore || Object.keys(legacyStore.entries).length === 0) {
+                            return [2 /*return*/, {
+                                    success: true,
+                                    message: 'No legacy data to migrate',
+                                    migrated: 0
+                                }];
+                        }
+                        // Run migration via ensureInitialized
+                        return [4 /*yield*/, ensureInitialized()];
+                    case 1:
+                        // Run migration via ensureInitialized
+                        _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                message: 'Migration completed',
+                                migrated: Object.keys(legacyStore.entries).length,
+                                backend: 'sql.js + HNSW'
+                            }];
+                }
+            });
+        }); }
     },
 ];
 //# sourceMappingURL=memory-tools.js.map