clawvault 3.1.0 → 3.2.0

package/dist/chunk-D2H45LON.js

@@ -1,1074 +0,0 @@
-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 [];
-  if (trimmed.startsWith("No results") || trimmed.startsWith("No matches")) 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
-};