@theokit/sdk 4.24.0 → 4.26.0

package/dist/chunk-G6GO6BXD.js

@@ -0,0 +1,994 @@
+import { openSqliteResilient, sanitizeFts5Query } from './chunk-77FOZCOT.js';
+import { withCwdMutex } from './chunk-2XLKLVVR.js';
+import { sanitizeIdentifier, safePathJoin, safeFilenameForId } from './chunk-POQT2OIF.js';
+import { replaceFileAtomic } from './chunk-S2BBRVQX.js';
+import { ConfigurationError } from './chunk-WLKFWQSJ.js';
+import { redactSecrets } from './chunk-JTFYYKDT.js';
+import { createHash } from 'crypto';
+import { readFile, mkdir, stat, readdir } from 'fs/promises';
+import { join, resolve, relative } from 'path';
+import { mkdirSync } from 'fs';
+import { createRequire } from 'module';
+
+// src/internal/memory/embedding-cache.ts
+var LruEmbeddingCache = class {
+  constructor(capacity = 5e3) {
+    this.capacity = capacity;
+  }
+  capacity;
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    const value = this.map.get(key);
+    if (value === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    else if (this.map.size >= this.capacity) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+    this.map.set(key, value);
+  }
+  size() {
+    return this.map.size;
+  }
+};
+var globalEmbeddingCache = new LruEmbeddingCache();
+
+// src/internal/memory/index-schema.ts
+var SCHEMA_STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS files (
+     id INTEGER PRIMARY KEY AUTOINCREMENT,
+     path TEXT UNIQUE NOT NULL,
+     rel_path TEXT NOT NULL,
+     mtime INTEGER NOT NULL,
+     hash TEXT NOT NULL,
+     source TEXT NOT NULL DEFAULT 'memory'
+   )`,
+  `CREATE TABLE IF NOT EXISTS chunks (
+     id INTEGER PRIMARY KEY AUTOINCREMENT,
+     file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+     start_line INTEGER NOT NULL,
+     end_line INTEGER NOT NULL,
+     text TEXT NOT NULL,
+     hash TEXT NOT NULL,
+     session_key TEXT
+   )`,
+  `CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+     text,
+     content='chunks',
+     content_rowid='id'
+   )`,
+  `CREATE TRIGGER IF NOT EXISTS chunks_fts_insert AFTER INSERT ON chunks BEGIN
+     INSERT INTO chunks_fts(rowid, text) VALUES (new.id, new.text);
+   END`,
+  `CREATE TRIGGER IF NOT EXISTS chunks_fts_delete AFTER DELETE ON chunks BEGIN
+     INSERT INTO chunks_fts(chunks_fts, rowid, text) VALUES ('delete', old.id, old.text);
+   END`,
+  `CREATE TABLE IF NOT EXISTS meta (
+     key TEXT PRIMARY KEY,
+     value TEXT
+   )`,
+  `CREATE INDEX IF NOT EXISTS idx_chunks_file_id ON chunks(file_id)`
+];
+var PRAGMA_STATEMENTS = [
+  "PRAGMA synchronous=NORMAL",
+  "PRAGMA foreign_keys=ON"
+];
+
+// src/internal/memory/index-db.ts
+async function openMemoryDb(opts) {
+  return openSqliteResilient({
+    filePath: opts.filePath,
+    label: "memory-index",
+    recoverCorrupt: opts.recoverCorrupt,
+    onOpen: (db) => {
+      for (const pragma of PRAGMA_STATEMENTS) db.exec(pragma);
+      for (const stmt of SCHEMA_STATEMENTS) db.exec(stmt);
+    }
+  });
+}
+function defaultIndexPath(cwd) {
+  return join(cwd, ".theokit", "memory", ".index", "memory.sqlite");
+}
+function requireLance() {
+  try {
+    const r = createRequire(import.meta.url);
+    return r("@lancedb/lancedb");
+  } catch (cause) {
+    throw new ConfigurationError(
+      'Lance backend selected but `@lancedb/lancedb` is not installed. Install with: `pnpm add @lancedb/lancedb`. SQLite remains available as the default (omit `backend: "lance"`).',
+      { code: "lance_backend_unavailable", cause }
+    );
+  }
+}
+var LanceIndex = class _LanceIndex {
+  constructor(table, embedding, embeddingDim) {
+    this.table = table;
+    this.embedding = embedding;
+    this.embeddingDim = embeddingDim;
+  }
+  table;
+  embedding;
+  embeddingDim;
+  static async open(opts) {
+    const lance = requireLance();
+    const storagePath = opts.storagePath ?? join(opts.cwd, ".theokit", "memory", "lance");
+    mkdirSync(storagePath, { recursive: true });
+    const conn = await lance.connect(storagePath);
+    const dim = opts.embedding.dimension;
+    const tableName = "facts";
+    const existing = await conn.tableNames();
+    let table;
+    if (existing.includes(tableName)) {
+      table = await conn.openTable(tableName);
+      const schema = await table.schema();
+      const embField = schema.fields.find((f) => f.name === "embedding");
+      const existingDim = embField?.type?.listSize ?? embField?.type?.fixedSize;
+      if (typeof existingDim === "number" && existingDim !== dim) {
+        throw new ConfigurationError(
+          `Embedding dimension mismatch in Lance index: storage has ${existingDim}-dim vectors, current provider yields ${dim}-dim. Run \`theokit-migrate-memory\` after switching providers, or use a different storagePath.`,
+          { code: "embedding_dimension_mismatch" }
+        );
+      }
+    } else {
+      const bootstrap = {
+        id: "__bootstrap__",
+        text: "",
+        source: "memory",
+        embedding: new Array(dim).fill(0),
+        namespace: "__bootstrap__",
+        scope: "__bootstrap__",
+        user_id: "__bootstrap__",
+        timestamp: 0
+      };
+      table = await conn.createTable(tableName, [bootstrap]);
+      await table.delete("namespace = '__bootstrap__'");
+    }
+    return new _LanceIndex(table, opts.embedding, dim);
+  }
+  async addFacts(facts) {
+    if (facts.length === 0) return;
+    const texts = facts.map((f) => f.text);
+    const embeddings = await this.embedding.embed(texts);
+    const rows = facts.map((f, i) => ({
+      ...f,
+      embedding: embeddings[i] ?? new Array(this.embeddingDim).fill(0)
+    }));
+    await this.table.add(rows);
+  }
+  /**
+   * Search facts by semantic similarity. EC-1: filters use Lance's
+   * structured object filter — NEVER string interpolation.
+   */
+  async search(query, opts) {
+    const [embedding] = await this.embedding.embed([query]);
+    if (embedding === void 0) return [];
+    const predicates = [`namespace = '${escapeSqlValue(opts.namespace)}'`];
+    if (opts.scope !== void 0) {
+      predicates.push(`scope = '${escapeSqlValue(opts.scope)}'`);
+    }
+    let q = this.table.search(embedding).where(predicates.join(" AND "));
+    if (opts.limit !== void 0) q = q.limit(opts.limit);
+    const results = await q.toArray();
+    return results.filter((r) => opts.sources === void 0 || opts.sources.includes(r.source)).map((r) => ({
+      id: r.id,
+      text: r.text,
+      source: r.source,
+      namespace: r.namespace,
+      scope: r.scope,
+      userId: r.user_id,
+      // Lower _distance = better match; normalize to 0..1 (1=best).
+      score: 1 / (1 + (r._distance ?? 1))
+    }));
+  }
+  async countFacts(namespace) {
+    return this.table.countRows();
+  }
+  async removeFacts(ids) {
+    if (ids.length === 0) return;
+    const escaped = ids.map((id) => `'${id.replace(/'/g, "''")}'`).join(", ");
+    await this.table.delete(`id IN (${escaped})`);
+  }
+  async close() {
+  }
+};
+function escapeSqlValue(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code === 0 || code >= 1 && code <= 31 || code === 127) {
+      throw new ConfigurationError(
+        `SQL filter value contains control character at position ${i} (0x${code.toString(16)}). This may indicate an injection attempt.`,
+        { code: "sql_injection_blocked" }
+      );
+    }
+  }
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "''");
+}
+function lanceStoragePath(cwd) {
+  return join(cwd, ".theokit", "memory", "lance");
+}
+
+// src/internal/memory/memory-index.ts
+function parseSearchOptions(options = {}) {
+  return {
+    maxResults: Math.max(1, options.maxResults ?? 10),
+    minScore: options.minScore ?? 0
+  };
+}
+
+// src/internal/memory/lance-memory-adapter.ts
+var DEFAULT_NAMESPACE = "default";
+var EMPTY_SYNC_RESULT = Object.freeze({
+  filesScanned: 0,
+  filesUpdated: 0,
+  chunksWritten: 0,
+  chunksEmbedded: 0
+});
+var LanceMemoryAdapter = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  /**
+   * No-op for Lance — see file header. Returns zero counts so callers'
+   * existing logging (`filesScanned: X`) does not break.
+   */
+  async sync() {
+    return EMPTY_SYNC_RESULT;
+  }
+  // jscpd:ignore-start — search signature + early-out is idiomatic
+  // overlap with IndexManager.search; further factoring would hurt
+  // readability (the bodies diverge sharply right after).
+  async search(query, options = {}) {
+    if (query.trim().length === 0) return [];
+    const { maxResults, minScore } = parseSearchOptions(options);
+    const lanceHits = await this.inner.search(query, {
+      namespace: DEFAULT_NAMESPACE,
+      limit: maxResults * 2,
+      ...options.sources !== void 0 ? { sources: options.sources } : {}
+    });
+    return lanceHits.filter((h) => h.score >= minScore).slice(0, maxResults).map((h) => translateLanceHit(h, query));
+  }
+  status() {
+    return {
+      backend: "hybrid",
+      filesIndexed: 0,
+      chunksIndexed: 0
+    };
+  }
+  async close() {
+    await this.inner.close();
+  }
+  /**
+   * Escape hatch for advanced callers (migration tool, benchmark script)
+   * that need direct access to addFacts/countFacts/removeFacts.
+   */
+  unwrap() {
+    return this.inner;
+  }
+};
+function translateLanceHit(hit, query) {
+  const textScore = query !== void 0 ? computeTermOverlapScore(query, hit.text) : 0;
+  const vectorScore = hit.score;
+  const combined = 0.7 * vectorScore + 0.3 * textScore;
+  return {
+    path: hit.id,
+    startLine: 0,
+    endLine: 0,
+    score: combined,
+    textScore,
+    vectorScore,
+    snippet: hit.text.slice(0, 200),
+    source: hit.source,
+    citation: hit.id
+  };
+}
+function computeTermOverlapScore(query, text) {
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 1);
+  if (queryTerms.length === 0) return 0;
+  const textLower = text.toLowerCase();
+  const matched = queryTerms.filter((term) => textLower.includes(term)).length;
+  return matched / queryTerms.length;
+}
+
+// src/internal/memory/index-manager-dispatch.ts
+var VALID_BACKENDS = ["sqlite-vec", "lance"];
+function assertValidBackend(backend) {
+  if (!VALID_BACKENDS.includes(backend)) {
+    throw new ConfigurationError(
+      `Invalid memory backend "${backend}". Valid values: ${VALID_BACKENDS.join(", ")}.`,
+      { code: "invalid_memory_backend" }
+    );
+  }
+}
+async function openLanceIndex(opts) {
+  if (opts.embedding === void 0) {
+    throw new ConfigurationError(
+      "Lance backend requires an embedding runtime. Pass `embedding: { provider, model, apiKey }` in Memory.create options (or omit `backend` to use SQLite default).",
+      { code: "lance_requires_embedding" }
+    );
+  }
+  const lance = await LanceIndex.open({
+    cwd: opts.cwd,
+    embedding: opts.embedding,
+    ...opts.filePath !== void 0 ? { storagePath: opts.filePath } : {}
+  });
+  return new LanceMemoryAdapter(lance);
+}
+function legacyMemoryJsonPath(cwd, config) {
+  if (config.storePath !== void 0) {
+    return resolve(cwd, config.storePath);
+  }
+  const namespace = sanitizeIdentifier(config.namespace ?? "default");
+  const scope = sanitizeIdentifier(config.scope ?? "agent", { maxLen: 16 });
+  const userId = sanitizeIdentifier(config.userId ?? "default");
+  return safePathJoin(cwd, ".theokit", "memory", namespace, `${scope}-${userId}.json`);
+}
+
+// src/internal/memory/storage/markdown-store.ts
+var MEMORY_MD_HEADER = "# Memory\n\n> Auto-managed by @theokit/sdk. Edit freely \u2014 the SDK reads from here.\n";
+var FACTS_HEADING = "## Facts";
+function memoryDir(cwd) {
+  return join(cwd, ".theokit", "memory");
+}
+function memoryMdPath(cwd) {
+  return join(memoryDir(cwd), "MEMORY.md");
+}
+function notesDir(cwd) {
+  return join(memoryDir(cwd), "notes");
+}
+async function readFactsFromMarkdown(cwd) {
+  let raw;
+  try {
+    raw = await readFile(memoryMdPath(cwd), "utf8");
+  } catch {
+    return [];
+  }
+  return parseFactsSection(raw);
+}
+function appendFactToMarkdown(cwd, fact) {
+  return withCwdMutex(memoryDir(cwd), async () => {
+    const path = memoryMdPath(cwd);
+    let raw = "";
+    try {
+      raw = await readFile(path, "utf8");
+    } catch {
+      raw = "";
+    }
+    const sanitized = redactSecrets(fact.text);
+    const next = insertFactBullet(raw, sanitized);
+    await mkdir(memoryDir(cwd), { recursive: true });
+    await replaceFileAtomic(path, next);
+  });
+}
+function parseFactsSection(raw) {
+  const idx = raw.indexOf(FACTS_HEADING);
+  if (idx === -1) return [];
+  const tail = raw.slice(idx + FACTS_HEADING.length);
+  const nextHeading = tail.search(/\n#{1,2}\s/);
+  const block = nextHeading === -1 ? tail : tail.slice(0, nextHeading);
+  return block.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("- ")).map((line) => ({ text: line.slice(2).trim() }));
+}
+function insertFactBullet(raw, fact) {
+  const bullet = `- ${fact}`;
+  if (raw.length === 0) {
+    return `${MEMORY_MD_HEADER}
+${FACTS_HEADING}
+
+${bullet}
+`;
+  }
+  const idx = raw.indexOf(FACTS_HEADING);
+  if (idx === -1) {
+    const sep = raw.endsWith("\n") ? "" : "\n";
+    return `${raw}${sep}
+${FACTS_HEADING}
+
+${bullet}
+`;
+  }
+  const after = idx + FACTS_HEADING.length;
+  const nextHeading = raw.slice(after).search(/\n#{1,2}\s/);
+  if (nextHeading === -1) {
+    const trailing = raw.endsWith("\n") ? "" : "\n";
+    return `${raw}${trailing}${bullet}
+`;
+  }
+  const insertAt = after + nextHeading;
+  return `${raw.slice(0, insertAt)}
+${bullet}${raw.slice(insertAt)}`;
+}
+async function readFacts(cwd, config) {
+  if (!config.enabled) return [];
+  return readFactsFromMarkdown(cwd);
+}
+async function appendFact(cwd, config, fact) {
+  if (!config.enabled) return;
+  await appendFactToMarkdown(cwd, fact);
+}
+var MAX_TURN_CHARS = 2e3;
+function sessionsDir(cwd) {
+  return join(memoryDir(cwd), "sessions");
+}
+function sessionSummaryPath(cwd, runId) {
+  return join(sessionsDir(cwd), `${safeFilenameForId(runId, { maxLen: 128 })}.md`);
+}
+function truncate(text) {
+  if (text.length <= MAX_TURN_CHARS) return text;
+  return `${text.slice(0, MAX_TURN_CHARS)}\u2026`;
+}
+async function writeSessionSummary(input) {
+  if (input.status !== "finished") return;
+  const path = sessionSummaryPath(input.cwd, input.runId);
+  await mkdir(sessionsDir(input.cwd), { recursive: true });
+  const safeUser = redactSecrets(truncate(input.userText));
+  const safeAssistant = redactSecrets(truncate(input.assistantText));
+  const iso = new Date(input.at).toISOString();
+  const body = [
+    "---",
+    `runId: ${input.runId}`,
+    `agentId: ${input.agentId}`,
+    `at: ${iso}`,
+    `status: ${input.status}`,
+    "---",
+    "",
+    "## User",
+    "",
+    safeUser,
+    "",
+    "## Assistant",
+    "",
+    safeAssistant,
+    ""
+  ].join("\n");
+  await replaceFileAtomic(path, body);
+}
+
+// src/internal/memory/storage/session-loader.ts
+async function discoverSessionFiles(cwd) {
+  let entries;
+  try {
+    entries = await readdir(sessionsDir(cwd));
+  } catch {
+    return [];
+  }
+  const root = memoryDir(cwd);
+  return entries.filter((entry) => entry.endsWith(".md")).map((entry) => {
+    const absolutePath = join(sessionsDir(cwd), entry);
+    return {
+      absolutePath,
+      relPath: relativeToRoot(root, absolutePath)
+    };
+  });
+}
+function relativeToRoot(root, absolutePath) {
+  if (absolutePath.startsWith(`${root}/`)) return absolutePath.slice(root.length + 1);
+  return absolutePath;
+}
+function wikiDir(cwd) {
+  return join(memoryDir(cwd), "wiki");
+}
+async function discoverWikiFiles(cwd) {
+  let entries;
+  try {
+    entries = await readdir(wikiDir(cwd));
+  } catch {
+    return [];
+  }
+  const root = memoryDir(cwd);
+  return entries.filter((entry) => entry.endsWith(".md")).map((entry) => ({
+    absolutePath: join(wikiDir(cwd), entry),
+    relPath: join("wiki", entry)
+  })).map((file) => ({
+    absolutePath: file.absolutePath,
+    relPath: relativeToRoot2(root, file.absolutePath)
+  }));
+}
+function relativeToRoot2(root, absolutePath) {
+  if (absolutePath.startsWith(`${root}/`)) return absolutePath.slice(root.length + 1);
+  return absolutePath;
+}
+
+// src/internal/memory/index-manager-helpers.ts
+function resolveWeights(options) {
+  const vectorWeight = options.vectorWeight ?? 0.6;
+  const textWeight = options.textWeight ?? 0.4;
+  const total = vectorWeight + textWeight || 1;
+  return { vectorWeight, textWeight, total };
+}
+function blendScores(hit, vectorScore, weights) {
+  const score = (vectorScore * weights.vectorWeight + hit.textScore * weights.textWeight) / weights.total;
+  return {
+    path: hit.path,
+    startLine: hit.startLine,
+    endLine: hit.endLine,
+    score,
+    textScore: hit.textScore,
+    snippet: hit.snippet,
+    source: hit.source,
+    citation: hit.citation,
+    ...vectorScore > 0 ? { vectorScore } : {}
+  };
+}
+async function collectMarkdownFiles(cwd) {
+  const root = memoryDir(cwd);
+  const results = [];
+  try {
+    await stat(memoryMdPath(cwd));
+    results.push({
+      absolutePath: memoryMdPath(cwd),
+      relPath: relative(root, memoryMdPath(cwd)),
+      source: "memory"
+    });
+  } catch {
+  }
+  try {
+    const entries = await readdir(notesDir(cwd));
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const abs = join(notesDir(cwd), entry);
+      results.push({ absolutePath: abs, relPath: relative(root, abs), source: "memory" });
+    }
+  } catch {
+  }
+  const wikiFiles = await discoverWikiFiles(cwd);
+  for (const wiki of wikiFiles) {
+    results.push({
+      absolutePath: wiki.absolutePath,
+      relPath: wiki.relPath,
+      source: "wiki"
+    });
+  }
+  const sessionFiles = await discoverSessionFiles(cwd);
+  for (const session of sessionFiles) {
+    results.push({
+      absolutePath: session.absolutePath,
+      relPath: session.relPath,
+      source: "sessions"
+    });
+  }
+  return results;
+}
+function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function truncateSnippet(text) {
+  const max = 500;
+  return text.length <= max ? text : `${text.slice(0, max)}\u2026`;
+}
+
+// src/internal/memory/sqlite-vec-loader.ts
+async function loadSqliteVecExtension(db) {
+  try {
+    const mod = await import('sqlite-vec');
+    const loadFn = mod.load;
+    if (typeof loadFn !== "function") {
+      throw new Error("sqlite-vec module exposes no `load` export");
+    }
+    loadFn(db);
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw new ConfigurationError(
+      `sqlite-vec extension unavailable. Install \`sqlite-vec\` and ensure the native binary matches your Node + OS. Cause: ${message}`,
+      { code: "sqlite_vec_unavailable", cause }
+    );
+  }
+}
+var HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+function chunkMarkdown(text, options = {}) {
+  const maxChars = options.maxChars ?? 800;
+  if (text.length === 0) return [];
+  const lines = text.split("\n");
+  const acc = { chunks: [], lines: [], start: 1, heading: void 0 };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const lineNumber = i + 1;
+    processLine(acc, line, lineNumber, maxChars);
+  }
+  flushAccumulator(acc, lines.length, maxChars);
+  return acc.chunks;
+}
+function processLine(acc, line, lineNumber, maxChars) {
+  const headingMatch = HEADING_RE.exec(line);
+  const isBlank = line.trim().length === 0;
+  if (headingMatch !== null && acc.lines.length > 0) {
+    flushAccumulator(acc, lineNumber - 1, maxChars);
+  }
+  if (headingMatch !== null) acc.heading = headingMatch[2];
+  acc.lines.push(line);
+  if (isBlank && acc.lines.length > 1) {
+    const joined = acc.lines.join("\n");
+    if (joined.trim().length > 0) flushAccumulator(acc, lineNumber, maxChars);
+  }
+}
+function flushAccumulator(acc, endLineExclusive, maxChars) {
+  if (acc.lines.length === 0) return;
+  const chunkText = acc.lines.join("\n");
+  if (chunkText.trim().length === 0) {
+    acc.lines = [];
+    acc.start = endLineExclusive + 1;
+    return;
+  }
+  if (chunkText.length > maxChars) {
+    pushOversizedSlices(acc.chunks, chunkText, acc.start, acc.heading, maxChars);
+  } else {
+    acc.chunks.push(buildChunk(chunkText, acc.start, endLineExclusive, acc.heading));
+  }
+  acc.lines = [];
+  acc.start = endLineExclusive + 1;
+}
+function buildChunk(text, startLine, endLine, heading) {
+  return {
+    startLine,
+    endLine,
+    text,
+    hash: createHash("sha256").update(text).digest("hex"),
+    ...heading !== void 0 ? { heading } : {}
+  };
+}
+function pushOversizedSlices(chunks, text, startLine, heading, maxChars) {
+  let remaining = text;
+  let lineCursor = startLine;
+  while (remaining.length > maxChars) {
+    const splitAt = findWordBoundarySplit(remaining, maxChars);
+    const slice = remaining.slice(0, splitAt);
+    const sliceLines = slice.split("\n").length;
+    chunks.push(buildChunk(slice, lineCursor, lineCursor + sliceLines - 1, heading));
+    remaining = remaining.slice(splitAt).replace(/^\s+/, "");
+    lineCursor += sliceLines - 1;
+  }
+  if (remaining.length > 0) {
+    const sliceLines = remaining.split("\n").length;
+    chunks.push(buildChunk(remaining, lineCursor, lineCursor + sliceLines - 1, heading));
+  }
+}
+function findWordBoundarySplit(text, maxChars) {
+  if (text.length <= maxChars) return text.length;
+  for (let i = maxChars; i > Math.max(0, maxChars - 200); i--) {
+    if (/\s/.test(text[i] ?? "x")) return i;
+  }
+  return maxChars;
+}
+
+// src/internal/memory/vec-index.ts
+var META_KEY_PROVIDER_ID = "embedding.providerId";
+var META_KEY_MODEL = "embedding.model";
+var META_KEY_DIMENSION = "embedding.dimension";
+function readEmbeddingIdentity(db) {
+  const get = (key) => {
+    const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row !== void 0 ? String(row.value) : void 0;
+  };
+  const providerId = get(META_KEY_PROVIDER_ID);
+  const model = get(META_KEY_MODEL);
+  const dimRaw = get(META_KEY_DIMENSION);
+  if (providerId === void 0 || model === void 0 || dimRaw === void 0) return void 0;
+  const dimension = Number(dimRaw);
+  if (!Number.isFinite(dimension) || dimension <= 0) return void 0;
+  return { providerId, model, dimension };
+}
+function writeEmbeddingIdentity(db, identity) {
+  const stmt = db.prepare(
+    "INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  );
+  stmt.run(META_KEY_PROVIDER_ID, identity.providerId);
+  stmt.run(META_KEY_MODEL, identity.model);
+  stmt.run(META_KEY_DIMENSION, String(identity.dimension));
+}
+function identityMatches(a, b) {
+  return a.providerId === b.providerId && a.model === b.model && a.dimension === b.dimension;
+}
+function dropVectorIndex(db) {
+  db.exec("DROP TABLE IF EXISTS embeddings");
+}
+function createVectorIndex(db, dimension) {
+  db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS embeddings USING vec0(
+    chunk_id INTEGER PRIMARY KEY,
+    vec FLOAT[${dimension}]
+  )`);
+}
+function packVector(vec) {
+  const f32 = new Float32Array(vec.length);
+  for (let i = 0; i < vec.length; i++) f32[i] = vec[i] ?? 0;
+  return Buffer.from(f32.buffer);
+}
+function upsertEmbedding(db, chunkId, vec) {
+  const id = BigInt(chunkId);
+  db.prepare("DELETE FROM embeddings WHERE chunk_id = ?").run(id);
+  db.prepare("INSERT INTO embeddings (chunk_id, vec) VALUES (?, ?)").run(id, packVector(vec));
+}
+function vectorSearch(db, query, k) {
+  const rows = db.prepare(
+    `SELECT chunk_id, distance FROM embeddings
+       WHERE vec MATCH ? AND k = ?
+       ORDER BY distance`
+  ).all(packVector(query), BigInt(k));
+  return rows.map((row) => ({ chunk_id: Number(row.chunk_id), distance: Number(row.distance) }));
+}
+async function embedMissingChunks(args) {
+  const rows = args.db.prepare(
+    `SELECT chunks.id as id, chunks.text as text
+       FROM chunks
+       LEFT JOIN embeddings ON embeddings.chunk_id = chunks.id
+       WHERE embeddings.chunk_id IS NULL`
+  ).all();
+  if (rows.length === 0) return 0;
+  const normalized = rows.map((row) => ({ id: Number(row.id), text: String(row.text ?? "") }));
+  const vectors = await args.runtime.embed(normalized.map((r) => r.text));
+  for (let i = 0; i < normalized.length; i++) {
+    const row = normalized[i];
+    const vector = vectors[i];
+    if (row === void 0 || vector === void 0) continue;
+    upsertEmbedding(args.db, row.id, vector);
+  }
+  return normalized.length;
+}
+
+// src/internal/memory/index-manager.ts
+var queryVectorCache = new LruEmbeddingCache(2e3);
+var IndexManager = class _IndexManager {
+  constructor(cwd, db, embedding) {
+    this.cwd = cwd;
+    this.db = db;
+    this.embedding = embedding;
+  }
+  cwd;
+  db;
+  embedding;
+  lastSyncMs;
+  vectorReady = false;
+  static async open(opts) {
+    const backend = opts.backend ?? "sqlite-vec";
+    assertValidBackend(backend);
+    if (backend === "lance") return await openLanceIndex(opts);
+    return await _IndexManager.openSqliteInternal(opts);
+  }
+  /** Internal SQLite-path open. Renamed from previous public `open`. */
+  static async openSqliteInternal(opts) {
+    const filePath = opts.filePath ?? defaultIndexPath(opts.cwd);
+    const db = await openMemoryDb({ filePath });
+    const manager = new _IndexManager(opts.cwd, db, opts.embedding);
+    if (opts.embedding !== void 0) await manager.initVectorBackend(opts.embedding);
+    return manager;
+  }
+  async initVectorBackend(runtime) {
+    await loadSqliteVecExtension(this.db);
+    const currentIdentity = {
+      providerId: runtime.id,
+      model: runtime.model,
+      dimension: runtime.dimension
+    };
+    const persisted = readEmbeddingIdentity(this.db);
+    if (persisted !== void 0 && !identityMatches(persisted, currentIdentity)) {
+      dropVectorIndex(this.db);
+    }
+    createVectorIndex(this.db, runtime.dimension);
+    writeEmbeddingIdentity(this.db, currentIdentity);
+    this.vectorReady = true;
+  }
+  /** Walk the memory corpus + (re)index changed files. */
+  async sync() {
+    const files = await collectMarkdownFiles(this.cwd);
+    let filesUpdated = 0;
+    let chunksWritten = 0;
+    const existingByPath = this.loadFilesIndex();
+    for (const entry of files) {
+      const raw = await readFile(entry.absolutePath, "utf8");
+      const hash = sha256(raw);
+      const existing = existingByPath.get(entry.absolutePath);
+      if (existing !== void 0 && existing.hash === hash) continue;
+      const stats = await stat(entry.absolutePath);
+      const fileId = this.upsertFile(
+        entry.absolutePath,
+        entry.relPath,
+        hash,
+        stats.mtimeMs,
+        entry.source
+      );
+      this.deleteChunksForFile(fileId);
+      const chunks = chunkMarkdown(raw);
+      for (const chunk of chunks) {
+        this.insertChunk(fileId, chunk.startLine, chunk.endLine, chunk.text, chunk.hash);
+      }
+      filesUpdated += 1;
+      chunksWritten += chunks.length;
+    }
+    let chunksEmbedded = 0;
+    if (this.vectorReady && this.embedding !== void 0) {
+      chunksEmbedded = await embedMissingChunks({ db: this.db, runtime: this.embedding });
+    }
+    this.lastSyncMs = Date.now();
+    return { filesScanned: files.length, filesUpdated, chunksWritten, chunksEmbedded };
+  }
+  async search(query, options = {}) {
+    if (query.trim().length === 0) return [];
+    const { maxResults, minScore } = parseSearchOptions(options);
+    const textHits = this.ftsSearch(query, maxResults * 2);
+    const vectorHitsById = await this.vectorSearchById(query, maxResults * 2);
+    const combined = this.combineHybridScores(textHits, vectorHitsById, options);
+    return combined.filter((h) => h.score >= minScore).filter((h) => options.sources === void 0 || options.sources.includes(h.source)).slice(0, maxResults);
+  }
+  status() {
+    const files = this.db.prepare("SELECT COUNT(*) as n FROM files").get() ?? { n: 0 };
+    const chunks = this.db.prepare("SELECT COUNT(*) as n FROM chunks").get() ?? { n: 0 };
+    const status = {
+      backend: this.vectorReady ? "hybrid" : "fts-only",
+      filesIndexed: Number(files.n ?? 0),
+      chunksIndexed: Number(chunks.n ?? 0)
+    };
+    if (this.lastSyncMs !== void 0) status.lastSyncMs = this.lastSyncMs;
+    return status;
+  }
+  // ───── search internals ──────────────────────────────────────────────
+  ftsSearch(query, limit) {
+    const sanitized = sanitizeFts5Query(query);
+    if (sanitized.length === 0) return [];
+    const stmt = this.db.prepare(
+      `SELECT chunks.id as id, files.rel_path as rel_path, files.source as source,
+              chunks.start_line as start_line, chunks.end_line as end_line,
+              chunks.text as text, bm25(chunks_fts) as bm25_score
+       FROM chunks_fts
+       JOIN chunks ON chunks_fts.rowid = chunks.id
+       JOIN files  ON chunks.file_id = files.id
+       WHERE chunks_fts MATCH ?
+       ORDER BY bm25_score
+       LIMIT ?`
+    );
+    let rows = [];
+    try {
+      rows = stmt.all(sanitized, limit);
+    } catch {
+      return this.likeSearchFallback(query, limit);
+    }
+    return rows.map((row) => {
+      const bm25 = Number(row.bm25_score ?? 0);
+      const textScore = bm25 < 0 ? 1 / (1 + Math.abs(bm25)) : 1 / (1 + bm25);
+      const startLine = Number(row.start_line ?? 0);
+      const endLine = Number(row.end_line ?? 0);
+      const path = String(row.rel_path);
+      return {
+        path,
+        startLine,
+        endLine,
+        score: textScore,
+        textScore,
+        snippet: truncateSnippet(String(row.text ?? "")),
+        source: String(row.source),
+        citation: `${path}:${startLine}-${endLine}`,
+        // sneak the chunk id through for the hybrid join below
+        // (cast away later)
+        chunkId: Number(row.id)
+      };
+    });
+  }
+  /**
+   * T4.8 — LIKE-based fallback for CJK and other scripts that FTS5's
+   * default tokenizer cannot segment. Slower than FTS5 (full table scan)
+   * but correct for any Unicode input. Returns the same shape as
+   * `ftsSearch` so callers are unaware of the fallback.
+   */
+  likeSearchFallback(query, limit) {
+    const pattern = `%${query.replace(/%/g, "\\%").replace(/_/g, "\\_")}%`;
+    const stmt = this.db.prepare(
+      `SELECT chunks.id as id, files.rel_path as rel_path, files.source as source,
+              chunks.start_line as start_line, chunks.end_line as end_line,
+              chunks.text as text
+       FROM chunks
+       JOIN files ON chunks.file_id = files.id
+       WHERE chunks.text LIKE ? ESCAPE '\\'
+       LIMIT ?`
+    );
+    const rows = stmt.all(pattern, limit);
+    return rows.map((row) => {
+      const path = String(row.rel_path ?? "");
+      const startLine = Number(row.start_line ?? 0);
+      const endLine = Number(row.end_line ?? 0);
+      return {
+        path,
+        startLine,
+        endLine,
+        score: 0.5,
+        // LIKE has no relevance score — use a neutral midpoint
+        textScore: 0.5,
+        snippet: truncateSnippet(String(row.text ?? "")),
+        source: String(row.source),
+        citation: `${path}:${startLine}-${endLine}`,
+        chunkId: Number(row.id)
+      };
+    });
+  }
+  async vectorSearchById(query, limit) {
+    if (!this.vectorReady || this.embedding === void 0) return /* @__PURE__ */ new Map();
+    const cacheKey = createHash("sha256").update(query).digest("hex");
+    const cached = queryVectorCache.get(cacheKey);
+    const queryVec = cached ?? (await this.embedding.embed([query]))[0];
+    if (queryVec === void 0) return /* @__PURE__ */ new Map();
+    if (cached === void 0) queryVectorCache.set(cacheKey, queryVec);
+    const rows = vectorSearch(this.db, queryVec, limit);
+    const out = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const score = 1 / (1 + Math.max(0, row.distance));
+      out.set(row.chunk_id, { vectorScore: score });
+    }
+    return out;
+  }
+  combineHybridScores(textHits, vectorHitsById, options) {
+    const weights = resolveWeights(options);
+    const merged = this.mergeHits(textHits, vectorHitsById);
+    const combined = [...merged.values()].map(
+      (hit) => blendScores(hit, vectorHitsById.get(hit.chunkId)?.vectorScore ?? 0, weights)
+    );
+    return combined.sort((a, b) => b.score - a.score);
+  }
+  mergeHits(textHits, vectorHitsById) {
+    const merged = /* @__PURE__ */ new Map();
+    for (const hit of textHits) merged.set(hit.chunkId, hit);
+    const missingIds = [...vectorHitsById.keys()].filter((id) => !merged.has(id));
+    if (missingIds.length > 0) {
+      for (const hit of this.fetchChunksByIds(missingIds)) {
+        merged.set(hit.chunkId, { ...hit, score: 0, textScore: 0 });
+      }
+    }
+    return merged;
+  }
+  fetchChunksByIds(ids) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT chunks.id as id, files.rel_path as rel_path, files.source as source,
+                chunks.start_line as start_line, chunks.end_line as end_line,
+                chunks.text as text
+         FROM chunks JOIN files ON chunks.file_id = files.id
+         WHERE chunks.id IN (${placeholders})`
+    ).all(...ids);
+    return rows.map((row) => {
+      const startLine = Number(row.start_line ?? 0);
+      const endLine = Number(row.end_line ?? 0);
+      const path = String(row.rel_path);
+      return {
+        chunkId: Number(row.id),
+        path,
+        startLine,
+        endLine,
+        score: 0,
+        textScore: 0,
+        snippet: truncateSnippet(String(row.text ?? "")),
+        source: String(row.source),
+        citation: `${path}:${startLine}-${endLine}`
+      };
+    });
+  }
+  // ───── persistence helpers ─────────────────────────────────────────
+  loadFilesIndex() {
+    const rows = this.db.prepare("SELECT id, path, hash FROM files").all();
+    return new Map(rows.map((row) => [row.path, { id: row.id, hash: row.hash }]));
+  }
+  upsertFile(absPath, relPath, hash, mtimeMs, source = "memory") {
+    const stmt = this.db.prepare(
+      `INSERT INTO files (path, rel_path, mtime, hash, source) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(path) DO UPDATE SET hash = excluded.hash, mtime = excluded.mtime, source = excluded.source
+       RETURNING id`
+    );
+    const row = stmt.get(absPath, relPath, Math.floor(mtimeMs), hash, source);
+    return row.id;
+  }
+  deleteChunksForFile(fileId) {
+    this.db.prepare("DELETE FROM chunks WHERE file_id = ?").run(fileId);
+  }
+  insertChunk(fileId, startLine, endLine, text, hash) {
+    this.db.prepare(
+      "INSERT INTO chunks (file_id, start_line, end_line, text, hash) VALUES (?, ?, ?, ?, ?)"
+    ).run(fileId, startLine, endLine, text, hash);
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+export { IndexManager, LanceIndex, appendFact, appendFactToMarkdown, defaultIndexPath, globalEmbeddingCache, lanceStoragePath, legacyMemoryJsonPath, memoryDir, memoryMdPath, openMemoryDb, readFacts, readFactsFromMarkdown, writeSessionSummary };
+//# sourceMappingURL=chunk-G6GO6BXD.js.map
+//# sourceMappingURL=chunk-G6GO6BXD.js.map