@mnemoai/core 1.1.0 → 1.1.1

package/dist/src/store.js

@@ -0,0 +1,939 @@
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  accessSync,
+  constants,
+  mkdirSync,
+  realpathSync,
+  lstatSync
+} from "node:fs";
+import { dirname } from "node:path";
+import { buildSmartMetadata, parseSmartMetadata, stringifySmartMetadata } from "./smart-metadata.js";
+import { requirePro } from "./license.js";
+import { log } from "./logger.js";
+let _auditCreate = null;
+let _auditUpdate = null;
+let _auditDelete = null;
+let _auditExpire = null;
+if (requirePro("audit-log")) {
+  import("./audit-log.js").then((mod) => {
+    _auditCreate = mod.auditCreate;
+    _auditUpdate = mod.auditUpdate;
+    _auditDelete = mod.auditDelete;
+    _auditExpire = mod.auditExpire;
+  }).catch(() => {
+  });
+}
+let walAppend = null;
+let walMarkCommitted = null;
+let walMarkFailed = null;
+if (requirePro("wal")) {
+  import("./wal-recovery.js").then((mod) => {
+    walAppend = mod.walAppend;
+    walMarkCommitted = mod.walMarkCommitted;
+    walMarkFailed = mod.walMarkFailed;
+  }).catch(() => {
+  });
+}
+const DEDUP_SIMILARITY_THRESHOLD = 0.92;
+const CONFLICT_SIMILARITY_THRESHOLD = 0.7;
+import { createAdapter, listAdapters } from "./storage-adapter.js";
+let _adaptersLoaded = false;
+async function ensureAdaptersLoaded() {
+  if (_adaptersLoaded) return;
+  _adaptersLoaded = true;
+  const dbg = !!process.env.MNEMO_DEBUG;
+  try {
+    await import("./adapters/lancedb.js");
+  } catch (e) {
+    if (dbg) log.debug("adapter lancedb not available:", e);
+  }
+  try {
+    await import("./adapters/qdrant.js");
+  } catch (e) {
+    if (dbg) log.debug("adapter qdrant not available:", e);
+  }
+  try {
+    await import("./adapters/chroma.js");
+  } catch (e) {
+    if (dbg) log.debug("adapter chroma not available:", e);
+  }
+  try {
+    await import("./adapters/pgvector.js");
+  } catch (e) {
+    if (dbg) log.debug("adapter pgvector not available:", e);
+  }
+}
+let lancedbImportPromise = null;
+const loadLanceDB = async () => {
+  if (!lancedbImportPromise) {
+    lancedbImportPromise = import("@lancedb/lancedb");
+  }
+  try {
+    return await lancedbImportPromise;
+  } catch (err) {
+    throw new Error(
+      `mnemo: failed to load LanceDB. ${String(err)}`,
+      { cause: err }
+    );
+  }
+};
+function clampInt(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function escapeSqlLiteral(value) {
+  if (typeof value !== "string") return "";
+  return value.replace(/[^a-zA-Z0-9\-_.:@ \u4e00-\u9fff\u3400-\u4dbf]/g, "");
+}
+function normalizeSearchText(value) {
+  return value.toLowerCase().trim();
+}
+function scoreLexicalHit(query, candidates) {
+  const normalizedQuery = normalizeSearchText(query);
+  if (!normalizedQuery) return 0;
+  let score = 0;
+  for (const candidate of candidates) {
+    const normalized = normalizeSearchText(candidate.text);
+    if (!normalized) continue;
+    if (normalized.includes(normalizedQuery)) {
+      score = Math.max(score, Math.min(0.95, 0.72 + normalizedQuery.length * 0.02) * candidate.weight);
+    }
+  }
+  return score;
+}
+function validateStoragePath(dbPath) {
+  let resolvedPath = dbPath;
+  try {
+    const stats = lstatSync(dbPath);
+    if (stats.isSymbolicLink()) {
+      try {
+        resolvedPath = realpathSync(dbPath);
+      } catch (err) {
+        const e = err;
+        throw new Error(
+          `dbPath "${dbPath}" is a symlink whose target does not exist.
+  Fix: Create the target directory, or update the symlink to point to a valid path.
+  Details: ${e.code || ""} ${e.message}`
+        );
+      }
+    }
+  } catch (err) {
+    const e = err;
+    if (e?.code === "ENOENT") {
+    } else if (typeof e?.message === "string" && e.message.includes("symlink whose target does not exist")) {
+      throw err;
+    } else {
+    }
+  }
+  if (!existsSync(resolvedPath)) {
+    try {
+      mkdirSync(resolvedPath, { recursive: true });
+    } catch (err) {
+      const e = err;
+      throw new Error(
+        `Failed to create dbPath directory "${resolvedPath}".
+  Fix: Ensure the parent directory "${dirname(resolvedPath)}" exists and is writable,
+       or create it manually: mkdir -p "${resolvedPath}"
+  Details: ${e.code || ""} ${e.message}`
+      );
+    }
+  }
+  try {
+    accessSync(resolvedPath, constants.W_OK);
+  } catch (err) {
+    const e = err;
+    throw new Error(
+      `dbPath directory "${resolvedPath}" is not writable.
+  Fix: Check permissions with: ls -la "${dirname(resolvedPath)}"
+       Or grant write access: chmod u+w "${resolvedPath}"
+  Details: ${e.code || ""} ${e.message}`
+    );
+  }
+  return resolvedPath;
+}
+const TABLE_NAME = "memories";
+class MemoryStore {
+  constructor(config) {
+    this.config = config;
+  }
+  db = null;
+  table = null;
+  initPromise = null;
+  ftsIndexCreated = false;
+  updateQueue = Promise.resolve();
+  semanticGateInstance = null;
+  /** When using a non-LanceDB adapter, this holds the active adapter instance */
+  _adapter = null;
+  /** True when using the adapter path (non-LanceDB backends) */
+  get usingAdapter() {
+    return this._adapter !== null;
+  }
+  /** Inject a SemanticGate instance (created externally with an Embedder). */
+  setSemanticGate(gate) {
+    this.semanticGateInstance = gate;
+  }
+  get dbPath() {
+    return this.config.dbPath;
+  }
+  /** Get the active adapter (null if using legacy LanceDB path) */
+  get adapter() {
+    return this._adapter;
+  }
+  /** Whether BM25 full-text search is available */
+  get hasFtsSupport() {
+    if (this._adapter) return this._adapter.hasFullTextSearch();
+    return this.ftsIndexCreated;
+  }
+  async ensureInitialized() {
+    if (this.table || this._adapter) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.doInitialize().catch((err) => {
+      this.initPromise = null;
+      throw err;
+    });
+    return this.initPromise;
+  }
+  async doInitialize() {
+    const backend = this.config.storageBackend;
+    if (backend && backend !== "lancedb") {
+      await ensureAdaptersLoaded();
+      const available = listAdapters();
+      if (!available.includes(backend)) {
+        throw new Error(
+          `Storage backend "${backend}" not available. Installed: ${available.join(", ")}. Check that the adapter is properly imported.`
+        );
+      }
+      this._adapter = createAdapter(backend, this.config.storageConfig);
+      await this._adapter.connect(this.config.dbPath);
+      await this._adapter.ensureTable(this.config.vectorDim);
+      this.ftsIndexCreated = this._adapter.hasFullTextSearch();
+      return;
+    }
+    const lancedb = await loadLanceDB();
+    let db;
+    try {
+      db = await lancedb.connect(this.config.dbPath);
+    } catch (err) {
+      const e = err;
+      const code = e.code || "";
+      const message = e.message || String(err);
+      throw new Error(
+        `Failed to open LanceDB at "${this.config.dbPath}": ${code} ${message}
+  Fix: Verify the path exists and is writable. Check parent directory permissions.`
+      );
+    }
+    let table;
+    try {
+      table = await db.openTable(TABLE_NAME);
+      try {
+        const sample2 = await table.query().limit(1).toArray();
+        if (sample2.length > 0 && !("scope" in sample2[0])) {
+          log.warn(
+            "Adding scope column for backward compatibility with existing data"
+          );
+        }
+      } catch (err) {
+        log.warn("Could not check table schema:", err);
+      }
+    } catch (_openErr) {
+      const schemaEntry = {
+        id: "__schema__",
+        text: "",
+        vector: Array.from({ length: this.config.vectorDim }).fill(
+          0
+        ),
+        category: "other",
+        scope: "global",
+        importance: 0,
+        timestamp: 0,
+        metadata: "{}"
+      };
+      try {
+        table = await db.createTable(TABLE_NAME, [schemaEntry]);
+        await table.delete('id = "__schema__"');
+      } catch (createErr) {
+        if (String(createErr).includes("already exists")) {
+          table = await db.openTable(TABLE_NAME);
+        } else {
+          throw createErr;
+        }
+      }
+    }
+    const sample = await table.query().limit(1).toArray();
+    if (sample.length > 0 && sample[0]?.vector?.length) {
+      const existingDim = sample[0].vector.length;
+      if (existingDim !== this.config.vectorDim) {
+        throw new Error(
+          `Vector dimension mismatch: table=${existingDim}, config=${this.config.vectorDim}. Create a new table/dbPath or set matching embedding.dimensions.`
+        );
+      }
+    }
+    try {
+      await this.createFtsIndex(table);
+      this.ftsIndexCreated = true;
+    } catch (err) {
+      log.warn(
+        "Failed to create FTS index, falling back to vector-only search:",
+        err
+      );
+      this.ftsIndexCreated = false;
+    }
+    this.db = db;
+    this.table = table;
+  }
+  async createFtsIndex(table) {
+    try {
+      const indices = await table.listIndices();
+      const hasFtsIndex = indices?.some(
+        // TODO: type this — LanceDB index type lacks proper typings for indexType/columns
+        (idx) => idx.indexType === "FTS" || idx.columns?.includes("text")
+      );
+      if (!hasFtsIndex) {
+        const lancedb = await loadLanceDB();
+        await table.createIndex("text", {
+          // TODO: type this — LanceDB dynamic import doesn't expose Index type
+          config: lancedb.Index.fts()
+        });
+      }
+    } catch (err) {
+      throw new Error(
+        `FTS index creation failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  async store(entry) {
+    await this.ensureInitialized();
+    if (this.config.semanticGate !== false && this.semanticGateInstance) {
+      try {
+        const passed = await this.semanticGateInstance.shouldPass(entry.vector, entry.text);
+        if (!passed) {
+          return {
+            ...entry,
+            id: "__filtered__",
+            timestamp: Date.now(),
+            metadata: entry.metadata || "{}"
+          };
+        }
+      } catch {
+      }
+    }
+    if (this.config.deduplication !== false && entry.vector && entry.vector.length > 0) {
+      try {
+        const scopeFilter = entry.scope ? [entry.scope] : void 0;
+        const similar = await this.vectorSearch(entry.vector, 3, 0.3, scopeFilter);
+        for (const match of similar) {
+          const cosineSim = 2 - 1 / match.score;
+          if (cosineSim > DEDUP_SIMILARITY_THRESHOLD) {
+            const existingMeta = parseSmartMetadata(match.entry.metadata, match.entry);
+            const accessCount = (existingMeta.access_count ?? 0) + 1;
+            const updates = {};
+            if (entry.text.length > match.entry.text.length) {
+              updates.text = entry.text;
+            }
+            if (entry.importance > match.entry.importance) {
+              updates.importance = entry.importance;
+            }
+            const patchedMeta = {
+              ...existingMeta,
+              access_count: accessCount,
+              updatedAt: Date.now()
+            };
+            updates.metadata = stringifySmartMetadata(patchedMeta);
+            await this.update(match.entry.id, updates, scopeFilter);
+            return {
+              ...match.entry,
+              id: match.entry.id,
+              timestamp: match.entry.timestamp,
+              metadata: updates.metadata
+            };
+          }
+        }
+      } catch {
+      }
+    }
+    if (this.config.deduplication !== false && entry.vector && entry.vector.length > 0) {
+      try {
+        const similar = await this.vectorSearch(entry.vector, 3, 0.3);
+        for (const match of similar) {
+          const cosineSim = 2 - 1 / match.score;
+          if (cosineSim > CONFLICT_SIMILARITY_THRESHOLD && cosineSim <= DEDUP_SIMILARITY_THRESHOLD) {
+            const oldText = match.entry.text || "";
+            const newText = entry.text || "";
+            const hasContradictionSignal = /改成|变成|更新为|换成|不再|取消了|changed to|updated to|no longer|switched to/i.test(newText) || oldText.match(/\d+/) && newText.match(/\d+/) && cosineSim > 0.8;
+            if (hasContradictionSignal) {
+              _auditExpire?.(
+                match.entry.id,
+                match.entry.scope || "global",
+                "contradiction",
+                `old: "${match.entry.text?.slice(0, 100)}" \u2192 new: "${newText.slice(0, 100)}"`
+              );
+              const existingMeta = parseSmartMetadata(match.entry.metadata, match.entry);
+              const oldImportance = match.entry.importance ?? 0.7;
+              existingMeta.expired_at = (/* @__PURE__ */ new Date()).toISOString();
+              existingMeta.expired_reason = `superseded: ${newText.slice(0, 80)}`;
+              await this.update(
+                match.entry.id,
+                {
+                  importance: Math.max(0.05, oldImportance * 0.1),
+                  metadata: stringifySmartMetadata(existingMeta)
+                }
+              );
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const fullEntry = {
+      ...entry,
+      id: randomUUID(),
+      timestamp: Date.now(),
+      metadata: entry.metadata || "{}"
+    };
+    try {
+      if (this._adapter) {
+        await this._adapter.add([fullEntry]);
+      } else {
+        await this.table.add([fullEntry]);
+      }
+    } catch (err) {
+      const e = err;
+      const code = e.code || "";
+      const message = e.message || String(err);
+      throw new Error(
+        `Failed to store memory in "${this.config.dbPath}": ${code} ${message}`
+      );
+    }
+    _auditCreate?.(fullEntry.id, fullEntry.scope, fullEntry.scope, "store", fullEntry.text?.slice(0, 200));
+    const textLen = (fullEntry.text || "").length;
+    const importance = typeof fullEntry.importance === "number" ? fullEntry.importance : 0.7;
+    if (process.env.GRAPHITI_ENABLED === "true" && importance >= 0.5 && textLen >= 20) {
+      const graphitiBase = process.env.GRAPHITI_BASE_URL || "http://127.0.0.1:18799";
+      const scope = fullEntry.scope || "default";
+      const groupId = scope.startsWith("agent:") ? scope.split(":")[1] || "default" : "default";
+      const walTs = new Date(fullEntry.timestamp).toISOString();
+      if (walAppend) {
+        walAppend({
+          ts: walTs,
+          action: "write",
+          text: fullEntry.text,
+          scope,
+          category: fullEntry.category || "fact",
+          groupId,
+          importance,
+          status: "pending"
+        }).catch(() => {
+        });
+      }
+      fetch(`${graphitiBase}/episodes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          text: `[${fullEntry.category || "fact"}] ${fullEntry.text}`,
+          group_id: groupId,
+          reference_time: walTs,
+          source: `lancedb-pro-store-${groupId}`,
+          category: fullEntry.category || "fact"
+        }),
+        signal: AbortSignal.timeout(15e3)
+      }).then(() => {
+        walMarkCommitted?.(walTs).catch(() => {
+        });
+      }).catch((err) => {
+        walMarkFailed?.(walTs, String(err)).catch(() => {
+        });
+      });
+    }
+    return fullEntry;
+  }
+  /**
+   * Import a pre-built entry while preserving its id/timestamp.
+   * Used for re-embedding / migration / A/B testing across embedding models.
+   * Intentionally separate from `store()` to keep normal writes simple.
+   */
+  async importEntry(entry) {
+    await this.ensureInitialized();
+    if (!entry.id || typeof entry.id !== "string") {
+      throw new Error("importEntry requires a stable id");
+    }
+    const vector = entry.vector || [];
+    if (!Array.isArray(vector) || vector.length !== this.config.vectorDim) {
+      throw new Error(
+        `Vector dimension mismatch: expected ${this.config.vectorDim}, got ${Array.isArray(vector) ? vector.length : "non-array"}`
+      );
+    }
+    const full = {
+      ...entry,
+      scope: entry.scope || "global",
+      importance: Number.isFinite(entry.importance) ? entry.importance : 0.7,
+      timestamp: Number.isFinite(entry.timestamp) ? entry.timestamp : Date.now(),
+      metadata: entry.metadata || "{}"
+    };
+    await this.table.add([full]);
+    return full;
+  }
+  async hasId(id) {
+    await this.ensureInitialized();
+    if (this._adapter) {
+      const results = await this._adapter.query({ where: `id = '${escapeSqlLiteral(id)}'`, limit: 1 });
+      return results.length > 0;
+    }
+    const safeId = escapeSqlLiteral(id);
+    const res = await this.table.query().select(["id"]).where(`id = '${safeId}'`).limit(1).toArray();
+    return res.length > 0;
+  }
+  async getById(id, scopeFilter) {
+    await this.ensureInitialized();
+    if (this._adapter) {
+      const results = await this._adapter.query({ where: `id = '${escapeSqlLiteral(id)}'`, limit: 1 });
+      if (results.length === 0) return null;
+      const r = results[0];
+      return { id: r.id, text: r.text, vector: r.vector, category: r.category, scope: r.scope, importance: r.importance, timestamp: r.timestamp, metadata: r.metadata };
+    }
+    const safeId = escapeSqlLiteral(id);
+    const rows = await this.table.query().where(`id = '${safeId}'`).limit(1).toArray();
+    if (rows.length === 0) return null;
+    const row = rows[0];
+    const rowScope = row.scope ?? "global";
+    if (scopeFilter && scopeFilter.length > 0 && !scopeFilter.includes(rowScope)) {
+      return null;
+    }
+    return {
+      id: row.id,
+      text: row.text,
+      vector: Array.from(row.vector),
+      category: row.category,
+      scope: rowScope,
+      importance: Number(row.importance),
+      timestamp: Number(row.timestamp),
+      metadata: row.metadata || "{}"
+    };
+  }
+  async vectorSearch(vector, limit = 5, minScore = 0.3, scopeFilter) {
+    await this.ensureInitialized();
+    if (this._adapter) {
+      const results2 = await this._adapter.vectorSearch(vector, limit, minScore, scopeFilter);
+      return results2.map((r) => ({
+        entry: { id: r.record.id, text: r.record.text, vector: r.record.vector, category: r.record.category, scope: r.record.scope, importance: r.record.importance, timestamp: r.record.timestamp, metadata: r.record.metadata },
+        score: r.score
+      }));
+    }
+    const safeLimit = clampInt(limit, 1, 20);
+    const fetchLimit = Math.min(safeLimit * 10, 200);
+    let query = this.table.vectorSearch(vector).distanceType("cosine").limit(fetchLimit);
+    if (scopeFilter && scopeFilter.length > 0) {
+      const scopeConditions = scopeFilter.map((scope) => `scope = '${escapeSqlLiteral(scope)}'`).join(" OR ");
+      query = query.where(`(${scopeConditions}) OR scope IS NULL`);
+    }
+    const results = await query.toArray();
+    const mapped = [];
+    for (const row of results) {
+      const distance = Number(row._distance ?? 0);
+      const score = 1 / (1 + distance);
+      if (score < minScore) continue;
+      const rowScope = row.scope ?? "global";
+      if (scopeFilter && scopeFilter.length > 0 && !scopeFilter.includes(rowScope)) {
+        continue;
+      }
+      mapped.push({
+        entry: {
+          id: row.id,
+          text: row.text,
+          vector: row.vector,
+          category: row.category,
+          scope: rowScope,
+          importance: Number(row.importance),
+          timestamp: Number(row.timestamp),
+          metadata: row.metadata || "{}"
+        },
+        score
+      });
+      if (mapped.length >= safeLimit) break;
+    }
+    return mapped;
+  }
+  async bm25Search(query, limit = 5, scopeFilter) {
+    await this.ensureInitialized();
+    if (this._adapter) {
+      const results = await this._adapter.fullTextSearch(query, limit, scopeFilter);
+      return results.map((r) => ({
+        entry: { id: r.record.id, text: r.record.text, vector: r.record.vector, category: r.record.category, scope: r.record.scope, importance: r.record.importance, timestamp: r.record.timestamp, metadata: r.record.metadata },
+        score: r.score
+      }));
+    }
+    const safeLimit = clampInt(limit, 1, 20);
+    if (!this.ftsIndexCreated) {
+      return this.lexicalFallbackSearch(query, safeLimit, scopeFilter);
+    }
+    try {
+      let searchQuery = this.table.search(query, "fts").limit(safeLimit);
+      if (scopeFilter && scopeFilter.length > 0) {
+        const scopeConditions = scopeFilter.map((scope) => `scope = '${escapeSqlLiteral(scope)}'`).join(" OR ");
+        searchQuery = searchQuery.where(
+          `(${scopeConditions}) OR scope IS NULL`
+        );
+      }
+      const results = await searchQuery.toArray();
+      const mapped = [];
+      for (const row of results) {
+        const rowScope = row.scope ?? "global";
+        if (scopeFilter && scopeFilter.length > 0 && !scopeFilter.includes(rowScope)) {
+          continue;
+        }
+        const rawScore = row._score != null ? Number(row._score) : 0;
+        const normalizedScore = rawScore > 0 ? 1 / (1 + Math.exp(-rawScore / 5)) : 0.5;
+        mapped.push({
+          entry: {
+            id: row.id,
+            text: row.text,
+            vector: row.vector,
+            category: row.category,
+            scope: rowScope,
+            importance: Number(row.importance),
+            timestamp: Number(row.timestamp),
+            metadata: row.metadata || "{}"
+          },
+          score: normalizedScore
+        });
+      }
+      if (mapped.length > 0) {
+        return mapped;
+      }
+      return this.lexicalFallbackSearch(query, safeLimit, scopeFilter);
+    } catch (err) {
+      log.warn("BM25 search failed, falling back to empty results:", err);
+      return this.lexicalFallbackSearch(query, safeLimit, scopeFilter);
+    }
+  }
+  async lexicalFallbackSearch(query, limit, scopeFilter) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) return [];
+    let searchQuery = this.table.query().select([
+      "id",
+      "text",
+      "vector",
+      "category",
+      "scope",
+      "importance",
+      "timestamp",
+      "metadata"
+    ]);
+    if (scopeFilter && scopeFilter.length > 0) {
+      const scopeConditions = scopeFilter.map((scope) => `scope = '${escapeSqlLiteral(scope)}'`).join(" OR ");
+      searchQuery = searchQuery.where(`(${scopeConditions}) OR scope IS NULL`);
+    }
+    const rows = await searchQuery.toArray();
+    const matches = [];
+    for (const row of rows) {
+      const rowScope = row.scope ?? "global";
+      if (scopeFilter && scopeFilter.length > 0 && !scopeFilter.includes(rowScope)) {
+        continue;
+      }
+      const entry = {
+        id: row.id,
+        text: row.text,
+        vector: row.vector,
+        category: row.category,
+        scope: rowScope,
+        importance: Number(row.importance),
+        timestamp: Number(row.timestamp),
+        metadata: row.metadata || "{}"
+      };
+      const metadata = parseSmartMetadata(entry.metadata, entry);
+      const score = scoreLexicalHit(trimmedQuery, [
+        { text: entry.text, weight: 1 },
+        { text: metadata.l0_abstract, weight: 0.98 },
+        { text: metadata.l1_overview, weight: 0.92 },
+        { text: metadata.l2_content, weight: 0.96 }
+      ]);
+      if (score <= 0) continue;
+      matches.push({ entry, score });
+    }
+    return matches.sort((a, b) => b.score - a.score || b.entry.timestamp - a.entry.timestamp).slice(0, limit);
+  }
+  async delete(id, scopeFilter) {
+    await this.ensureInitialized();
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const prefixRegex = /^[0-9a-f]{8,}$/i;
+    const isFullId = uuidRegex.test(id);
+    const isPrefix = !isFullId && prefixRegex.test(id);
+    if (!isFullId && !isPrefix) {
+      throw new Error(`Invalid memory ID format: ${id}`);
+    }
+    let candidates;
+    if (isFullId) {
+      candidates = await this.table.query().where(`id = '${id}'`).limit(1).toArray();
+    } else {
+      const all = await this.table.query().select(["id", "scope"]).limit(1e3).toArray();
+      candidates = all.filter((r) => r.id.startsWith(id));
+      if (candidates.length > 1) {
+        throw new Error(
+          `Ambiguous prefix "${id}" matches ${candidates.length} memories. Use a longer prefix or full ID.`
+        );
+      }
+    }
+    if (candidates.length === 0) {
+      return false;
+    }
+    const resolvedId = candidates[0].id;
+    const rowScope = candidates[0].scope ?? "global";
+    if (scopeFilter && scopeFilter.length > 0 && !scopeFilter.includes(rowScope)) {
+      throw new Error(`Memory ${resolvedId} is outside accessible scopes`);
+    }
+    _auditDelete?.([resolvedId], rowScope, "user-request");
+    if (this._adapter) {
+      await this._adapter.delete(`id = '${escapeSqlLiteral(resolvedId)}'`);
+    } else {
+      await this.table.delete(`id = '${resolvedId}'`);
+    }
+    return true;
+  }
+  async list(scopeFilter, category, limit = 20, offset = 0) {
+    await this.ensureInitialized();
+    let query = this.table.query();
+    const conditions = [];
+    if (scopeFilter && scopeFilter.length > 0) {
+      const scopeConditions = scopeFilter.map((scope) => `scope = '${escapeSqlLiteral(scope)}'`).join(" OR ");
+      conditions.push(`((${scopeConditions}) OR scope IS NULL)`);
+    }
+    if (category) {
+      conditions.push(`category = '${escapeSqlLiteral(category)}'`);
+    }
+    if (conditions.length > 0) {
+      query = query.where(conditions.join(" AND "));
+    }
+    const results = await query.select([
+      "id",
+      "text",
+      "category",
+      "scope",
+      "importance",
+      "timestamp",
+      "metadata"
+    ]).toArray();
+    return results.map(
+      (row) => ({
+        id: row.id,
+        text: row.text,
+        vector: [],
+        // Don't include vectors in list results for performance
+        category: row.category,
+        scope: row.scope ?? "global",
+        importance: Number(row.importance),
+        timestamp: Number(row.timestamp),
+        metadata: row.metadata || "{}"
+      })
+    ).sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0)).slice(offset, offset + limit);
+  }
+  async stats(scopeFilter) {
+    await this.ensureInitialized();
+    let query = this.table.query();
+    if (scopeFilter && scopeFilter.length > 0) {
+      const scopeConditions = scopeFilter.map((scope) => `scope = '${escapeSqlLiteral(scope)}'`).join(" OR ");
+      query = query.where(`((${scopeConditions}) OR scope IS NULL)`);
+    }
+    const results = await query.select(["scope", "category"]).toArray();
+    const scopeCounts = {};
+    const categoryCounts = {};
+    for (const row of results) {
+      const scope = row.scope ?? "global";
+      const category = row.category;
+      scopeCounts[scope] = (scopeCounts[scope] || 0) + 1;
+      categoryCounts[category] = (categoryCounts[category] || 0) + 1;
+    }
+    return {
+      totalCount: results.length,
+      scopeCounts,
+      categoryCounts
+    };
+  }
+  async update(id, updates, scopeFilter) {
+    await this.ensureInitialized();
+    return this.runSerializedUpdate(async () => {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+      const prefixRegex = /^[0-9a-f]{8,}$/i;
+      const isFullId = uuidRegex.test(id);
+      const isPrefix = !isFullId && prefixRegex.test(id);
+      if (!isFullId && !isPrefix) {
+        throw new Error(`Invalid memory ID format: ${id}`);
+      }
+      let rows;
+      if (isFullId) {
+        const safeId = escapeSqlLiteral(id);
+        rows = await this.table.query().where(`id = '${safeId}'`).limit(1).toArray();
+      } else {
+        const all = await this.table.query().select([
+          "id",
+          "text",
+          "vector",
+          "category",
+          "scope",
+          "importance",
+          "timestamp",
+          "metadata"
+        ]).limit(1e3).toArray();
+        rows = all.filter((r) => r.id.startsWith(id));
+        if (rows.length > 1) {
+          throw new Error(
+            `Ambiguous prefix "${id}" matches ${rows.length} memories. Use a longer prefix or full ID.`
+          );
+        }
+      }
+      if (rows.length === 0) return null;
+      const row = rows[0];
+      const rowScope = row.scope ?? "global";
+      if (scopeFilter && scopeFilter.length > 0 && !scopeFilter.includes(rowScope)) {
+        throw new Error(`Memory ${id} is outside accessible scopes`);
+      }
+      const original = {
+        id: row.id,
+        text: row.text,
+        vector: Array.from(row.vector),
+        category: row.category,
+        scope: rowScope,
+        importance: Number(row.importance),
+        timestamp: Number(row.timestamp),
+        metadata: row.metadata || "{}"
+      };
+      const updated = {
+        ...original,
+        text: updates.text ?? original.text,
+        vector: updates.vector ?? original.vector,
+        category: updates.category ?? original.category,
+        scope: rowScope,
+        importance: updates.importance ?? original.importance,
+        timestamp: original.timestamp,
+        // preserve original
+        metadata: updates.metadata ?? original.metadata
+      };
+      _auditUpdate?.(
+        original.id,
+        rowScope,
+        "memory-update",
+        JSON.stringify({
+          old: { text: original.text?.slice(0, 200), importance: original.importance, category: original.category },
+          new: { text: updated.text?.slice(0, 200), importance: updated.importance, category: updated.category }
+        })
+      );
+      const rollbackCandidate = await this.getById(original.id).catch(() => null) ?? original;
+      const resolvedId = escapeSqlLiteral(row.id);
+      await this.table.delete(`id = '${resolvedId}'`);
+      try {
+        await this.table.add([updated]);
+      } catch (addError) {
+        const current = await this.getById(original.id).catch(() => null);
+        if (current) {
+          throw new Error(
+            `Failed to update memory ${id}: write failed after delete, but an existing record was preserved. Write error: ${addError instanceof Error ? addError.message : String(addError)}`
+          );
+        }
+        try {
+          await this.table.add([rollbackCandidate]);
+        } catch (rollbackError) {
+          throw new Error(
+            `Failed to update memory ${id}: write failed after delete, and rollback also failed. Write error: ${addError instanceof Error ? addError.message : String(addError)}. Rollback error: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`
+          );
+        }
+        throw new Error(
+          `Failed to update memory ${id}: write failed after delete, latest available record restored. Write error: ${addError instanceof Error ? addError.message : String(addError)}`
+        );
+      }
+      return updated;
+    });
+  }
+  async runSerializedUpdate(action) {
+    const previous = this.updateQueue;
+    let release;
+    const lock = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.updateQueue = previous.then(() => lock);
+    await previous;
+    try {
+      return await action();
+    } finally {
+      release?.();
+    }
+  }
+  async patchMetadata(id, patch, scopeFilter) {
+    const existing = await this.getById(id, scopeFilter);
+    if (!existing) return null;
+    const metadata = buildSmartMetadata(existing, patch);
+    return this.update(
+      id,
+      { metadata: stringifySmartMetadata(metadata) },
+      scopeFilter
+    );
+  }
+  async bulkDelete(scopeFilter, beforeTimestamp) {
+    await this.ensureInitialized();
+    const conditions = [];
+    if (scopeFilter.length > 0) {
+      const scopeConditions = scopeFilter.map((scope) => `scope = '${escapeSqlLiteral(scope)}'`).join(" OR ");
+      conditions.push(`(${scopeConditions})`);
+    }
+    if (beforeTimestamp) {
+      conditions.push(`timestamp < ${beforeTimestamp}`);
+    }
+    if (conditions.length === 0) {
+      throw new Error(
+        "Bulk delete requires at least scope or timestamp filter for safety"
+      );
+    }
+    const whereClause = conditions.join(" AND ");
+    const countResults = await this.table.query().where(whereClause).toArray();
+    const deleteCount = countResults.length;
+    if (deleteCount > 0) {
+      await this.table.delete(whereClause);
+    }
+    return deleteCount;
+  }
+  /** Last FTS error for diagnostics */
+  _lastFtsError = null;
+  get lastFtsError() {
+    return this._lastFtsError;
+  }
+  /** Get FTS index health status */
+  getFtsStatus() {
+    return {
+      available: this.ftsIndexCreated,
+      lastError: this._lastFtsError
+    };
+  }
+  /** Rebuild FTS index (drops and recreates). Useful for recovery after corruption. */
+  async rebuildFtsIndex() {
+    await this.ensureInitialized();
+    try {
+      const indices = await this.table.listIndices();
+      for (const idx of indices) {
+        if (idx.indexType === "FTS" || idx.columns?.includes("text")) {
+          try {
+            await this.table.dropIndex(idx.name || "text");
+          } catch (err) {
+            log.warn(`dropIndex(${idx.name || "text"}) failed:`, err);
+          }
+        }
+      }
+      await this.createFtsIndex(this.table);
+      this.ftsIndexCreated = true;
+      this._lastFtsError = null;
+      return { success: true };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this._lastFtsError = msg;
+      this.ftsIndexCreated = false;
+      return { success: false, error: msg };
+    }
+  }
+}
+export {
+  MemoryStore,
+  loadLanceDB,
+  validateStoragePath
+};
+//# sourceMappingURL=store.js.map