clawvault 2.6.1 → 3.0.0

package/dist/chunk-K234IDRJ.js

@@ -0,0 +1,1073 @@
+import {
+  DATE_HEADING_RE,
+  parseObservationMarkdown
+} from "./chunk-QK3UCXWL.js";
+import {
+  listObservationFiles
+} from "./chunk-Z2XBWN7A.js";
+
+// src/lib/reweave.ts
+import * as fs from "fs";
+var SUPERSEDED_MARKER_RE = /\[superseded\|by=([^\]|]+)\|detected=([^\]]+)\]/;
+function isSuperseded(line) {
+  return SUPERSEDED_MARKER_RE.test(line);
+}
+function getSupersessionInfo(line) {
+  const m = line.match(SUPERSEDED_MARKER_RE);
+  if (!m) return null;
+  return { supersededBy: m[1], detectedAt: m[2] };
+}
+function makeSupersededMarker(supersedingDate, detectedAt) {
+  return ` [superseded|by=${supersedingDate}|detected=${detectedAt}]`;
+}
+function extractEntities(content) {
+  const normalized = content.toLowerCase().replace(/['']/g, "'");
+  const quoted = [];
+  for (const m of normalized.matchAll(/[""]([^""]+)[""]/g)) {
+    quoted.push(m[1].trim());
+  }
+  for (const m of normalized.matchAll(/"([^"]+)"/g)) {
+    quoted.push(m[1].trim());
+  }
+  const patterns = [
+    /(\w[\w\s]{1,30}?)\s+(?:is|are|was|were|changed to|switched to|moved to|updated to|now uses?|now lives?|now works?)\s+/gi,
+    /(?:uses?|prefers?|likes?|lives? (?:in|at)|works? (?:at|for)|drives?|owns?)\s+([\w\s]{2,30})/gi,
+    /(\w[\w\s]{1,20}?)'s\s+(\w[\w\s]{1,20})/gi
+  ];
+  const phrases = [...quoted];
+  for (const pat of patterns) {
+    for (const m of content.matchAll(pat)) {
+      if (m[1]) phrases.push(m[1].trim().toLowerCase());
+      if (m[2]) phrases.push(m[2].trim().toLowerCase());
+    }
+  }
+  const stopwords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "ought",
+    "used",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "out",
+    "off",
+    "over",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "not",
+    "so",
+    "yet",
+    "both",
+    "either",
+    "neither",
+    "each",
+    "every",
+    "all",
+    "any",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "only",
+    "own",
+    "same",
+    "than",
+    "too",
+    "very",
+    "just",
+    "because",
+    "that",
+    "this",
+    "these",
+    "those",
+    "it",
+    "its",
+    "he",
+    "she",
+    "they",
+    "we",
+    "you",
+    "i",
+    "me",
+    "my",
+    "his",
+    "her",
+    "our",
+    "your",
+    "their",
+    "pedro",
+    "clawdious"
+  ]);
+  const words = normalized.replace(/[^a-z0-9\s'-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !stopwords.has(w));
+  return [.../* @__PURE__ */ new Set([...phrases, ...words])].filter(Boolean);
+}
+function entitySimilarity(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const setA = new Set(a);
+  const setB = new Set(b);
+  let overlap = 0;
+  for (const item of setA) {
+    if (setB.has(item)) overlap++;
+  }
+  const union = (/* @__PURE__ */ new Set([...a, ...b])).size;
+  return union > 0 ? overlap / union : 0;
+}
+function isKnowledgeUpdate(older, newer, threshold = 0.3) {
+  const updateableTypes = /* @__PURE__ */ new Set(["fact", "preference", "decision", "commitment", "project", "relationship"]);
+  if (!updateableTypes.has(older.type) && !updateableTypes.has(newer.type)) {
+    return { isUpdate: false, reason: "non-updateable types" };
+  }
+  const olderEntities = extractEntities(older.content);
+  const newerEntities = extractEntities(newer.content);
+  const similarity = entitySimilarity(olderEntities, newerEntities);
+  if (similarity < threshold) {
+    return { isUpdate: false, reason: `low entity similarity: ${similarity.toFixed(2)}` };
+  }
+  const normalizeContent = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+  if (normalizeContent(older.content) === normalizeContent(newer.content)) {
+    return { isUpdate: false, reason: "identical content" };
+  }
+  return {
+    isUpdate: true,
+    reason: `entity overlap ${similarity.toFixed(2)}: entities=[${olderEntities.slice(0, 3).join(", ")}]`
+  };
+}
+function loadObservations(vaultPath, since) {
+  const files = listObservationFiles(vaultPath, {
+    fromDate: since
+  });
+  return files.map((f) => {
+    const content = fs.readFileSync(f.path, "utf-8");
+    const records = parseObservationMarkdown(content);
+    return { file: f, records };
+  });
+}
+function reweave(options) {
+  const { vaultPath, since, dryRun = false, similarityThreshold = 0.3 } = options;
+  const allObsFiles = loadObservations(vaultPath);
+  const newObsFiles = since ? allObsFiles.filter((f) => f.file.date >= since) : allObsFiles;
+  const allRecordsWithFile = [];
+  for (const { file, records } of allObsFiles) {
+    for (let i = 0; i < records.length; i++) {
+      allRecordsWithFile.push({ record: records[i], file, lineIndex: i });
+    }
+  }
+  allRecordsWithFile.sort((a, b) => a.record.date.localeCompare(b.record.date));
+  const supersessions = [];
+  const detectedAt = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  for (const { file: newFile, records: newRecords } of newObsFiles) {
+    for (const newRec of newRecords) {
+      if (isSuperseded(newRec.rawLine)) continue;
+      for (const { record: oldRec, file: oldFile } of allRecordsWithFile) {
+        if (oldRec.date >= newRec.date && oldFile.path === newFile.path) continue;
+        if (oldRec.date > newRec.date) continue;
+        if (isSuperseded(oldRec.rawLine)) continue;
+        const { isUpdate, reason } = isKnowledgeUpdate(oldRec, newRec, similarityThreshold);
+        if (isUpdate) {
+          supersessions.push({
+            oldObservation: oldRec,
+            newObservation: newRec,
+            oldFile: oldFile.path,
+            newFile: newFile.path,
+            reason,
+            detectedAt
+          });
+        }
+      }
+    }
+  }
+  if (!dryRun && supersessions.length > 0) {
+    applySupersessions(supersessions, detectedAt);
+  }
+  return {
+    filesScanned: allObsFiles.length,
+    observationsChecked: allRecordsWithFile.length,
+    supersessions,
+    dryRun
+  };
+}
+function applySupersessions(supersessions, detectedAt) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const s of supersessions) {
+    const existing = byFile.get(s.oldFile) ?? [];
+    existing.push(s);
+    byFile.set(s.oldFile, existing);
+  }
+  for (const [filePath, records] of byFile) {
+    let content = fs.readFileSync(filePath, "utf-8");
+    for (const s of records) {
+      const oldLine = s.oldObservation.rawLine;
+      if (content.includes(oldLine) && !isSuperseded(oldLine)) {
+        const marker = makeSupersededMarker(s.newObservation.date, detectedAt);
+        content = content.replace(oldLine, oldLine + marker);
+      }
+    }
+    fs.writeFileSync(filePath, content, "utf-8");
+  }
+}
+function filterSuperseded(lines) {
+  return lines.filter((line) => !isSuperseded(line));
+}
+function stripSupersededObservations(markdown) {
+  const lines = markdown.split("\n");
+  const result = [];
+  for (const line of lines) {
+    if (DATE_HEADING_RE.test(line) || line.trim() === "") {
+      result.push(line);
+      continue;
+    }
+    if (isSuperseded(line)) continue;
+    result.push(line);
+  }
+  return result.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/lib/search.ts
+import { execFileSync, spawnSync } from "child_process";
+import * as fs2 from "fs";
+import * as path from "path";
+var QMD_INSTALL_URL = "https://github.com/tobi/qmd";
+var QMD_INSTALL_COMMAND = "bun install -g github:tobi/qmd";
+var QMD_NOT_INSTALLED_MESSAGE = `ClawVault requires qmd. Install: ${QMD_INSTALL_COMMAND}`;
+var QMD_INDEX_ENV_VAR = "CLAWVAULT_QMD_INDEX";
+var QmdUnavailableError = class extends Error {
+  constructor(message = QMD_NOT_INSTALLED_MESSAGE) {
+    super(message);
+    this.name = "QmdUnavailableError";
+  }
+};
+function ensureJsonArgs(args) {
+  return args.includes("--json") ? args : [...args, "--json"];
+}
+function resolveQmdIndexName(indexName) {
+  const explicit = indexName?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const fromEnv = process.env[QMD_INDEX_ENV_VAR]?.trim();
+  return fromEnv || void 0;
+}
+function withQmdIndexArgs(args, indexName) {
+  if (args.includes("--index")) {
+    return [...args];
+  }
+  const resolvedIndexName = resolveQmdIndexName(indexName);
+  if (!resolvedIndexName) {
+    return [...args];
+  }
+  return ["--index", resolvedIndexName, ...args];
+}
+function tryParseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractJsonPayload(raw) {
+  const start = raw.search(/[\[{]/);
+  if (start === -1) return null;
+  const end = Math.max(raw.lastIndexOf("]"), raw.lastIndexOf("}"));
+  if (end <= start) return null;
+  return raw.slice(start, end + 1);
+}
+function stripQmdNoise(raw) {
+  return raw.split("\n").filter((line) => {
+    const t = line.trim();
+    if (!t) return true;
+    if (t.startsWith("[node-llama-cpp]")) return false;
+    if (t.startsWith("Expanding query")) return false;
+    if (t.startsWith("Searching ") && t.endsWith("queries...")) return false;
+    if (/^[├└─│]/.test(t)) return false;
+    return true;
+  }).join("\n");
+}
+function parseQmdOutput(raw) {
+  const trimmed = stripQmdNoise(raw).trim();
+  if (!trimmed) return [];
+  const direct = tryParseJson(trimmed);
+  const extracted = direct ? null : extractJsonPayload(trimmed);
+  const parsed = direct ?? (extracted ? tryParseJson(extracted) : null);
+  if (!parsed) {
+    throw new Error("qmd returned non-JSON output. Ensure qmd supports --json.");
+  }
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (parsed && typeof parsed === "object") {
+    const candidate = parsed.results ?? parsed.items ?? parsed.data;
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("qmd returned an unexpected JSON shape.");
+}
+function ensureQmdAvailable() {
+  if (!hasQmd()) {
+    throw new QmdUnavailableError();
+  }
+}
+function execQmd(args, indexName) {
+  ensureQmdAvailable();
+  const finalArgs = withQmdIndexArgs(ensureJsonArgs(args), indexName);
+  try {
+    const result = execFileSync("qmd", finalArgs, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    });
+    return parseQmdOutput(result);
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      throw new QmdUnavailableError();
+    }
+    const output = [err?.stdout, err?.stderr].filter(Boolean).join("\n");
+    if (output) {
+      try {
+        return parseQmdOutput(output);
+      } catch {
+      }
+    }
+    const message = err?.message ? `qmd failed: ${err.message}` : "qmd failed";
+    throw new Error(message);
+  }
+}
+function hasQmd() {
+  const result = spawnSync("qmd", ["--version"], { stdio: "ignore" });
+  return !result.error;
+}
+function qmdUpdate(collection, indexName) {
+  ensureQmdAvailable();
+  const args = ["update"];
+  if (collection) {
+    args.push("-c", collection);
+  }
+  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
+}
+function qmdEmbed(collection, indexName) {
+  ensureQmdAvailable();
+  const args = ["embed"];
+  if (collection) {
+    args.push("-c", collection);
+  }
+  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
+}
+function sentenceChunk(text, maxChars = 600, overlapSentences = 1) {
+  const sentences = text.split(/(?<=[.!?])\s+|\n{2,}/).map((s) => s.trim()).filter(Boolean);
+  if (sentences.length === 0) return text.trim() ? [text] : [];
+  const chunks = [];
+  let i = 0;
+  while (i < sentences.length) {
+    const chunkSents = [];
+    let chunkLen = 0;
+    let j = i;
+    while (j < sentences.length && chunkLen + sentences[j].length < maxChars) {
+      chunkSents.push(sentences[j]);
+      chunkLen += sentences[j].length + 1;
+      j++;
+    }
+    if (chunkSents.length === 0) {
+      chunkSents.push(sentences[j].slice(0, maxChars));
+      j++;
+    }
+    chunks.push(chunkSents.join(" "));
+    i = Math.max(j - overlapSentences, i + 1);
+  }
+  return chunks;
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "what",
+  "when",
+  "where",
+  "which",
+  "that",
+  "this",
+  "have",
+  "from",
+  "with",
+  "they",
+  "been",
+  "were",
+  "will",
+  "about",
+  "would",
+  "could",
+  "should",
+  "their",
+  "there",
+  "does",
+  "your",
+  "more",
+  "some",
+  "than",
+  "into",
+  "also",
+  "just",
+  "very",
+  "much",
+  "most",
+  "many",
+  "only",
+  "other",
+  "each",
+  "every",
+  "after",
+  "before",
+  "did",
+  "the",
+  "and",
+  "for",
+  "are",
+  "was",
+  "not",
+  "but",
+  "can",
+  "had",
+  "has",
+  "how",
+  "who",
+  "why",
+  "its",
+  "you",
+  "my",
+  "me",
+  "is",
+  "it",
+  "do",
+  "so",
+  "if",
+  "or",
+  "an",
+  "on",
+  "at",
+  "by",
+  "no",
+  "up",
+  "to",
+  "in",
+  "of",
+  "am",
+  "be"
+]);
+function tokenize(text) {
+  return text.toLowerCase().split(/\s+/).map((w) => w.replace(/^[?.,!"'\-():;[\]{}*]+|[?.,!"'\-():;[\]{}*]+$/g, "")).filter((w) => w.length > 1);
+}
+function queryTerms(query) {
+  return tokenize(query).filter((w) => !STOPWORDS.has(w));
+}
+function bm25RankChunks(chunks, terms, max = 5) {
+  if (chunks.length === 0) return [];
+  const termSet = new Set(terms);
+  const scored = chunks.map((text, idx) => {
+    const words = new Set(tokenize(text));
+    let overlap = 0;
+    for (const t of termSet) if (words.has(t)) overlap++;
+    return { text, score: overlap, idx };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  seen.add(0);
+  result.push({ text: chunks[0], score: scored.find((s) => s.idx === 0)?.score ?? 0 });
+  for (const s of scored) {
+    if (result.length >= max) break;
+    if (!seen.has(s.idx) && s.score > 0) {
+      seen.add(s.idx);
+      result.push({ text: s.text, score: s.score });
+    }
+  }
+  return result;
+}
+var MONTH_NAMES = {
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12,
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  sept: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+var MONTH_RE_PART = Object.keys(MONTH_NAMES).join("|");
+var DATE_ISO_RE = /\b(\d{4})[/-](\d{1,2})[/-](\d{1,2})\b/g;
+var DATE_US_RE = /\b(\d{1,2})\/(\d{1,2})\/(\d{4})\b/g;
+var DATE_MONTH_DAY_YEAR_RE = new RegExp(
+  `\\b(${MONTH_RE_PART})\\s+(\\d{1,2})(?:st|nd|rd|th)?,?\\s*(\\d{4})\\b`,
+  "gi"
+);
+var DATE_DAY_MONTH_YEAR_RE = new RegExp(
+  `\\b(\\d{1,2})(?:st|nd|rd|th)?\\s+(${MONTH_RE_PART}),?\\s*(\\d{4})\\b`,
+  "gi"
+);
+var DATE_MONTH_DAY_RE = new RegExp(
+  `\\b(${MONTH_RE_PART})\\s+(\\d{1,2})(?:st|nd|rd|th)?\\b`,
+  "gi"
+);
+var RELATIVE_AGO_RE = /\b(\d+)\s+(days?|weeks?|months?|years?)\s+ago\b/gi;
+var RELATIVE_IN_RE = /\bin\s+(\d+)\s+(days?|weeks?|months?|years?)\b/gi;
+var DURATION_RE = /(?:for|took|spent|lasted|about|approximately|around)\s+(\d+)\s+(days?|weeks?|months?|years?|hours?|minutes?)/gi;
+function tryParseISODate(y, m, d) {
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  if (dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d) return dt;
+  return null;
+}
+function unitToDays(n, unit) {
+  const u = unit.toLowerCase().replace(/s$/, "");
+  switch (u) {
+    case "day":
+      return n;
+    case "week":
+      return n * 7;
+    case "month":
+      return n * 30;
+    case "year":
+      return n * 365;
+    default:
+      return null;
+  }
+}
+function contextSnippet(text, start, end, maxLen = 150) {
+  const s = Math.max(0, start - Math.floor(maxLen / 2));
+  const e = Math.min(text.length, end + Math.floor(maxLen / 2));
+  return text.slice(s, e).replace(/\n/g, " ").trim();
+}
+function isoStr(d) {
+  const yy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  return `${yy}-${mm}-${dd}`;
+}
+function extractDates(text, sessionDateStr) {
+  const results = [];
+  const sessionDate = sessionDateStr ? new Date(sessionDateStr) : null;
+  const seen = /* @__PURE__ */ new Set();
+  function push(date, ctx, docId = "") {
+    const key = `${date}|${ctx.slice(0, 60)}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    results.push({ date, context: ctx, documentId: docId });
+  }
+  for (const m of text.matchAll(DATE_ISO_RE)) {
+    const dt = tryParseISODate(+m[1], +m[2], +m[3]);
+    if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+  }
+  for (const m of text.matchAll(DATE_US_RE)) {
+    const dt = tryParseISODate(+m[3], +m[1], +m[2]);
+    if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+  }
+  for (const m of text.matchAll(DATE_MONTH_DAY_YEAR_RE)) {
+    const mon = MONTH_NAMES[m[1].toLowerCase()];
+    if (mon) {
+      const dt = tryParseISODate(+m[3], mon, +m[2]);
+      if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+    }
+  }
+  for (const m of text.matchAll(DATE_DAY_MONTH_YEAR_RE)) {
+    const mon = MONTH_NAMES[m[2].toLowerCase()];
+    if (mon) {
+      const dt = tryParseISODate(+m[3], mon, +m[1]);
+      if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+    }
+  }
+  if (sessionDate) {
+    for (const m of text.matchAll(DATE_MONTH_DAY_RE)) {
+      const mon = MONTH_NAMES[m[1].toLowerCase()];
+      if (mon) {
+        const dt = tryParseISODate(sessionDate.getFullYear(), mon, +m[2]);
+        if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+      }
+    }
+  }
+  if (sessionDate) {
+    for (const m of text.matchAll(RELATIVE_AGO_RE)) {
+      const days = unitToDays(+m[1], m[2]);
+      if (days !== null) {
+        const dt = new Date(sessionDate.getTime() - days * 864e5);
+        push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+      }
+    }
+    for (const m of text.matchAll(RELATIVE_IN_RE)) {
+      const days = unitToDays(+m[1], m[2]);
+      if (days !== null) {
+        const dt = new Date(sessionDate.getTime() + days * 864e5);
+        push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+      }
+    }
+  }
+  for (const m of text.matchAll(DURATION_RE)) {
+    push(`duration:${m[1]} ${m[2]}`, contextSnippet(text, m.index, m.index + m[0].length));
+  }
+  return results;
+}
+var PREF_PATTERNS = [
+  // "I use/prefer/like/love/enjoy X"
+  /\bi\s+(?:use|prefer|like|love|enjoy|favor|chose|switched to|started using|always use|usually use)\s+(.{3,60}?)(?:[.,;!?\n]|$)/gi,
+  // "my favorite X is Y"
+  /\bmy\s+(?:favorite|preferred|go-to|usual)\s+\w+\s+(?:is|are|was)\s+(.{3,60}?)(?:[.,;!?\n]|$)/gi,
+  // "I'm a big fan of X"
+  /\bi(?:'m| am)\s+(?:a )?(?:big |huge )?fan of\s+(.{3,60}?)(?:[.,;!?\n]|$)/gi,
+  // "I switched from X to Y"
+  /\bi\s+switched\s+from\s+(.{3,40}?)\s+to\s+(.{3,40}?)(?:[.,;!?\n]|$)/gi
+];
+function extractPreferences(text, documentId = "") {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of PREF_PATTERNS) {
+    for (const m of text.matchAll(pattern)) {
+      const value = (m[1] || "").trim();
+      if (!value || value.length < 3) continue;
+      const key = value.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const ctx = contextSnippet(text, m.index, m.index + m[0].length, 200);
+      let category = "general";
+      if (/tool|software|app|editor|ide|framework|library|language/i.test(ctx)) category = "tool";
+      else if (/hobby|sport|exercise|game|play/i.test(ctx)) category = "hobby";
+      else if (/brand|product|model|device|hardware/i.test(ctx)) category = "brand";
+      else if (/food|drink|restaurant|cuisine|recipe/i.test(ctx)) category = "food";
+      else if (/music|movie|show|book|podcast|artist|band/i.test(ctx)) category = "entertainment";
+      results.push({ category, value, documentId, context: ctx });
+    }
+  }
+  return results;
+}
+var PREFERENCE_Q_RE = /(?:can you (?:recommend|suggest)|any (?:tips|advice|suggestions|recommendations)|what .*(?:recommend|suggest)|what should i|where should i|which .* should i|please (?:recommend|suggest)|based on .* (?:interest|preference|taste)|personalized|tailored to (?:my|me))/i;
+var TEMPORAL_Q_RE = /(?:how many (?:days|weeks|months|years|hours|minutes) (?:passed|did|have|ago|between|since|in total|took)|how long (?:did|was|were|have|has|does)|how long ago|what (?:is the )?order|in order|which .* (?:first|last|earlier|later|before|after|most recent|oldest|newest)|chronological|(?:earlier|later|sooner|newer|older) than)/i;
+var AGGREGATION_Q_RE = /(?:how many|how much|total|all the|count|list all|every|what are all|name all)/i;
+function classifyQuestion(q) {
+  if (PREFERENCE_Q_RE.test(q)) return "preference";
+  if (TEMPORAL_Q_RE.test(q)) return "temporal";
+  if (!TEMPORAL_Q_RE.test(q) && AGGREGATION_Q_RE.test(q)) return "aggregation";
+  return "default";
+}
+var SearchEngine = class {
+  documents = /* @__PURE__ */ new Map();
+  collection = "clawvault";
+  vaultPath = "";
+  collectionRoot = "";
+  qmdIndexName;
+  /** v2.7 — Per-document date index built at ingest time */
+  dateIndex = /* @__PURE__ */ new Map();
+  /** v2.7 — Per-document preference index built at ingest time */
+  preferenceIndex = /* @__PURE__ */ new Map();
+  /** v2.7 — Per-document chunk cache for BM25 pre-filtering */
+  chunkCache = /* @__PURE__ */ new Map();
+  /**
+   * Set the collection name (usually vault name)
+   */
+  setCollection(name) {
+    this.collection = name;
+  }
+  /**
+   * Set the vault path for file resolution
+   */
+  setVaultPath(vaultPath) {
+    this.vaultPath = vaultPath;
+  }
+  /**
+   * Set the collection root for qmd:// URI resolution
+   */
+  setCollectionRoot(root) {
+    this.collectionRoot = path.resolve(root);
+  }
+  /**
+   * Set qmd index name (defaults to qmd global default when omitted)
+   */
+  setIndexName(indexName) {
+    this.qmdIndexName = indexName;
+  }
+  /**
+   * Add or update a document in the local cache.
+   * v2.7: also extracts dates, preferences, and chunks at ingest time.
+   * Note: qmd indexing happens via qmd update command
+   */
+  addDocument(doc) {
+    this.documents.set(doc.id, doc);
+    if (doc.content) {
+      const sessionDate = doc.modified ? isoStr(doc.modified) : void 0;
+      const dates = extractDates(doc.content, sessionDate);
+      for (const d of dates) d.documentId = doc.id;
+      if (dates.length > 0) this.dateIndex.set(doc.id, dates);
+      const prefs = extractPreferences(doc.content, doc.id);
+      if (prefs.length > 0) this.preferenceIndex.set(doc.id, prefs);
+      const chunks = sentenceChunk(doc.content, 600, 1);
+      if (chunks.length > 0) this.chunkCache.set(doc.id, chunks);
+    }
+  }
+  /**
+   * Remove a document from the local cache
+   */
+  removeDocument(id) {
+    this.documents.delete(id);
+    this.dateIndex.delete(id);
+    this.preferenceIndex.delete(id);
+    this.chunkCache.delete(id);
+  }
+  /**
+   * No-op for qmd - indexing is managed externally
+   */
+  rebuildIDF() {
+  }
+  /**
+   * BM25 search via qmd
+   */
+  search(query, options = {}) {
+    return this.runQmdQuery("search", query, options);
+  }
+  /**
+   * Vector/semantic search via qmd vsearch
+   */
+  vsearch(query, options = {}) {
+    return this.runQmdQuery("vsearch", query, options);
+  }
+  /**
+   * Combined search with query expansion (qmd query command)
+   */
+  query(query, options = {}) {
+    return this.runQmdQuery("query", query, options);
+  }
+  runQmdQuery(command, query, options) {
+    const {
+      limit = 10,
+      minScore = 0,
+      category,
+      tags,
+      fullContent = false,
+      temporalBoost = false,
+      relevanceThreshold,
+      thresholdMaxResults = 40
+    } = options;
+    if (!query.trim()) return [];
+    const fetchLimit = relevanceThreshold !== void 0 ? thresholdMaxResults * 2 : limit * 2;
+    const args = [
+      command,
+      query,
+      "-n",
+      String(fetchLimit),
+      "--json"
+    ];
+    if (this.collection) {
+      args.push("-c", this.collection);
+    }
+    const qmdResults = execQmd(args, this.qmdIndexName);
+    const effectiveLimit = relevanceThreshold !== void 0 ? thresholdMaxResults : limit;
+    const results = this.convertResults(qmdResults, {
+      limit: effectiveLimit,
+      minScore: relevanceThreshold !== void 0 ? relevanceThreshold : minScore,
+      category,
+      tags,
+      fullContent,
+      temporalBoost
+    });
+    return results;
+  }
+  // -------------------------------------------------------------------------
+  // v2.7 — New public APIs
+  // -------------------------------------------------------------------------
+  /**
+   * v2.7 — Chunk-level BM25 pre-filtered search. Ranks chunks within each
+   * document by keyword relevance before semantic ranking, so relevant
+   * content deep in long documents isn't missed.
+   *
+   * Returns results with snippets from the best-matching chunks.
+   */
+  chunkPrefilterSearch(query, options = {}) {
+    const terms = queryTerms(query);
+    const results = this.runQmdQuery("query", query, options);
+    for (const r of results) {
+      const chunks = this.chunkCache.get(r.document.id);
+      if (chunks && chunks.length > 0 && terms.length > 0) {
+        const ranked = bm25RankChunks(chunks, terms, 3);
+        if (ranked.length > 0 && ranked[0].score > 0) {
+          r.snippet = ranked.map((c) => c.text).join("\n...\n").slice(0, 600);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * v2.7 — Exhaustive threshold-based search for aggregation queries.
+   * Keeps pulling results until relevance drops below threshold.
+   */
+  exhaustiveSearch(query, threshold = 0.01, maxResults = 40) {
+    return this.runQmdQuery("query", query, {
+      relevanceThreshold: threshold,
+      thresholdMaxResults: maxResults,
+      fullContent: false
+    });
+  }
+  /**
+   * v2.7 — Get all extracted dates, optionally filtered by document ids.
+   */
+  getDates(documentIds) {
+    const all = [];
+    const iter = documentIds ? documentIds.map((id) => [id, this.dateIndex.get(id)]).filter(([, v]) => v) : this.dateIndex.entries();
+    for (const [, dates] of iter) {
+      if (dates) all.push(...dates);
+    }
+    return all;
+  }
+  /**
+   * v2.7 — Get all extracted preferences, optionally filtered by document ids.
+   */
+  getPreferences(documentIds) {
+    const all = [];
+    const iter = documentIds ? documentIds.map((id) => [id, this.preferenceIndex.get(id)]).filter(([, v]) => v) : this.preferenceIndex.entries();
+    for (const [, prefs] of iter) {
+      if (prefs) all.push(...prefs);
+    }
+    return all;
+  }
+  /**
+   * v2.7 — Search with automatic strategy selection based on question type.
+   * Classifies the query and routes to the appropriate pipeline.
+   */
+  smartQuery(query, options = {}) {
+    const qtype = classifyQuestion(query);
+    switch (qtype) {
+      case "aggregation":
+        return this.exhaustiveSearch(query, 0.01, options.thresholdMaxResults ?? 40);
+      case "preference":
+      case "temporal":
+      default:
+        return this.chunkPrefilterSearch(query, { ...options, limit: options.limit ?? 10 });
+    }
+  }
+  /**
+   * Convert qmd results to ClawVault SearchResult format
+   */
+  convertResults(qmdResults, options) {
+    const { limit = 10, minScore = 0, category, tags, fullContent = false, temporalBoost = false } = options;
+    const results = [];
+    const maxScore = qmdResults[0]?.score || 1;
+    for (const qr of qmdResults) {
+      const filePath = this.qmdUriToPath(qr.file);
+      const relativePath = this.vaultPath ? path.relative(this.vaultPath, filePath) : filePath;
+      const normalizedRelativePath = relativePath.replace(/\\/g, "/");
+      if (normalizedRelativePath.startsWith("ledger/archive/") || normalizedRelativePath.includes("/ledger/archive/")) {
+        continue;
+      }
+      const docId = normalizedRelativePath.replace(/\.md$/, "");
+      let doc = this.documents.get(docId) ?? this.documents.get(docId.split("/").join(path.sep));
+      const modifiedAt = this.resolveModifiedAt(doc, filePath);
+      const parts = normalizedRelativePath.split("/");
+      const docCategory = parts.length > 1 ? parts[0] : "root";
+      if (category && docCategory !== category) continue;
+      if (tags && tags.length > 0 && doc) {
+        const docTags = new Set(doc.tags);
+        if (!tags.some((t) => docTags.has(t))) continue;
+      }
+      const normalizedScore = maxScore > 0 ? qr.score / maxScore : 0;
+      const finalScore = temporalBoost ? normalizedScore * this.getRecencyFactor(modifiedAt) : normalizedScore;
+      if (finalScore < minScore) continue;
+      if (!doc) {
+        doc = {
+          id: docId,
+          path: filePath,
+          category: docCategory,
+          title: qr.title || path.basename(relativePath, ".md"),
+          content: "",
+          // Content loaded separately if needed
+          frontmatter: {},
+          links: [],
+          tags: [],
+          modified: modifiedAt
+        };
+      }
+      results.push({
+        document: fullContent ? doc : { ...doc, content: "" },
+        score: finalScore,
+        snippet: this.stripSupersededFromSnippet(this.cleanSnippet(qr.snippet)),
+        matchedTerms: []
+        // qmd doesn't provide this
+      });
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  resolveModifiedAt(doc, filePath) {
+    if (doc) return doc.modified;
+    try {
+      return fs2.statSync(filePath).mtime;
+    } catch {
+      return /* @__PURE__ */ new Date(0);
+    }
+  }
+  getRecencyFactor(modifiedAt) {
+    const ageMs = Math.max(0, Date.now() - modifiedAt.getTime());
+    const ageDays = ageMs / (24 * 60 * 60 * 1e3);
+    if (ageDays < 1) return 1;
+    if (ageDays <= 7) return 0.9;
+    return 0.7;
+  }
+  /**
+   * Convert qmd:// URI to file path
+   */
+  qmdUriToPath(uri) {
+    if (uri.startsWith("qmd://")) {
+      const withoutScheme = uri.slice(6);
+      const slashIndex = withoutScheme.indexOf("/");
+      if (slashIndex > -1) {
+        const relativePath = withoutScheme.slice(slashIndex + 1);
+        const root = this.collectionRoot || this.vaultPath;
+        if (root) {
+          return path.join(root, relativePath);
+        }
+        return relativePath;
+      }
+    }
+    return uri;
+  }
+  /**
+   * v2.8 — Filter superseded observation lines from snippet text.
+   * Ensures search results prefer the latest version of knowledge.
+   */
+  stripSupersededFromSnippet(snippet) {
+    if (!snippet) return snippet;
+    return snippet.split("\n").filter((line) => !isSuperseded(line)).join("\n");
+  }
+  /**
+   * Clean up qmd snippet format
+   */
+  cleanSnippet(snippet) {
+    if (!snippet) return "";
+    return snippet.replace(/@@ [-+]?\d+,?\d* @@ \([^)]+\)/g, "").trim().split("\n").slice(0, 3).join("\n").slice(0, 300);
+  }
+  /**
+   * Get all cached documents
+   */
+  getAllDocuments() {
+    return [...this.documents.values()];
+  }
+  /**
+   * Get document count
+   */
+  get size() {
+    return this.documents.size;
+  }
+  /**
+   * Clear the local document cache and all v2.7 indices
+   */
+  clear() {
+    this.documents.clear();
+    this.dateIndex.clear();
+    this.preferenceIndex.clear();
+    this.chunkCache.clear();
+  }
+  /**
+   * Export documents for persistence
+   */
+  export() {
+    return {
+      documents: [...this.documents.values()]
+    };
+  }
+  /**
+   * Import from persisted data
+   */
+  import(data) {
+    this.clear();
+    for (const doc of data.documents) {
+      this.addDocument(doc);
+    }
+  }
+};
+function extractWikiLinks(content) {
+  const matches = content.match(/\[\[([^\]]+)\]\]/g) || [];
+  return matches.map((m) => m.slice(2, -2).toLowerCase());
+}
+function extractTags(content) {
+  const matches = content.match(/#[\w-]+/g) || [];
+  return [...new Set(matches.map((m) => m.slice(1).toLowerCase()))];
+}
+
+export {
+  isSuperseded,
+  getSupersessionInfo,
+  extractEntities,
+  entitySimilarity,
+  isKnowledgeUpdate,
+  reweave,
+  filterSuperseded,
+  stripSupersededObservations,
+  QMD_INSTALL_URL,
+  QMD_INSTALL_COMMAND,
+  QmdUnavailableError,
+  withQmdIndexArgs,
+  hasQmd,
+  qmdUpdate,
+  qmdEmbed,
+  sentenceChunk,
+  bm25RankChunks,
+  extractDates,
+  extractPreferences,
+  classifyQuestion,
+  SearchEngine,
+  extractWikiLinks,
+  extractTags
+};