kynjal-cli 4.0.0 → 4.0.1

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

@@ -9,48 +9,12 @@
  *
  * @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
-var MEMORY_DIR = '.claude-flow/memory';
-var LEGACY_MEMORY_FILE = 'store.json';
-var MIGRATION_MARKER = '.migrated-to-sqlite';
+const MEMORY_DIR = '.claude-flow/memory';
+const LEGACY_MEMORY_FILE = 'store.json';
+const MIGRATION_MARKER = '.migrated-to-sqlite';
 function getMemoryDir() {
     return resolve(MEMORY_DIR);
 }
@@ -61,32 +25,32 @@ function getMigrationMarkerPath() {
     return resolve(join(MEMORY_DIR, MIGRATION_MARKER));
 }
 function ensureMemoryDir() {
-    var dir = getMemoryDir();
+    const 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;
+const MAX_KEY_LENGTH = 1024;
+const MAX_VALUE_SIZE = 1024 * 1024; // 1MB
+const 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");
+        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");
+        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");
+        throw new Error(`Query exceeds maximum length of ${MAX_QUERY_LENGTH} characters`);
     }
 }
 /**
  * Check if legacy JSON store exists and needs migration
  */
 function hasLegacyStore() {
-    var legacyPath = getLegacyPath();
-    var migrationMarker = getMigrationMarkerPath();
+    const legacyPath = getLegacyPath();
+    const migrationMarker = getMigrationMarkerPath();
     return existsSync(legacyPath) && !existsSync(migrationMarker);
 }
 /**
@@ -94,13 +58,13 @@ function hasLegacyStore() {
  */
 function loadLegacyStore() {
     try {
-        var path = getLegacyPath();
+        const path = getLegacyPath();
         if (existsSync(path)) {
-            var data = readFileSync(path, 'utf-8');
+            const data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
         }
     }
-    catch (_a) {
+    catch {
         // Return null on error
     }
     return null;
@@ -112,94 +76,62 @@ 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
  */
-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
-                        }];
-            }
-        });
-    });
+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,
+    };
 }
 /**
  * Ensure memory database is initialized and migrate legacy data if needed
  */
-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();
+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,
+                    });
                     migrated++;
-                    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*/];
+                }
+                catch (e) {
+                    console.error(`[MCP Memory] Failed to migrate key "${key}":`, e);
+                }
             }
-        });
-    });
+            console.error(`[MCP Memory] Migrated ${migrated}/${Object.keys(legacyStore.entries).length} entries`);
+            markMigrationComplete();
+        }
+    }
 }
-export var memoryTools = [
+export const 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.',
@@ -213,80 +145,66 @@ export var 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']
+            required: ['key', 'value'],
+        },
+        handler: async (input) => {
+            await ensureInitialized();
+            const { storeEntry } = await getMemoryFunctions();
+            const key = input.key;
+            const namespace = input.namespace || 'default';
+            const rawValue = input.value;
+            const value = typeof rawValue === 'string' ? rawValue : (rawValue !== undefined ? JSON.stringify(rawValue) : '');
+            const tags = input.tags || [];
+            const ttl = input.ttl;
+            const upsert = input.upsert || false;
+            if (!value) {
+                return {
+                    success: false,
+                    key,
+                    stored: false,
+                    hasEmbedding: false,
+                    error: 'Value is required and cannot be empty',
+                };
+            }
+            validateMemoryInput(key, value);
+            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',
+                };
+            }
         },
-        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',
@@ -296,69 +214,57 @@ export var 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: 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*/];
+        handler: async (input) => {
+            await ensureInitialized();
+            const { getEntry } = await getMemoryFunctions();
+            const key = input.key;
+            const namespace = input.namespace || 'default';
+            validateMemoryInput(key);
+            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',
+                    };
                 }
-            });
-        }); }
+                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',
@@ -370,72 +276,60 @@ export var 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']
+            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;
+            validateMemoryInput(undefined, undefined, query);
+            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',
+                };
+            }
         },
-        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',
@@ -445,50 +339,37 @@ export var 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 { deleteEntry } = await getMemoryFunctions();
+            const key = input.key;
+            const namespace = input.namespace || 'default';
+            validateMemoryInput(key);
+            try {
+                const result = await deleteEntry({ key, namespace });
+                return {
+                    success: result.deleted,
+                    key,
+                    namespace,
+                    deleted: result.deleted,
+                    hnswIndexInvalidated: result.deleted,
+                    backend: 'sql.js + HNSW',
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    key,
+                    namespace,
+                    deleted: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
         },
-        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',
@@ -499,61 +380,48 @@ export var 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)' }
+                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',
+                };
             }
         },
-        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',
@@ -561,61 +429,46 @@ export var memoryTools = [
         category: 'memory',
         inputSchema: {
             type: 'object',
-            properties: {}
+            properties: {},
         },
-        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*/];
+        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++;
                 }
-            });
-        }); }
+                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',
@@ -624,44 +477,36 @@ export var memoryTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                force: { type: 'boolean', description: 'Force re-migration even if already done' }
-            }
+                force: { type: 'boolean', description: 'Force re-migration even if already done' },
+            },
         },
-        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'
-                            }];
+        handler: async (input) => {
+            const force = input.force;
+            // Remove migration marker if forcing
+            if (force) {
+                const markerPath = getMigrationMarkerPath();
+                if (existsSync(markerPath)) {
+                    unlinkSync(markerPath);
                 }
-            });
-        }); }
+            }
+            // 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',
+            };
+        },
     },
 ];
 //# sourceMappingURL=memory-tools.js.map