memorix 1.9.6 → 1.9.8

package/CHANGELOG.md

@@ -6,6 +6,24 @@ All notable changes to this project will be documented in this file.
 
 No unreleased changes.
 
+## [1.9.8] - 2026-10-02
+
+### Fixed
+- **OpenCode v2 plugin compatibility** -- generated plugins retain the v1
+  named export while also exposing the v2 default `id`/`setup` contract,
+  including event subscriptions, tool hooks, cleanup, and host session IDs.
+
+## [1.9.7] - 2026-09-28
+
+### Fixed
+- **SQLite FTS5 startup resilience** -- transient `SQLITE_BUSY` contention during
+  lexical-index initialization is retried before FTS5 is marked unavailable.
+- **Large-store search fallback** -- runtime embedding failure, provider
+  disappearance, and vector-dimension mismatch now all fall back to the durable
+  SQLite lexical index instead of returning a silent empty result.
+- **Release metadata** -- synchronized the npm, MCP Registry, and packaged
+  integration metadata for the 1.9.7 patch release.
+
 ## [1.9.6] - 2026-09-22
 
 ### Added

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.9.6" : pkg.version;
+  return true ? "1.9.8" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -9349,6 +9349,74 @@ var init_launch_root = __esm({
   }
 });
 
+// src/store/sqlite-reliability.ts
+function isTransientSqliteError(error40) {
+  const code = error40?.code;
+  if (typeof code === "string") {
+    return /^SQLITE_BUSY(?:_|$)/i.test(code);
+  }
+  return error40 instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error40.message);
+}
+function isSqliteUnavailableError(error40) {
+  return error40 instanceof SqliteUnavailableError || error40 instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error40.message);
+}
+function degradedReadError(storeName) {
+  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
+}
+function degradedWriteError(storeName) {
+  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
+}
+function formatSqliteFailure(error40) {
+  return error40 instanceof Error && error40.message ? error40.message : String(error40);
+}
+function delay(ms2) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms2));
+}
+async function retrySqliteBusy(operation, label) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation();
+    } catch (error40) {
+      if (!isTransientSqliteError(error40) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error40;
+      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
+      console.error(
+        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
+      );
+      await delay(waitMs);
+    }
+  }
+}
+async function initializeSqliteStore(factory, dataDir, label) {
+  try {
+    loadBetterSqlite3();
+  } catch (error40) {
+    throw new SqliteUnavailableError(error40);
+  }
+  return retrySqliteBusy(async () => {
+    const store2 = factory();
+    await store2.init(dataDir);
+    return store2;
+  }, label);
+}
+var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
+var init_sqlite_reliability = __esm({
+  "src/store/sqlite-reliability.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
+    SqliteUnavailableError = class extends Error {
+      code = "MEMORIX_SQLITE_UNAVAILABLE";
+      constructor(cause) {
+        super(
+          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
+        );
+        this.name = "SqliteUnavailableError";
+      }
+    };
+  }
+});
+
 // src/store/sqlite-fts.ts
 function normalizeFtsToken(token) {
   return token.replace(/"/g, '""');
@@ -9362,22 +9430,27 @@ function buildFtsQuery(query) {
 function initializeObservationLexicalIndex(db2) {
   const known = ftsAvailability.get(db2);
   if (known !== void 0) return known;
-  try {
-    db2.exec(CREATE_OBSERVATION_FTS);
-    const observationCount = Number(db2.prepare("SELECT COUNT(*) AS count FROM observations").get()?.count ?? 0);
-    const indexedCount = Number(db2.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
-    if (observationCount !== indexedCount) {
-      db2.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+  let lastError;
+  for (let attempt = 1; attempt <= FTS_INIT_MAX_ATTEMPTS; attempt++) {
+    try {
+      db2.exec(CREATE_OBSERVATION_FTS);
+      const observationCount = Number(db2.prepare("SELECT COUNT(*) AS count FROM observations").get()?.count ?? 0);
+      const indexedCount = Number(db2.prepare(`SELECT COUNT(*) AS count FROM ${FTS_TABLE}`).get()?.count ?? 0);
+      if (observationCount !== indexedCount) {
+        db2.exec(`INSERT INTO ${FTS_TABLE}(${FTS_TABLE}) VALUES ('rebuild')`);
+      }
+      ftsAvailability.set(db2, true);
+      return true;
+    } catch (error40) {
+      lastError = error40;
+      if (!isTransientSqliteError(error40) || attempt === FTS_INIT_MAX_ATTEMPTS) break;
     }
-    ftsAvailability.set(db2, true);
-    return true;
-  } catch (error40) {
-    ftsAvailability.set(db2, false);
-    console.warn(
-      `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${error40 instanceof Error ? error40.message : String(error40)}`
-    );
-    return false;
   }
+  ftsAvailability.set(db2, false);
+  console.warn(
+    `[memorix] SQLite FTS5 unavailable; using the existing search fallback: ${lastError instanceof Error ? lastError.message : String(lastError)}`
+  );
+  return false;
 }
 function isObservationLexicalIndexEnabled(db2) {
   return ftsAvailability.get(db2) === true;
@@ -9431,11 +9504,12 @@ function searchObservationLexically(db2, options) {
     score: Math.max(0, Number(row.lexical_score ?? 0))
   }));
 }
-var ftsAvailability, FTS_TABLE, CREATE_OBSERVATION_FTS;
+var ftsAvailability, FTS_TABLE, CREATE_OBSERVATION_FTS, FTS_INIT_MAX_ATTEMPTS;
 var init_sqlite_fts = __esm({
   "src/store/sqlite-fts.ts"() {
     "use strict";
     init_esm_shims();
+    init_sqlite_reliability();
     ftsAvailability = /* @__PURE__ */ new WeakMap();
     FTS_TABLE = "observations_fts";
     CREATE_OBSERVATION_FTS = `
@@ -9469,6 +9543,7 @@ CREATE TRIGGER IF NOT EXISTS observations_fts_au AFTER UPDATE ON observations BE
   VALUES (new.id, new.entityName, new.title, new.narrative, new.facts, new.filesModified, new.concepts, new.attachments);
 END;
 `;
+    FTS_INIT_MAX_ATTEMPTS = 3;
   }
 });
 
@@ -10724,74 +10799,6 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   }
 });
 
-// src/store/sqlite-reliability.ts
-function isTransientSqliteError(error40) {
-  const code = error40?.code;
-  if (typeof code === "string") {
-    return /^SQLITE_BUSY(?:_|$)/i.test(code);
-  }
-  return error40 instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error40.message);
-}
-function isSqliteUnavailableError(error40) {
-  return error40 instanceof SqliteUnavailableError || error40 instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error40.message);
-}
-function degradedReadError(storeName) {
-  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
-}
-function degradedWriteError(storeName) {
-  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
-}
-function formatSqliteFailure(error40) {
-  return error40 instanceof Error && error40.message ? error40.message : String(error40);
-}
-function delay(ms2) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms2));
-}
-async function retrySqliteBusy(operation, label) {
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return await operation();
-    } catch (error40) {
-      if (!isTransientSqliteError(error40) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error40;
-      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
-      console.error(
-        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
-      );
-      await delay(waitMs);
-    }
-  }
-}
-async function initializeSqliteStore(factory, dataDir, label) {
-  try {
-    loadBetterSqlite3();
-  } catch (error40) {
-    throw new SqliteUnavailableError(error40);
-  }
-  return retrySqliteBusy(async () => {
-    const store2 = factory();
-    await store2.init(dataDir);
-    return store2;
-  }, label);
-}
-var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
-var init_sqlite_reliability = __esm({
-  "src/store/sqlite-reliability.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_sqlite_db();
-    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
-    SqliteUnavailableError = class extends Error {
-      code = "MEMORIX_SQLITE_UNAVAILABLE";
-      constructor(cause) {
-        super(
-          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
-        );
-        this.name = "SqliteUnavailableError";
-      }
-    };
-  }
-});
-
 // src/store/file-lock.ts
 import { promises as fs2 } from "fs";
 import { randomUUID } from "crypto";
@@ -188224,6 +188231,7 @@ async function searchObservations(options) {
   };
   let queryVector = null;
   let embeddingProviderForSearch = null;
+  let embeddingUnavailable = false;
   if (quality !== "fast" && embeddingEnabled && hasQuery && tier !== "fast") {
     try {
       const provider2 = await getEmbeddingProvider();
@@ -188231,6 +188239,7 @@ async function searchObservations(options) {
         embeddingProviderForSearch = provider2;
         const activeVectorDimensions = getVectorDimensions();
         if (activeVectorDimensions !== null && provider2.dimensions !== activeVectorDimensions) {
+          embeddingUnavailable = true;
           rememberSearchMode(
             modeKey,
             `fulltext (embedding dimension mismatch: provider ${provider2.dimensions}d vs index ${activeVectorDimensions}d)`
@@ -188270,8 +188279,11 @@ async function searchObservations(options) {
             hybridWeights: isCJKHeavy ? { text: 0.2, vector: 0.8 } : { text: 0.6, vector: 0.4 }
           };
         }
+      } else {
+        embeddingUnavailable = true;
       }
     } catch (error40) {
+      embeddingUnavailable = true;
       rememberSearchMode(modeKey, "fulltext (embedding unavailable)");
       console.error("[memorix] Embedding failed or timed out, falling back to fulltext search");
     }
@@ -188279,7 +188291,7 @@ async function searchObservations(options) {
   mark("preSearch");
   let results;
   const persistentCorpusEligible = await shouldUsePersistentSearch(projectIds, options.projectId);
-  const canUsePersistentLexical = persistentCorpusEligible && Boolean(hasQuery) && !queryVector && (quality === "fast" || tier === "fast" || !embeddingEnabled);
+  const canUsePersistentLexical = persistentCorpusEligible && Boolean(hasQuery) && !queryVector && (quality === "fast" || tier === "fast" || !embeddingEnabled || embeddingUnavailable);
   let persistent = persistentCorpusEligible && queryVector && embeddingProviderForSearch ? await searchPersistentSemantically(options, projectIds, requestLimit, queryVector, embeddingProviderForSearch) : canUsePersistentLexical ? await searchPersistentLexically(options, projectIds, requestLimit) : null;
   const durableStore = getOptionalObservationStore();
   if (!persistent && queryVector && durableStore?.hasLexicalIndex?.() && count2(database) === 0) {
@@ -195655,6 +195667,161 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
     },
   };
 };
+
+/**
+ * OpenCode v2 compatibility layer. Keep this beside the v1 export so one
+ * generated file can be loaded by both host generations during migration.
+ */
+const v2HookCommand = ${hookCommand};
+
+function v2ReportHookFailure(eventName, detail) {
+  if (process.env.MEMORIX_HOOK_DEBUG !== '1') return;
+  console.error('[memorix-plugin] v2 hook delivery failed:', eventName, detail);
+}
+
+function v2EventData(event) {
+  return event && typeof event.data === 'object' && event.data !== null ? event.data : {};
+}
+
+function v2SessionId(event) {
+  const data = v2EventData(event);
+  const value = data.sessionID ?? data.sessionId ?? data.session_id
+    ?? event?.sessionID ?? event?.sessionId;
+  return typeof value === 'string' ? value : '';
+}
+
+function v2RunHook(payload, directory, sessionId) {
+  const nextPayload = { agent: 'opencode', cwd: directory, ...payload };
+  if (sessionId) nextPayload.session_id = sessionId;
+  const eventName = nextPayload.hook_event_name || 'unknown';
+  try {
+    const result = spawnSync(v2HookCommand, ['hook'], {
+      input: JSON.stringify(nextPayload),
+      timeout: 10_000,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      shell: process.platform === 'win32',
+      windowsHide: true,
+    });
+    if (result.status !== 0) {
+      v2ReportHookFailure(eventName, {
+        exit: result.status,
+        stderr: (result.stderr || '').slice(0, 200),
+        error: result.error?.message,
+      });
+    }
+  } catch (error) {
+    v2ReportHookFailure(eventName, error?.message ?? error);
+  }
+}
+
+function v2SessionState(states, sessionId) {
+  const key = sessionId || '__unknown__';
+  let state = states.get(key);
+  if (!state) {
+    state = { pendingText: '', lastDeliveredKey: '' };
+    states.set(key, state);
+  }
+  return state;
+}
+
+function v2FlushAssistant(state, directory, sessionId) {
+  const text = state.pendingText.trim();
+  if (!text || text === state.lastDeliveredKey) return;
+  v2RunHook({ hook_event_name: 'message.updated', ai_response: text }, directory, sessionId);
+  state.lastDeliveredKey = text;
+  state.pendingText = '';
+}
+
+function v2FilePath(file) {
+  if (typeof file === 'string') return file;
+  if (!file || typeof file !== 'object') return '';
+  return file.path ?? file.file ?? file.name ?? '';
+}
+
+function v2HandleEvent(event, directory, states) {
+  if (!event || typeof event !== 'object') return;
+  const type = typeof event.type === 'string' ? event.type : '';
+  const data = v2EventData(event);
+  const sessionId = v2SessionId(event);
+  const state = v2SessionState(states, sessionId);
+  const run = (payload) => v2RunHook(payload, directory, sessionId);
+
+  switch (type) {
+    case 'session.created':
+      run({ hook_event_name: 'session.created' });
+      break;
+    case 'session.text.delta':
+      state.pendingText += typeof data.delta === 'string' ? data.delta : (typeof data.text === 'string' ? data.text : '');
+      break;
+    case 'session.message.updated':
+    case 'message.updated':
+      if (data.role === 'assistant' && typeof data.text === 'string') state.pendingText = data.text;
+      break;
+    case 'session.step.ended': {
+      const files = Array.isArray(data.files) ? data.files : [];
+      for (const file of files) {
+        const filePath = v2FilePath(file);
+        if (filePath) run({ hook_event_name: 'file.edited', file_path: filePath });
+      }
+      if (typeof data.text === 'string') state.pendingText += data.text;
+      break;
+    }
+    case 'session.idle':
+      v2FlushAssistant(state, directory, sessionId);
+      run({ hook_event_name: 'session.idle' });
+      break;
+    case 'session.compacted':
+      run({ hook_event_name: 'session.compacted' });
+      break;
+    default:
+      break;
+  }
+}
+
+function setup(ctx) {
+  const directory = ctx?.location?.directory || ctx?.location?.worktree || process.cwd();
+  const controller = new AbortController();
+  const states = new Map();
+
+  if (ctx?.tool?.hook) {
+    try {
+      Promise.resolve(ctx.tool.hook('execute.after', async (event) => {
+        const sessionId = v2SessionId(event);
+        const data = event && typeof event.input === 'object' ? event.input : {};
+        const tool = event?.tool ?? event?.name ?? '';
+        v2RunHook({
+          hook_event_name: 'tool.execute.after',
+          tool_name: tool,
+          tool_input: data,
+        }, directory, sessionId);
+        if (tool === 'shell') {
+          v2RunHook({
+            hook_event_name: 'command.executed',
+            command: data.command ?? data.cmd ?? '',
+          }, directory, sessionId);
+        }
+      })).catch((error) => v2ReportHookFailure('execute.after', error?.message ?? error));
+    } catch (error) {
+      v2ReportHookFailure('execute.after', error?.message ?? error);
+    }
+  }
+
+  if (ctx?.event?.subscribe) {
+    void (async () => {
+      try {
+        const stream = ctx.event.subscribe({ signal: controller.signal });
+        for await (const event of stream) v2HandleEvent(event, directory, states);
+      } catch (error) {
+        if (!controller.signal.aborted) v2ReportHookFailure('event.subscribe', error?.message ?? error);
+      }
+    })();
+  }
+
+  return () => controller.abort();
+}
+
+export default { id: 'memorix', setup };
 `;
 }
 async function installOpenCodeSkills(projectRoot, global2 = false) {
@@ -196480,7 +196647,7 @@ var init_installers = __esm({
     "use strict";
     init_esm_shims();
     init_official_skills();
-    OPENCODE_PLUGIN_VERSION = 7;
+    OPENCODE_PLUGIN_VERSION = 8;
     AGENT_SKILL_DIRS = {
       cursor: { project: path31.join(".cursor", "skills"), global: path31.join(".cursor", "skills") },
       windsurf: { project: path31.join(".windsurf", "skills"), global: path31.join(".windsurf", "skills") },
@@ -209007,7 +209174,7 @@ var init_tool_profile = __esm({
 function getMcpServerInfo() {
   return {
     name: "memorix",
-    version: true ? "1.9.6" : "1.0.1"
+    version: true ? "1.9.8" : "1.0.1"
   };
 }
 function createMcpDiscoverResult(capabilities, serverInfo) {