minimem 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -0,0 +1,3993 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  KNOWLEDGE_GRAPH_TOOL: () => KNOWLEDGE_GRAPH_TOOL,
+  KNOWLEDGE_PATH_TOOL: () => KNOWLEDGE_PATH_TOOL,
+  KNOWLEDGE_SEARCH_TOOL: () => KNOWLEDGE_SEARCH_TOOL,
+  MEMORY_GET_DETAILS_TOOL: () => MEMORY_GET_DETAILS_TOOL,
+  MEMORY_SEARCH_TOOL: () => MEMORY_SEARCH_TOOL,
+  MEMORY_TOOLS: () => MEMORY_TOOLS,
+  McpServer: () => McpServer,
+  MemoryIndexer: () => MemoryIndexer,
+  MemorySearcher: () => MemorySearcher,
+  MemoryToolExecutor: () => MemoryToolExecutor,
+  Minimem: () => Minimem,
+  addFrontmatter: () => addFrontmatter,
+  addSessionToContent: () => addSessionToContent,
+  buildFileEntry: () => buildFileEntry,
+  buildKnowledgeFilterSql: () => buildKnowledgeFilterSql,
+  chunkMarkdown: () => chunkMarkdown,
+  cosineSimilarity: () => cosineSimilarity,
+  createEmbeddingProvider: () => createEmbeddingProvider,
+  createGeminiEmbeddingProvider: () => createGeminiEmbeddingProvider,
+  createMcpServer: () => createMcpServer,
+  createOpenAiEmbeddingProvider: () => createOpenAiEmbeddingProvider,
+  createToolExecutor: () => createToolExecutor,
+  extractChunkMetadata: () => extractChunkMetadata,
+  extractSession: () => extractSession,
+  generateMcpConfig: () => generateMcpConfig,
+  getLinksFrom: () => getLinksFrom,
+  getLinksTo: () => getLinksTo,
+  getNeighbors: () => getNeighbors,
+  getPathBetween: () => getPathBetween,
+  getToolDefinitions: () => getToolDefinitions,
+  hashText: () => hashText,
+  isMemoryPath: () => isMemoryPath,
+  listMemoryFiles: () => listMemoryFiles,
+  parseFrontmatter: () => parseFrontmatter,
+  runGeminiEmbeddingBatches: () => runGeminiEmbeddingBatches,
+  runMcpServer: () => runMcpServer,
+  runOpenAiEmbeddingBatches: () => runOpenAiEmbeddingBatches,
+  serializeFrontmatter: () => serializeFrontmatter,
+  stripPrivateContent: () => stripPrivateContent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/minimem.ts
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_sqlite = require("node:sqlite");
+var import_chokidar = __toESM(require("chokidar"), 1);
+
+// src/internal.ts
+var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function logError(context, error, debug) {
+  if (!debug) return;
+  const message = error instanceof Error ? error.message : String(error);
+  debug(`[${context}] Error: ${message}`);
+}
+function ensureDir(dir, debug) {
+  try {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+  } catch (error) {
+    const nodeError = error;
+    if (nodeError.code !== "EEXIST") {
+      logError("ensureDir", error, debug);
+    }
+  }
+  return dir;
+}
+function normalizeRelPath(value) {
+  const trimmed = value.trim().replace(/^[./]+/, "");
+  return trimmed.replace(/\\/g, "/");
+}
+function isMemoryPath(relPath) {
+  const normalized = normalizeRelPath(relPath);
+  if (!normalized) return false;
+  if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
+  return normalized.startsWith("memory/");
+}
+async function exists(filePath) {
+  try {
+    await import_promises.default.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function walkDir(dir, files) {
+  const entries = await import_promises.default.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = import_node_path.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(full, files);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".md")) continue;
+    files.push(full);
+  }
+}
+async function listMemoryFiles(memoryDir) {
+  const result = [];
+  const memoryFile = import_node_path.default.join(memoryDir, "MEMORY.md");
+  const altMemoryFile = import_node_path.default.join(memoryDir, "memory.md");
+  const hasUpper = await exists(memoryFile);
+  const hasLower = await exists(altMemoryFile);
+  if (hasUpper && hasLower) {
+    let upperReal = memoryFile;
+    let lowerReal = altMemoryFile;
+    try {
+      upperReal = await import_promises.default.realpath(memoryFile);
+    } catch {
+    }
+    try {
+      lowerReal = await import_promises.default.realpath(altMemoryFile);
+    } catch {
+    }
+    if (upperReal !== lowerReal) {
+      throw new Error(
+        `Both MEMORY.md and memory.md exist in ${memoryDir}. Please remove one to avoid ambiguity.`
+      );
+    }
+    result.push(memoryFile);
+  } else if (hasUpper) {
+    result.push(memoryFile);
+  } else if (hasLower) {
+    result.push(altMemoryFile);
+  }
+  const memorySubDir = import_node_path.default.join(memoryDir, "memory");
+  if (await exists(memorySubDir)) {
+    await walkDir(memorySubDir, result);
+  }
+  if (result.length <= 1) return result;
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const entry of result) {
+    let key = entry;
+    try {
+      key = await import_promises.default.realpath(entry);
+    } catch {
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(entry);
+  }
+  return deduped;
+}
+function hashText(value) {
+  return import_node_crypto.default.createHash("sha256").update(value).digest("hex");
+}
+async function buildFileEntry(absPath, memoryDir) {
+  const stat = await import_promises.default.stat(absPath);
+  const content = await import_promises.default.readFile(absPath, "utf-8");
+  const hash = hashText(content);
+  return {
+    path: import_node_path.default.relative(memoryDir, absPath).replace(/\\/g, "/"),
+    absPath,
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    hash
+  };
+}
+function stripPrivateContent(content) {
+  return content.replace(/<private>[\s\S]*?<\/private>/gi, (match) => {
+    const lineCount = match.split("\n").length;
+    return "\n".repeat(lineCount - 1);
+  });
+}
+function chunkMarkdown(content, chunking) {
+  const stripped = stripPrivateContent(content);
+  const lines = stripped.split("\n");
+  if (lines.length === 0) return [];
+  const maxChars = Math.max(32, chunking.tokens * 4);
+  const overlapChars = Math.max(0, chunking.overlap * 4);
+  const chunks = [];
+  let current = [];
+  let currentChars = 0;
+  const flush = () => {
+    if (current.length === 0) return;
+    const firstEntry = current[0];
+    const lastEntry = current[current.length - 1];
+    if (!firstEntry || !lastEntry) return;
+    const text = current.map((entry) => entry.line).join("\n");
+    const startLine = firstEntry.lineNo;
+    const endLine = lastEntry.lineNo;
+    chunks.push({
+      startLine,
+      endLine,
+      text,
+      hash: hashText(text)
+    });
+  };
+  const carryOverlap = () => {
+    if (overlapChars <= 0 || current.length === 0) {
+      current = [];
+      currentChars = 0;
+      return;
+    }
+    let acc = 0;
+    const kept = [];
+    for (let i = current.length - 1; i >= 0; i -= 1) {
+      const entry = current[i];
+      if (!entry) continue;
+      acc += entry.line.length + 1;
+      kept.unshift(entry);
+      if (acc >= overlapChars) break;
+    }
+    current = kept;
+    currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const lineNo = i + 1;
+    const segments = [];
+    if (line.length === 0) {
+      segments.push("");
+    } else {
+      for (let start = 0; start < line.length; start += maxChars) {
+        segments.push(line.slice(start, start + maxChars));
+      }
+    }
+    for (const segment of segments) {
+      const lineSize = segment.length + 1;
+      if (currentChars + lineSize > maxChars && current.length > 0) {
+        flush();
+        carryOverlap();
+      }
+      current.push({ line: segment, lineNo });
+      currentChars += lineSize;
+    }
+  }
+  flush();
+  return chunks;
+}
+function extractChunkMetadata(text) {
+  const typeMatch = text.match(/<!--\s*type:\s*([\w-]+)\s*-->/i);
+  return typeMatch ? { type: typeMatch[1].toLowerCase() } : {};
+}
+function parseEmbedding(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const len = Math.min(a.length, b.length);
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < len; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function truncateUtf16Safe(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars);
+}
+function vectorToBlob(embedding) {
+  return Buffer.from(new Float32Array(embedding).buffer);
+}
+
+// src/search/hybrid.ts
+function buildFtsQuery(raw) {
+  const tokens = raw.match(/[A-Za-z0-9_]+/g)?.map((t) => t.trim()).filter(Boolean) ?? [];
+  if (tokens.length === 0) return null;
+  const quoted = tokens.map((t) => `"${t.replaceAll('"', "")}"`);
+  return quoted.join(" AND ");
+}
+function bm25RankToScore(rank) {
+  if (!Number.isFinite(rank)) {
+    return 0;
+  }
+  const absRank = Math.abs(rank);
+  return 1 / (1 + absRank);
+}
+function mergeHybridResults(params) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of params.vector) {
+    byId.set(r.id, {
+      id: r.id,
+      path: r.path,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      source: r.source,
+      snippet: r.snippet,
+      vectorScore: r.vectorScore,
+      textScore: 0
+    });
+  }
+  for (const r of params.keyword) {
+    const existing = byId.get(r.id);
+    if (existing) {
+      existing.textScore = r.textScore;
+      if (r.snippet && r.snippet.length > 0) existing.snippet = r.snippet;
+    } else {
+      byId.set(r.id, {
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        vectorScore: 0,
+        textScore: r.textScore
+      });
+    }
+  }
+  let vw = params.vectorWeight;
+  let tw = params.textWeight;
+  if (params.vector.length === 0 && params.keyword.length > 0) {
+    vw = 0;
+    tw = 1;
+  } else if (params.keyword.length === 0 && params.vector.length > 0) {
+    vw = 1;
+    tw = 0;
+  }
+  const merged = Array.from(byId.values()).map((entry) => {
+    const score = vw * entry.vectorScore + tw * entry.textScore;
+    return {
+      path: entry.path,
+      startLine: entry.startLine,
+      endLine: entry.endLine,
+      score,
+      snippet: entry.snippet,
+      source: entry.source
+    };
+  });
+  return merged.sort((a, b) => b.score - a.score);
+}
+
+// src/search/search.ts
+function buildKnowledgeFilterSql(opts) {
+  const clauses = [];
+  const params = [];
+  if (opts.knowledgeType) {
+    clauses.push(` AND c.knowledge_type = ?`);
+    params.push(opts.knowledgeType);
+  }
+  if (opts.minConfidence !== void 0) {
+    clauses.push(` AND c.confidence >= ?`);
+    params.push(opts.minConfidence);
+  }
+  if (opts.domain && opts.domain.length > 0) {
+    const domainPlaceholders = opts.domain.map(() => "?").join(", ");
+    clauses.push(
+      ` AND EXISTS (SELECT 1 FROM json_each(c.domains) AS d WHERE d.value IN (${domainPlaceholders}))`
+    );
+    params.push(...opts.domain);
+  }
+  if (opts.entities && opts.entities.length > 0) {
+    const entityPlaceholders = opts.entities.map(() => "?").join(", ");
+    clauses.push(
+      ` AND EXISTS (SELECT 1 FROM json_each(c.entities) AS e WHERE e.value IN (${entityPlaceholders}))`
+    );
+    params.push(...opts.entities);
+  }
+  return { sql: clauses.join(""), params };
+}
+async function searchVector(params) {
+  if (params.queryVec.length === 0 || params.limit <= 0) return [];
+  if (await params.ensureVectorReady(params.queryVec.length)) {
+    const rows = params.db.prepare(
+      `SELECT c.id, c.path, c.start_line, c.end_line, c.text,
+       c.source,
+       vec_distance_cosine(v.embedding, ?) AS dist
+  FROM ${params.vectorTable} v
+  JOIN chunks c ON c.id = v.id
+ WHERE c.model = ?${params.sourceFilterVec.sql}
+ ORDER BY dist ASC
+ LIMIT ?`
+    ).all(
+      vectorToBlob(params.queryVec),
+      params.providerModel,
+      ...params.sourceFilterVec.params,
+      params.limit
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      path: row.path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      score: 1 - row.dist,
+      snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+      source: row.source
+    }));
+  }
+  const candidates = listChunks({
+    db: params.db,
+    providerModel: params.providerModel,
+    sourceFilter: params.sourceFilterChunks
+  });
+  const scored = candidates.map((chunk) => ({
+    chunk,
+    score: cosineSimilarity(params.queryVec, chunk.embedding)
+  })).filter((entry) => Number.isFinite(entry.score));
+  return scored.sort((a, b) => b.score - a.score).slice(0, params.limit).map((entry) => ({
+    id: entry.chunk.id,
+    path: entry.chunk.path,
+    startLine: entry.chunk.startLine,
+    endLine: entry.chunk.endLine,
+    score: entry.score,
+    snippet: truncateUtf16Safe(entry.chunk.text, params.snippetMaxChars),
+    source: entry.chunk.source
+  }));
+}
+function listChunks(params) {
+  const rows = params.db.prepare(
+    `SELECT id, path, start_line, end_line, text, embedding, source
+  FROM chunks
+ WHERE model = ?${params.sourceFilter.sql}`
+  ).all(params.providerModel, ...params.sourceFilter.params);
+  return rows.map((row) => ({
+    id: row.id,
+    path: row.path,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    text: row.text,
+    embedding: parseEmbedding(row.embedding),
+    source: row.source
+  }));
+}
+async function searchKeyword(params) {
+  if (params.limit <= 0) return [];
+  const ftsQuery = params.buildFtsQuery(params.query);
+  if (!ftsQuery) return [];
+  const rows = params.db.prepare(
+    `SELECT id, path, source, start_line, end_line, text,
+       bm25(${params.ftsTable}) AS rank
+  FROM ${params.ftsTable}
+ WHERE ${params.ftsTable} MATCH ? AND model = ?${params.sourceFilter.sql}
+ ORDER BY rank ASC
+ LIMIT ?`
+  ).all(ftsQuery, params.providerModel, ...params.sourceFilter.params, params.limit);
+  return rows.map((row) => {
+    const textScore = params.bm25RankToScore(row.rank);
+    return {
+      id: row.id,
+      path: row.path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      score: textScore,
+      textScore,
+      snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
+      source: row.source
+    };
+  });
+}
+
+// src/db/schema.ts
+var SCHEMA_VERSION = 4;
+function ensureMemoryIndexSchema(params) {
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  const migrated = migrateIfNeeded(params.db, params.ftsTable);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS files (
+      path TEXT PRIMARY KEY,
+      source TEXT NOT NULL DEFAULT 'memory',
+      hash TEXT NOT NULL,
+      mtime INTEGER NOT NULL,
+      size INTEGER NOT NULL
+    );
+  `);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS chunks (
+      id TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'memory',
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      hash TEXT NOT NULL,
+      model TEXT NOT NULL,
+      text TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS ${params.embeddingCacheTable} (
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      provider_key TEXT NOT NULL,
+      hash TEXT NOT NULL,
+      embedding TEXT NOT NULL,
+      dims INTEGER,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (provider, model, provider_key, hash)
+    );
+  `);
+  params.db.exec(
+    `CREATE INDEX IF NOT EXISTS idx_embedding_cache_updated_at ON ${params.embeddingCacheTable}(updated_at);`
+  );
+  let ftsAvailable = false;
+  let ftsError;
+  if (params.ftsEnabled) {
+    try {
+      params.db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${params.ftsTable} USING fts5(
+  text,
+  id UNINDEXED,
+  path UNINDEXED,
+  source UNINDEXED,
+  model UNINDEXED,
+  start_line UNINDEXED,
+  end_line UNINDEXED
+);`
+      );
+      ftsAvailable = true;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      ftsAvailable = false;
+      ftsError = message;
+    }
+  }
+  ensureColumn(params.db, "files", "source", "TEXT NOT NULL DEFAULT 'memory'");
+  ensureColumn(params.db, "chunks", "source", "TEXT NOT NULL DEFAULT 'memory'");
+  ensureColumn(params.db, "chunks", "type", "TEXT");
+  ensureColumn(params.db, "chunks", "knowledge_type", "TEXT");
+  ensureColumn(params.db, "chunks", "knowledge_id", "TEXT");
+  ensureColumn(params.db, "chunks", "domains", "TEXT");
+  ensureColumn(params.db, "chunks", "entities", "TEXT");
+  ensureColumn(params.db, "chunks", "confidence", "REAL");
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_type ON chunks(type);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_knowledge_type ON chunks(knowledge_type);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_knowledge_id ON chunks(knowledge_id);`);
+  params.db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_links (
+      from_id TEXT NOT NULL,
+      to_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      layer TEXT,
+      weight REAL DEFAULT 0.5,
+      source_path TEXT,
+      created_at INTEGER,
+      PRIMARY KEY (from_id, to_id, relation)
+    );
+  `);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_from ON knowledge_links(from_id);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_to ON knowledge_links(to_id);`);
+  params.db.exec(`CREATE INDEX IF NOT EXISTS idx_kl_layer ON knowledge_links(layer);`);
+  params.db.prepare(
+    `INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)`
+  ).run(String(SCHEMA_VERSION));
+  return { ftsAvailable, ...ftsError ? { ftsError } : {}, ...migrated ? { migrated } : {} };
+}
+function migrateIfNeeded(db, ftsTable) {
+  let storedVersion = 0;
+  try {
+    const row = db.prepare(
+      `SELECT value FROM meta WHERE key = 'schema_version'`
+    ).get();
+    if (row) {
+      storedVersion = parseInt(row.value, 10) || 0;
+    }
+  } catch {
+    storedVersion = 0;
+  }
+  if (storedVersion >= SCHEMA_VERSION) return false;
+  if (storedVersion > 0 && storedVersion < SCHEMA_VERSION) {
+    db.exec(`DROP TABLE IF EXISTS files`);
+    db.exec(`DROP TABLE IF EXISTS chunks`);
+    db.exec(`DROP TABLE IF EXISTS knowledge_links`);
+    db.exec(`DROP TABLE IF EXISTS ${ftsTable}`);
+    try {
+      db.exec(`DROP TABLE IF EXISTS chunks_vec`);
+    } catch {
+    }
+  }
+  return storedVersion > 0;
+}
+function ensureColumn(db, table, column, definition) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (rows.some((row) => row.name === column)) return;
+  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}
+
+// src/session.ts
+var os = __toESM(require("os"), 1);
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { frontmatter: void 0, body: content };
+  }
+  const yamlContent = match[1];
+  const body = content.slice(match[0].length);
+  try {
+    const frontmatter = parseSimpleYaml(yamlContent);
+    return { frontmatter, body };
+  } catch {
+    return { frontmatter: void 0, body: content };
+  }
+}
+function parseSimpleYaml(yaml) {
+  const lines = yaml.split("\n");
+  return parseYamlBlock(lines, 0, 0, lines.length).value;
+}
+function parseYamlBlock(lines, indent, startIdx, endIdx) {
+  const result = {};
+  let i = startIdx;
+  while (i < endIdx) {
+    const line = lines[i];
+    if (!line || !line.trim()) {
+      i++;
+      continue;
+    }
+    const lineIndent = getIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      i++;
+      continue;
+    }
+    const keyMatch = line.match(/^(\s*)([\w-]+):\s*(.*)?$/);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const [, , key, rawValue] = keyMatch;
+    const value = rawValue?.trim() ?? "";
+    if (value === "" || value === void 0) {
+      const nextNonEmpty = findNextNonEmptyLine(lines, i + 1, endIdx);
+      if (nextNonEmpty < endIdx) {
+        const nextLine = lines[nextNonEmpty];
+        const nextIndent = getIndent(nextLine);
+        if (nextIndent > indent) {
+          if (nextLine.trimStart().startsWith("- ")) {
+            const listResult = parseYamlList(lines, nextIndent, i + 1, endIdx);
+            result[key] = listResult.value;
+            i = listResult.nextIdx;
+          } else {
+            const blockResult = parseYamlBlock(lines, nextIndent, i + 1, endIdx);
+            result[key] = blockResult.value;
+            i = blockResult.nextIdx;
+          }
+          continue;
+        }
+      }
+      result[key] = null;
+      i++;
+    } else {
+      result[key] = parseYamlValue(value);
+      i++;
+    }
+  }
+  return { value: result, nextIdx: i };
+}
+function parseYamlList(lines, indent, startIdx, endIdx) {
+  const result = [];
+  let i = startIdx;
+  while (i < endIdx) {
+    const line = lines[i];
+    if (!line || !line.trim()) {
+      i++;
+      continue;
+    }
+    const lineIndent = getIndent(line);
+    if (lineIndent < indent) break;
+    if (lineIndent > indent) {
+      i++;
+      continue;
+    }
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith("- ")) break;
+    const itemContent = trimmed.slice(2).trim();
+    if (itemContent === "" || itemContent === void 0) {
+      const nextNonEmpty = findNextNonEmptyLine(lines, i + 1, endIdx);
+      if (nextNonEmpty < endIdx) {
+        const nextIndent = getIndent(lines[nextNonEmpty]);
+        if (nextIndent > indent) {
+          const blockResult = parseYamlBlock(lines, nextIndent, i + 1, endIdx);
+          result.push(blockResult.value);
+          i = blockResult.nextIdx;
+          continue;
+        }
+      }
+      result.push(null);
+      i++;
+    } else {
+      const kvMatch = itemContent.match(/^([\w-]+):\s*(.*)$/);
+      if (kvMatch) {
+        const obj = {};
+        const [, firstKey, firstVal] = kvMatch;
+        obj[firstKey] = parseYamlValue(firstVal?.trim() ?? "");
+        const itemKeyIndent = indent + 2;
+        let j = i + 1;
+        while (j < endIdx) {
+          const nextLine = lines[j];
+          if (!nextLine || !nextLine.trim()) {
+            j++;
+            continue;
+          }
+          const nextLineIndent = getIndent(nextLine);
+          if (nextLineIndent < itemKeyIndent) break;
+          if (nextLineIndent === itemKeyIndent) {
+            const nextKv = nextLine.match(/^\s*([\w-]+):\s*(.*)$/);
+            if (nextKv) {
+              const [, nk, nv] = nextKv;
+              obj[nk] = parseYamlValue(nv?.trim() ?? "");
+              j++;
+              continue;
+            }
+          }
+          break;
+        }
+        result.push(obj);
+        i = j;
+      } else {
+        result.push(parseYamlValue(itemContent));
+        i++;
+      }
+    }
+  }
+  return { value: result, nextIdx: i };
+}
+function getIndent(line) {
+  const match = line.match(/^(\s*)/);
+  return match ? match[1].length : 0;
+}
+function findNextNonEmptyLine(lines, from, end) {
+  for (let i = from; i < end; i++) {
+    if (lines[i]?.trim()) return i;
+  }
+  return end;
+}
+function parseYamlValue(value) {
+  if (value === "") return null;
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num) && value !== "") return num;
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1);
+    if (inner.trim() === "") return [];
+    return inner.split(",").map((s) => parseYamlValue(s.trim()));
+  }
+  return value;
+}
+function serializeFrontmatter(frontmatter) {
+  const lines = ["---"];
+  if (frontmatter.id) {
+    lines.push(`id: ${frontmatter.id}`);
+  }
+  if (frontmatter.type) {
+    lines.push(`type: ${frontmatter.type}`);
+  }
+  if (frontmatter.session) {
+    lines.push("session:");
+    const session = frontmatter.session;
+    if (session.id) lines.push(`  id: ${session.id}`);
+    if (session.source) lines.push(`  source: ${session.source}`);
+    if (session.project) lines.push(`  project: ${formatPath(session.project)}`);
+    if (session.transcript) lines.push(`  transcript: ${formatPath(session.transcript)}`);
+  }
+  if (frontmatter.created) {
+    lines.push(`created: ${frontmatter.created}`);
+  }
+  if (frontmatter.updated) {
+    lines.push(`updated: ${frontmatter.updated}`);
+  }
+  if (frontmatter.tags && frontmatter.tags.length > 0) {
+    lines.push(`tags: [${frontmatter.tags.join(", ")}]`);
+  }
+  if (frontmatter.domain && frontmatter.domain.length > 0) {
+    lines.push(`domain: [${frontmatter.domain.join(", ")}]`);
+  }
+  if (frontmatter.entities && frontmatter.entities.length > 0) {
+    lines.push(`entities: [${frontmatter.entities.join(", ")}]`);
+  }
+  if (frontmatter.confidence !== void 0) {
+    lines.push(`confidence: ${frontmatter.confidence}`);
+  }
+  if (frontmatter.source) {
+    lines.push("source:");
+    if (frontmatter.source.origin) lines.push(`  origin: ${frontmatter.source.origin}`);
+    if (frontmatter.source.trajectories && frontmatter.source.trajectories.length > 0) {
+      lines.push(`  trajectories: [${frontmatter.source.trajectories.join(", ")}]`);
+    }
+    if (frontmatter.source.agentId) lines.push(`  agentId: ${frontmatter.source.agentId}`);
+  }
+  if (frontmatter.links && frontmatter.links.length > 0) {
+    lines.push("links:");
+    for (const link of frontmatter.links) {
+      lines.push(`  - target: ${link.target}`);
+      lines.push(`    relation: ${link.relation}`);
+      if (link.layer) lines.push(`    layer: ${link.layer}`);
+    }
+  }
+  if (frontmatter.supersedes !== void 0) {
+    lines.push(`supersedes: ${frontmatter.supersedes === null ? "~" : frontmatter.supersedes}`);
+  }
+  lines.push("---");
+  return lines.join("\n") + "\n";
+}
+function addFrontmatter(content, frontmatter) {
+  const { frontmatter: existing, body } = parseFrontmatter(content);
+  const merged = {
+    ...existing,
+    ...frontmatter,
+    session: {
+      ...existing?.session,
+      ...frontmatter.session
+    }
+  };
+  if (!merged.created) {
+    merged.created = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  merged.updated = (/* @__PURE__ */ new Date()).toISOString();
+  return serializeFrontmatter(merged) + body;
+}
+function addSessionToContent(content, session) {
+  return addFrontmatter(content, { session });
+}
+function formatPath(filePath) {
+  const home = os.homedir();
+  if (filePath.startsWith(home)) {
+    return "~" + filePath.slice(home.length);
+  }
+  return filePath;
+}
+function extractSession(content) {
+  const { frontmatter } = parseFrontmatter(content);
+  return frontmatter?.session;
+}
+
+// src/search/graph.ts
+function getLinksFrom(db, fromId, opts) {
+  let sql = `SELECT from_id, to_id, relation, layer, weight, source_path FROM knowledge_links WHERE from_id = ?`;
+  const params = [fromId];
+  if (opts?.relation) {
+    sql += ` AND relation = ?`;
+    params.push(opts.relation);
+  }
+  if (opts?.layer) {
+    sql += ` AND layer = ?`;
+    params.push(opts.layer);
+  }
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(toGraphLink);
+}
+function getLinksTo(db, toId, opts) {
+  let sql = `SELECT from_id, to_id, relation, layer, weight, source_path FROM knowledge_links WHERE to_id = ?`;
+  const params = [toId];
+  if (opts?.relation) {
+    sql += ` AND relation = ?`;
+    params.push(opts.relation);
+  }
+  if (opts?.layer) {
+    sql += ` AND layer = ?`;
+    params.push(opts.layer);
+  }
+  const rows = db.prepare(sql).all(...params);
+  return rows.map(toGraphLink);
+}
+function getNeighbors(db, startId, depth = 1, opts) {
+  const visited = /* @__PURE__ */ new Set([startId]);
+  const result = [];
+  let frontier = [startId];
+  for (let d = 1; d <= depth; d++) {
+    const nextFrontier = [];
+    for (const nodeId of frontier) {
+      const outgoing = getLinksFrom(db, nodeId, opts);
+      for (const link of outgoing) {
+        if (!visited.has(link.toId)) {
+          visited.add(link.toId);
+          nextFrontier.push(link.toId);
+          result.push({ id: link.toId, depth: d, link });
+        }
+      }
+      const incoming = getLinksTo(db, nodeId, opts);
+      for (const link of incoming) {
+        if (!visited.has(link.fromId)) {
+          visited.add(link.fromId);
+          nextFrontier.push(link.fromId);
+          result.push({ id: link.fromId, depth: d, link });
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+  return result;
+}
+function getPathBetween(db, fromId, toId, maxDepth = 3) {
+  if (fromId === toId) return [];
+  const visited = /* @__PURE__ */ new Set([fromId]);
+  const parentLink = /* @__PURE__ */ new Map();
+  let frontier = [fromId];
+  for (let d = 0; d < maxDepth; d++) {
+    const nextFrontier = [];
+    for (const nodeId of frontier) {
+      const outgoing = getLinksFrom(db, nodeId);
+      for (const link of outgoing) {
+        if (!visited.has(link.toId)) {
+          visited.add(link.toId);
+          parentLink.set(link.toId, link);
+          if (link.toId === toId) {
+            return reconstructPath(parentLink, fromId, toId);
+          }
+          nextFrontier.push(link.toId);
+        }
+      }
+      const incoming = getLinksTo(db, nodeId);
+      for (const link of incoming) {
+        if (!visited.has(link.fromId)) {
+          visited.add(link.fromId);
+          parentLink.set(link.fromId, link);
+          if (link.fromId === toId) {
+            return reconstructPath(parentLink, fromId, toId);
+          }
+          nextFrontier.push(link.fromId);
+        }
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+  return [];
+}
+function reconstructPath(parentLink, fromId, toId) {
+  const path5 = [];
+  let current = toId;
+  while (current !== fromId) {
+    const link = parentLink.get(current);
+    if (!link) break;
+    path5.unshift(link);
+    current = link.toId === current ? link.fromId : link.toId;
+  }
+  return path5;
+}
+function toGraphLink(row) {
+  return {
+    fromId: row.from_id,
+    toId: row.to_id,
+    relation: row.relation,
+    layer: row.layer,
+    weight: row.weight,
+    sourcePath: row.source_path
+  };
+}
+
+// src/db/sqlite-vec.ts
+async function loadSqliteVecExtension(params) {
+  try {
+    const sqliteVec = await import("sqlite-vec");
+    const resolvedPath = params.extensionPath?.trim() ? params.extensionPath.trim() : void 0;
+    const extensionPath = resolvedPath ?? sqliteVec.getLoadablePath();
+    params.db.enableLoadExtension(true);
+    if (resolvedPath) {
+      params.db.loadExtension(extensionPath);
+    } else {
+      sqliteVec.load(params.db);
+    }
+    return { ok: true, extensionPath };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+// src/embeddings/embeddings.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
+var DEFAULT_OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
+var DEFAULT_GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+function createNoOpEmbeddingProvider() {
+  return {
+    id: "none",
+    model: "bm25-only",
+    embedQuery: async () => [],
+    embedBatch: async (texts) => texts.map(() => [])
+  };
+}
+function resolveUserPath(filePath) {
+  if (filePath.startsWith("~/")) {
+    return import_node_path2.default.join(import_node_os.default.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+function canAutoSelectLocal(options) {
+  const modelPath = options.local?.modelPath?.trim();
+  if (!modelPath) return false;
+  if (/^(hf:|https?:)/i.test(modelPath)) return false;
+  const resolved = resolveUserPath(modelPath);
+  try {
+    return import_node_fs2.default.statSync(resolved).isFile();
+  } catch {
+    return false;
+  }
+}
+function isMissingApiKeyError(err) {
+  const message = formatError(err);
+  return message.includes("API key") || message.includes("apiKey");
+}
+async function importNodeLlamaCpp() {
+  const llama = await import("node-llama-cpp");
+  return llama;
+}
+async function createLocalEmbeddingProvider(options) {
+  const modelPath = options.local?.modelPath?.trim() || DEFAULT_LOCAL_MODEL;
+  const modelCacheDir = options.local?.modelCacheDir?.trim();
+  const { getLlama, resolveModelFile, LlamaLogLevel } = await importNodeLlamaCpp();
+  let llama = null;
+  let embeddingModel = null;
+  let embeddingContext = null;
+  const ensureContext = async () => {
+    if (!llama) {
+      llama = await getLlama({ logLevel: LlamaLogLevel.error });
+    }
+    if (!embeddingModel) {
+      const resolved = await resolveModelFile(modelPath, modelCacheDir || void 0);
+      embeddingModel = await llama.loadModel({ modelPath: resolved });
+    }
+    if (!embeddingContext) {
+      embeddingContext = await embeddingModel.createEmbeddingContext();
+    }
+    return embeddingContext;
+  };
+  return {
+    id: "local",
+    model: modelPath,
+    embedQuery: async (text) => {
+      const ctx = await ensureContext();
+      const embedding = await ctx.getEmbeddingFor(text);
+      return Array.from(embedding.vector);
+    },
+    embedBatch: async (texts) => {
+      const ctx = await ensureContext();
+      const embeddings = await Promise.all(
+        texts.map(async (text) => {
+          const embedding = await ctx.getEmbeddingFor(text);
+          return Array.from(embedding.vector);
+        })
+      );
+      return embeddings;
+    }
+  };
+}
+function normalizeOpenAiModel(model) {
+  const trimmed = model.trim();
+  if (!trimmed) return DEFAULT_OPENAI_EMBEDDING_MODEL;
+  if (trimmed.startsWith("openai/")) return trimmed.slice("openai/".length);
+  return trimmed;
+}
+function resolveOpenAiApiKey(options) {
+  const apiKey = options.openai?.apiKey?.trim();
+  if (apiKey) return apiKey;
+  const envKey = process.env.OPENAI_API_KEY?.trim();
+  if (envKey) return envKey;
+  throw new Error("OpenAI API key not found. Set OPENAI_API_KEY env var or pass openai.apiKey option.");
+}
+async function createOpenAiEmbeddingProvider(options) {
+  const apiKey = resolveOpenAiApiKey(options);
+  const baseUrl = options.openai?.baseUrl?.trim() || DEFAULT_OPENAI_BASE_URL;
+  const headerOverrides = options.openai?.headers ?? {};
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+    ...headerOverrides
+  };
+  const model = normalizeOpenAiModel(options.model || "");
+  const client = { baseUrl, headers, model };
+  const url = `${baseUrl.replace(/\/$/, "")}/embeddings`;
+  const embed = async (input) => {
+    if (input.length === 0) return [];
+    const res = await fetch(url, {
+      method: "POST",
+      headers: client.headers,
+      body: JSON.stringify({ model: client.model, input })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`openai embeddings failed: ${res.status} ${text}`);
+    }
+    const payload = await res.json();
+    const data = payload.data ?? [];
+    return data.map((entry) => entry.embedding ?? []);
+  };
+  return {
+    provider: {
+      id: "openai",
+      model: client.model,
+      embedQuery: async (text) => {
+        const [vec] = await embed([text]);
+        return vec ?? [];
+      },
+      embedBatch: embed
+    },
+    client
+  };
+}
+function normalizeGeminiModel(model) {
+  const trimmed = model.trim();
+  if (!trimmed) return DEFAULT_GEMINI_EMBEDDING_MODEL;
+  const withoutPrefix = trimmed.replace(/^models\//, "");
+  if (withoutPrefix.startsWith("gemini/")) return withoutPrefix.slice("gemini/".length);
+  if (withoutPrefix.startsWith("google/")) return withoutPrefix.slice("google/".length);
+  return withoutPrefix;
+}
+function normalizeGeminiBaseUrl(raw) {
+  const trimmed = raw.replace(/\/+$/, "");
+  const openAiIndex = trimmed.indexOf("/openai");
+  if (openAiIndex > -1) return trimmed.slice(0, openAiIndex);
+  return trimmed;
+}
+function buildGeminiModelPath(model) {
+  return model.startsWith("models/") ? model : `models/${model}`;
+}
+function resolveGeminiApiKey(options) {
+  const apiKey = options.gemini?.apiKey?.trim();
+  if (apiKey) return apiKey;
+  const googleKey = process.env.GOOGLE_API_KEY?.trim();
+  if (googleKey) return googleKey;
+  const geminiKey = process.env.GEMINI_API_KEY?.trim();
+  if (geminiKey) return geminiKey;
+  throw new Error("Gemini API key not found. Set GOOGLE_API_KEY or GEMINI_API_KEY env var or pass gemini.apiKey option.");
+}
+async function createGeminiEmbeddingProvider(options) {
+  const apiKey = resolveGeminiApiKey(options);
+  const rawBaseUrl = options.gemini?.baseUrl?.trim() || DEFAULT_GEMINI_BASE_URL;
+  const baseUrl = normalizeGeminiBaseUrl(rawBaseUrl);
+  const headerOverrides = options.gemini?.headers ?? {};
+  const headers = {
+    "Content-Type": "application/json",
+    "x-goog-api-key": apiKey,
+    ...headerOverrides
+  };
+  const model = normalizeGeminiModel(options.model || "");
+  const modelPath = buildGeminiModelPath(model);
+  const client = { baseUrl, headers, model, modelPath };
+  const embedUrl = `${baseUrl}/${modelPath}:embedContent`;
+  const batchUrl = `${baseUrl}/${modelPath}:batchEmbedContents`;
+  const embedQuery = async (text) => {
+    if (!text.trim()) return [];
+    const res = await fetch(embedUrl, {
+      method: "POST",
+      headers: client.headers,
+      body: JSON.stringify({
+        content: { parts: [{ text }] },
+        taskType: "RETRIEVAL_QUERY"
+      })
+    });
+    if (!res.ok) {
+      const payload2 = await res.text();
+      throw new Error(`gemini embeddings failed: ${res.status} ${payload2}`);
+    }
+    const payload = await res.json();
+    return payload.embedding?.values ?? [];
+  };
+  const embedBatch = async (texts) => {
+    if (texts.length === 0) return [];
+    const requests = texts.map((text) => ({
+      model: modelPath,
+      content: { parts: [{ text }] },
+      taskType: "RETRIEVAL_DOCUMENT"
+    }));
+    const res = await fetch(batchUrl, {
+      method: "POST",
+      headers: client.headers,
+      body: JSON.stringify({ requests })
+    });
+    if (!res.ok) {
+      const payload2 = await res.text();
+      throw new Error(`gemini embeddings failed: ${res.status} ${payload2}`);
+    }
+    const payload = await res.json();
+    const embeddings = Array.isArray(payload.embeddings) ? payload.embeddings : [];
+    return texts.map((_, index) => embeddings[index]?.values ?? []);
+  };
+  return {
+    provider: {
+      id: "gemini",
+      model: client.model,
+      embedQuery,
+      embedBatch
+    },
+    client
+  };
+}
+async function createEmbeddingProvider(options) {
+  const requestedProvider = options.provider;
+  const fallback = options.fallback ?? "none";
+  if (requestedProvider === "none") {
+    return {
+      provider: createNoOpEmbeddingProvider(),
+      requestedProvider: "none"
+    };
+  }
+  const createProvider = async (id) => {
+    if (id === "local") {
+      const provider2 = await createLocalEmbeddingProvider(options);
+      return { provider: provider2 };
+    }
+    if (id === "gemini") {
+      const { provider: provider2, client: client2 } = await createGeminiEmbeddingProvider(options);
+      return { provider: provider2, gemini: client2 };
+    }
+    const { provider, client } = await createOpenAiEmbeddingProvider(options);
+    return { provider, openAi: client };
+  };
+  const formatPrimaryError = (err, provider) => provider === "local" ? formatLocalSetupError(err) : formatError(err);
+  if (requestedProvider === "auto") {
+    const missingKeyErrors = [];
+    let localError = null;
+    if (canAutoSelectLocal(options)) {
+      try {
+        const local = await createProvider("local");
+        return { ...local, requestedProvider };
+      } catch (err) {
+        localError = formatLocalSetupError(err);
+      }
+    }
+    for (const provider of ["openai", "gemini"]) {
+      try {
+        const result = await createProvider(provider);
+        return { ...result, requestedProvider };
+      } catch (err) {
+        const message = formatPrimaryError(err, provider);
+        if (isMissingApiKeyError(err)) {
+          missingKeyErrors.push(message);
+          continue;
+        }
+        throw new Error(message);
+      }
+    }
+    return {
+      provider: createNoOpEmbeddingProvider(),
+      requestedProvider,
+      fallbackFrom: "auto",
+      fallbackReason: "No embedding API available. Using BM25 full-text search only."
+    };
+  }
+  try {
+    const primary = await createProvider(requestedProvider);
+    return { ...primary, requestedProvider };
+  } catch (primaryErr) {
+    const reason = formatPrimaryError(primaryErr, requestedProvider);
+    if (fallback && fallback !== "none" && fallback !== requestedProvider) {
+      try {
+        const fallbackResult = await createProvider(fallback);
+        return {
+          ...fallbackResult,
+          requestedProvider,
+          fallbackFrom: requestedProvider,
+          fallbackReason: reason
+        };
+      } catch (fallbackErr) {
+        throw new Error(`${reason}
+
+Fallback to ${fallback} failed: ${formatError(fallbackErr)}`);
+      }
+    }
+    throw new Error(reason);
+  }
+}
+function formatError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function isNodeLlamaCppMissing(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (code === "ERR_MODULE_NOT_FOUND") {
+    return err.message.includes("node-llama-cpp");
+  }
+  return false;
+}
+function formatLocalSetupError(err) {
+  const detail = formatError(err);
+  const missing = isNodeLlamaCppMissing(err);
+  return [
+    "Local embeddings unavailable.",
+    missing ? "Reason: optional dependency node-llama-cpp is missing (or failed to install)." : detail ? `Reason: ${detail}` : void 0,
+    missing && detail ? `Detail: ${detail}` : null,
+    "To enable local embeddings:",
+    "1) Use Node 22 LTS (recommended for installs/updates)",
+    missing ? "2) Install node-llama-cpp: npm install node-llama-cpp" : null,
+    "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
+    'Or set provider = "openai" or "gemini" (remote).'
+  ].filter(Boolean).join("\n");
+}
+
+// src/embeddings/batch-openai.ts
+var OPENAI_BATCH_ENDPOINT = "/v1/embeddings";
+var OPENAI_BATCH_COMPLETION_WINDOW = "24h";
+var OPENAI_BATCH_MAX_REQUESTS = 5e4;
+function getOpenAiBaseUrl(openAi) {
+  return openAi.baseUrl?.replace(/\/$/, "") ?? "";
+}
+function getOpenAiHeaders(openAi, params) {
+  const headers = openAi.headers ? { ...openAi.headers } : {};
+  if (params.json) {
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  } else {
+    delete headers["Content-Type"];
+    delete headers["content-type"];
+  }
+  return headers;
+}
+function splitOpenAiBatchRequests(requests) {
+  if (requests.length <= OPENAI_BATCH_MAX_REQUESTS) return [requests];
+  const groups = [];
+  for (let i = 0; i < requests.length; i += OPENAI_BATCH_MAX_REQUESTS) {
+    groups.push(requests.slice(i, i + OPENAI_BATCH_MAX_REQUESTS));
+  }
+  return groups;
+}
+async function retryAsync(fn, opts) {
+  let lastError;
+  for (let attempt = 0; attempt < opts.attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!opts.shouldRetry(err) || attempt === opts.attempts - 1) {
+        throw err;
+      }
+      const delay = Math.min(
+        opts.maxDelayMs,
+        opts.minDelayMs * Math.pow(2, attempt) * (1 + Math.random() * opts.jitter)
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+async function submitOpenAiBatch(params) {
+  const baseUrl = getOpenAiBaseUrl(params.openAi);
+  const jsonl = params.requests.map((request) => JSON.stringify(request)).join("\n");
+  const form = new FormData();
+  form.append("purpose", "batch");
+  form.append(
+    "file",
+    new Blob([jsonl], { type: "application/jsonl" }),
+    `memory-embeddings.${hashText(String(Date.now()))}.jsonl`
+  );
+  const fileRes = await fetch(`${baseUrl}/files`, {
+    method: "POST",
+    headers: getOpenAiHeaders(params.openAi, { json: false }),
+    body: form
+  });
+  if (!fileRes.ok) {
+    const text = await fileRes.text();
+    throw new Error(`openai batch file upload failed: ${fileRes.status} ${text}`);
+  }
+  const filePayload = await fileRes.json();
+  if (!filePayload.id) {
+    throw new Error("openai batch file upload failed: missing file id");
+  }
+  const batchRes = await retryAsync(
+    async () => {
+      const res = await fetch(`${baseUrl}/batches`, {
+        method: "POST",
+        headers: getOpenAiHeaders(params.openAi, { json: true }),
+        body: JSON.stringify({
+          input_file_id: filePayload.id,
+          endpoint: OPENAI_BATCH_ENDPOINT,
+          completion_window: OPENAI_BATCH_COMPLETION_WINDOW,
+          metadata: {
+            source: params.source
+          }
+        })
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        const err = new Error(`openai batch create failed: ${res.status} ${text}`);
+        err.status = res.status;
+        throw err;
+      }
+      return res;
+    },
+    {
+      attempts: 3,
+      minDelayMs: 300,
+      maxDelayMs: 2e3,
+      jitter: 0.2,
+      shouldRetry: (err) => {
+        const status = err.status;
+        return status === 429 || typeof status === "number" && status >= 500;
+      }
+    }
+  );
+  return await batchRes.json();
+}
+async function fetchOpenAiBatchStatus(params) {
+  const baseUrl = getOpenAiBaseUrl(params.openAi);
+  const res = await fetch(`${baseUrl}/batches/${params.batchId}`, {
+    headers: getOpenAiHeaders(params.openAi, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`openai batch status failed: ${res.status} ${text}`);
+  }
+  return await res.json();
+}
+async function fetchOpenAiFileContent(params) {
+  const baseUrl = getOpenAiBaseUrl(params.openAi);
+  const res = await fetch(`${baseUrl}/files/${params.fileId}/content`, {
+    headers: getOpenAiHeaders(params.openAi, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`openai batch file content failed: ${res.status} ${text}`);
+  }
+  return await res.text();
+}
+function parseOpenAiBatchOutput(text) {
+  if (!text.trim()) return [];
+  return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function readOpenAiBatchError(params) {
+  try {
+    const content = await fetchOpenAiFileContent({
+      openAi: params.openAi,
+      fileId: params.errorFileId
+    });
+    const lines = parseOpenAiBatchOutput(content);
+    const first = lines.find((line) => line.error?.message || line.response?.body?.error);
+    const message = first?.error?.message ?? (typeof first?.response?.body?.error?.message === "string" ? first?.response?.body?.error?.message : void 0);
+    return message;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message ? `error file unavailable: ${message}` : void 0;
+  }
+}
+async function waitForOpenAiBatch(params) {
+  const start = Date.now();
+  let current = params.initial;
+  while (true) {
+    const status = current ?? await fetchOpenAiBatchStatus({
+      openAi: params.openAi,
+      batchId: params.batchId
+    });
+    const state = status.status ?? "unknown";
+    if (state === "completed") {
+      if (!status.output_file_id) {
+        throw new Error(`openai batch ${params.batchId} completed without output file`);
+      }
+      return {
+        outputFileId: status.output_file_id,
+        errorFileId: status.error_file_id ?? void 0
+      };
+    }
+    if (["failed", "expired", "cancelled", "canceled"].includes(state)) {
+      const detail = status.error_file_id ? await readOpenAiBatchError({ openAi: params.openAi, errorFileId: status.error_file_id }) : void 0;
+      const suffix = detail ? `: ${detail}` : "";
+      throw new Error(`openai batch ${params.batchId} ${state}${suffix}`);
+    }
+    if (!params.wait) {
+      throw new Error(`openai batch ${params.batchId} still ${state}; wait disabled`);
+    }
+    if (Date.now() - start > params.timeoutMs) {
+      throw new Error(`openai batch ${params.batchId} timed out after ${params.timeoutMs}ms`);
+    }
+    params.debug?.(`openai batch ${params.batchId} ${state}; waiting ${params.pollIntervalMs}ms`);
+    await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+    current = void 0;
+  }
+}
+async function runWithConcurrency(tasks, limit) {
+  if (tasks.length === 0) return [];
+  const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+  const results = Array.from({ length: tasks.length });
+  let next = 0;
+  let firstError = null;
+  const workers = Array.from({ length: resolvedLimit }, async () => {
+    while (true) {
+      if (firstError) return;
+      const index = next;
+      next += 1;
+      if (index >= tasks.length) return;
+      try {
+        results[index] = await tasks[index]();
+      } catch (err) {
+        firstError = err;
+        return;
+      }
+    }
+  });
+  await Promise.allSettled(workers);
+  if (firstError) throw firstError;
+  return results;
+}
+async function runOpenAiEmbeddingBatches(params) {
+  if (params.requests.length === 0) return /* @__PURE__ */ new Map();
+  const groups = splitOpenAiBatchRequests(params.requests);
+  const byCustomId = /* @__PURE__ */ new Map();
+  const tasks = groups.map((group, groupIndex) => async () => {
+    const batchInfo = await submitOpenAiBatch({
+      openAi: params.openAi,
+      requests: group,
+      source: params.source
+    });
+    if (!batchInfo.id) {
+      throw new Error("openai batch create failed: missing batch id");
+    }
+    params.debug?.("memory embeddings: openai batch created", {
+      batchId: batchInfo.id,
+      status: batchInfo.status,
+      group: groupIndex + 1,
+      groups: groups.length,
+      requests: group.length
+    });
+    if (!params.wait && batchInfo.status !== "completed") {
+      throw new Error(
+        `openai batch ${batchInfo.id} submitted; enable batch.wait to await completion`
+      );
+    }
+    const completed = batchInfo.status === "completed" ? {
+      outputFileId: batchInfo.output_file_id ?? "",
+      errorFileId: batchInfo.error_file_id ?? void 0
+    } : await waitForOpenAiBatch({
+      openAi: params.openAi,
+      batchId: batchInfo.id,
+      wait: params.wait,
+      pollIntervalMs: params.pollIntervalMs,
+      timeoutMs: params.timeoutMs,
+      debug: params.debug,
+      initial: batchInfo
+    });
+    if (!completed.outputFileId) {
+      throw new Error(`openai batch ${batchInfo.id} completed without output file`);
+    }
+    const content = await fetchOpenAiFileContent({
+      openAi: params.openAi,
+      fileId: completed.outputFileId
+    });
+    const outputLines = parseOpenAiBatchOutput(content);
+    const errors = [];
+    const remaining = new Set(group.map((request) => request.custom_id));
+    for (const line of outputLines) {
+      const customId = line.custom_id;
+      if (!customId) continue;
+      remaining.delete(customId);
+      if (line.error?.message) {
+        errors.push(`${customId}: ${line.error.message}`);
+        continue;
+      }
+      const response = line.response;
+      const statusCode = response?.status_code ?? 0;
+      if (statusCode >= 400) {
+        const message = response?.body?.error?.message ?? (typeof response?.body === "string" ? response.body : void 0) ?? "unknown error";
+        errors.push(`${customId}: ${message}`);
+        continue;
+      }
+      const data = response?.body?.data ?? [];
+      const embedding = data[0]?.embedding ?? [];
+      if (embedding.length === 0) {
+        errors.push(`${customId}: empty embedding`);
+        continue;
+      }
+      byCustomId.set(customId, embedding);
+    }
+    if (errors.length > 0) {
+      throw new Error(`openai batch ${batchInfo.id} failed: ${errors.join("; ")}`);
+    }
+    if (remaining.size > 0) {
+      throw new Error(`openai batch ${batchInfo.id} missing ${remaining.size} embedding responses`);
+    }
+  });
+  params.debug?.("memory embeddings: openai batch submit", {
+    requests: params.requests.length,
+    groups: groups.length,
+    wait: params.wait,
+    concurrency: params.concurrency,
+    pollIntervalMs: params.pollIntervalMs,
+    timeoutMs: params.timeoutMs
+  });
+  await runWithConcurrency(tasks, params.concurrency);
+  return byCustomId;
+}
+
+// src/embeddings/batch-gemini.ts
+var GEMINI_BATCH_MAX_REQUESTS = 5e4;
+function getGeminiBaseUrl(gemini) {
+  return gemini.baseUrl?.replace(/\/$/, "") ?? "";
+}
+function getGeminiHeaders(gemini, params) {
+  const headers = gemini.headers ? { ...gemini.headers } : {};
+  if (params.json) {
+    if (!headers["Content-Type"] && !headers["content-type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+  } else {
+    delete headers["Content-Type"];
+    delete headers["content-type"];
+  }
+  return headers;
+}
+function getGeminiUploadUrl(baseUrl) {
+  if (baseUrl.includes("/v1beta")) {
+    return baseUrl.replace(/\/v1beta\/?$/, "/upload/v1beta");
+  }
+  return `${baseUrl.replace(/\/$/, "")}/upload`;
+}
+function splitGeminiBatchRequests(requests) {
+  if (requests.length <= GEMINI_BATCH_MAX_REQUESTS) return [requests];
+  const groups = [];
+  for (let i = 0; i < requests.length; i += GEMINI_BATCH_MAX_REQUESTS) {
+    groups.push(requests.slice(i, i + GEMINI_BATCH_MAX_REQUESTS));
+  }
+  return groups;
+}
+function buildGeminiUploadBody(params) {
+  const boundary = `minimem-${hashText(params.displayName)}`;
+  const jsonPart = JSON.stringify({
+    file: {
+      displayName: params.displayName,
+      mimeType: "application/jsonl"
+    }
+  });
+  const delimiter = `--${boundary}\r
+`;
+  const closeDelimiter = `--${boundary}--\r
+`;
+  const parts = [
+    `${delimiter}Content-Type: application/json; charset=UTF-8\r
+\r
+${jsonPart}\r
+`,
+    `${delimiter}Content-Type: application/jsonl; charset=UTF-8\r
+\r
+${params.jsonl}\r
+`,
+    closeDelimiter
+  ];
+  const body = new Blob([parts.join("")], { type: "multipart/related" });
+  return {
+    body,
+    contentType: `multipart/related; boundary=${boundary}`
+  };
+}
+async function submitGeminiBatch(params) {
+  const baseUrl = getGeminiBaseUrl(params.gemini);
+  const jsonl = params.requests.map(
+    (request) => JSON.stringify({
+      key: request.custom_id,
+      request: {
+        content: request.content,
+        task_type: request.taskType
+      }
+    })
+  ).join("\n");
+  const displayName = `memory-embeddings-${hashText(String(Date.now()))}`;
+  const uploadPayload = buildGeminiUploadBody({ jsonl, displayName });
+  const uploadUrl = `${getGeminiUploadUrl(baseUrl)}/files?uploadType=multipart`;
+  const fileRes = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      ...getGeminiHeaders(params.gemini, { json: false }),
+      "Content-Type": uploadPayload.contentType
+    },
+    body: uploadPayload.body
+  });
+  if (!fileRes.ok) {
+    const text2 = await fileRes.text();
+    throw new Error(`gemini batch file upload failed: ${fileRes.status} ${text2}`);
+  }
+  const filePayload = await fileRes.json();
+  const fileId = filePayload.name ?? filePayload.file?.name;
+  if (!fileId) {
+    throw new Error("gemini batch file upload failed: missing file id");
+  }
+  const batchBody = {
+    batch: {
+      displayName: `memory-embeddings-${params.source}`,
+      inputConfig: {
+        file_name: fileId
+      }
+    }
+  };
+  const batchEndpoint = `${baseUrl}/${params.gemini.modelPath}:asyncBatchEmbedContent`;
+  const batchRes = await fetch(batchEndpoint, {
+    method: "POST",
+    headers: getGeminiHeaders(params.gemini, { json: true }),
+    body: JSON.stringify(batchBody)
+  });
+  if (batchRes.ok) {
+    return await batchRes.json();
+  }
+  const text = await batchRes.text();
+  if (batchRes.status === 404) {
+    throw new Error(
+      "gemini batch create failed: 404 (asyncBatchEmbedContent not available for this model/baseUrl). Disable batch.enabled or switch providers."
+    );
+  }
+  throw new Error(`gemini batch create failed: ${batchRes.status} ${text}`);
+}
+async function fetchGeminiBatchStatus(params) {
+  const baseUrl = getGeminiBaseUrl(params.gemini);
+  const name = params.batchName.startsWith("batches/") ? params.batchName : `batches/${params.batchName}`;
+  const statusUrl = `${baseUrl}/${name}`;
+  const res = await fetch(statusUrl, {
+    headers: getGeminiHeaders(params.gemini, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`gemini batch status failed: ${res.status} ${text}`);
+  }
+  return await res.json();
+}
+async function fetchGeminiFileContent(params) {
+  const baseUrl = getGeminiBaseUrl(params.gemini);
+  const file = params.fileId.startsWith("files/") ? params.fileId : `files/${params.fileId}`;
+  const downloadUrl = `${baseUrl}/${file}:download`;
+  const res = await fetch(downloadUrl, {
+    headers: getGeminiHeaders(params.gemini, { json: true })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`gemini batch file content failed: ${res.status} ${text}`);
+  }
+  return await res.text();
+}
+function parseGeminiBatchOutput(text) {
+  if (!text.trim()) return [];
+  return text.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+}
+async function waitForGeminiBatch(params) {
+  const start = Date.now();
+  let current = params.initial;
+  while (true) {
+    const status = current ?? await fetchGeminiBatchStatus({
+      gemini: params.gemini,
+      batchName: params.batchName
+    });
+    const state = status.state ?? "UNKNOWN";
+    if (["SUCCEEDED", "COMPLETED", "DONE"].includes(state)) {
+      const outputFileId = status.outputConfig?.file ?? status.outputConfig?.fileId ?? status.metadata?.output?.responsesFile;
+      if (!outputFileId) {
+        throw new Error(`gemini batch ${params.batchName} completed without output file`);
+      }
+      return { outputFileId };
+    }
+    if (["FAILED", "CANCELLED", "CANCELED", "EXPIRED"].includes(state)) {
+      const message = status.error?.message ?? "unknown error";
+      throw new Error(`gemini batch ${params.batchName} ${state}: ${message}`);
+    }
+    if (!params.wait) {
+      throw new Error(`gemini batch ${params.batchName} still ${state}; wait disabled`);
+    }
+    if (Date.now() - start > params.timeoutMs) {
+      throw new Error(`gemini batch ${params.batchName} timed out after ${params.timeoutMs}ms`);
+    }
+    params.debug?.(`gemini batch ${params.batchName} ${state}; waiting ${params.pollIntervalMs}ms`);
+    await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+    current = void 0;
+  }
+}
+async function runWithConcurrency2(tasks, limit) {
+  if (tasks.length === 0) return [];
+  const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+  const results = Array.from({ length: tasks.length });
+  let next = 0;
+  let firstError = null;
+  const workers = Array.from({ length: resolvedLimit }, async () => {
+    while (true) {
+      if (firstError) return;
+      const index = next;
+      next += 1;
+      if (index >= tasks.length) return;
+      try {
+        results[index] = await tasks[index]();
+      } catch (err) {
+        firstError = err;
+        return;
+      }
+    }
+  });
+  await Promise.allSettled(workers);
+  if (firstError) throw firstError;
+  return results;
+}
+async function runGeminiEmbeddingBatches(params) {
+  if (params.requests.length === 0) return /* @__PURE__ */ new Map();
+  const groups = splitGeminiBatchRequests(params.requests);
+  const byCustomId = /* @__PURE__ */ new Map();
+  const tasks = groups.map((group, groupIndex) => async () => {
+    const batchInfo = await submitGeminiBatch({
+      gemini: params.gemini,
+      requests: group,
+      source: params.source
+    });
+    const batchName = batchInfo.name ?? "";
+    if (!batchName) {
+      throw new Error("gemini batch create failed: missing batch name");
+    }
+    params.debug?.("memory embeddings: gemini batch created", {
+      batchName,
+      state: batchInfo.state,
+      group: groupIndex + 1,
+      groups: groups.length,
+      requests: group.length
+    });
+    if (!params.wait && batchInfo.state && !["SUCCEEDED", "COMPLETED", "DONE"].includes(batchInfo.state)) {
+      throw new Error(
+        `gemini batch ${batchName} submitted; enable batch.wait to await completion`
+      );
+    }
+    const completed = batchInfo.state && ["SUCCEEDED", "COMPLETED", "DONE"].includes(batchInfo.state) ? {
+      outputFileId: batchInfo.outputConfig?.file ?? batchInfo.outputConfig?.fileId ?? batchInfo.metadata?.output?.responsesFile ?? ""
+    } : await waitForGeminiBatch({
+      gemini: params.gemini,
+      batchName,
+      wait: params.wait,
+      pollIntervalMs: params.pollIntervalMs,
+      timeoutMs: params.timeoutMs,
+      debug: params.debug,
+      initial: batchInfo
+    });
+    if (!completed.outputFileId) {
+      throw new Error(`gemini batch ${batchName} completed without output file`);
+    }
+    const content = await fetchGeminiFileContent({
+      gemini: params.gemini,
+      fileId: completed.outputFileId
+    });
+    const outputLines = parseGeminiBatchOutput(content);
+    const errors = [];
+    const remaining = new Set(group.map((request) => request.custom_id));
+    for (const line of outputLines) {
+      const customId = line.key ?? line.custom_id ?? line.request_id;
+      if (!customId) continue;
+      remaining.delete(customId);
+      if (line.error?.message) {
+        errors.push(`${customId}: ${line.error.message}`);
+        continue;
+      }
+      if (line.response?.error?.message) {
+        errors.push(`${customId}: ${line.response.error.message}`);
+        continue;
+      }
+      const embedding = line.embedding?.values ?? line.response?.embedding?.values ?? [];
+      if (embedding.length === 0) {
+        errors.push(`${customId}: empty embedding`);
+        continue;
+      }
+      byCustomId.set(customId, embedding);
+    }
+    if (errors.length > 0) {
+      throw new Error(`gemini batch ${batchName} failed: ${errors.join("; ")}`);
+    }
+    if (remaining.size > 0) {
+      throw new Error(`gemini batch ${batchName} missing ${remaining.size} embedding responses`);
+    }
+  });
+  params.debug?.("memory embeddings: gemini batch submit", {
+    requests: params.requests.length,
+    groups: groups.length,
+    wait: params.wait,
+    concurrency: params.concurrency,
+    pollIntervalMs: params.pollIntervalMs,
+    timeoutMs: params.timeoutMs
+  });
+  await runWithConcurrency2(tasks, params.concurrency);
+  return byCustomId;
+}
+
+// src/minimem.ts
+function resolveMinimemSubdir(memoryDir) {
+  const envDir = process.env.MINIMEM_CONFIG_DIR;
+  if (envDir) return envDir;
+  if (import_node_fs3.default.existsSync(import_node_path3.default.join(memoryDir, "config.json"))) return ".";
+  const swarmDir = import_node_path3.default.join(memoryDir, ".swarm", "minimem");
+  if (import_node_fs3.default.existsSync(import_node_path3.default.join(swarmDir, "config.json"))) return import_node_path3.default.join(".swarm", "minimem");
+  return ".minimem";
+}
+var META_KEY = "memory_index_meta_v1";
+var SNIPPET_MAX_CHARS = 700;
+var VECTOR_TABLE = "chunks_vec";
+var FTS_TABLE = "chunks_fts";
+var EMBEDDING_CACHE_TABLE = "embedding_cache";
+var EMBEDDING_RETRY_MAX_ATTEMPTS = 3;
+var EMBEDDING_RETRY_BASE_DELAY_MS = 500;
+var EMBEDDING_RETRY_MAX_DELAY_MS = 8e3;
+var EMBEDDING_QUERY_TIMEOUT_REMOTE_MS = 6e4;
+var EMBEDDING_QUERY_TIMEOUT_LOCAL_MS = 5 * 6e4;
+var Minimem = class _Minimem {
+  memoryDir;
+  dbPath;
+  chunking;
+  cache;
+  hybrid;
+  queryConfig;
+  watchConfig;
+  batchConfig;
+  vectorExtensionPath;
+  debug;
+  provider;
+  openAi;
+  gemini;
+  providerKey = "";
+  providerFallbackReason;
+  db;
+  vector;
+  fts;
+  vectorReady = null;
+  watcher = null;
+  watchTimer = null;
+  closed = false;
+  dirty = true;
+  syncing = null;
+  syncLock = false;
+  embeddingOptions;
+  constructor(config) {
+    this.memoryDir = import_node_path3.default.resolve(config.memoryDir);
+    this.dbPath = config.dbPath ?? import_node_path3.default.join(this.memoryDir, resolveMinimemSubdir(this.memoryDir), "index.db");
+    this.chunking = {
+      tokens: config.chunking?.tokens ?? 256,
+      overlap: config.chunking?.overlap ?? 32
+    };
+    this.cache = {
+      enabled: config.cache?.enabled ?? true,
+      maxEntries: config.cache?.maxEntries ?? 1e4
+    };
+    this.hybrid = {
+      enabled: config.hybrid?.enabled ?? true,
+      vectorWeight: config.hybrid?.vectorWeight ?? 0.7,
+      textWeight: config.hybrid?.textWeight ?? 0.3,
+      candidateMultiplier: config.hybrid?.candidateMultiplier ?? 2
+    };
+    this.queryConfig = {
+      maxResults: config.query?.maxResults ?? 10,
+      minScore: config.query?.minScore ?? 0.3
+    };
+    this.watchConfig = {
+      enabled: config.watch?.enabled ?? true,
+      debounceMs: config.watch?.debounceMs ?? 1e3
+    };
+    this.batchConfig = {
+      enabled: config.batch?.enabled ?? false,
+      wait: config.batch?.wait ?? true,
+      concurrency: config.batch?.concurrency ?? 2,
+      pollIntervalMs: config.batch?.pollIntervalMs ?? 2e3,
+      timeoutMs: config.batch?.timeoutMs ?? 60 * 60 * 1e3
+    };
+    this.vectorExtensionPath = config.vectorExtensionPath;
+    this.debug = config.debug;
+    this.embeddingOptions = config.embedding;
+    this.vector = {
+      enabled: true,
+      available: null,
+      extensionPath: this.vectorExtensionPath
+    };
+    this.fts = { enabled: this.hybrid.enabled, available: false };
+  }
+  static async create(config) {
+    const instance = new _Minimem(config);
+    await instance.initialize();
+    return instance;
+  }
+  async initialize() {
+    const providerResult = await createEmbeddingProvider(this.embeddingOptions);
+    this.provider = providerResult.provider;
+    this.openAi = providerResult.openAi;
+    this.gemini = providerResult.gemini;
+    this.providerKey = this.computeProviderKey();
+    this.providerFallbackReason = providerResult.fallbackReason;
+    if (this.provider.id === "none") {
+      this.debug?.("Running in BM25-only mode (no embedding API available)");
+    }
+    this.db = this.openDatabase();
+    this.ensureSchema();
+    const meta = this.readMeta();
+    if (meta?.vectorDims) {
+      this.vector.dims = meta.vectorDims;
+    }
+    if (this.watchConfig.enabled) {
+      this.ensureWatcher();
+    }
+  }
+  openDatabase() {
+    const dbDir = import_node_path3.default.dirname(this.dbPath);
+    ensureDir(dbDir);
+    return new import_node_sqlite.DatabaseSync(this.dbPath);
+  }
+  ensureSchema() {
+    const result = ensureMemoryIndexSchema({
+      db: this.db,
+      embeddingCacheTable: EMBEDDING_CACHE_TABLE,
+      ftsTable: FTS_TABLE,
+      ftsEnabled: this.fts.enabled
+    });
+    this.fts.available = result.ftsAvailable;
+    if (result.ftsError) {
+      this.fts.loadError = result.ftsError;
+    }
+  }
+  computeProviderKey() {
+    const parts = [this.provider.id, this.provider.model];
+    if (this.openAi) {
+      parts.push(this.openAi.baseUrl);
+    }
+    if (this.gemini) {
+      parts.push(this.gemini.baseUrl);
+    }
+    return hashText(parts.join(":"));
+  }
+  readMeta() {
+    try {
+      const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY);
+      if (!row?.value) return null;
+      return JSON.parse(row.value);
+    } catch {
+      return null;
+    }
+  }
+  writeMeta(meta) {
+    this.db.prepare(`INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)`).run(META_KEY, JSON.stringify(meta));
+  }
+  ensureWatcher() {
+    if (this.watcher) return;
+    const memorySubDir = import_node_path3.default.join(this.memoryDir, "memory");
+    const memoryFile = import_node_path3.default.join(this.memoryDir, "MEMORY.md");
+    this.watcher = import_chokidar.default.watch([memoryFile, memorySubDir], {
+      ignoreInitial: true,
+      persistent: true,
+      awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+    });
+    const scheduleSync = () => {
+      this.dirty = true;
+      if (this.watchTimer) clearTimeout(this.watchTimer);
+      this.watchTimer = setTimeout(() => {
+        void this.sync({ reason: "watch" }).catch((err) => {
+          this.debug?.(`memory sync failed (watch): ${String(err)}`);
+        });
+      }, this.watchConfig.debounceMs);
+    };
+    this.watcher.on("add", scheduleSync);
+    this.watcher.on("change", scheduleSync);
+    this.watcher.on("unlink", scheduleSync);
+  }
+  /**
+   * Check if the index is stale by comparing file mtimes against stored values.
+   * This is a lightweight check (stat calls only, no file reads).
+   */
+  async isStale() {
+    try {
+      const files = await listMemoryFiles(this.memoryDir);
+      const stored = this.db.prepare(`SELECT path, mtime FROM files WHERE source = ?`).all("memory");
+      if (files.length !== stored.length) {
+        this.debug?.(`Stale: file count changed (${stored.length} -> ${files.length})`);
+        return true;
+      }
+      const storedMap = new Map(stored.map((f) => [f.path, f.mtime]));
+      for (const absPath of files) {
+        const relPath = import_node_path3.default.relative(this.memoryDir, absPath).replace(/\\/g, "/");
+        const storedMtime = storedMap.get(relPath);
+        if (storedMtime === void 0) {
+          this.debug?.(`Stale: new file ${relPath}`);
+          return true;
+        }
+        const stat = await import_promises2.default.stat(absPath);
+        const currentMtime = Math.floor(stat.mtimeMs);
+        if (currentMtime !== storedMtime) {
+          this.debug?.(`Stale: mtime changed for ${relPath}`);
+          return true;
+        }
+      }
+      return false;
+    } catch (err) {
+      this.debug?.(`Stale check failed: ${String(err)}`);
+      return true;
+    }
+  }
+  async search(query, opts) {
+    if (this.dirty || !this.watchConfig.enabled && await this.isStale()) {
+      await this.sync({ reason: "search" });
+    }
+    const cleaned = query.trim();
+    if (!cleaned) return [];
+    const minScore = opts?.minScore ?? this.queryConfig.minScore;
+    const maxResults = opts?.maxResults ?? this.queryConfig.maxResults;
+    const candidates = Math.min(
+      200,
+      Math.max(1, Math.floor(maxResults * this.hybrid.candidateMultiplier))
+    );
+    const sourceFilter = { sql: "", params: [] };
+    const keywordResults = this.hybrid.enabled && this.fts.available ? await searchKeyword({
+      db: this.db,
+      ftsTable: FTS_TABLE,
+      providerModel: this.provider.model,
+      query: cleaned,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS,
+      sourceFilter,
+      buildFtsQuery,
+      bm25RankToScore
+    }).catch(() => []) : [];
+    const queryVec = await this.embedQueryWithTimeout(cleaned);
+    const hasVector = queryVec.some((v) => v !== 0);
+    const vectorResults = hasVector ? await searchVector({
+      db: this.db,
+      vectorTable: VECTOR_TABLE,
+      providerModel: this.provider.model,
+      queryVec,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS,
+      ensureVectorReady: (dims) => this.ensureVectorReady(dims),
+      sourceFilterVec: sourceFilter,
+      sourceFilterChunks: sourceFilter
+    }).catch(() => []) : [];
+    const typeFilterFn = opts?.type ? (id) => {
+      const row = this.db.prepare(`SELECT type FROM chunks WHERE id = ?`).get(id);
+      return row?.type === opts.type;
+    } : void 0;
+    if (!this.hybrid.enabled) {
+      let results = vectorResults;
+      if (typeFilterFn) results = results.filter((r) => typeFilterFn(r.id));
+      return results.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        score: r.score,
+        snippet: r.snippet
+      }));
+    }
+    let filteredVector = vectorResults;
+    let filteredKeyword = keywordResults;
+    if (typeFilterFn) {
+      filteredVector = vectorResults.filter((r) => typeFilterFn(r.id));
+      filteredKeyword = keywordResults.filter((r) => typeFilterFn(r.id));
+    }
+    const merged = mergeHybridResults({
+      vector: filteredVector.map((r) => ({
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        vectorScore: r.score
+      })),
+      keyword: filteredKeyword.map((r) => ({
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        textScore: r.textScore
+      })),
+      vectorWeight: this.hybrid.vectorWeight,
+      textWeight: this.hybrid.textWeight
+    });
+    return merged.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+      path: r.path,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      score: r.score,
+      snippet: r.snippet
+    }));
+  }
+  async sync(opts) {
+    if (this.syncing) {
+      await this.syncing;
+      return;
+    }
+    if (this.syncLock) {
+      return;
+    }
+    this.syncLock = true;
+    this.syncing = this.runSync(opts);
+    try {
+      await this.syncing;
+    } finally {
+      this.syncing = null;
+      this.syncLock = false;
+    }
+  }
+  async runSync(opts) {
+    this.debug?.(`memory sync starting`, { reason: opts?.reason });
+    await this.ensureVectorReady();
+    const meta = this.readMeta();
+    const needsFullReindex = opts?.force || !meta || meta.model !== this.provider.model || meta.provider !== this.provider.id || meta.providerKey !== this.providerKey || meta.chunkTokens !== this.chunking.tokens || meta.chunkOverlap !== this.chunking.overlap || this.vector.available && !meta?.vectorDims;
+    const files = await listMemoryFiles(this.memoryDir);
+    const activePaths = /* @__PURE__ */ new Set();
+    for (const absPath of files) {
+      const entry = await buildFileEntry(absPath, this.memoryDir);
+      activePaths.add(entry.path);
+      const record = this.db.prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`).get(entry.path, "memory");
+      if (!needsFullReindex && record?.hash === entry.hash) {
+        continue;
+      }
+      await this.indexFile(entry);
+    }
+    const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("memory");
+    for (const stale of staleRows) {
+      if (activePaths.has(stale.path)) continue;
+      this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "memory");
+      try {
+        this.db.prepare(
+          `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
+        ).run(stale.path, "memory");
+      } catch (err) {
+        logError("deleteStaleVectorEntries", err, this.debug);
+      }
+      this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(stale.path, "memory");
+      this.db.prepare(`DELETE FROM knowledge_links WHERE source_path = ?`).run(stale.path);
+      if (this.fts.enabled && this.fts.available) {
+        try {
+          this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`).run(stale.path, "memory", this.provider.model);
+        } catch (err) {
+          logError("deleteStaleFtsEntries", err, this.debug);
+        }
+      }
+    }
+    this.writeMeta({
+      model: this.provider.model,
+      provider: this.provider.id,
+      providerKey: this.providerKey,
+      chunkTokens: this.chunking.tokens,
+      chunkOverlap: this.chunking.overlap,
+      vectorDims: this.vector.dims
+    });
+    this.pruneEmbeddingCacheIfNeeded();
+    this.dirty = false;
+    this.debug?.(`memory sync complete`, { files: files.length });
+  }
+  async indexFile(entry) {
+    const content = await import_promises2.default.readFile(entry.absPath, "utf-8");
+    const chunks = chunkMarkdown(content, this.chunking);
+    const { frontmatter } = parseFrontmatter(content);
+    const knowledgeType = frontmatter?.type ?? null;
+    const knowledgeId = frontmatter?.id ?? null;
+    const domains = frontmatter?.domain ?? null;
+    const entities = frontmatter?.entities ?? null;
+    const confidence = frontmatter?.confidence ?? null;
+    const links = frontmatter?.links ?? null;
+    const embeddings = await this.embedChunks(chunks);
+    this.db.prepare(
+      `INSERT OR REPLACE INTO files (path, source, hash, mtime, size) VALUES (?, ?, ?, ?, ?)`
+    ).run(entry.path, "memory", entry.hash, Math.floor(entry.mtimeMs), entry.size);
+    try {
+      this.db.prepare(
+        `DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
+      ).run(entry.path, "memory");
+    } catch (err) {
+      logError("deleteOldVectorChunks", err, this.debug);
+    }
+    this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(entry.path, "memory");
+    if (this.fts.enabled && this.fts.available) {
+      try {
+        this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`).run(entry.path, "memory", this.provider.model);
+      } catch (err) {
+        logError("deleteOldFtsChunks", err, this.debug);
+      }
+    }
+    this.db.prepare(`DELETE FROM knowledge_links WHERE source_path = ?`).run(entry.path);
+    const now = Date.now();
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const embedding = embeddings[i] ?? [];
+      const chunkId = (0, import_node_crypto2.randomUUID)();
+      const meta = extractChunkMetadata(chunk.text);
+      this.db.prepare(
+        `INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at, type, knowledge_type, knowledge_id, domains, entities, confidence)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        chunkId,
+        entry.path,
+        "memory",
+        chunk.startLine,
+        chunk.endLine,
+        chunk.hash,
+        this.provider.model,
+        chunk.text,
+        JSON.stringify(embedding),
+        now,
+        meta.type ?? null,
+        knowledgeType,
+        knowledgeId,
+        domains ? JSON.stringify(domains) : null,
+        entities ? JSON.stringify(entities) : null,
+        confidence
+      );
+      if (this.vector.available && embedding.length > 0) {
+        if (!this.vector.dims) {
+          this.vector.dims = embedding.length;
+          this.ensureVectorTable(embedding.length);
+        }
+        try {
+          this.db.prepare(`INSERT INTO ${VECTOR_TABLE} (id, embedding) VALUES (?, ?)`).run(chunkId, vectorToBlob(embedding));
+        } catch (err) {
+          logError("insertVectorChunk", err, this.debug);
+        }
+      }
+      if (this.fts.enabled && this.fts.available) {
+        try {
+          this.db.prepare(
+            `INSERT INTO ${FTS_TABLE} (text, id, path, source, model, start_line, end_line)
+               VALUES (?, ?, ?, ?, ?, ?, ?)`
+          ).run(
+            chunk.text,
+            chunkId,
+            entry.path,
+            "memory",
+            this.provider.model,
+            chunk.startLine,
+            chunk.endLine
+          );
+        } catch (err) {
+          logError("insertFtsChunk", err, this.debug);
+        }
+      }
+    }
+    if (links && knowledgeId) {
+      const upsertLink = this.db.prepare(
+        `INSERT OR REPLACE INTO knowledge_links (from_id, to_id, relation, layer, weight, source_path, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      );
+      for (const link of links) {
+        upsertLink.run(
+          knowledgeId,
+          link.target,
+          link.relation,
+          link.layer ?? null,
+          0.5,
+          entry.path,
+          now
+        );
+      }
+    }
+  }
+  async embedChunks(chunks) {
+    if (chunks.length === 0) return [];
+    const hashes = chunks.map((c) => c.hash);
+    const cached = this.loadEmbeddingCache(hashes);
+    const missing = [];
+    for (let i = 0; i < chunks.length; i++) {
+      if (!cached.has(hashes[i])) {
+        missing.push({ index: i, chunk: chunks[i] });
+      }
+    }
+    if (missing.length > 0) {
+      const texts = missing.map((m) => m.chunk.text);
+      const newEmbeddings = await this.embedBatchWithRetry(texts);
+      for (let i = 0; i < missing.length; i++) {
+        const hash = missing[i].chunk.hash;
+        const embedding = newEmbeddings[i] ?? [];
+        cached.set(hash, embedding);
+        this.upsertEmbeddingCache(hash, embedding);
+      }
+    }
+    return hashes.map((h) => cached.get(h) ?? []);
+  }
+  async embedBatchWithRetry(texts) {
+    if (texts.length === 0) return [];
+    if (this.batchConfig.enabled) {
+      try {
+        return await this.embedWithBatchApi(texts);
+      } catch (err) {
+        this.debug?.(`batch embedding failed, falling back to direct: ${String(err)}`);
+      }
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < EMBEDDING_RETRY_MAX_ATTEMPTS; attempt++) {
+      try {
+        return await this.provider.embedBatch(texts);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < EMBEDDING_RETRY_MAX_ATTEMPTS - 1) {
+          const delay = Math.min(
+            EMBEDDING_RETRY_MAX_DELAY_MS,
+            EMBEDDING_RETRY_BASE_DELAY_MS * Math.pow(2, attempt)
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  async embedWithBatchApi(texts) {
+    if (this.openAi) {
+      const requests = texts.map((text, i) => ({
+        custom_id: `chunk-${i}`,
+        method: "POST",
+        url: OPENAI_BATCH_ENDPOINT,
+        body: { model: this.openAi.model, input: text }
+      }));
+      const results = await runOpenAiEmbeddingBatches({
+        openAi: this.openAi,
+        source: "minimem",
+        requests,
+        wait: this.batchConfig.wait,
+        pollIntervalMs: this.batchConfig.pollIntervalMs,
+        timeoutMs: this.batchConfig.timeoutMs,
+        concurrency: this.batchConfig.concurrency,
+        debug: this.debug
+      });
+      return texts.map((_, i) => results.get(`chunk-${i}`) ?? []);
+    }
+    if (this.gemini) {
+      const requests = texts.map((text, i) => ({
+        custom_id: `chunk-${i}`,
+        content: { parts: [{ text }] },
+        taskType: "RETRIEVAL_DOCUMENT"
+      }));
+      const results = await runGeminiEmbeddingBatches({
+        gemini: this.gemini,
+        source: "minimem",
+        requests,
+        wait: this.batchConfig.wait,
+        pollIntervalMs: this.batchConfig.pollIntervalMs,
+        timeoutMs: this.batchConfig.timeoutMs,
+        concurrency: this.batchConfig.concurrency,
+        debug: this.debug
+      });
+      return texts.map((_, i) => results.get(`chunk-${i}`) ?? []);
+    }
+    throw new Error("Batch API not available for local embeddings");
+  }
+  async embedQueryWithTimeout(text) {
+    const timeout = this.provider.id === "local" ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeout);
+    try {
+      const result = await Promise.race([
+        this.provider.embedQuery(text),
+        new Promise((_, reject) => {
+          ac.signal.addEventListener(
+            "abort",
+            () => reject(new Error("embedding query timeout"))
+          );
+        })
+      ]);
+      return result;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  loadEmbeddingCache(hashes) {
+    const result = /* @__PURE__ */ new Map();
+    if (!this.cache.enabled || hashes.length === 0) return result;
+    const placeholders = hashes.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT hash, embedding FROM ${EMBEDDING_CACHE_TABLE}
+         WHERE provider = ? AND model = ? AND provider_key = ? AND hash IN (${placeholders})`
+    ).all(this.provider.id, this.provider.model, this.providerKey, ...hashes);
+    const now = Date.now();
+    for (const row of rows) {
+      result.set(row.hash, parseEmbedding(row.embedding));
+      this.db.prepare(
+        `UPDATE ${EMBEDDING_CACHE_TABLE} SET updated_at = ?
+           WHERE provider = ? AND model = ? AND provider_key = ? AND hash = ?`
+      ).run(now, this.provider.id, this.provider.model, this.providerKey, row.hash);
+    }
+    return result;
+  }
+  upsertEmbeddingCache(hash, embedding) {
+    if (!this.cache.enabled) return;
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO ${EMBEDDING_CACHE_TABLE}
+         (provider, model, provider_key, hash, embedding, dims, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      this.provider.id,
+      this.provider.model,
+      this.providerKey,
+      hash,
+      JSON.stringify(embedding),
+      embedding.length,
+      now
+    );
+  }
+  pruneEmbeddingCacheIfNeeded() {
+    if (!this.cache.enabled) return;
+    const row = this.db.prepare(`SELECT COUNT(*) as count FROM ${EMBEDDING_CACHE_TABLE}`).get();
+    if (row.count <= this.cache.maxEntries) return;
+    const excess = row.count - this.cache.maxEntries;
+    this.db.prepare(
+      `DELETE FROM ${EMBEDDING_CACHE_TABLE}
+         WHERE rowid IN (
+           SELECT rowid FROM ${EMBEDDING_CACHE_TABLE}
+           ORDER BY updated_at ASC
+           LIMIT ?
+         )`
+    ).run(excess);
+  }
+  async ensureVectorReady(dimensions) {
+    if (this.vector.available === true) return true;
+    if (this.vector.available === false) return false;
+    if (!this.vectorReady) {
+      this.vectorReady = this.loadVectorExtension();
+    }
+    const ready = await this.vectorReady;
+    if (ready && dimensions && !this.vector.dims) {
+      this.vector.dims = dimensions;
+      this.ensureVectorTable(dimensions);
+    }
+    return ready;
+  }
+  async loadVectorExtension() {
+    const result = await loadSqliteVecExtension({
+      db: this.db,
+      extensionPath: this.vectorExtensionPath
+    });
+    this.vector.available = result.ok;
+    if (result.error) {
+      this.vector.loadError = result.error;
+      this.debug?.(`sqlite-vec load failed: ${result.error}`);
+    }
+    if (result.extensionPath) {
+      this.vector.extensionPath = result.extensionPath;
+    }
+    return result.ok;
+  }
+  ensureVectorTable(dimensions) {
+    if (!this.vector.available) return;
+    try {
+      this.db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${VECTOR_TABLE} USING vec0(
+          id TEXT PRIMARY KEY,
+          embedding FLOAT[${dimensions}]
+        )`
+      );
+    } catch (err) {
+      this.debug?.(`vector table creation failed: ${String(err)}`);
+    }
+  }
+  async readFile(relativePath) {
+    const absPath = import_node_path3.default.join(this.memoryDir, relativePath);
+    try {
+      return await import_promises2.default.readFile(absPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Read specific lines from a memory file
+   */
+  async readLines(relativePath, opts) {
+    const content = await this.readFile(relativePath);
+    if (content === null) return null;
+    const allLines = content.split("\n");
+    const from = Math.max(1, opts?.from ?? 1);
+    const lines = opts?.lines ?? allLines.length;
+    const startIdx = from - 1;
+    const endIdx = Math.min(startIdx + lines, allLines.length);
+    const selectedLines = allLines.slice(startIdx, endIdx);
+    return {
+      content: selectedLines.join("\n"),
+      startLine: from,
+      endLine: startIdx + selectedLines.length
+    };
+  }
+  /**
+   * Write content to a memory file (creates or overwrites)
+   */
+  async writeFile(relativePath, content) {
+    this.validateMemoryPath(relativePath);
+    const absPath = import_node_path3.default.join(this.memoryDir, relativePath);
+    const dir = import_node_path3.default.dirname(absPath);
+    await import_promises2.default.mkdir(dir, { recursive: true });
+    await import_promises2.default.writeFile(absPath, content, "utf-8");
+    this.dirty = true;
+    this.debug?.(`memory write: ${relativePath}`);
+  }
+  /**
+   * Append content to a memory file (creates if doesn't exist)
+   */
+  async appendFile(relativePath, content) {
+    this.validateMemoryPath(relativePath);
+    const absPath = import_node_path3.default.join(this.memoryDir, relativePath);
+    const dir = import_node_path3.default.dirname(absPath);
+    await import_promises2.default.mkdir(dir, { recursive: true });
+    let toAppend = content;
+    try {
+      const existing = await import_promises2.default.readFile(absPath, "utf-8");
+      if (existing.length > 0 && !existing.endsWith("\n")) {
+        toAppend = "\n" + content;
+      }
+    } catch {
+    }
+    await import_promises2.default.appendFile(absPath, toAppend, "utf-8");
+    this.dirty = true;
+    this.debug?.(`memory append: ${relativePath}`);
+  }
+  /**
+   * Append content to today's daily log (memory/YYYY-MM-DD.md)
+   */
+  async appendToday(content) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const relativePath = `memory/${today}.md`;
+    await this.appendFile(relativePath, content);
+    return relativePath;
+  }
+  /**
+   * List all memory files
+   */
+  async listFiles() {
+    const files = await listMemoryFiles(this.memoryDir);
+    return files.map((f) => import_node_path3.default.relative(this.memoryDir, f).replace(/\\/g, "/"));
+  }
+  /**
+   * Validate that a path is within allowed memory locations
+   */
+  validateMemoryPath(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (normalized === "MEMORY.md" || normalized === "memory.md") {
+      return;
+    }
+    if (normalized.startsWith("memory/") && normalized.endsWith(".md")) {
+      if (normalized.includes("..")) {
+        throw new Error(`Invalid memory path: ${relativePath} (path traversal not allowed)`);
+      }
+      return;
+    }
+    throw new Error(
+      `Invalid memory path: ${relativePath}. Must be MEMORY.md or memory/*.md`
+    );
+  }
+  async status() {
+    const fileRow = this.db.prepare(`SELECT COUNT(*) as count FROM files`).get();
+    const chunkRow = this.db.prepare(`SELECT COUNT(*) as count FROM chunks`).get();
+    const cacheRow = this.db.prepare(`SELECT COUNT(*) as count FROM ${EMBEDDING_CACHE_TABLE}`).get();
+    return {
+      memoryDir: this.memoryDir,
+      dbPath: this.dbPath,
+      provider: this.provider.id,
+      model: this.provider.model,
+      vectorAvailable: this.vector.available === true,
+      ftsAvailable: this.fts.available,
+      bm25Only: this.provider.id === "none",
+      fallbackReason: this.providerFallbackReason,
+      fileCount: fileRow.count,
+      chunkCount: chunkRow.count,
+      cacheCount: cacheRow.count
+    };
+  }
+  /**
+   * Search with knowledge metadata filters (domain, entities, confidence, type).
+   * Runs a standard search then post-filters by knowledge columns.
+   */
+  async knowledgeSearch(query, opts) {
+    if (this.dirty || !this.watchConfig.enabled && await this.isStale()) {
+      await this.sync({ reason: "knowledgeSearch" });
+    }
+    const cleaned = query.trim();
+    if (!cleaned) return [];
+    const minScore = opts?.minScore ?? this.queryConfig.minScore;
+    const maxResults = opts?.maxResults ?? this.queryConfig.maxResults;
+    const { sql: knowledgeWhere, params: knowledgeParams } = buildKnowledgeFilterSql({
+      domain: opts?.domain,
+      entities: opts?.entities,
+      minConfidence: opts?.minConfidence,
+      knowledgeType: opts?.knowledgeType
+    });
+    if (!knowledgeWhere) {
+      return this.search(query, { maxResults, minScore });
+    }
+    const matchingRows = this.db.prepare(
+      `SELECT id FROM chunks c WHERE c.model = ? AND c.source = 'memory'${knowledgeWhere}`
+    ).all(this.provider.model, ...knowledgeParams);
+    const matchingIds = new Set(matchingRows.map((r) => r.id));
+    if (matchingIds.size === 0) return [];
+    const overFetch = Math.max(maxResults * 3, 30);
+    const results = await this.search(query, {
+      maxResults: overFetch,
+      minScore
+    });
+    const filtered = [];
+    for (const r of results) {
+      const row = this.db.prepare(
+        `SELECT id FROM chunks WHERE path = ? AND start_line = ? AND end_line = ? AND model = ?`
+      ).get(r.path, r.startLine, r.endLine, this.provider.model);
+      if (row && matchingIds.has(row.id)) {
+        filtered.push(r);
+        if (filtered.length >= maxResults) break;
+      }
+    }
+    return filtered;
+  }
+  /**
+   * Get knowledge graph links from or to a node.
+   */
+  getLinks(nodeId, direction = "from", opts) {
+    if (direction === "from") {
+      return getLinksFrom(this.db, nodeId, opts);
+    }
+    return getLinksTo(this.db, nodeId, opts);
+  }
+  /**
+   * Get neighbor nodes via BFS traversal.
+   */
+  getGraphNeighbors(nodeId, depth = 1, opts) {
+    return getNeighbors(this.db, nodeId, depth, opts);
+  }
+  /**
+   * Find shortest path between two knowledge nodes.
+   */
+  getGraphPath(fromId, toId, maxDepth = 3) {
+    return getPathBetween(this.db, fromId, toId, maxDepth);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.watchTimer) {
+      clearTimeout(this.watchTimer);
+      this.watchTimer = null;
+    }
+    if (this.watcher) {
+      void this.watcher.close();
+      this.watcher = null;
+    }
+    try {
+      this.db.close();
+    } catch (err) {
+      logError("dbClose", err, this.debug);
+    }
+  }
+};
+
+// src/server/tools.ts
+var MEMORY_SEARCH_TOOL = {
+  name: "memory_search",
+  description: "Semantically search through memory files (MEMORY.md and memory/*.md). Use this to recall prior decisions, facts, preferences, people, dates, or context. Returns ranked snippets with file paths and line numbers. When multiple memory directories are configured, searches all by default.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Natural language search query"
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results to return (default: 10)"
+      },
+      minScore: {
+        type: "number",
+        description: "Minimum relevance score threshold 0-1 (default: 0.3)"
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories by name/path. If omitted, searches all configured directories."
+      },
+      detail: {
+        type: "string",
+        enum: ["compact", "full"],
+        description: "Result detail level. 'compact' returns a lightweight index with short previews (~80 chars). 'full' returns complete snippets. Use 'compact' first, then memory_get_details for selected results. (default: 'compact')"
+      },
+      type: {
+        type: "string",
+        description: "Filter by observation type. Matches <!-- type: X --> comments in memory entries. Common types: decision, bugfix, feature, discovery, context, note."
+      }
+    },
+    required: ["query"]
+  }
+};
+var MEMORY_GET_DETAILS_TOOL = {
+  name: "memory_get_details",
+  description: "Fetch full text for specific memory chunks identified by path and line range. Use after memory_search with compact results to get details for selected items only. This two-step approach significantly reduces token usage.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      results: {
+        type: "array",
+        items: { type: "object" },
+        description: "Array of { path, startLine, endLine } objects from compact search results."
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories."
+      }
+    },
+    required: ["results"]
+  }
+};
+var KNOWLEDGE_SEARCH_TOOL = {
+  name: "knowledge_search",
+  description: "Search memory with knowledge metadata filters. Filter by domain, entities, confidence level, or knowledge type (observation, entity, domain-summary). Combines semantic search with structured knowledge filtering.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Natural language search query"
+      },
+      domain: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter to entries in these knowledge domains"
+      },
+      entities: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter to entries referencing these entities"
+      },
+      minConfidence: {
+        type: "number",
+        description: "Minimum confidence threshold (0-1)"
+      },
+      knowledgeType: {
+        type: "string",
+        description: "Filter by knowledge type: observation, entity, domain-summary"
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results (default: 10)"
+      },
+      minScore: {
+        type: "number",
+        description: "Minimum relevance score 0-1 (default: 0.3)"
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
+      }
+    },
+    required: ["query"]
+  }
+};
+var KNOWLEDGE_GRAPH_TOOL = {
+  name: "knowledge_graph",
+  description: "Traverse knowledge graph links from a note. Returns neighbor nodes connected by typed relationships (e.g., relates-to, supports, contradicts). Use depth parameter for multi-hop traversal.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      nodeId: {
+        type: "string",
+        description: "The knowledge node ID to start traversal from"
+      },
+      depth: {
+        type: "number",
+        description: "Maximum traversal depth (default: 1, max: 3)",
+        default: 1
+      },
+      relation: {
+        type: "string",
+        description: "Optional: filter to specific relation type"
+      },
+      layer: {
+        type: "string",
+        description: "Optional: filter to specific graph layer"
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
+      }
+    },
+    required: ["nodeId"]
+  }
+};
+var KNOWLEDGE_PATH_TOOL = {
+  name: "knowledge_path",
+  description: "Find the shortest path between two knowledge nodes in the graph. Uses BFS traversal up to a configurable max depth. Returns the sequence of links connecting the two nodes.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      fromId: {
+        type: "string",
+        description: "Starting knowledge node ID"
+      },
+      toId: {
+        type: "string",
+        description: "Target knowledge node ID"
+      },
+      maxDepth: {
+        type: "number",
+        description: "Maximum path length (default: 3)",
+        default: 3
+      },
+      directories: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional: filter to specific memory directories"
+      }
+    },
+    required: ["fromId", "toId"]
+  }
+};
+var MEMORY_TOOLS = [
+  MEMORY_SEARCH_TOOL,
+  MEMORY_GET_DETAILS_TOOL,
+  KNOWLEDGE_SEARCH_TOOL,
+  KNOWLEDGE_GRAPH_TOOL,
+  KNOWLEDGE_PATH_TOOL
+];
+function getToolDefinitions() {
+  return MEMORY_TOOLS;
+}
+var MemoryToolExecutor = class {
+  instances;
+  constructor(instances) {
+    if (Array.isArray(instances)) {
+      this.instances = instances;
+    } else if ("minimem" in instances) {
+      this.instances = [instances];
+    } else {
+      this.instances = [{ minimem: instances, memoryDir: "default" }];
+    }
+  }
+  /**
+   * Get list of configured directory names/paths
+   */
+  getDirectories() {
+    return this.instances.map((i) => i.name ?? i.memoryDir);
+  }
+  /**
+   * Execute a tool by name with given parameters
+   */
+  async execute(toolName, params) {
+    try {
+      switch (toolName) {
+        case "memory_search":
+          return await this.memorySearch(params);
+        case "memory_get_details":
+          return await this.memoryGetDetails(params);
+        case "knowledge_search":
+          return await this.knowledgeSearch(params);
+        case "knowledge_graph":
+          return await this.knowledgeGraph(params);
+        case "knowledge_path":
+          return await this.knowledgePath(params);
+        default:
+          return {
+            content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+            isError: true
+          };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Filter instances by directory names/paths
+   */
+  filterInstances(directories) {
+    if (!directories || directories.length === 0) return this.instances;
+    const dirFilter = new Set(directories.map((d) => d.toLowerCase()));
+    const filtered = this.instances.filter((i) => {
+      const name = (i.name ?? i.memoryDir).toLowerCase();
+      const dir = i.memoryDir.toLowerCase();
+      return dirFilter.has(name) || dirFilter.has(dir) || [...dirFilter].some((f) => dir.includes(f) || name.includes(f));
+    });
+    return filtered.length > 0 ? filtered : null;
+  }
+  async memorySearch(params) {
+    const maxResults = params.maxResults ?? 10;
+    const minScore = params.minScore;
+    const detail = params.detail ?? "compact";
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No matching directories found. Available: ${available}`
+          }
+        ],
+        isError: true
+      };
+    }
+    const allResults = [];
+    for (const instance of instancesToSearch) {
+      const perDirMax = Math.ceil(maxResults * 1.5);
+      const results = await instance.minimem.search(params.query, {
+        maxResults: perDirMax,
+        minScore,
+        type: params.type
+      });
+      for (const result of results) {
+        allResults.push({
+          ...result,
+          memoryDir: instance.name ?? instance.memoryDir
+        });
+      }
+    }
+    allResults.sort((a, b) => b.score - a.score);
+    const topResults = allResults.slice(0, maxResults);
+    if (topResults.length === 0) {
+      return {
+        content: [{ type: "text", text: "No results found." }]
+      };
+    }
+    const showSource = instancesToSearch.length > 1;
+    if (detail === "compact") {
+      return this.formatCompactResults(topResults, showSource, instancesToSearch.length);
+    }
+    return this.formatFullResults(topResults, showSource, instancesToSearch.length);
+  }
+  formatCompactResults(results, showSource, dirCount) {
+    const formatted = results.map((r, i) => {
+      const location = `${r.path}:${r.startLine}-${r.endLine}`;
+      const score = (r.score * 100).toFixed(0);
+      const source = showSource ? ` [${r.memoryDir}]` : "";
+      const preview = compactPreview(r.snippet);
+      return `[${i}] ${location}${source} (${score}%) \u2014 ${preview}`;
+    }).join("\n");
+    const hint = "\n\nUse memory_get_details to fetch full text for selected results.";
+    const dirSummary = dirCount > 1 ? `
+(Searched ${dirCount} directories)` : "";
+    return {
+      content: [{ type: "text", text: formatted + dirSummary + hint }]
+    };
+  }
+  formatFullResults(results, showSource, dirCount) {
+    const formatted = results.map((r, i) => {
+      const location = `${r.path}:${r.startLine}-${r.endLine}`;
+      const score = (r.score * 100).toFixed(1);
+      const source = showSource ? ` [${r.memoryDir}]` : "";
+      return `[${i + 1}] ${location}${source} (${score}% match)
+${r.snippet}`;
+    }).join("\n\n");
+    const dirSummary = dirCount > 1 ? `
+
+(Searched ${dirCount} directories)` : "";
+    return {
+      content: [{ type: "text", text: formatted + dirSummary }]
+    };
+  }
+  async memoryGetDetails(params) {
+    if (!params.results || params.results.length === 0) {
+      return {
+        content: [{ type: "text", text: "No results specified." }],
+        isError: true
+      };
+    }
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No matching directories found. Available: ${available}`
+          }
+        ],
+        isError: true
+      };
+    }
+    const details = [];
+    for (const ref of params.results) {
+      let found = false;
+      for (const instance of instancesToSearch) {
+        const lineCount = ref.endLine - ref.startLine + 1;
+        const result = await instance.minimem.readLines(ref.path, {
+          from: ref.startLine,
+          lines: lineCount
+        });
+        if (result) {
+          const location = `${ref.path}:${result.startLine}-${result.endLine}`;
+          details.push(`--- ${location} ---
+${result.content}`);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        details.push(`--- ${ref.path}:${ref.startLine}-${ref.endLine} ---
+(not found)`);
+      }
+    }
+    return {
+      content: [{ type: "text", text: details.join("\n\n") }]
+    };
+  }
+  async knowledgeSearch(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const maxResults = params.maxResults ?? 10;
+    const allResults = [];
+    for (const instance of instancesToSearch) {
+      const results = await instance.minimem.knowledgeSearch(params.query, {
+        maxResults: Math.ceil(maxResults * 1.5),
+        minScore: params.minScore,
+        domain: params.domain,
+        entities: params.entities,
+        minConfidence: params.minConfidence,
+        knowledgeType: params.knowledgeType
+      });
+      for (const result of results) {
+        allResults.push({
+          ...result,
+          memoryDir: instance.name ?? instance.memoryDir
+        });
+      }
+    }
+    allResults.sort((a, b) => b.score - a.score);
+    const topResults = allResults.slice(0, maxResults);
+    if (topResults.length === 0) {
+      return { content: [{ type: "text", text: "No knowledge results found." }] };
+    }
+    const formatted = topResults.map((r, i) => {
+      const location = `${r.path}:${r.startLine}-${r.endLine}`;
+      const score = (r.score * 100).toFixed(0);
+      const preview = compactPreview(r.snippet);
+      return `[${i}] ${location} (${score}%) \u2014 ${preview}`;
+    }).join("\n");
+    return { content: [{ type: "text", text: formatted }] };
+  }
+  async knowledgeGraph(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const depth = Math.min(params.depth ?? 1, 3);
+    const allNeighbors = [];
+    for (const instance of instancesToSearch) {
+      const neighbors = instance.minimem.getGraphNeighbors(params.nodeId, depth, {
+        relation: params.relation,
+        layer: params.layer
+      });
+      for (const n of neighbors) {
+        allNeighbors.push({
+          id: n.id,
+          depth: n.depth,
+          relation: n.link.relation,
+          layer: n.link.layer,
+          memoryDir: instance.name ?? instance.memoryDir
+        });
+      }
+    }
+    if (allNeighbors.length === 0) {
+      return { content: [{ type: "text", text: `No neighbors found for node "${params.nodeId}".` }] };
+    }
+    const formatted = allNeighbors.map((n) => `  [depth=${n.depth}] ${n.id} \u2014(${n.relation})${n.layer ? ` [${n.layer}]` : ""}`).join("\n");
+    return {
+      content: [{ type: "text", text: `Neighbors of "${params.nodeId}":
+${formatted}` }]
+    };
+  }
+  async knowledgePath(params) {
+    const instancesToSearch = this.filterInstances(params.directories);
+    if (!instancesToSearch) {
+      const available = this.getDirectories().join(", ");
+      return {
+        content: [{ type: "text", text: `No matching directories found. Available: ${available}` }],
+        isError: true
+      };
+    }
+    const maxDepth = Math.min(params.maxDepth ?? 3, 5);
+    for (const instance of instancesToSearch) {
+      const path5 = instance.minimem.getGraphPath(params.fromId, params.toId, maxDepth);
+      if (path5.length > 0) {
+        const steps = path5.map((link) => `  ${link.fromId} \u2014(${link.relation})\u2192 ${link.toId}`).join("\n");
+        return {
+          content: [{
+            type: "text",
+            text: `Path from "${params.fromId}" to "${params.toId}" (${path5.length} steps):
+${steps}`
+          }]
+        };
+      }
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `No path found from "${params.fromId}" to "${params.toId}" within depth ${maxDepth}.`
+      }]
+    };
+  }
+};
+function compactPreview(snippet) {
+  const maxLen = 80;
+  const lines = snippet.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return "(empty)";
+  const heading = lines.find((l) => l.startsWith("#"));
+  const text = heading ?? lines[0];
+  const cleaned = text.replace(/^#+\s*/, "").trim();
+  if (cleaned.length <= maxLen) return `"${cleaned}"`;
+  return `"${cleaned.slice(0, maxLen - 3)}..."`;
+}
+function createToolExecutor(instances) {
+  return new MemoryToolExecutor(instances);
+}
+
+// src/server/mcp.ts
+var readline = __toESM(require("readline"), 1);
+var PROTOCOL_VERSION = "2024-11-05";
+var SERVER_NAME = "minimem";
+var SERVER_VERSION = "0.1.0";
+var McpServer = class {
+  executor;
+  initialized = false;
+  constructor(instances) {
+    this.executor = new MemoryToolExecutor(instances);
+  }
+  /**
+   * Handle a JSON-RPC request and return a response
+   */
+  async handleRequest(request) {
+    try {
+      const result = await this.dispatch(request.method, request.params);
+      return {
+        jsonrpc: "2.0",
+        id: request.id,
+        result
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = err instanceof McpError ? err.code : -32603;
+      return {
+        jsonrpc: "2.0",
+        id: request.id,
+        error: { code, message }
+      };
+    }
+  }
+  /**
+   * Dispatch a method call
+   */
+  async dispatch(method, params) {
+    switch (method) {
+      case "initialize":
+        return this.initialize(params);
+      case "initialized":
+        return {};
+      case "tools/list":
+        return this.listTools();
+      case "tools/call":
+        return this.callTool(params);
+      case "ping":
+        return {};
+      default:
+        throw new McpError(-32601, `Method not found: ${method}`);
+    }
+  }
+  /**
+   * Handle initialize request
+   */
+  initialize(params) {
+    this.initialized = true;
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: {
+        tools: {
+          listChanged: false
+        }
+      },
+      serverInfo: {
+        name: SERVER_NAME,
+        version: SERVER_VERSION
+      }
+    };
+  }
+  /**
+   * List available tools
+   */
+  listTools() {
+    const tools = MEMORY_TOOLS.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+    return { tools };
+  }
+  /**
+   * Call a tool
+   */
+  async callTool(params) {
+    if (!params?.name || typeof params.name !== "string") {
+      throw new McpError(-32602, "Missing tool name");
+    }
+    const toolName = params.name;
+    const toolParams = params.arguments ?? {};
+    const result = await this.executor.execute(toolName, toolParams);
+    return result;
+  }
+};
+var McpError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "McpError";
+  }
+};
+function createMcpServer(instances) {
+  return new McpServer(instances);
+}
+async function runMcpServer(server) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+  const send = (message) => {
+    const json = JSON.stringify(message);
+    process.stdout.write(json + "\n");
+  };
+  rl.on("line", async (line) => {
+    if (!line.trim()) return;
+    try {
+      const request = JSON.parse(line);
+      if (request.jsonrpc !== "2.0") {
+        send({
+          jsonrpc: "2.0",
+          id: request.id ?? null,
+          error: { code: -32600, message: "Invalid JSON-RPC version" }
+        });
+        return;
+      }
+      if (request.id === void 0) {
+        await server.handleRequest({ ...request, id: 0 });
+        return;
+      }
+      const response = await server.handleRequest(request);
+      send(response);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      send({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: `Parse error: ${message}` }
+      });
+    }
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+function generateMcpConfig(opts) {
+  return {
+    command: "node",
+    args: [opts.serverPath],
+    env: {
+      MEMORY_DIR: opts.memoryDir,
+      ...opts.embeddingProvider ? { EMBEDDING_PROVIDER: opts.embeddingProvider } : {}
+    }
+  };
+}
+
+// src/core/indexer.ts
+var import_node_crypto3 = require("crypto");
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var META_KEY2 = "memory_index_meta_v1";
+var EMBEDDING_CACHE_TABLE2 = "embedding_cache";
+var VECTOR_TABLE2 = "chunks_vec";
+var FTS_TABLE2 = "chunks_fts";
+var EMBEDDING_RETRY_MAX_ATTEMPTS2 = 3;
+var EMBEDDING_RETRY_BASE_DELAY_MS2 = 500;
+var EMBEDDING_RETRY_MAX_DELAY_MS2 = 8e3;
+var MemoryIndexer = class {
+  config;
+  db;
+  provider;
+  providerKey;
+  openAi;
+  gemini;
+  // Vector/FTS state (shared with parent)
+  vectorState;
+  ftsAvailable;
+  constructor(db, provider, config, options) {
+    this.db = db;
+    this.provider = provider;
+    this.config = config;
+    this.openAi = options?.openAi;
+    this.gemini = options?.gemini;
+    this.vectorState = options?.vectorState ?? { available: false };
+    this.ftsAvailable = options?.ftsAvailable ?? false;
+    this.providerKey = this.computeProviderKey();
+  }
+  /**
+   * Update vector/FTS availability (called by parent when extensions load)
+   */
+  setVectorState(state) {
+    this.vectorState = state;
+  }
+  setFtsAvailable(available) {
+    this.ftsAvailable = available;
+  }
+  getVectorDims() {
+    return this.vectorState.dims;
+  }
+  /**
+   * Compute a unique key for the current provider configuration
+   */
+  computeProviderKey() {
+    const parts = [this.provider.id, this.provider.model];
+    if (this.openAi) {
+      parts.push(this.openAi.baseUrl);
+    }
+    if (this.gemini) {
+      parts.push(this.gemini.baseUrl);
+    }
+    return hashText(parts.join(":"));
+  }
+  /**
+   * Read index metadata from database
+   */
+  readMeta() {
+    try {
+      const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY2);
+      if (!row?.value) return null;
+      return JSON.parse(row.value);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write index metadata to database
+   */
+  writeMeta(meta) {
+    this.db.prepare(`INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)`).run(META_KEY2, JSON.stringify(meta));
+  }
+  /**
+   * Check if the index is stale by comparing file mtimes
+   */
+  async isStale() {
+    try {
+      const files = await listMemoryFiles(this.config.memoryDir);
+      const stored = this.db.prepare(`SELECT path, mtime FROM files WHERE source = ?`).all("memory");
+      if (files.length !== stored.length) {
+        this.config.debug?.(`Stale: file count changed (${stored.length} -> ${files.length})`);
+        return true;
+      }
+      const storedMap = new Map(stored.map((f) => [f.path, f.mtime]));
+      for (const absPath of files) {
+        const relPath = import_node_path4.default.relative(this.config.memoryDir, absPath).replace(/\\/g, "/");
+        const storedMtime = storedMap.get(relPath);
+        if (storedMtime === void 0) {
+          this.config.debug?.(`Stale: new file ${relPath}`);
+          return true;
+        }
+        const stat = await import_promises3.default.stat(absPath);
+        const currentMtime = Math.floor(stat.mtimeMs);
+        if (currentMtime !== storedMtime) {
+          this.config.debug?.(`Stale: mtime changed for ${relPath}`);
+          return true;
+        }
+      }
+      return false;
+    } catch (err) {
+      this.config.debug?.(`Stale check failed: ${String(err)}`);
+      return true;
+    }
+  }
+  /**
+   * Check if a full reindex is needed based on configuration changes
+   */
+  needsFullReindex(force) {
+    const meta = this.readMeta();
+    return force === true || !meta || meta.model !== this.provider.model || meta.provider !== this.provider.id || meta.providerKey !== this.providerKey || meta.chunkTokens !== this.config.chunking.tokens || meta.chunkOverlap !== this.config.chunking.overlap || this.vectorState.available && !meta?.vectorDims;
+  }
+  /**
+   * Index all memory files, returns stats
+   */
+  async indexAll(force) {
+    const needsFullReindex = this.needsFullReindex(force);
+    const files = await listMemoryFiles(this.config.memoryDir);
+    const activePaths = /* @__PURE__ */ new Set();
+    let filesProcessed = 0;
+    let chunksCreated = 0;
+    for (const absPath of files) {
+      const entry = await buildFileEntry(absPath, this.config.memoryDir);
+      activePaths.add(entry.path);
+      const record = this.db.prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`).get(entry.path, "memory");
+      if (!needsFullReindex && record?.hash === entry.hash) {
+        continue;
+      }
+      const chunkCount = await this.indexFile(entry);
+      filesProcessed++;
+      chunksCreated += chunkCount;
+    }
+    const staleRemoved = this.removeStaleEntries(activePaths);
+    this.writeMeta({
+      model: this.provider.model,
+      provider: this.provider.id,
+      providerKey: this.providerKey,
+      chunkTokens: this.config.chunking.tokens,
+      chunkOverlap: this.config.chunking.overlap,
+      vectorDims: this.vectorState.dims
+    });
+    this.pruneEmbeddingCacheIfNeeded();
+    return { filesProcessed, chunksCreated, staleRemoved };
+  }
+  /**
+   * Index a single file
+   */
+  async indexFile(entry) {
+    const content = await import_promises3.default.readFile(entry.absPath, "utf-8");
+    const chunks = chunkMarkdown(content, this.config.chunking);
+    const embeddings = await this.embedChunks(chunks);
+    this.db.prepare(
+      `INSERT OR REPLACE INTO files (path, source, hash, mtime, size) VALUES (?, ?, ?, ?, ?)`
+    ).run(entry.path, "memory", entry.hash, Math.floor(entry.mtimeMs), entry.size);
+    this.deleteChunksForFile(entry.path);
+    const now = Date.now();
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const embedding = embeddings[i] ?? [];
+      this.insertChunk(entry.path, chunk, embedding, now);
+    }
+    return chunks.length;
+  }
+  /**
+   * Delete all chunks for a file
+   */
+  deleteChunksForFile(filePath) {
+    try {
+      this.db.prepare(
+        `DELETE FROM ${VECTOR_TABLE2} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`
+      ).run(filePath, "memory");
+    } catch {
+    }
+    this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(filePath, "memory");
+    if (this.config.ftsEnabled && this.ftsAvailable) {
+      try {
+        this.db.prepare(`DELETE FROM ${FTS_TABLE2} WHERE path = ? AND source = ? AND model = ?`).run(filePath, "memory", this.provider.model);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Insert a chunk into the database
+   */
+  insertChunk(filePath, chunk, embedding, timestamp) {
+    const chunkId = (0, import_node_crypto3.randomUUID)();
+    this.db.prepare(
+      `INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      chunkId,
+      filePath,
+      "memory",
+      chunk.startLine,
+      chunk.endLine,
+      chunk.hash,
+      this.provider.model,
+      chunk.text,
+      JSON.stringify(embedding),
+      timestamp
+    );
+    if (this.vectorState.available && embedding.length > 0) {
+      if (!this.vectorState.dims) {
+        this.vectorState.dims = embedding.length;
+        this.ensureVectorTable(embedding.length);
+      }
+      try {
+        this.db.prepare(`INSERT INTO ${VECTOR_TABLE2} (id, embedding) VALUES (?, ?)`).run(chunkId, vectorToBlob(embedding));
+      } catch {
+      }
+    }
+    if (this.config.ftsEnabled && this.ftsAvailable) {
+      try {
+        this.db.prepare(
+          `INSERT INTO ${FTS_TABLE2} (text, id, path, source, model, start_line, end_line)
+             VALUES (?, ?, ?, ?, ?, ?, ?)`
+        ).run(
+          chunk.text,
+          chunkId,
+          filePath,
+          "memory",
+          this.provider.model,
+          chunk.startLine,
+          chunk.endLine
+        );
+      } catch {
+      }
+    }
+  }
+  /**
+   * Remove stale file entries that no longer exist
+   */
+  removeStaleEntries(activePaths) {
+    const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("memory");
+    let removed = 0;
+    for (const stale of staleRows) {
+      if (activePaths.has(stale.path)) continue;
+      this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "memory");
+      this.deleteChunksForFile(stale.path);
+      removed++;
+    }
+    return removed;
+  }
+  /**
+   * Create vector table with the given dimensions
+   */
+  ensureVectorTable(dimensions) {
+    if (!this.vectorState.available) return;
+    try {
+      this.db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${VECTOR_TABLE2} USING vec0(
+          id TEXT PRIMARY KEY,
+          embedding FLOAT[${dimensions}]
+        )`
+      );
+    } catch (err) {
+      this.config.debug?.(`vector table creation failed: ${String(err)}`);
+    }
+  }
+  /**
+   * Get embeddings for chunks, using cache when available
+   */
+  async embedChunks(chunks) {
+    if (chunks.length === 0) return [];
+    const hashes = chunks.map((c) => c.hash);
+    const cached = this.loadEmbeddingCache(hashes);
+    const missing = [];
+    for (let i = 0; i < chunks.length; i++) {
+      if (!cached.has(hashes[i])) {
+        missing.push({ index: i, chunk: chunks[i] });
+      }
+    }
+    if (missing.length > 0) {
+      const texts = missing.map((m) => m.chunk.text);
+      const newEmbeddings = await this.embedBatchWithRetry(texts);
+      for (let i = 0; i < missing.length; i++) {
+        const hash = missing[i].chunk.hash;
+        const embedding = newEmbeddings[i] ?? [];
+        cached.set(hash, embedding);
+        this.upsertEmbeddingCache(hash, embedding);
+      }
+    }
+    return hashes.map((h) => cached.get(h) ?? []);
+  }
+  /**
+   * Embed texts with retry logic
+   */
+  async embedBatchWithRetry(texts) {
+    if (texts.length === 0) return [];
+    if (this.config.batch.enabled) {
+      try {
+        return await this.embedWithBatchApi(texts);
+      } catch (err) {
+        this.config.debug?.(`batch embedding failed, falling back to direct: ${String(err)}`);
+      }
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < EMBEDDING_RETRY_MAX_ATTEMPTS2; attempt++) {
+      try {
+        return await this.provider.embedBatch(texts);
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < EMBEDDING_RETRY_MAX_ATTEMPTS2 - 1) {
+          const delay = Math.min(
+            EMBEDDING_RETRY_MAX_DELAY_MS2,
+            EMBEDDING_RETRY_BASE_DELAY_MS2 * Math.pow(2, attempt)
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Use batch API for large embedding jobs
+   */
+  async embedWithBatchApi(texts) {
+    if (this.openAi) {
+      const requests = texts.map((text, i) => ({
+        custom_id: `chunk-${i}`,
+        method: "POST",
+        url: OPENAI_BATCH_ENDPOINT,
+        body: { model: this.openAi.model, input: text }
+      }));
+      const results = await runOpenAiEmbeddingBatches({
+        openAi: this.openAi,
+        source: "minimem",
+        requests,
+        wait: this.config.batch.wait,
+        pollIntervalMs: this.config.batch.pollIntervalMs,
+        timeoutMs: this.config.batch.timeoutMs,
+        concurrency: this.config.batch.concurrency,
+        debug: this.config.debug
+      });
+      return texts.map((_, i) => results.get(`chunk-${i}`) ?? []);
+    }
+    if (this.gemini) {
+      const requests = texts.map((text, i) => ({
+        custom_id: `chunk-${i}`,
+        content: { parts: [{ text }] },
+        taskType: "RETRIEVAL_DOCUMENT"
+      }));
+      const results = await runGeminiEmbeddingBatches({
+        gemini: this.gemini,
+        source: "minimem",
+        requests,
+        wait: this.config.batch.wait,
+        pollIntervalMs: this.config.batch.pollIntervalMs,
+        timeoutMs: this.config.batch.timeoutMs,
+        concurrency: this.config.batch.concurrency,
+        debug: this.config.debug
+      });
+      return texts.map((_, i) => results.get(`chunk-${i}`) ?? []);
+    }
+    throw new Error("Batch API not available for local embeddings");
+  }
+  /**
+   * Load embeddings from cache
+   */
+  loadEmbeddingCache(hashes) {
+    const result = /* @__PURE__ */ new Map();
+    if (!this.config.cache.enabled || hashes.length === 0) return result;
+    const placeholders = hashes.map(() => "?").join(",");
+    const rows = this.db.prepare(
+      `SELECT hash, embedding FROM ${EMBEDDING_CACHE_TABLE2}
+         WHERE provider = ? AND model = ? AND provider_key = ? AND hash IN (${placeholders})`
+    ).all(this.provider.id, this.provider.model, this.providerKey, ...hashes);
+    const now = Date.now();
+    for (const row of rows) {
+      result.set(row.hash, parseEmbedding(row.embedding));
+      this.db.prepare(
+        `UPDATE ${EMBEDDING_CACHE_TABLE2} SET updated_at = ?
+           WHERE provider = ? AND model = ? AND provider_key = ? AND hash = ?`
+      ).run(now, this.provider.id, this.provider.model, this.providerKey, row.hash);
+    }
+    return result;
+  }
+  /**
+   * Save embedding to cache
+   */
+  upsertEmbeddingCache(hash, embedding) {
+    if (!this.config.cache.enabled) return;
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO ${EMBEDDING_CACHE_TABLE2}
+         (provider, model, provider_key, hash, embedding, dims, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      this.provider.id,
+      this.provider.model,
+      this.providerKey,
+      hash,
+      JSON.stringify(embedding),
+      embedding.length,
+      now
+    );
+  }
+  /**
+   * Prune old cache entries if over limit
+   */
+  pruneEmbeddingCacheIfNeeded() {
+    if (!this.config.cache.enabled) return;
+    const row = this.db.prepare(`SELECT COUNT(*) as count FROM ${EMBEDDING_CACHE_TABLE2}`).get();
+    if (row.count <= this.config.cache.maxEntries) return;
+    const excess = row.count - this.config.cache.maxEntries;
+    this.db.prepare(
+      `DELETE FROM ${EMBEDDING_CACHE_TABLE2}
+         WHERE rowid IN (
+           SELECT rowid FROM ${EMBEDDING_CACHE_TABLE2}
+           ORDER BY updated_at ASC
+           LIMIT ?
+         )`
+    ).run(excess);
+  }
+};
+
+// src/core/searcher.ts
+var SNIPPET_MAX_CHARS2 = 700;
+var VECTOR_TABLE3 = "chunks_vec";
+var FTS_TABLE3 = "chunks_fts";
+var EMBEDDING_QUERY_TIMEOUT_REMOTE_MS2 = 6e4;
+var EMBEDDING_QUERY_TIMEOUT_LOCAL_MS2 = 5 * 6e4;
+var MemorySearcher = class {
+  db;
+  provider;
+  config;
+  // State from parent
+  vectorState;
+  ftsAvailable;
+  // Callback to ensure vector is ready
+  ensureVectorReadyFn;
+  constructor(db, provider, config, options) {
+    this.db = db;
+    this.provider = provider;
+    this.config = config;
+    this.vectorState = options?.vectorState ?? { available: false };
+    this.ftsAvailable = options?.ftsAvailable ?? false;
+    this.ensureVectorReadyFn = options?.ensureVectorReady;
+  }
+  /**
+   * Update vector/FTS availability (called by parent when extensions load)
+   */
+  setVectorState(state) {
+    this.vectorState = state;
+  }
+  setFtsAvailable(available) {
+    this.ftsAvailable = available;
+  }
+  /**
+   * Execute a search query
+   */
+  async search(query, opts) {
+    const cleaned = query.trim();
+    if (!cleaned) return [];
+    const minScore = opts?.minScore ?? this.config.query.minScore;
+    const maxResults = opts?.maxResults ?? this.config.query.maxResults;
+    const candidates = Math.min(
+      200,
+      Math.max(1, Math.floor(maxResults * this.config.hybrid.candidateMultiplier))
+    );
+    const sourceFilter = { sql: "", params: [] };
+    const keywordResults = this.config.hybrid.enabled && this.ftsAvailable ? await searchKeyword({
+      db: this.db,
+      ftsTable: FTS_TABLE3,
+      providerModel: this.provider.model,
+      query: cleaned,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS2,
+      sourceFilter,
+      buildFtsQuery,
+      bm25RankToScore
+    }).catch(() => []) : [];
+    const queryVec = await this.embedQueryWithTimeout(cleaned);
+    const hasVector = queryVec.some((v) => v !== 0);
+    const vectorResults = hasVector ? await searchVector({
+      db: this.db,
+      vectorTable: VECTOR_TABLE3,
+      providerModel: this.provider.model,
+      queryVec,
+      limit: candidates,
+      snippetMaxChars: SNIPPET_MAX_CHARS2,
+      ensureVectorReady: (dims) => this.ensureVectorReady(dims),
+      sourceFilterVec: sourceFilter,
+      sourceFilterChunks: sourceFilter
+    }).catch(() => []) : [];
+    if (!this.config.hybrid.enabled) {
+      return vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        score: r.score,
+        snippet: r.snippet
+      }));
+    }
+    const merged = mergeHybridResults({
+      vector: vectorResults.map((r) => ({
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        vectorScore: r.score
+      })),
+      keyword: keywordResults.map((r) => ({
+        id: r.id,
+        path: r.path,
+        startLine: r.startLine,
+        endLine: r.endLine,
+        source: r.source,
+        snippet: r.snippet,
+        textScore: r.textScore
+      })),
+      vectorWeight: this.config.hybrid.vectorWeight,
+      textWeight: this.config.hybrid.textWeight
+    });
+    return merged.filter((entry) => entry.score >= minScore).slice(0, maxResults).map((r) => ({
+      path: r.path,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      score: r.score,
+      snippet: r.snippet
+    }));
+  }
+  /**
+   * Embed a query string with timeout
+   */
+  async embedQueryWithTimeout(text) {
+    const timeout = this.provider.id === "local" ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS2 : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS2;
+    return Promise.race([
+      this.provider.embedQuery(text),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("embedding query timeout")), timeout)
+      )
+    ]);
+  }
+  /**
+   * Ensure vector extension is ready
+   */
+  async ensureVectorReady(dims) {
+    if (this.vectorState.available) return true;
+    if (this.ensureVectorReadyFn) {
+      return this.ensureVectorReadyFn(dims);
+    }
+    return false;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KNOWLEDGE_GRAPH_TOOL,
+  KNOWLEDGE_PATH_TOOL,
+  KNOWLEDGE_SEARCH_TOOL,
+  MEMORY_GET_DETAILS_TOOL,
+  MEMORY_SEARCH_TOOL,
+  MEMORY_TOOLS,
+  McpServer,
+  MemoryIndexer,
+  MemorySearcher,
+  MemoryToolExecutor,
+  Minimem,
+  addFrontmatter,
+  addSessionToContent,
+  buildFileEntry,
+  buildKnowledgeFilterSql,
+  chunkMarkdown,
+  cosineSimilarity,
+  createEmbeddingProvider,
+  createGeminiEmbeddingProvider,
+  createMcpServer,
+  createOpenAiEmbeddingProvider,
+  createToolExecutor,
+  extractChunkMetadata,
+  extractSession,
+  generateMcpConfig,
+  getLinksFrom,
+  getLinksTo,
+  getNeighbors,
+  getPathBetween,
+  getToolDefinitions,
+  hashText,
+  isMemoryPath,
+  listMemoryFiles,
+  parseFrontmatter,
+  runGeminiEmbeddingBatches,
+  runMcpServer,
+  runOpenAiEmbeddingBatches,
+  serializeFrontmatter,
+  stripPrivateContent
+});
+//# sourceMappingURL=index.cjs.map