@vheins/local-memory-mcp 0.8.0 → 0.8.2

package/dist/{chunk-CQK2B6SF.js → chunk-MC6NSQJ6.js}

@@ -173,8 +173,8 @@ var LOG_LEVEL_VALUES = Object.keys(LEVELS);
 
 // src/mcp/storage/sqlite.ts
 import Database from "better-sqlite3";
-import path2 from "path";
-import fs2 from "fs";
+import path3 from "path";
+import fs3 from "fs";
 import os from "os";
 
 // src/mcp/storage/migrations.ts
@@ -783,6 +783,9 @@ var BaseEntity = class {
     this.db = db;
   }
   db;
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
   run(sql, params = []) {
     const stmt = this.db.prepare(sql);
     const result = stmt.run(...params);
@@ -1031,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;
@@ -1088,28 +1093,32 @@ 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 = [], sortOrder = "DESC") {
     let query = "SELECT * FROM memories WHERE repo = ?";
@@ -1521,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(
@@ -1882,16 +1893,79 @@ var SummaryEntity = class extends BaseEntity {
   }
 };
 
+// src/mcp/storage/write-lock.ts
+import lockfile from "proper-lockfile";
+import path2 from "path";
+import fs2 from "fs";
+var LOCK_STALE_MS = 15e3;
+var LOCK_RETRY_DELAY_MS = 100;
+var LOCK_RETRY_COUNT = 150;
+var WriteLock = class {
+  lockTarget;
+  locked = false;
+  constructor(dbPath) {
+    this.lockTarget = dbPath;
+    if (!fs2.existsSync(dbPath)) {
+      fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
+      fs2.writeFileSync(dbPath, "");
+    }
+  }
+  /**
+   * Acquire the write lock. Waits up to 15s for other processes to release.
+   */
+  async acquire() {
+    await lockfile.lock(this.lockTarget, {
+      stale: LOCK_STALE_MS,
+      retries: {
+        retries: LOCK_RETRY_COUNT,
+        minTimeout: LOCK_RETRY_DELAY_MS,
+        maxTimeout: LOCK_RETRY_DELAY_MS
+      },
+      realpath: false
+    });
+    this.locked = true;
+  }
+  /**
+   * Release the write lock.
+   */
+  async release() {
+    if (!this.locked) return;
+    try {
+      await lockfile.unlock(this.lockTarget, { realpath: false });
+    } catch {
+    }
+    this.locked = false;
+  }
+  /**
+   * Run a synchronous write function under the lock.
+   * Guarantees lock is always released, even on error.
+   */
+  async withLock(fn) {
+    await this.acquire();
+    try {
+      return fn();
+    } finally {
+      await this.release();
+    }
+  }
+  /**
+   * Check if a lock file exists (another process may be writing).
+   */
+  isLocked() {
+    return lockfile.checkSync(this.lockTarget, { realpath: false });
+  }
+};
+
 // src/mcp/storage/sqlite.ts
 function resolveDbPath() {
   if (process.env.MEMORY_DB_PATH) return process.env.MEMORY_DB_PATH;
-  const standardConfigDir = process.platform === "win32" ? path2.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path2.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path2.join(os.homedir(), ".config", "local-memory-mcp");
-  const standardPath = path2.join(standardConfigDir, "memory.db");
-  if (fs2.existsSync(standardPath)) return standardPath;
-  const legacyPath = path2.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
-  if (fs2.existsSync(legacyPath)) return legacyPath;
-  const localCwdFile = path2.join(process.cwd(), "storage", "memory.db");
-  if (fs2.existsSync(localCwdFile)) return localCwdFile;
+  const standardConfigDir = process.platform === "win32" ? path3.join(os.homedir(), ".local-memory-mcp") : process.platform === "darwin" ? path3.join(os.homedir(), "Library", "Application Support", "local-memory-mcp") : path3.join(os.homedir(), ".config", "local-memory-mcp");
+  const standardPath = path3.join(standardConfigDir, "memory.db");
+  if (fs3.existsSync(standardPath)) return standardPath;
+  const legacyPath = path3.join(os.homedir(), ".config", "local-memory-mcp", "memory.db");
+  if (fs3.existsSync(legacyPath)) return legacyPath;
+  const localCwdFile = path3.join(process.cwd(), "storage", "memory.db");
+  if (fs3.existsSync(localCwdFile)) return localCwdFile;
   return standardPath;
 }
 var DB_PATH = resolveDbPath();
@@ -1902,21 +1976,26 @@ var SQLiteStore = class _SQLiteStore {
   actions;
   system;
   summaries;
+  lock;
   dbPathInstance;
   constructor(dbPath) {
     const finalPath = dbPath ?? DB_PATH;
     this.dbPathInstance = finalPath;
     if (finalPath !== ":memory:") {
-      const dbDir = path2.dirname(finalPath);
-      if (!fs2.existsSync(dbDir)) {
-        fs2.mkdirSync(dbDir, { recursive: true });
+      const dbDir = path3.dirname(finalPath);
+      if (!fs3.existsSync(dbDir)) {
+        fs3.mkdirSync(dbDir, { recursive: true });
       }
     }
     this.db = new Database(finalPath);
     this.db.pragma("journal_mode = WAL");
-    this.db.pragma("synchronous = NORMAL");
-    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("synchronous = FULL");
+    this.db.pragma("busy_timeout = 30000");
     this.db.pragma("foreign_keys = ON");
+    this.db.pragma("wal_autocheckpoint = 100");
+    if (finalPath !== ":memory:") {
+      this._startupChecks(finalPath);
+    }
     const migrator = new MigrationManager(this.db);
     migrator.migrate();
     migrator.addMemoryCodeColumn();
@@ -1925,10 +2004,88 @@ var SQLiteStore = class _SQLiteStore {
     this.actions = new ActionEntity(this.db);
     this.system = new SystemEntity(this.db);
     this.summaries = new SummaryEntity(this.db);
+    this.lock = new WriteLock(finalPath);
   }
-  async ready() {
+  /**
+   * Run on startup: checkpoint WAL and verify integrity.
+   * If integrity check fails, attempt to restore from backup.
+   */
+  _startupChecks(dbPath) {
+    try {
+      this.db.pragma("wal_checkpoint(TRUNCATE)");
+      logger.debug("[SQLiteStore] WAL checkpoint completed on startup");
+    } catch (err) {
+      logger.warn("[SQLiteStore] WAL checkpoint failed on startup", { error: String(err) });
+    }
+    try {
+      const result = this.db.pragma("integrity_check");
+      const ok = result.length === 1 && result[0].integrity_check === "ok";
+      if (!ok) {
+        logger.error("[SQLiteStore] Integrity check FAILED", { result });
+        this._attemptRecovery(dbPath);
+      } else {
+        logger.debug("[SQLiteStore] Integrity check passed");
+      }
+    } catch (err) {
+      logger.error("[SQLiteStore] Integrity check threw error", { error: String(err) });
+      this._attemptRecovery(dbPath);
+    }
+  }
+  /**
+   * Attempt to recover from a corrupt DB by restoring the latest backup.
+   */
+  _attemptRecovery(dbPath) {
+    const backupPath = dbPath + ".backup";
+    if (fs3.existsSync(backupPath)) {
+      logger.warn("[SQLiteStore] Attempting recovery from backup", { backupPath });
+      try {
+        const corruptPath = `${dbPath}.corrupt_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 15)}`;
+        fs3.copyFileSync(dbPath, corruptPath);
+        fs3.copyFileSync(backupPath, dbPath);
+        logger.warn("[SQLiteStore] Recovery successful. Corrupt file saved to", { corruptPath });
+      } catch (err) {
+        logger.error("[SQLiteStore] Recovery failed", { error: String(err) });
+      }
+    } else {
+      logger.error("[SQLiteStore] No backup found for recovery. DB may be corrupt.");
+    }
   }
+  /**
+   * Create a timestamped backup of the DB file.
+   * Called automatically after successful writes (via withWrite).
+   */
+  backup() {
+    if (this.dbPathInstance === ":memory:") return;
+    try {
+      this.db.pragma("wal_checkpoint(PASSIVE)");
+      const backupPath = this.dbPathInstance + ".backup";
+      fs3.copyFileSync(this.dbPathInstance, backupPath);
+    } catch (err) {
+      logger.warn("[SQLiteStore] Backup failed", { error: String(err) });
+    }
+  }
+  /**
+   * Execute a write operation under the file lock.
+   * This is the ONLY way writes should be performed.
+   *
+   * @example
+   * await db.withWrite(() => db.tasks.insertTask(task));
+   */
+  async withWrite(fn) {
+    return this.lock.withLock(fn);
+  }
+  /**
+   * Checkpoint WAL so dashboard (and other readers) see latest data.
+   * Called by dashboard controllers before reads.
+   */
   async refresh() {
+    try {
+      this.db.pragma("wal_checkpoint(PASSIVE)");
+    } catch (err) {
+      logger.warn("[SQLiteStore] refresh checkpoint failed", { error: String(err) });
+    }
+  }
+  async ready() {
   }
   static async create(dbPath) {
     return new _SQLiteStore(dbPath);
@@ -1938,13 +2095,17 @@ var SQLiteStore = class _SQLiteStore {
   }
   close() {
     if (this.db && this.db.open) {
+      try {
+        this.db.pragma("wal_checkpoint(TRUNCATE)");
+      } catch {
+      }
       this.db.close();
     }
   }
 };
 
 // src/mcp/session.ts
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function createSessionContext() {
   return {
@@ -2010,7 +2171,7 @@ function getFilesystemRoots(session) {
   for (const root of session.roots) {
     if (!root.uri.startsWith("file://")) continue;
     try {
-      resolved.push(path3.resolve(fileURLToPath2(root.uri)));
+      resolved.push(path4.resolve(fileURLToPath2(root.uri)));
     } catch {
     }
   }
@@ -2019,19 +2180,19 @@ function getFilesystemRoots(session) {
 function isPathWithinRoots(targetPath, session) {
   const roots = getFilesystemRoots(session);
   if (roots.length === 0) return true;
-  const normalizedTarget = path3.resolve(targetPath);
+  const normalizedTarget = path4.resolve(targetPath);
   return roots.some((rootPath) => {
-    const relative = path3.relative(rootPath, normalizedTarget);
-    return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+    const relative = path4.relative(rootPath, normalizedTarget);
+    return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
   });
 }
 function findContainingRoot(targetPath, session) {
   const roots = getFilesystemRoots(session);
   if (roots.length === 0) return null;
-  const normalizedTarget = path3.resolve(targetPath);
+  const normalizedTarget = path4.resolve(targetPath);
   for (const rootPath of roots) {
-    const relative = path3.relative(rootPath, normalizedTarget);
-    if (relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative)) {
+    const relative = path4.relative(rootPath, normalizedTarget);
+    if (relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative)) {
       return rootPath;
     }
   }
@@ -2040,7 +2201,7 @@ function findContainingRoot(targetPath, session) {
 function inferRepoFromSession(session) {
   const roots = getFilesystemRoots(session);
   if (roots.length === 1) {
-    return path3.basename(roots[0]);
+    return path4.basename(roots[0]);
   }
   return void 0;
 }
@@ -3468,9 +3629,9 @@ function parseRepoUri(uri) {
   const slashIdx = withoutQuery.indexOf("/");
   if (slashIdx === -1) return null;
   const name = withoutQuery.slice(0, slashIdx);
-  const path5 = withoutQuery.slice(slashIdx + 1);
-  if (!name || !path5) return null;
-  return { name, path: path5, query: new URLSearchParams(queryString) };
+  const path6 = withoutQuery.slice(slashIdx + 1);
+  if (!name || !path6) return null;
+  return { name, path: path6, query: new URLSearchParams(queryString) };
 }
 function paginateEntries(key, entries, params) {
   const limit = normalizeLimit(params?.limit);
@@ -3505,12 +3666,12 @@ function invalidCompletionParams(message) {
 }
 
 // src/mcp/prompts/loader.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import matter from "gray-matter";
 var __filename = fileURLToPath3(import.meta.url);
-var __dirname2 = path4.dirname(__filename);
+var __dirname2 = path5.dirname(__filename);
 function findPromptDir() {
   const candidates = [
     // Production if chunked into dist/
@@ -3519,28 +3680,28 @@ function findPromptDir() {
     "../prompts",
     // Dev: /src/mcp/prompts/definitions (next to loader.ts)
     "./definitions"
-  ].map((relPath) => path4.resolve(__dirname2, relPath));
+  ].map((relPath) => path5.resolve(__dirname2, relPath));
   for (const dir of candidates) {
-    if (fs3.existsSync(dir)) {
-      const files = fs3.readdirSync(dir);
+    if (fs4.existsSync(dir)) {
+      const files = fs4.readdirSync(dir);
       if (files.some((f) => f.endsWith(".md"))) {
         return dir;
       }
     }
   }
-  return path4.resolve(__dirname2, "./definitions");
+  return path5.resolve(__dirname2, "./definitions");
 }
 var PROMPT_DIR = findPromptDir();
 function listPromptFiles() {
-  if (!fs3.existsSync(PROMPT_DIR)) return [];
-  return fs3.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
+  if (!fs4.existsSync(PROMPT_DIR)) return [];
+  return fs4.readdirSync(PROMPT_DIR).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).sort();
 }
 function loadPromptFromMarkdown(name) {
-  const filePath = path4.join(PROMPT_DIR, `${name}.md`);
-  if (!fs3.existsSync(filePath)) {
+  const filePath = path5.join(PROMPT_DIR, `${name}.md`);
+  if (!fs4.existsSync(filePath)) {
     throw new Error(`Prompt file not found: ${filePath}`);
   }
-  const fileContent = fs3.readFileSync(filePath, "utf-8");
+  const fileContent = fs4.readFileSync(filePath, "utf-8");
   const { data, content } = matter(fileContent);
   return {
     name: data.name || name,