memorix 1.2.3 → 1.2.5

package/dist/maintenance-runner.js

@@ -30,36 +30,111 @@ var init_esm_shims = __esm({
 
 // src/store/bun-sqlite-compat.ts
 import { createRequire } from "module";
+function loadNodeSqlite() {
+  const nodeSqlite = requireFromHere("node:sqlite");
+  return nodeSqlite.DatabaseSync;
+}
+function isNativeBindingFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /could not locate the bindings file|better_sqlite3\.node|module did not self-register/i.test(message);
+}
+function addCompatibility(db2) {
+  if (!db2.pragma) {
+    db2.pragma = function(pragma, options) {
+      const statement = db2.prepare(`PRAGMA ${pragma}`);
+      if (options?.simple) {
+        const result = statement.get();
+        return result ? Object.values(result)[0] : void 0;
+      }
+      return statement.all();
+    };
+  }
+  if (!db2.transaction) {
+    let depth = 0;
+    let sequence = 0;
+    db2.transaction = function(fn) {
+      return (...args) => {
+        const outermost = depth === 0;
+        const savepoint = `memorix_tx_${++sequence}`;
+        if (outermost) {
+          db2.exec("BEGIN IMMEDIATE");
+        } else {
+          db2.exec(`SAVEPOINT ${savepoint}`);
+        }
+        depth += 1;
+        try {
+          const result = fn(...args);
+          if (result && typeof result.then === "function") {
+            throw new Error("[memorix] SQLite transactions must be synchronous");
+          }
+          depth -= 1;
+          if (outermost) {
+            db2.exec("COMMIT");
+          } else {
+            db2.exec(`RELEASE SAVEPOINT ${savepoint}`);
+          }
+          return result;
+        } catch (error) {
+          depth -= 1;
+          try {
+            if (outermost) {
+              db2.exec("ROLLBACK");
+            } else {
+              db2.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+              db2.exec(`RELEASE SAVEPOINT ${savepoint}`);
+            }
+          } catch {
+          }
+          throw error;
+        }
+      };
+    };
+  }
+  return db2;
+}
+function instantiateDatabase(Sqlite, filePath, options) {
+  return driver === "node:sqlite" && options === void 0 ? new Sqlite(filePath) : new Sqlite(filePath, options);
+}
 function loadSqlite() {
   if (Database) return Database;
+  if (process.env.MEMORIX_SQLITE_DRIVER === "node") {
+    Database = loadNodeSqlite();
+    driver = "node:sqlite";
+    return Database;
+  }
   try {
     Database = requireFromHere("better-sqlite3");
+    driver = "better-sqlite3";
+    return Database;
+  } catch {
+  }
+  try {
+    Database = loadNodeSqlite();
+    driver = "node:sqlite";
     return Database;
   } catch {
   }
   try {
     const bunSqlite = requireFromHere("bun:sqlite");
     Database = bunSqlite.Database;
+    driver = "bun:sqlite";
     return Database;
   } catch {
-    throw new Error("[memorix] Neither better-sqlite3 nor bun:sqlite is available");
+    throw new Error("[memorix] SQLite is unavailable (better-sqlite3, node:sqlite, and bun:sqlite failed)");
   }
 }
 function createDatabase(path13, options) {
   const Sqlite = loadSqlite();
-  const db2 = new Sqlite(path13, options);
-  if (!db2.pragma) {
-    db2.pragma = function(pragma, options2) {
-      if (options2 && options2.simple) {
-        const result = db2.prepare(`PRAGMA ${pragma}`).get();
-        return result ? Object.values(result)[0] : void 0;
-      }
-      return db2.prepare(`PRAGMA ${pragma}`).all();
-    };
+  try {
+    return addCompatibility(instantiateDatabase(Sqlite, path13, options));
+  } catch (error) {
+    if (driver !== "better-sqlite3" || !isNativeBindingFailure(error)) throw error;
+    Database = loadNodeSqlite();
+    driver = "node:sqlite";
+    return addCompatibility(instantiateDatabase(Database, path13, options));
   }
-  return db2;
 }
-var Database, requireFromHere;
+var Database, driver, requireFromHere;
 var init_bun_sqlite_compat = __esm({
   "src/store/bun-sqlite-compat.ts"() {
     "use strict";
@@ -78,7 +153,7 @@ function loadBetterSqlite3() {
     BetterSqlite3 = loadSqlite();
     return BetterSqlite3;
   } catch {
-    throw new Error("[memorix] SQLite is not available (neither better-sqlite3 nor bun:sqlite)");
+    throw new Error("[memorix] SQLite is not available (better-sqlite3, node:sqlite, and bun:sqlite all failed)");
   }
 }
 function hasColumn(db2, table, column) {
@@ -1163,6 +1238,9 @@ function parseTomlValue(raw, filePath, line) {
   if (raw.startsWith('"') && raw.endsWith('"')) {
     return raw.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
   }
+  if (raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
   if (raw === "true") return true;
   if (raw === "false") return false;
   if (/^-?\d+$/.test(raw)) return Number.parseInt(raw, 10);
@@ -1175,7 +1253,7 @@ function parseTomlValue(raw, filePath, line) {
   throw new Error(`Unsupported TOML value in ${filePath}:${line}`);
 }
 function stripComment(line) {
-  let inString = false;
+  let quote = null;
   let escaped = false;
   for (let i = 0; i < line.length; i++) {
     const char = line[i];
@@ -1183,15 +1261,16 @@ function stripComment(line) {
       escaped = false;
       continue;
     }
-    if (char === "\\" && inString) {
+    if (char === "\\" && quote === '"') {
       escaped = true;
       continue;
     }
-    if (char === '"') {
-      inString = !inString;
+    if (char === '"' || char === "'") {
+      if (quote === char) quote = null;
+      else if (quote === null) quote = char;
       continue;
     }
-    if (char === "#" && !inString) {
+    if (char === "#" && quote === null) {
       return line.slice(0, i);
     }
   }
@@ -1228,6 +1307,25 @@ function getResolvedConfig(options = {}) {
   const legacy = loadFileConfig();
   const embeddingBaseUrl = first(process.env.MEMORIX_EMBEDDING_BASE_URL, toml.embedding?.base_url, yaml.embedding?.baseUrl, legacy.embeddingApi?.baseUrl);
   const openRouterEmbeddingApiKey = isOpenRouterUrl(embeddingBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
+  const memoryLlmProvider = first(
+    process.env.MEMORIX_LLM_PROVIDER,
+    toml.memory?.llm?.provider,
+    yaml.llm?.provider,
+    legacy.llm?.provider
+  );
+  const memoryLlmModel = first(
+    process.env.MEMORIX_LLM_MODEL,
+    toml.memory?.llm?.model,
+    yaml.llm?.model,
+    legacy.llm?.model
+  );
+  const memoryLlmBaseUrl = first(
+    process.env.MEMORIX_LLM_BASE_URL,
+    toml.memory?.llm?.base_url,
+    yaml.llm?.baseUrl,
+    legacy.llm?.baseUrl
+  );
+  const openRouterMemoryLlmApiKey = isOpenRouterMemoryLane(memoryLlmProvider, memoryLlmBaseUrl) ? process.env.OPENROUTER_API_KEY : void 0;
   const resolved = {
     agent: {
       provider: first(
@@ -1265,9 +1363,9 @@ function getResolvedConfig(options = {}) {
       autoCleanup: firstBool(toml.memory?.auto_cleanup, yaml.behavior?.autoCleanup),
       syncAdvisory: firstBool(toml.memory?.sync_advisory, yaml.behavior?.syncAdvisory),
       llm: {
-        provider: first(process.env.MEMORIX_LLM_PROVIDER, toml.memory?.llm?.provider, yaml.llm?.provider, legacy.llm?.provider),
-        model: first(process.env.MEMORIX_LLM_MODEL, toml.memory?.llm?.model, yaml.llm?.model, legacy.llm?.model),
-        baseUrl: first(process.env.MEMORIX_LLM_BASE_URL, toml.memory?.llm?.base_url, yaml.llm?.baseUrl, legacy.llm?.baseUrl),
+        provider: memoryLlmProvider,
+        model: memoryLlmModel,
+        baseUrl: memoryLlmBaseUrl,
         apiKey: first(
           process.env.MEMORIX_LLM_API_KEY,
           process.env.MEMORIX_API_KEY,
@@ -1276,7 +1374,7 @@ function getResolvedConfig(options = {}) {
           legacy.llm?.apiKey,
           process.env.OPENAI_API_KEY,
           process.env.ANTHROPIC_API_KEY,
-          process.env.OPENROUTER_API_KEY
+          openRouterMemoryLlmApiKey
         )
       }
     },
@@ -1413,6 +1511,9 @@ function isOpenRouterUrl(value) {
     return /(^|\.)openrouter\.ai(?::|\/|$)/i.test(value);
   }
 }
+function isOpenRouterMemoryLane(provider2, baseUrl) {
+  return provider2?.trim().toLowerCase() === "openrouter" || isOpenRouterUrl(baseUrl);
+}
 function normalizeExternalContext(value) {
   const normalized = value?.trim().toLowerCase();
   if (normalized === "auto" || normalized === "off") return normalized;
@@ -4180,6 +4281,29 @@ Rules:
   }
 });
 
+// src/timeout.ts
+function withTimeout(promise, ms, label) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+var init_timeout = __esm({
+  "src/timeout.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/project/aliases.ts
 var aliases_exports = {};
 __export(aliases_exports, {
@@ -4945,8 +5069,12 @@ async function searchObservations(options) {
     }
   };
   const modeKey = options.projectId ?? SEARCH_MODE_DEFAULT_KEY;
-  lastSearchModeByProject.set(modeKey, embeddingEnabled ? "hybrid" : "fulltext");
+  const quality = options.quality ?? "balanced";
   const database = await getDb();
+  lastSearchModeByProject.set(
+    modeKey,
+    quality === "fast" ? "fulltext (fast profile)" : embeddingEnabled ? "hybrid" : "fulltext"
+  );
   let projectIds = null;
   if (options.projectId) {
     try {
@@ -4968,11 +5096,15 @@ async function searchObservations(options) {
   }
   const hasQuery = options.query && options.query.trim().length > 0;
   const originalQuery = options.query;
-  const tier = hasQuery ? classifyQueryTier(originalQuery) : "fast";
+  const tier = quality === "fast" ? "fast" : hasQuery ? classifyQueryTier(originalQuery) : "fast";
   mark(`tier=${tier}`);
-  const expandedEmbeddingQuery = tier === "heavy" ? await maybeExpandSearchQuery(options.query) : options.query;
+  if (quality === "thorough" && hasQuery) {
+    const { initLLM: initLLM2, isLLMEnabled: isLLMEnabled2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
+    if (!isLLMEnabled2()) initLLM2();
+  }
+  const expandedEmbeddingQuery = quality === "thorough" && tier === "heavy" ? await maybeExpandSearchQuery(options.query) : options.query;
   mark("queryExpansion");
-  const intentResult = hasQuery ? detectQueryIntent(originalQuery) : null;
+  const intentResult = quality === "fast" || !hasQuery ? null : detectQueryIntent(originalQuery);
   const requestLimit = projectIds ? (options.limit ?? 20) * 3 : options.limit ?? 20;
   const defaultBoost = {
     title: 3,
@@ -4986,17 +5118,21 @@ async function searchObservations(options) {
   let searchParams = {
     term: originalQuery,
     limit: requestLimit,
-    includeVectors: true,
+    // Fast search never uses vectors, so returning them only adds work and
+    // payload pressure to an explicitly latency-sensitive path.
+    includeVectors: quality !== "fast",
     ...Object.keys(filters).length > 0 ? { where: filters } : {},
     // Search specific fields (not tokens, accessCount, etc.)
     properties: ["title", "entityName", "narrative", "facts", "concepts", "filesModified"],
     // Field boosting: intent-aware or default
     boost: fieldBoost,
     // Fuzzy tolerance: allow 1-char typos for short queries, 2 for longer
-    ...hasQuery ? { tolerance: originalQuery.length > 6 ? 2 : 1 } : {}
+    // Fuzzy matching is useful for ordinary recall, but grows sharply with
+    // corpus size. The fast profile deliberately uses exact lexical matching.
+    ...hasQuery && quality !== "fast" ? { tolerance: originalQuery.length > 6 ? 2 : 1 } : {}
   };
   let queryVector = null;
-  if (embeddingEnabled && hasQuery && tier !== "fast") {
+  if (quality !== "fast" && embeddingEnabled && hasQuery && tier !== "fast") {
     try {
       const provider2 = await getEmbeddingProvider();
       if (provider2) {
@@ -5011,11 +5147,11 @@ async function searchObservations(options) {
           );
         } else {
           const EMBEDDING_TIMEOUT_MS = 15e3;
-          const embedPromise = provider2.embed(expandedEmbeddingQuery);
-          const timeoutPromise = new Promise(
-            (_, reject) => setTimeout(() => reject(new Error(`Embedding timeout after ${EMBEDDING_TIMEOUT_MS}ms`)), EMBEDDING_TIMEOUT_MS)
+          queryVector = await withTimeout(
+            provider2.embed(expandedEmbeddingQuery),
+            EMBEDDING_TIMEOUT_MS,
+            "Embedding"
           );
-          queryVector = await Promise.race([embedPromise, timeoutPromise]);
           mark("embedding");
           const cjkRatio = (originalQuery.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g) || []).length / originalQuery.length;
           const isCJKHeavy = cjkRatio > 0.3;
@@ -5256,7 +5392,7 @@ async function searchObservations(options) {
       }
     }
   }
-  const shouldRerank = tier === "heavy" && hasQuery && intermediate.length > 2 && (() => {
+  const shouldRerank = quality === "thorough" && tier === "heavy" && hasQuery && intermediate.length > 2 && (() => {
     const top = intermediate[0]?.score ?? 0;
     const second = intermediate[1]?.score ?? 0;
     return top > 0 && second / top > 0.7;
@@ -5280,11 +5416,11 @@ async function searchObservations(options) {
       }));
       const _parsedRerank = parseInt(process.env.MEMORIX_RERANK_TIMEOUT_MS || "", 10);
       const RERANK_TIMEOUT_MS = Number.isFinite(_parsedRerank) && _parsedRerank > 0 ? _parsedRerank : 5e3;
-      const rerankPromise = rerankResults2(originalQuery, candidates);
-      const timeoutPromise = new Promise(
-        (_, reject) => setTimeout(() => reject(new Error(`LLM rerank timeout after ${RERANK_TIMEOUT_MS}ms`)), RERANK_TIMEOUT_MS)
+      const { reranked, usedLLM } = await withTimeout(
+        rerankResults2(originalQuery, candidates),
+        RERANK_TIMEOUT_MS,
+        "LLM rerank"
       );
-      const { reranked, usedLLM } = await Promise.race([rerankPromise, timeoutPromise]);
       mark(`rerank(usedLLM=${usedLLM})`);
       if (usedLLM) {
         lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? "fulltext") + " + LLM rerank");
@@ -5476,6 +5612,7 @@ var init_orama_store = __esm({
     init_project_affinity();
     init_intent_detector();
     init_query_expansion();
+    init_timeout();
     db = null;
     dbInitPromise = null;
     dbGeneration = 0;
@@ -11720,6 +11857,7 @@ var DEFAULT_TIMEOUT_MS = 5 * 6e4;
 // src/runtime/project-maintenance.ts
 init_esm_shims();
 init_lifecycle();
+init_timeout();
 var DEFAULT_VECTOR_BATCH_SIZE = 12;
 var DEFAULT_RETENTION_BATCH_SIZE = 100;
 var DEFAULT_CONSOLIDATION_BATCH_SIZE = 200;
@@ -11790,21 +11928,6 @@ async function loadWorkspaceForMaintenance(projectId, projectDir2, mode) {
   ]);
   return versioned ?? local;
 }
-function withTimeout(promise, ms, label) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        reject(error);
-      }
-    );
-  });
-}
 async function runAutomaticConsolidation(projectId, projectDir2, options) {
   const { isLLMEnabled: isLLMEnabled2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
   if (!isLLMEnabled2()) {