@vheins/local-memory-mcp 0.7.4 → 0.8.1

package/dist/{chunk-BSASVWKJ.js → chunk-3JIOCO3K.js}

@@ -172,40 +172,28 @@ function addLogSink(sink) {
 var LOG_LEVEL_VALUES = Object.keys(LEVELS);
 
 // src/mcp/storage/sqlite.ts
-import initSqlJs from "sql.js";
+import Database from "better-sqlite3";
 import path2 from "path";
 import fs2 from "fs";
 import os from "os";
 
 // src/mcp/storage/migrations.ts
 var MigrationManager = class {
-  constructor(db, saveDb) {
+  constructor(db) {
     this.db = db;
-    this.saveDb = saveDb;
   }
   db;
-  saveDb;
   run(sql) {
-    this.db.run(sql);
+    this.db.prepare(sql).run();
   }
   exec(sql) {
     this.db.exec(sql);
   }
   all(sql) {
-    const result = this.db.exec(sql);
-    if (result.length === 0) return [];
-    const { columns, values } = result[0];
-    return values.map((row) => {
-      const obj = {};
-      columns.forEach((col, i) => {
-        obj[col] = row[i];
-      });
-      return obj;
-    });
+    return this.db.prepare(sql).all();
   }
   get(sql) {
-    const rows = this.all(sql);
-    return rows[0];
+    return this.db.prepare(sql).get();
   }
   migrate() {
     this.exec(`
@@ -427,7 +415,6 @@ var MigrationManager = class {
       this.run("UPDATE tasks SET task_code = substr(id, 1, 8) WHERE task_code IS NULL");
     } catch {
     }
-    if (this.saveDb) this.saveDb();
   }
   ensureMemoryTypeConstraint() {
     const tableSql = this.get("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memories'");
@@ -531,7 +518,7 @@ var MigrationManager = class {
   }
   ensureMemoryStatusConstraintRemoved() {
     const tableSql = this.get("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'memories'");
-    if (tableSql?.sql?.includes("status TEXT NOT NULL DEFAULT 'active' CHECK")) {
+    if (typeof tableSql?.sql === "string" && tableSql.sql.includes("status TEXT NOT NULL DEFAULT 'active' CHECK")) {
       this.ensureMemoryTypeConstraint();
     }
   }
@@ -792,36 +779,28 @@ function tokenize(text) {
 
 // src/mcp/storage/base.ts
 var BaseEntity = class {
-  constructor(db, saveDb) {
+  constructor(db) {
     this.db = db;
-    this.saveDb = saveDb;
   }
   db;
-  saveDb;
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
   run(sql, params = []) {
-    this.db.run(sql, params);
-    if (this.saveDb) this.saveDb();
-    return { changes: this.db.getRowsModified() };
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(...params);
+    return { changes: result.changes };
   }
   exec(sql) {
     this.db.exec(sql);
-    if (this.saveDb) this.saveDb();
   }
   all(sql, params = []) {
-    const result = this.db.exec(sql, params);
-    if (result.length === 0) return [];
-    const { columns, values } = result[0];
-    return values.map((row) => {
-      const obj = {};
-      columns.forEach((col, i) => {
-        obj[col] = row[i];
-      });
-      return obj;
-    });
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params);
   }
   get(sql, params = []) {
-    const rows = this.all(sql, params);
-    return rows[0];
+    const stmt = this.db.prepare(sql);
+    return stmt.get(...params);
   }
   safeJSONParse(json, defaultValue) {
     if (!json) return defaultValue;
@@ -1055,40 +1034,42 @@ var MemoryEntity = class extends BaseEntity {
     return rows.map((row) => this.rowToMemoryEntry(row));
   }
   bulkInsertMemories(entries) {
-    let count = 0;
-    for (const entry of entries) {
-      this.run(
-        `INSERT INTO memories (
-					id, repo, type, title, content, importance, folder, language,
-					created_at, updated_at, hit_count, recall_count, last_used_at, expires_at,
-					supersedes, status, is_global, tags, metadata, agent, role, model, completed_at
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          entry.id,
-          entry.scope.repo,
-          entry.type,
-          entry.title || null,
-          entry.content,
-          entry.importance,
-          entry.scope.folder || null,
-          entry.scope.language || null,
-          entry.created_at,
-          entry.updated_at,
-          entry.expires_at ?? null,
-          entry.supersedes ?? null,
-          entry.status || "active",
-          entry.is_global ? 1 : 0,
-          entry.tags ? JSON.stringify(entry.tags) : null,
-          entry.metadata ? JSON.stringify(entry.metadata) : null,
-          entry.agent || "unknown",
-          entry.role || "unknown",
-          entry.model || "unknown",
-          entry.completed_at || null
-        ]
-      );
-      count++;
-    }
-    return count;
+    return this.transaction(() => {
+      let count = 0;
+      for (const entry of entries) {
+        this.run(
+          `INSERT INTO memories (
+						id, repo, type, title, content, importance, folder, language,
+						created_at, updated_at, hit_count, recall_count, last_used_at, expires_at,
+						supersedes, status, is_global, tags, metadata, agent, role, model, completed_at
+					) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            entry.id,
+            entry.scope.repo,
+            entry.type,
+            entry.title || null,
+            entry.content,
+            entry.importance,
+            entry.scope.folder || null,
+            entry.scope.language || null,
+            entry.created_at,
+            entry.updated_at,
+            entry.expires_at ?? null,
+            entry.supersedes ?? null,
+            entry.status || "active",
+            entry.is_global ? 1 : 0,
+            entry.tags ? JSON.stringify(entry.tags) : null,
+            entry.metadata ? JSON.stringify(entry.metadata) : null,
+            entry.agent || "unknown",
+            entry.role || "unknown",
+            entry.model || "unknown",
+            entry.completed_at || null
+          ]
+        );
+        count++;
+      }
+      return count;
+    });
   }
   bulkUpdateMemories(ids, updates) {
     if (ids.length === 0) return 0;
@@ -1112,30 +1093,34 @@ var MemoryEntity = class extends BaseEntity {
     if (fields.length === 0) return 0;
     fields.push("updated_at = ?");
     values.push((/* @__PURE__ */ new Date()).toISOString());
-    let count = 0;
-    const chunkSize = 500;
-    for (let i = 0; i < ids.length; i += chunkSize) {
-      const chunk = ids.slice(i, i + chunkSize);
-      const result = this.run(
-        `UPDATE memories SET ${fields.join(", ")} WHERE id IN (${chunk.map(() => "?").join(",")})`,
-        [...values, ...chunk]
-      );
-      count += result.changes;
-    }
-    return count;
+    return this.transaction(() => {
+      let count = 0;
+      const chunkSize = 500;
+      for (let i = 0; i < ids.length; i += chunkSize) {
+        const chunk = ids.slice(i, i + chunkSize);
+        const result = this.run(
+          `UPDATE memories SET ${fields.join(", ")} WHERE id IN (${chunk.map(() => "?").join(",")})`,
+          [...values, ...chunk]
+        );
+        count += result.changes;
+      }
+      return count;
+    });
   }
   bulkDeleteMemories(ids) {
     if (ids.length === 0) return 0;
-    let count = 0;
-    const chunkSize = 500;
-    for (let i = 0; i < ids.length; i += chunkSize) {
-      const chunk = ids.slice(i, i + chunkSize);
-      const result = this.run(`DELETE FROM memories WHERE id IN (${chunk.map(() => "?").join(",")})`, chunk);
-      count += result.changes;
-    }
-    return count;
+    return this.transaction(() => {
+      let count = 0;
+      const chunkSize = 500;
+      for (let i = 0; i < ids.length; i += chunkSize) {
+        const chunk = ids.slice(i, i + chunkSize);
+        const result = this.run(`DELETE FROM memories WHERE id IN (${chunk.map(() => "?").join(",")})`, chunk);
+        count += result.changes;
+      }
+      return count;
+    });
   }
-  getRecentMemories(repo, limit, offset = 0, includeArchived = false, excludeTypes = []) {
+  getRecentMemories(repo, limit, offset = 0, includeArchived = false, excludeTypes = [], sortOrder = "DESC") {
     let query = "SELECT * FROM memories WHERE repo = ?";
     const params = [repo];
     if (!includeArchived) {
@@ -1145,7 +1130,7 @@ var MemoryEntity = class extends BaseEntity {
       query += ` AND type NOT IN (${excludeTypes.map(() => "?").join(",")})`;
       params.push(...excludeTypes);
     }
-    query += " ORDER BY created_at DESC LIMIT ? OFFSET ?";
+    query += ` ORDER BY importance DESC, created_at ${sortOrder} LIMIT ? OFFSET ?`;
     params.push(limit, offset);
     const rows = this.all(query, params);
     return rows.map((row) => this.rowToMemoryEntry(row));
@@ -1380,8 +1365,28 @@ var TaskEntity = class extends BaseEntity {
     const fields = [];
     const values = [];
     const anyUpdates = updates;
+    const VALID_COLUMNS = /* @__PURE__ */ new Set([
+      "repo",
+      "task_code",
+      "phase",
+      "title",
+      "description",
+      "status",
+      "priority",
+      "agent",
+      "role",
+      "doc_path",
+      "finished_at",
+      "canceled_at",
+      "tags",
+      "metadata",
+      "parent_id",
+      "depends_on",
+      "est_tokens",
+      "in_progress_at"
+    ]);
     Object.keys(updates).forEach((key) => {
-      if (key !== "comment" && key !== "model" && anyUpdates[key] !== void 0) {
+      if (VALID_COLUMNS.has(key) && anyUpdates[key] !== void 0) {
         if (key === "tags" || key === "metadata") {
           fields.push(`${key} = ?`);
           values.push(JSON.stringify(anyUpdates[key]));
@@ -1525,40 +1530,42 @@ var TaskEntity = class extends BaseEntity {
     return (row?.count ?? 0) > 0;
   }
   bulkInsertTasks(tasks) {
-    let count = 0;
-    for (const task of tasks) {
-      this.run(
-        `INSERT INTO tasks (
-					id, repo, task_code, phase, title, description, status, priority,
-					agent, role, doc_path, created_at, updated_at, finished_at, canceled_at, tags, metadata, parent_id, depends_on, est_tokens, in_progress_at
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          task.id,
-          task.repo,
-          task.task_code,
-          task.phase || null,
-          task.title,
-          task.description || null,
-          task.status || "backlog",
-          task.priority || 3,
-          task.agent || "unknown",
-          task.role || "unknown",
-          task.doc_path || null,
-          task.created_at,
-          task.updated_at,
-          task.finished_at || null,
-          task.canceled_at || null,
-          task.tags ? JSON.stringify(task.tags) : null,
-          task.metadata ? JSON.stringify(task.metadata) : null,
-          task.parent_id || null,
-          task.depends_on || null,
-          task.est_tokens || 0,
-          task.in_progress_at || null
-        ]
-      );
-      count++;
-    }
-    return count;
+    return this.transaction(() => {
+      let count = 0;
+      for (const task of tasks) {
+        this.run(
+          `INSERT INTO tasks (
+						id, repo, task_code, phase, title, description, status, priority,
+						agent, role, doc_path, created_at, updated_at, finished_at, canceled_at, tags, metadata, parent_id, depends_on, est_tokens, in_progress_at
+					) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            task.id,
+            task.repo,
+            task.task_code,
+            task.phase || null,
+            task.title,
+            task.description || null,
+            task.status || "backlog",
+            task.priority || 3,
+            task.agent || "unknown",
+            task.role || "unknown",
+            task.doc_path || null,
+            task.created_at,
+            task.updated_at,
+            task.finished_at || null,
+            task.canceled_at || null,
+            task.tags ? JSON.stringify(task.tags) : null,
+            task.metadata ? JSON.stringify(task.metadata) : null,
+            task.parent_id || null,
+            task.depends_on || null,
+            task.est_tokens || 0,
+            task.in_progress_at || null
+          ]
+        );
+        count++;
+      }
+      return count;
+    });
   }
   insertTaskComment(comment) {
     this.run(
@@ -1899,32 +1906,6 @@ function resolveDbPath() {
   return standardPath;
 }
 var DB_PATH = resolveDbPath();
-var sqlJsReady = null;
-var sqlJsModule = null;
-async function getSqlJs() {
-  if (!sqlJsModule) {
-    sqlJsModule = await initSqlJs();
-  }
-  await sqlJsReady;
-  return sqlJsModule;
-}
-function createSaveFunction(db, dbPath) {
-  return () => {
-    if (dbPath && dbPath !== ":memory:") {
-      const data = db.export();
-      const buffer = Buffer.from(data);
-      fs2.writeFileSync(dbPath, buffer);
-    }
-  };
-}
-function warmUpSqlJs() {
-  if (!sqlJsReady) {
-    sqlJsReady = (async () => {
-      sqlJsModule = await initSqlJs();
-    })();
-  }
-  return sqlJsReady;
-}
 var SQLiteStore = class _SQLiteStore {
   db;
   memories;
@@ -1932,106 +1913,43 @@ var SQLiteStore = class _SQLiteStore {
   actions;
   system;
   summaries;
-  _ready;
-  lastLoadedAt = 0;
-  saveDbPtr;
   dbPathInstance;
   constructor(dbPath) {
     const finalPath = dbPath ?? DB_PATH;
     this.dbPathInstance = finalPath;
-    warmUpSqlJs();
-    this.db = {};
-    this.memories = {};
-    this.tasks = {};
-    this.actions = {};
-    this.system = {};
-    this.summaries = {};
-    this._ready = this._init(finalPath);
-  }
-  async _init(finalPath) {
-    const SQL = await getSqlJs();
-    let db;
-    if (finalPath === ":memory:") {
-      db = new SQL.Database();
-    } else {
+    if (finalPath !== ":memory:") {
       const dbDir = path2.dirname(finalPath);
       if (!fs2.existsSync(dbDir)) {
         fs2.mkdirSync(dbDir, { recursive: true });
       }
-      if (fs2.existsSync(finalPath)) {
-        const fileBuffer = fs2.readFileSync(finalPath);
-        db = new SQL.Database(fileBuffer);
-      } else {
-        db = new SQL.Database();
-      }
     }
-    this.saveDbPtr = createSaveFunction(db, finalPath);
-    const wrappedSaveDb = () => {
-      if (this.saveDbPtr) {
-        this.saveDbPtr();
-        this.lastLoadedAt = Date.now();
-      }
-    };
-    db.run("PRAGMA journal_mode = WAL");
-    db.run("PRAGMA synchronous = NORMAL");
-    db.run("PRAGMA busy_timeout = 5000");
-    const migrator = new MigrationManager(db, wrappedSaveDb);
+    this.db = new Database(finalPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = FULL");
+    this.db.pragma("busy_timeout = 10000");
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("wal_autocheckpoint = 1000");
+    const migrator = new MigrationManager(this.db);
     migrator.migrate();
     migrator.addMemoryCodeColumn();
-    Object.assign(this, {
-      db,
-      memories: new MemoryEntity(db, wrappedSaveDb),
-      tasks: new TaskEntity(db, wrappedSaveDb),
-      actions: new ActionEntity(db, wrappedSaveDb),
-      system: new SystemEntity(db, wrappedSaveDb),
-      summaries: new SummaryEntity(db, wrappedSaveDb)
-    });
-    this.lastLoadedAt = Date.now();
-    if (finalPath !== ":memory:") {
-      wrappedSaveDb();
-    }
-  }
-  async refresh(force = false) {
-    const path5 = this.getDbPath();
-    if (path5 === ":memory:") return;
-    try {
-      const stats = fs2.statSync(path5);
-      const mtime = stats.mtimeMs;
-      if (force || mtime > this.lastLoadedAt) {
-        const SQL = await getSqlJs();
-        const fileBuffer = fs2.readFileSync(path5);
-        const newDb = new SQL.Database(fileBuffer);
-        const wrappedSaveDb = () => {
-          if (this.saveDbPtr) {
-            this.saveDbPtr();
-            this.lastLoadedAt = Date.now();
-          }
-        };
-        this.db = newDb;
-        this.memories = new MemoryEntity(newDb, wrappedSaveDb);
-        this.tasks = new TaskEntity(newDb, wrappedSaveDb);
-        this.actions = new ActionEntity(newDb, wrappedSaveDb);
-        this.system = new SystemEntity(newDb, wrappedSaveDb);
-        this.summaries = new SummaryEntity(newDb, wrappedSaveDb);
-        this.lastLoadedAt = Date.now();
-      }
-    } catch (e) {
-      console.error("Failed to refresh database from disk:", e);
-    }
+    this.memories = new MemoryEntity(this.db);
+    this.tasks = new TaskEntity(this.db);
+    this.actions = new ActionEntity(this.db);
+    this.system = new SystemEntity(this.db);
+    this.summaries = new SummaryEntity(this.db);
   }
   async ready() {
-    await this._ready;
+  }
+  async refresh() {
   }
   static async create(dbPath) {
-    const store = new _SQLiteStore(dbPath);
-    await store.ready();
-    return store;
+    return new _SQLiteStore(dbPath);
   }
   getDbPath() {
     return this.dbPathInstance;
   }
   close() {
-    if (this.db && this.db.close) {
+    if (this.db && this.db.open) {
       this.db.close();
     }
   }
@@ -2057,7 +1975,8 @@ function updateSessionFromInitialize(session, params) {
   session.clientCapabilities = capabilities;
   session.supportsRoots = Boolean(capabilities.roots);
   session.supportsSampling = Boolean(capabilities.sampling);
-  session.supportsSamplingTools = Boolean(capabilities.sampling?.tools);
+  const sampling = capabilities.sampling;
+  session.supportsSamplingTools = Boolean(sampling?.tools);
   session.supportsElicitation = Boolean(capabilities.elicitation);
   session.supportsElicitationForm = supportsElicitationMode(capabilities.elicitation, "form");
   session.supportsElicitationUrl = supportsElicitationMode(capabilities.elicitation, "url");