@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-XJNBEDFE.js

@@ -0,0 +1,193 @@
+import {
+  encodeStoragePathSegment,
+  resolvePathInsideStorageRoot
+} from "./chunk-FF4KLI5W.js";
+
+// src/summary-snapshot.ts
+import {
+  mkdir,
+  open,
+  readFile,
+  stat,
+  unlink,
+  utimes,
+  writeFile
+} from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var summarySnapshotSchemaVersion = 1;
+var SummarySnapshotItemSchema = z.object({
+  hour: z.string(),
+  sessionKey: z.string(),
+  bullets: z.array(z.string()),
+  turnCount: z.number().int().nonnegative(),
+  generatedAt: z.string()
+});
+var SummarySnapshotSchema = z.object({
+  schemaVersion: z.number().default(summarySnapshotSchemaVersion),
+  sessionKey: z.string(),
+  generatedAt: z.string().datetime({ offset: true }),
+  summaries: z.array(SummarySnapshotItemSchema)
+});
+var summarySnapshotUpserts = /* @__PURE__ */ new Map();
+var summarySnapshotLockTimeoutMs = 5e3;
+var summarySnapshotLockStaleMs = 3e4;
+var summarySnapshotLockHeartbeatMs = Math.max(
+  1e3,
+  Math.floor(summarySnapshotLockStaleMs / 3)
+);
+function summarySnapshotPath(memoryDir, sessionKey) {
+  return resolveSummarySnapshotPath(memoryDir, sessionKey, "json");
+}
+function summarySnapshotLockPath(memoryDir, sessionKey) {
+  return resolveSummarySnapshotPath(memoryDir, sessionKey, "lock");
+}
+function summarySnapshotRoot(memoryDir) {
+  return resolvePathInsideStorageRoot(memoryDir, "state", "summaries");
+}
+function resolveSummarySnapshotPath(memoryDir, sessionKey, extension) {
+  const safeSessionKey = encodeStoragePathSegment(sessionKey, "session");
+  return resolvePathInsideStorageRoot(
+    summarySnapshotRoot(memoryDir),
+    `${safeSessionKey}.${extension}`
+  );
+}
+function legacySummarySnapshotPath(memoryDir, sessionKey) {
+  if (sessionKey.includes("\0")) {
+    return null;
+  }
+  try {
+    return resolvePathInsideStorageRoot(
+      summarySnapshotRoot(memoryDir),
+      `${sessionKey}.json`
+    );
+  } catch {
+    return null;
+  }
+}
+async function readSummarySnapshot(memoryDir, sessionKey) {
+  const filePath = summarySnapshotPath(memoryDir, sessionKey);
+  const snapshot = await readSummarySnapshotFile(filePath, sessionKey);
+  if (snapshot !== null) return snapshot;
+  const legacyPath = legacySummarySnapshotPath(memoryDir, sessionKey);
+  if (legacyPath === null || legacyPath === filePath) return null;
+  return readSummarySnapshotFile(legacyPath, sessionKey);
+}
+async function readSummarySnapshotFile(filePath, sessionKey) {
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    const data = SummarySnapshotSchema.parse(JSON.parse(raw));
+    if (data.sessionKey !== sessionKey) return null;
+    return data.summaries;
+  } catch {
+    return null;
+  }
+}
+async function writeSummarySnapshot(memoryDir, sessionKey, summaries) {
+  const filePath = summarySnapshotPath(memoryDir, sessionKey);
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const payload = {
+    schemaVersion: summarySnapshotSchemaVersion,
+    sessionKey,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summaries: summaries.map((summary) => ({
+      hour: summary.hour,
+      sessionKey: summary.sessionKey,
+      bullets: summary.bullets,
+      turnCount: summary.turnCount,
+      generatedAt: summary.generatedAt
+    })).sort((a, b) => new Date(b.hour).getTime() - new Date(a.hour).getTime())
+  };
+  await writeFile(filePath, JSON.stringify(payload, null, 2), "utf-8");
+}
+async function withSummarySnapshotLock(memoryDir, sessionKey, work) {
+  const previous = summarySnapshotUpserts.get(sessionKey) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const chained = previous.then(() => current);
+  summarySnapshotUpserts.set(sessionKey, chained);
+  await previous;
+  try {
+    return await withExclusiveSummarySnapshotFileLock(
+      summarySnapshotLockPath(memoryDir, sessionKey),
+      work
+    );
+  } finally {
+    release();
+    if (summarySnapshotUpserts.get(sessionKey) === chained) {
+      summarySnapshotUpserts.delete(sessionKey);
+    }
+  }
+}
+async function upsertSummarySnapshot(memoryDir, summary) {
+  await withSummarySnapshotLock(memoryDir, summary.sessionKey, async () => {
+    const existing = await readSummarySnapshot(memoryDir, summary.sessionKey);
+    const byHour = /* @__PURE__ */ new Map();
+    for (const item of existing ?? []) {
+      byHour.set(item.hour, {
+        ...item,
+        generatedAt: item.generatedAt || (/* @__PURE__ */ new Date()).toISOString(),
+        sessionKey: summary.sessionKey
+      });
+    }
+    byHour.set(summary.hour, summary);
+    const next = Array.from(byHour.values()).sort(
+      (a, b) => new Date(b.hour).getTime() - new Date(a.hour).getTime()
+    );
+    await writeSummarySnapshot(memoryDir, summary.sessionKey, next);
+  });
+}
+async function withExclusiveSummarySnapshotFileLock(lockPath, callback) {
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  const startedAt = Date.now();
+  while (true) {
+    try {
+      const handle = await open(lockPath, "wx");
+      let heartbeat = null;
+      if (summarySnapshotLockHeartbeatMs > 0) {
+        heartbeat = setInterval(() => {
+          void utimes(lockPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0);
+        }, summarySnapshotLockHeartbeatMs);
+        heartbeat.unref?.();
+      }
+      try {
+        return await callback();
+      } finally {
+        if (heartbeat) clearInterval(heartbeat);
+        await handle.close().catch(() => void 0);
+        await unlink(lockPath).catch(() => void 0);
+      }
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) throw error;
+      try {
+        const lockStat = await stat(lockPath);
+        if (Date.now() - lockStat.mtimeMs > summarySnapshotLockStaleMs) {
+          await unlink(lockPath).catch(() => void 0);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - startedAt > summarySnapshotLockTimeoutMs) {
+        throw new Error("timed out acquiring summary snapshot lock");
+      }
+      await sleep(10);
+    }
+  }
+}
+function isAlreadyExistsError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  summarySnapshotPath,
+  readSummarySnapshot,
+  writeSummarySnapshot,
+  upsertSummarySnapshot
+};
+//# sourceMappingURL=chunk-XJNBEDFE.js.map

package/dist/chunk-XJNBEDFE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/summary-snapshot.ts"],"sourcesContent":["import {\n  mkdir,\n  open,\n  readFile,\n  stat,\n  unlink,\n  utimes,\n  writeFile,\n} from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { z } from \"zod\";\nimport {\n  encodeStoragePathSegment,\n  resolvePathInsideStorageRoot,\n} from \"./storage-paths.js\";\nimport type { HourlySummary } from \"./types.js\";\n\nconst summarySnapshotSchemaVersion = 1;\n\nconst SummarySnapshotItemSchema = z.object({\n  hour: z.string(),\n  sessionKey: z.string(),\n  bullets: z.array(z.string()),\n  turnCount: z.number().int().nonnegative(),\n  generatedAt: z.string(),\n});\n\nconst SummarySnapshotSchema = z.object({\n  schemaVersion: z.number().default(summarySnapshotSchemaVersion),\n  sessionKey: z.string(),\n  generatedAt: z.string().datetime({ offset: true }),\n  summaries: z.array(SummarySnapshotItemSchema),\n});\n\ntype SummarySnapshot = z.infer<typeof SummarySnapshotSchema>;\n\nconst summarySnapshotUpserts = new Map<string, Promise<void>>();\nconst summarySnapshotLockTimeoutMs = 5_000;\nconst summarySnapshotLockStaleMs = 30_000;\nconst summarySnapshotLockHeartbeatMs = Math.max(\n  1_000,\n  Math.floor(summarySnapshotLockStaleMs / 3),\n);\n\nexport function summarySnapshotPath(\n  memoryDir: string,\n  sessionKey: string,\n): string {\n  return resolveSummarySnapshotPath(memoryDir, sessionKey, \"json\");\n}\n\nfunction summarySnapshotLockPath(memoryDir: string, sessionKey: string): string {\n  return resolveSummarySnapshotPath(memoryDir, sessionKey, \"lock\");\n}\n\nfunction summarySnapshotRoot(memoryDir: string): string {\n  return resolvePathInsideStorageRoot(memoryDir, \"state\", \"summaries\");\n}\n\nfunction resolveSummarySnapshotPath(\n  memoryDir: string,\n  sessionKey: string,\n  extension: \"json\" | \"lock\",\n): string {\n  const safeSessionKey = encodeStoragePathSegment(sessionKey, \"session\");\n  return resolvePathInsideStorageRoot(\n    summarySnapshotRoot(memoryDir),\n    `${safeSessionKey}.${extension}`,\n  );\n}\n\nfunction legacySummarySnapshotPath(\n  memoryDir: string,\n  sessionKey: string,\n): string | null {\n  if (sessionKey.includes(\"\\0\")) {\n    return null;\n  }\n  try {\n    return resolvePathInsideStorageRoot(\n      summarySnapshotRoot(memoryDir),\n      `${sessionKey}.json`,\n    );\n  } catch {\n    return null;\n  }\n}\n\nexport async function readSummarySnapshot(\n  memoryDir: string,\n  sessionKey: string,\n): Promise<HourlySummary[] | null> {\n  const filePath = summarySnapshotPath(memoryDir, sessionKey);\n  const snapshot = await readSummarySnapshotFile(filePath, sessionKey);\n  if (snapshot !== null) return snapshot;\n\n  const legacyPath = legacySummarySnapshotPath(memoryDir, sessionKey);\n  if (legacyPath === null || legacyPath === filePath) return null;\n  return readSummarySnapshotFile(legacyPath, sessionKey);\n}\n\nasync function readSummarySnapshotFile(\n  filePath: string,\n  sessionKey: string,\n): Promise<HourlySummary[] | null> {\n  try {\n    const raw = await readFile(filePath, \"utf-8\");\n    const data = SummarySnapshotSchema.parse(JSON.parse(raw));\n    if (data.sessionKey !== sessionKey) return null;\n    return data.summaries;\n  } catch {\n    return null;\n  }\n}\n\nexport async function writeSummarySnapshot(\n  memoryDir: string,\n  sessionKey: string,\n  summaries: HourlySummary[],\n): Promise<void> {\n  const filePath = summarySnapshotPath(memoryDir, sessionKey);\n  await mkdir(path.dirname(filePath), { recursive: true });\n  const payload: SummarySnapshot = {\n    schemaVersion: summarySnapshotSchemaVersion,\n    sessionKey,\n    generatedAt: new Date().toISOString(),\n    summaries: summaries\n      .map((summary) => ({\n        hour: summary.hour,\n        sessionKey: summary.sessionKey,\n        bullets: summary.bullets,\n        turnCount: summary.turnCount,\n        generatedAt: summary.generatedAt,\n      }))\n      .sort((a, b) => new Date(b.hour).getTime() - new Date(a.hour).getTime()),\n  };\n  await writeFile(filePath, JSON.stringify(payload, null, 2), \"utf-8\");\n}\n\nasync function withSummarySnapshotLock<T>(\n  memoryDir: string,\n  sessionKey: string,\n  work: () => Promise<T>,\n): Promise<T> {\n  const previous = summarySnapshotUpserts.get(sessionKey) ?? Promise.resolve();\n  let release!: () => void;\n  const current = new Promise<void>((resolve) => {\n    release = resolve;\n  });\n  const chained = previous.then(() => current);\n  summarySnapshotUpserts.set(sessionKey, chained);\n\n  await previous;\n  try {\n    return await withExclusiveSummarySnapshotFileLock(\n      summarySnapshotLockPath(memoryDir, sessionKey),\n      work,\n    );\n  } finally {\n    release();\n    if (summarySnapshotUpserts.get(sessionKey) === chained) {\n      summarySnapshotUpserts.delete(sessionKey);\n    }\n  }\n}\n\nexport async function upsertSummarySnapshot(\n  memoryDir: string,\n  summary: HourlySummary,\n): Promise<void> {\n  await withSummarySnapshotLock(memoryDir, summary.sessionKey, async () => {\n    const existing = await readSummarySnapshot(memoryDir, summary.sessionKey);\n    const byHour = new Map<string, HourlySummary>();\n    for (const item of existing ?? []) {\n      byHour.set(item.hour, {\n        ...item,\n        generatedAt: item.generatedAt || new Date().toISOString(),\n        sessionKey: summary.sessionKey,\n      });\n    }\n    byHour.set(summary.hour, summary);\n    const next = Array.from(byHour.values()).sort(\n      (a, b) => new Date(b.hour).getTime() - new Date(a.hour).getTime(),\n    );\n    await writeSummarySnapshot(memoryDir, summary.sessionKey, next);\n  });\n}\n\nasync function withExclusiveSummarySnapshotFileLock<T>(\n  lockPath: string,\n  callback: () => Promise<T>,\n): Promise<T> {\n  await mkdir(path.dirname(lockPath), { recursive: true });\n  const startedAt = Date.now();\n\n  while (true) {\n    try {\n      const handle = await open(lockPath, \"wx\");\n      let heartbeat: NodeJS.Timeout | null = null;\n      if (summarySnapshotLockHeartbeatMs > 0) {\n        heartbeat = setInterval(() => {\n          void utimes(lockPath, new Date(), new Date()).catch(() => undefined);\n        }, summarySnapshotLockHeartbeatMs);\n        heartbeat.unref?.();\n      }\n      try {\n        return await callback();\n      } finally {\n        if (heartbeat) clearInterval(heartbeat);\n        await handle.close().catch(() => undefined);\n        await unlink(lockPath).catch(() => undefined);\n      }\n    } catch (error) {\n      if (!isAlreadyExistsError(error)) throw error;\n      try {\n        const lockStat = await stat(lockPath);\n        if (Date.now() - lockStat.mtimeMs > summarySnapshotLockStaleMs) {\n          await unlink(lockPath).catch(() => undefined);\n          continue;\n        }\n      } catch {\n        continue;\n      }\n      if (Date.now() - startedAt > summarySnapshotLockTimeoutMs) {\n        throw new Error(\"timed out acquiring summary snapshot lock\");\n      }\n      await sleep(10);\n    }\n  }\n}\n\nfunction isAlreadyExistsError(error: unknown): boolean {\n  return typeof error === \"object\" && error !== null && \"code\" in error && error.code === \"EEXIST\";\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-XVVIG67A.js

@@ -0,0 +1,291 @@
+import {
+  scanMemoryDir
+} from "./chunk-MJFNCJXV.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/search/orama-backend.ts
+import path from "path";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+var OramaBackend = class {
+  dbPath;
+  collection;
+  embedHelper;
+  memoryDir;
+  embeddingDimension;
+  available = false;
+  db = null;
+  oramaModule = null;
+  persistModule = null;
+  constructor(opts) {
+    this.dbPath = opts.dbPath;
+    this.collection = opts.collection;
+    this.embedHelper = opts.embedHelper;
+    this.memoryDir = opts.memoryDir;
+    this.embeddingDimension = opts.embeddingDimension;
+  }
+  async probe() {
+    try {
+      await this.ensureModules();
+      await this.ensureDb();
+      this.available = true;
+      return true;
+    } catch (err) {
+      log.debug(`OramaBackend probe failed: ${err}`);
+      this.available = false;
+      return false;
+    }
+  }
+  isAvailable() {
+    return this.available;
+  }
+  debugStatus() {
+    return `backend=orama available=${this.available} dbPath=${this.dbPath}`;
+  }
+  async search(query, _collection, maxResults, _options, _execution) {
+    return this.hybridSearch(query, _collection, maxResults);
+  }
+  async searchGlobal(query, maxResults, _execution) {
+    const limit = maxResults ?? 10;
+    if (!this.available) return [];
+    try {
+      const files = await this.listDbFiles();
+      const allResults = [];
+      for (const file of files) {
+        const db = await this.loadDbFromFile(file);
+        if (!db) continue;
+        const results = await this.searchDb(db, query, "hybrid", limit);
+        allResults.push(...results);
+      }
+      allResults.sort((a, b) => b.score - a.score);
+      return allResults.slice(0, limit);
+    } catch (err) {
+      log.debug(`OramaBackend searchGlobal failed: ${err}`);
+      return [];
+    }
+  }
+  async bm25Search(query, collection, maxResults, _execution) {
+    const db = await this.ensureDbForCollection(collection ?? this.collection);
+    if (!db) return [];
+    return this.searchDb(db, query, "fulltext", maxResults ?? 10);
+  }
+  async vectorSearch(query, collection, maxResults, _execution) {
+    const db = await this.ensureDbForCollection(collection ?? this.collection);
+    if (!db) return [];
+    return this.searchDb(db, query, "vector", maxResults ?? 10);
+  }
+  async hybridSearch(query, collection, maxResults, _execution) {
+    const db = await this.ensureDbForCollection(collection ?? this.collection);
+    if (!db) return [];
+    return this.searchDb(db, query, "hybrid", maxResults ?? 10);
+  }
+  async update(execution) {
+    await this.updateCollection(this.collection, execution);
+  }
+  async updateCollection(collection, _execution) {
+    const db = await this.ensureDbForCollection(collection);
+    if (!db) return;
+    const { search: oramaSearch, insert, remove, count } = this.oramaModule;
+    const docs = await scanMemoryDir(this.memoryDir);
+    const docMap = new Map(docs.map((d) => [d.docid, d]));
+    const { update: oramaUpdate } = this.oramaModule;
+    const existingDocs = /* @__PURE__ */ new Map();
+    const existingCount = await count(db);
+    if (existingCount > 0) {
+      const allHits = await oramaSearch(db, { term: "", limit: existingCount + 100 });
+      for (const hit of allHits.hits) {
+        if (!docMap.has(hit.document.id)) {
+          await remove(db, hit.id);
+        } else {
+          existingDocs.set(hit.document.id, {
+            internalId: hit.id,
+            vector: hit.document.vector
+          });
+        }
+      }
+    }
+    for (const doc of docs) {
+      const existing = existingDocs.get(doc.docid);
+      if (existing) {
+        const payload = {
+          id: doc.docid,
+          path: doc.path,
+          content: doc.content,
+          snippet: doc.snippet
+        };
+        if (existing.vector && existing.vector.length > 0) {
+          payload.vector = existing.vector;
+        }
+        try {
+          await oramaUpdate(db, existing.internalId, payload);
+        } catch {
+        }
+      } else {
+        try {
+          await insert(db, {
+            id: doc.docid,
+            path: doc.path,
+            content: doc.content,
+            snippet: doc.snippet
+          });
+        } catch {
+        }
+      }
+    }
+    await this.persistDbForCollection(db, collection);
+  }
+  async embed() {
+    await this.embedCollection(this.collection);
+  }
+  async embedCollection(collection) {
+    if (!this.embedHelper.isAvailable()) return;
+    const db = await this.ensureDbForCollection(collection);
+    if (!db) return;
+    const { search: oramaSearch, update: oramaUpdate, count } = this.oramaModule;
+    const existingCount = await count(db);
+    if (existingCount === 0) return;
+    const allHits = await oramaSearch(db, { term: "", limit: existingCount + 100 });
+    const needsEmbed = allHits.hits.filter((h) => !h.document.vector || h.document.vector.length === 0);
+    if (needsEmbed.length === 0) return;
+    const texts = needsEmbed.map((h) => h.document.content);
+    const vectors = await this.embedHelper.embedBatch(texts);
+    for (let i = 0; i < needsEmbed.length; i++) {
+      const vec = vectors[i];
+      if (!vec) continue;
+      const doc = needsEmbed[i].document;
+      await oramaUpdate(db, needsEmbed[i].id, {
+        id: doc.id,
+        path: doc.path,
+        content: doc.content,
+        snippet: doc.snippet,
+        vector: vec
+      });
+    }
+    await this.persistDbForCollection(db, collection);
+  }
+  async ensureCollection(_memoryDir) {
+    try {
+      await this.ensureModules();
+      await this.ensureDb();
+      return "present";
+    } catch {
+      return "missing";
+    }
+  }
+  async ensureModules() {
+    if (this.oramaModule && this.persistModule) return;
+    this.oramaModule = await import("@orama/orama");
+    this.persistModule = await import("@orama/plugin-data-persistence");
+  }
+  async ensureDb() {
+    if (this.db) return this.db;
+    await this.ensureModules();
+    await mkdir(this.dbPath, { recursive: true });
+    const filePath = this.dbFilePath(this.collection);
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      this.db = await this.persistModule.restore("json", raw);
+      return this.db;
+    } catch {
+    }
+    const { create } = this.oramaModule;
+    const schema = {
+      id: "string",
+      path: "string",
+      content: "string",
+      snippet: "string"
+    };
+    if (this.embedHelper.isAvailable()) {
+      schema.vector = `vector[${this.embeddingDimension}]`;
+    }
+    this.db = await create({ schema });
+    return this.db;
+  }
+  async ensureDbForCollection(collection) {
+    if (collection === this.collection) return this.ensureDb();
+    await this.ensureModules();
+    await mkdir(this.dbPath, { recursive: true });
+    const filePath = this.dbFilePath(collection);
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      return await this.persistModule.restore("json", raw);
+    } catch {
+    }
+    const { create } = this.oramaModule;
+    const schema = {
+      id: "string",
+      path: "string",
+      content: "string",
+      snippet: "string"
+    };
+    if (this.embedHelper.isAvailable()) {
+      schema.vector = `vector[${this.embeddingDimension}]`;
+    }
+    return await create({ schema });
+  }
+  async persistDbForCollection(db, collection) {
+    const data = await this.persistModule.persist(db, "json");
+    const filePath = this.dbFilePath(collection);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, data, "utf-8");
+  }
+  dbFilePath(collection) {
+    return path.join(this.dbPath, `${collection}.msp`);
+  }
+  async listDbFiles() {
+    try {
+      const entries = await readdir(this.dbPath);
+      return entries.filter((e) => e.endsWith(".msp")).map((e) => path.join(this.dbPath, e));
+    } catch {
+      return [];
+    }
+  }
+  async loadDbFromFile(filePath) {
+    try {
+      await this.ensureModules();
+      const raw = await readFile(filePath, "utf-8");
+      return await this.persistModule.restore("json", raw);
+    } catch {
+      return null;
+    }
+  }
+  async searchDb(db, query, mode, limit) {
+    const { search: oramaSearch } = this.oramaModule;
+    try {
+      let searchParams;
+      if (mode === "fulltext") {
+        searchParams = { term: query, limit };
+      } else if (mode === "vector") {
+        const vec = await this.embedHelper.embed(query);
+        if (!vec) {
+          searchParams = { term: query, limit };
+        } else {
+          searchParams = { mode: "vector", vector: { value: vec, property: "vector" }, limit };
+        }
+      } else {
+        const vec = await this.embedHelper.embed(query);
+        if (!vec) {
+          searchParams = { term: query, limit };
+        } else {
+          searchParams = { mode: "hybrid", term: query, vector: { value: vec, property: "vector" }, limit };
+        }
+      }
+      const result = await oramaSearch(db, searchParams);
+      return (result.hits ?? []).map((hit) => ({
+        docid: hit.document?.id ?? "",
+        path: hit.document?.path ?? "",
+        snippet: hit.document?.snippet ?? hit.document?.content?.slice(0, 200) ?? "",
+        score: hit.score ?? 0
+      }));
+    } catch (err) {
+      log.debug(`OramaBackend search (${mode}) failed: ${err}`);
+      return [];
+    }
+  }
+};
+
+export {
+  OramaBackend
+};
+//# sourceMappingURL=chunk-XVVIG67A.js.map

package/dist/chunk-XVVIG67A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/search/orama-backend.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, readdir, readFile, writeFile } from \"node:fs/promises\";\nimport { log } from \"../logger.js\";\nimport type { SearchBackend, SearchExecutionOptions, SearchQueryOptions, SearchResult } from \"./port.js\";\nimport type { EmbedHelper } from \"./embed-helper.js\";\nimport { scanMemoryDir } from \"./document-scanner.js\";\n\nexport interface OramaBackendOptions {\n  dbPath: string;\n  collection: string;\n  embedHelper: EmbedHelper;\n  memoryDir: string;\n  embeddingDimension: number;\n}\n\n/**\n * Orama search backend — embedded hybrid FTS+vector, pure JS.\n *\n * Uses @orama/orama for full-text search with optional vector support.\n * Persists data to JSON files via @orama/plugin-data-persistence.\n */\nexport class OramaBackend implements SearchBackend {\n  private readonly dbPath: string;\n  private readonly collection: string;\n  private readonly embedHelper: EmbedHelper;\n  private readonly memoryDir: string;\n  private readonly embeddingDimension: number;\n  private available = false;\n  private db: any = null;\n  private oramaModule: any = null;\n  private persistModule: any = null;\n\n  constructor(opts: OramaBackendOptions) {\n    this.dbPath = opts.dbPath;\n    this.collection = opts.collection;\n    this.embedHelper = opts.embedHelper;\n    this.memoryDir = opts.memoryDir;\n    this.embeddingDimension = opts.embeddingDimension;\n  }\n\n  async probe(): Promise<boolean> {\n    try {\n      await this.ensureModules();\n      await this.ensureDb();\n      this.available = true;\n      return true;\n    } catch (err) {\n      log.debug(`OramaBackend probe failed: ${err}`);\n      this.available = false;\n      return false;\n    }\n  }\n\n  isAvailable(): boolean {\n    return this.available;\n  }\n\n  debugStatus(): string {\n    return `backend=orama available=${this.available} dbPath=${this.dbPath}`;\n  }\n\n  async search(\n    query: string,\n    _collection?: string,\n    maxResults?: number,\n    _options?: SearchQueryOptions,\n    _execution?: SearchExecutionOptions,\n  ): Promise<SearchResult[]> {\n    return this.hybridSearch(query, _collection, maxResults);\n  }\n\n  async searchGlobal(query: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    const limit = maxResults ?? 10;\n    if (!this.available) return [];\n    try {\n      const files = await this.listDbFiles();\n      const allResults: SearchResult[] = [];\n      for (const file of files) {\n        const db = await this.loadDbFromFile(file);\n        if (!db) continue;\n        const results = await this.searchDb(db, query, \"hybrid\", limit);\n        allResults.push(...results);\n      }\n      allResults.sort((a, b) => b.score - a.score);\n      return allResults.slice(0, limit);\n    } catch (err) {\n      log.debug(`OramaBackend searchGlobal failed: ${err}`);\n      return [];\n    }\n  }\n\n  async bm25Search(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    const db = await this.ensureDbForCollection(collection ?? this.collection);\n    if (!db) return [];\n    return this.searchDb(db, query, \"fulltext\", maxResults ?? 10);\n  }\n\n  async vectorSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    const db = await this.ensureDbForCollection(collection ?? this.collection);\n    if (!db) return [];\n    return this.searchDb(db, query, \"vector\", maxResults ?? 10);\n  }\n\n  async hybridSearch(query: string, collection?: string, maxResults?: number, _execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    const db = await this.ensureDbForCollection(collection ?? this.collection);\n    if (!db) return [];\n    return this.searchDb(db, query, \"hybrid\", maxResults ?? 10);\n  }\n\n  async update(execution?: SearchExecutionOptions): Promise<void> {\n    await this.updateCollection(this.collection, execution);\n  }\n\n  async updateCollection(collection: string, _execution?: SearchExecutionOptions): Promise<void> {\n    const db = await this.ensureDbForCollection(collection);\n    if (!db) return;\n    const { search: oramaSearch, insert, remove, count } = this.oramaModule;\n\n    const docs = await scanMemoryDir(this.memoryDir);\n    const docMap = new Map(docs.map((d) => [d.docid, d]));\n    const { update: oramaUpdate } = this.oramaModule;\n\n    // Get existing docs to diff — map user doc ID → { internalId, vector }\n    const existingDocs = new Map<string, { internalId: string; vector?: number[] }>();\n    const existingCount = await count(db);\n    if (existingCount > 0) {\n      const allHits = await oramaSearch(db, { term: \"\", limit: existingCount + 100 });\n      for (const hit of allHits.hits) {\n        if (!docMap.has(hit.document.id)) {\n          await remove(db, hit.id);\n        } else {\n          existingDocs.set(hit.document.id, {\n            internalId: hit.id,\n            vector: hit.document.vector,\n          });\n        }\n      }\n    }\n\n    // Insert new docs, update existing ones (preserving vectors since update is remove+insert)\n    for (const doc of docs) {\n      const existing = existingDocs.get(doc.docid);\n      if (existing) {\n        const payload: Record<string, unknown> = {\n          id: doc.docid,\n          path: doc.path,\n          content: doc.content,\n          snippet: doc.snippet,\n        };\n        if (existing.vector && existing.vector.length > 0) {\n          payload.vector = existing.vector;\n        }\n        try {\n          await oramaUpdate(db, existing.internalId, payload);\n        } catch {\n          // Update failed — skip and continue with remaining docs\n        }\n      } else {\n        try {\n          await insert(db, {\n            id: doc.docid,\n            path: doc.path,\n            content: doc.content,\n            snippet: doc.snippet,\n          });\n        } catch {\n          // Duplicate id edge case — skip\n        }\n      }\n    }\n\n    await this.persistDbForCollection(db, collection);\n  }\n\n  async embed(): Promise<void> {\n    await this.embedCollection(this.collection);\n  }\n\n  async embedCollection(collection: string): Promise<void> {\n    if (!this.embedHelper.isAvailable()) return;\n\n    const db = await this.ensureDbForCollection(collection);\n    if (!db) return;\n    const { search: oramaSearch, update: oramaUpdate, count } = this.oramaModule;\n\n    const existingCount = await count(db);\n    if (existingCount === 0) return;\n\n    // Find docs without vectors\n    const allHits = await oramaSearch(db, { term: \"\", limit: existingCount + 100 });\n    const needsEmbed = allHits.hits.filter((h: any) => !h.document.vector || h.document.vector.length === 0);\n\n    if (needsEmbed.length === 0) return;\n\n    const texts = needsEmbed.map((h: any) => h.document.content as string);\n    const vectors = await this.embedHelper.embedBatch(texts);\n\n    for (let i = 0; i < needsEmbed.length; i++) {\n      const vec = vectors[i];\n      if (!vec) continue;\n      // Orama update is remove+insert — must include all fields to avoid data loss\n      const doc = needsEmbed[i].document;\n      await oramaUpdate(db, needsEmbed[i].id, {\n        id: doc.id,\n        path: doc.path,\n        content: doc.content,\n        snippet: doc.snippet,\n        vector: vec,\n      });\n    }\n\n    await this.persistDbForCollection(db, collection);\n  }\n\n  async ensureCollection(_memoryDir: string): Promise<\"present\" | \"missing\" | \"unknown\" | \"skipped\"> {\n    try {\n      await this.ensureModules();\n      await this.ensureDb();\n      return \"present\";\n    } catch {\n      return \"missing\";\n    }\n  }\n\n  private async ensureModules(): Promise<void> {\n    if (this.oramaModule && this.persistModule) return;\n    this.oramaModule = await import(\"@orama/orama\");\n    this.persistModule = await import(\"@orama/plugin-data-persistence\");\n  }\n\n  private async ensureDb(): Promise<any> {\n    if (this.db) return this.db;\n    await this.ensureModules();\n\n    await mkdir(this.dbPath, { recursive: true });\n    const filePath = this.dbFilePath(this.collection);\n\n    try {\n      const raw = await readFile(filePath, \"utf-8\");\n      this.db = await this.persistModule.restore(\"json\", raw);\n      return this.db;\n    } catch {\n      // No existing DB — create fresh\n    }\n\n    const { create } = this.oramaModule;\n    const schema: Record<string, string> = {\n      id: \"string\",\n      path: \"string\",\n      content: \"string\",\n      snippet: \"string\",\n    };\n    if (this.embedHelper.isAvailable()) {\n      schema.vector = `vector[${this.embeddingDimension}]`;\n    }\n    this.db = await create({ schema });\n    return this.db;\n  }\n\n  private async ensureDbForCollection(collection: string): Promise<any> {\n    // For the default collection, use the cached instance\n    if (collection === this.collection) return this.ensureDb();\n\n    await this.ensureModules();\n    await mkdir(this.dbPath, { recursive: true });\n    const filePath = this.dbFilePath(collection);\n\n    try {\n      const raw = await readFile(filePath, \"utf-8\");\n      return await this.persistModule.restore(\"json\", raw);\n    } catch {\n      // No existing DB — create fresh\n    }\n\n    const { create } = this.oramaModule;\n    const schema: Record<string, string> = {\n      id: \"string\",\n      path: \"string\",\n      content: \"string\",\n      snippet: \"string\",\n    };\n    if (this.embedHelper.isAvailable()) {\n      schema.vector = `vector[${this.embeddingDimension}]`;\n    }\n    return await create({ schema });\n  }\n\n  private async persistDbForCollection(db: any, collection: string): Promise<void> {\n    const data = await this.persistModule.persist(db, \"json\");\n    const filePath = this.dbFilePath(collection);\n    await mkdir(path.dirname(filePath), { recursive: true });\n    await writeFile(filePath, data, \"utf-8\");\n  }\n\n  private dbFilePath(collection: string): string {\n    return path.join(this.dbPath, `${collection}.msp`);\n  }\n\n  private async listDbFiles(): Promise<string[]> {\n    try {\n      const entries = await readdir(this.dbPath);\n      return entries\n        .filter((e) => e.endsWith(\".msp\"))\n        .map((e) => path.join(this.dbPath, e));\n    } catch {\n      return [];\n    }\n  }\n\n  private async loadDbFromFile(filePath: string): Promise<any> {\n    try {\n      await this.ensureModules();\n      const raw = await readFile(filePath, \"utf-8\");\n      return await this.persistModule.restore(\"json\", raw);\n    } catch {\n      return null;\n    }\n  }\n\n  private async searchDb(db: any, query: string, mode: \"fulltext\" | \"vector\" | \"hybrid\", limit: number): Promise<SearchResult[]> {\n    const { search: oramaSearch } = this.oramaModule;\n\n    try {\n      let searchParams: any;\n\n      if (mode === \"fulltext\") {\n        searchParams = { term: query, limit };\n      } else if (mode === \"vector\") {\n        const vec = await this.embedHelper.embed(query);\n        if (!vec) {\n          // Fall back to fulltext if no embeddings available\n          searchParams = { term: query, limit };\n        } else {\n          searchParams = { mode: \"vector\", vector: { value: vec, property: \"vector\" }, limit };\n        }\n      } else {\n        // hybrid\n        const vec = await this.embedHelper.embed(query);\n        if (!vec) {\n          searchParams = { term: query, limit };\n        } else {\n          searchParams = { mode: \"hybrid\", term: query, vector: { value: vec, property: \"vector\" }, limit };\n        }\n      }\n\n      const result = await oramaSearch(db, searchParams);\n      return (result.hits ?? []).map((hit: any) => ({\n        docid: hit.document?.id ?? \"\",\n        path: hit.document?.path ?? \"\",\n        snippet: hit.document?.snippet ?? hit.document?.content?.slice(0, 200) ?? \"\",\n        score: hit.score ?? 0,\n      }));\n    } catch (err) {\n      log.debug(`OramaBackend search (${mode}) failed: ${err}`);\n      return [];\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-XVZ7B3HG.js

@@ -0,0 +1,135 @@
+import {
+  StorageManager
+} from "./chunk-7AAT6G4Q.js";
+
+// src/semantic-rule-promotion.ts
+function normalizeRuleWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function stripTrailingClausePunctuation(value) {
+  return value.replace(/[,:;]+$/g, "").trim();
+}
+function canonicalizeRuleContent(value) {
+  return extractExplicitIfThenRule(value) ?? normalizeRuleWhitespace(value);
+}
+function canonicalizeRuleKey(value) {
+  return canonicalizeRuleContent(value).toLowerCase();
+}
+function extractExplicitIfThenRule(content) {
+  const match = content.match(/\bif\b([\s\S]+?)\bthen\b([\s\S]+?)(?:[.!?](?:\s|$)|$)/i);
+  if (!match) return null;
+  const condition = stripTrailingClausePunctuation(normalizeRuleWhitespace(match[1] ?? ""));
+  const outcome = stripTrailingClausePunctuation(normalizeRuleWhitespace(match[2] ?? ""));
+  if (condition.length === 0 || outcome.length === 0) return null;
+  return `IF ${condition} THEN ${outcome}.`;
+}
+function promotionConfidence(memory) {
+  const base = Number.isFinite(memory.frontmatter.confidence) ? memory.frontmatter.confidence : 0.8;
+  return Math.max(0.6, Math.min(0.98, base));
+}
+function promotionTags(memory) {
+  return Array.from(/* @__PURE__ */ new Set([...memory.frontmatter.tags ?? [], "semantic-rule", "promoted-rule"]));
+}
+function buildSupportLinks(sourceMemoryId, confidence) {
+  return [
+    {
+      targetId: sourceMemoryId,
+      linkType: "supports",
+      strength: confidence,
+      reason: "Promoted from verified episodic memory"
+    }
+  ];
+}
+async function promoteSemanticRuleFromMemory(options) {
+  const report = {
+    enabled: options.enabled,
+    dryRun: options.dryRun === true,
+    promoted: [],
+    skipped: []
+  };
+  if (!options.enabled) {
+    report.skipped.push({
+      sourceMemoryId: options.sourceMemoryId,
+      reason: "disabled"
+    });
+    return report;
+  }
+  const storage = new StorageManager(options.memoryDir);
+  const sourceMemory = await storage.getMemoryById(options.sourceMemoryId);
+  if (!sourceMemory) {
+    report.skipped.push({
+      sourceMemoryId: options.sourceMemoryId,
+      reason: "source-memory-missing"
+    });
+    return report;
+  }
+  if (sourceMemory.frontmatter.status === "forgotten") {
+    report.skipped.push({
+      sourceMemoryId: options.sourceMemoryId,
+      reason: "source-memory-forgotten"
+    });
+    return report;
+  }
+  if (sourceMemory.frontmatter.status === "archived" || sourceMemory.frontmatter.memoryKind !== "episode") {
+    report.skipped.push({
+      sourceMemoryId: options.sourceMemoryId,
+      reason: "source-memory-not-episode"
+    });
+    return report;
+  }
+  const content = extractExplicitIfThenRule(sourceMemory.content);
+  if (!content) {
+    report.skipped.push({
+      sourceMemoryId: options.sourceMemoryId,
+      reason: "no-explicit-rule"
+    });
+    return report;
+  }
+  const ruleKey = canonicalizeRuleKey(content);
+  const existingRule = (await storage.readAllMemories()).find(
+    (memory) => memory.frontmatter.category === "rule" && memory.frontmatter.status !== "archived" && memory.frontmatter.status !== "forgotten" && canonicalizeRuleKey(memory.content) === ruleKey
+  );
+  if (existingRule) {
+    report.skipped.push({
+      sourceMemoryId: options.sourceMemoryId,
+      reason: "duplicate-rule",
+      existingRuleId: existingRule.frontmatter.id
+    });
+    return report;
+  }
+  const confidence = promotionConfidence(sourceMemory);
+  const candidateBase = {
+    sourceMemoryId: options.sourceMemoryId,
+    content,
+    confidence,
+    tags: promotionTags(sourceMemory),
+    memoryKind: "note",
+    lineage: [options.sourceMemoryId]
+  };
+  if (options.dryRun === true) {
+    report.promoted.push({
+      id: `dry-run:${options.sourceMemoryId}`,
+      ...candidateBase
+    });
+    return report;
+  }
+  const id = await storage.writeMemory("rule", content, {
+    confidence,
+    tags: candidateBase.tags,
+    source: "semantic-rule-promotion",
+    lineage: candidateBase.lineage,
+    sourceMemoryId: options.sourceMemoryId,
+    memoryKind: "note",
+    links: buildSupportLinks(options.sourceMemoryId, confidence)
+  });
+  report.promoted.push({
+    id,
+    ...candidateBase
+  });
+  return report;
+}
+
+export {
+  promoteSemanticRuleFromMemory
+};
+//# sourceMappingURL=chunk-XVZ7B3HG.js.map