clawvault 3.2.1 → 3.4.0

package/dist/chunk-RL2L6I6K.js

@@ -0,0 +1,223 @@
+// src/recall/strategies.ts
+var VERIFICATION_PATTERN = /\b(verify|verification|source|citation|cite|proof|prove|where did|evidence)\b/i;
+var TEMPORAL_PATTERN = /\b(today|yesterday|last\s+(?:day|week|month|year)|this\s+(?:week|month|year)|recent|recently|timeline|when)\b/i;
+var RELATIONSHIP_PATTERN = /\b(relationship|relates?|connected|between|depends on|works with|reports to|interacts? with)\b/i;
+function parseTemporalWindowDays(query) {
+  if (/\byesterday\b/i.test(query)) return 2;
+  if (/\btoday\b/i.test(query)) return 1;
+  if (/\blast\s+day\b/i.test(query)) return 1;
+  if (/\blast\s+week\b/i.test(query)) return 7;
+  if (/\bthis\s+week\b/i.test(query)) return 7;
+  if (/\blast\s+month\b/i.test(query)) return 31;
+  if (/\bthis\s+month\b/i.test(query)) return 31;
+  if (/\blast\s+year\b/i.test(query) || /\bthis\s+year\b/i.test(query)) return 366;
+  return void 0;
+}
+function inferEntityName(query, knownEntityNames) {
+  const wikiLink = query.match(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/);
+  if (wikiLink?.[1]) {
+    return wikiLink[1].trim();
+  }
+  const normalizedQuery = query.toLowerCase();
+  for (const entity of knownEntityNames) {
+    if (!entity.trim()) continue;
+    if (normalizedQuery.includes(entity.toLowerCase())) {
+      return entity;
+    }
+  }
+  const capSequence = query.match(/\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,2})\b/);
+  if (capSequence?.[1]) {
+    return capSequence[1].trim();
+  }
+  return void 0;
+}
+function classifyRecallQuery(query, knownEntityNames = [], forcedStrategy) {
+  if (forcedStrategy) {
+    return {
+      strategy: forcedStrategy,
+      entityName: forcedStrategy === "entity" ? inferEntityName(query, knownEntityNames) : void 0,
+      temporalDays: forcedStrategy === "temporal" ? parseTemporalWindowDays(query) : void 0
+    };
+  }
+  const entityName = inferEntityName(query, knownEntityNames);
+  if (RELATIONSHIP_PATTERN.test(query)) {
+    return { strategy: "relationship", entityName };
+  }
+  if (VERIFICATION_PATTERN.test(query)) {
+    return { strategy: "verification", entityName };
+  }
+  if (TEMPORAL_PATTERN.test(query)) {
+    return {
+      strategy: "temporal",
+      entityName,
+      temporalDays: parseTemporalWindowDays(query)
+    };
+  }
+  if (entityName) {
+    return { strategy: "entity", entityName };
+  }
+  return { strategy: "quick" };
+}
+
+// src/recall/service.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+var DEFAULT_LIMIT = 6;
+var DEFAULT_MAX_SNIPPET = 220;
+function compactSnippet(value, maxChars = DEFAULT_MAX_SNIPPET) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) return "No snippet available.";
+  return normalized.slice(0, maxChars);
+}
+function toIso(value) {
+  return value.toISOString();
+}
+function parseFrontmatterDate(raw) {
+  if (typeof raw !== "string" && !(raw instanceof Date)) return null;
+  const date = raw instanceof Date ? raw : new Date(raw);
+  if (Number.isNaN(date.getTime())) return null;
+  return date;
+}
+function formatContextHeader(strategy, query) {
+  return [
+    "[ClawVault memory recall]",
+    `strategy: ${strategy}`,
+    `query: ${query}`
+  ].join(" | ");
+}
+function isRelationshipResult(result) {
+  const memoryType = typeof result.document.frontmatter.memoryType === "string" ? result.document.frontmatter.memoryType.toLowerCase() : "";
+  if (memoryType === "relationship") {
+    return true;
+  }
+  const content = `${result.document.title}
+${result.document.content}`;
+  return /\b(works with|reports to|related to|depends on|collaborates with|partnered with|between)\b/i.test(content) || (result.document.links?.length ?? 0) >= 2;
+}
+function filterTemporalResults(results, days) {
+  if (!days || !Number.isFinite(days) || days <= 0) {
+    return results;
+  }
+  const windowMs = days * 24 * 60 * 60 * 1e3;
+  const cutoff = Date.now() - windowMs;
+  return results.filter((result) => {
+    const fmDate = parseFrontmatterDate(result.document.frontmatter.date);
+    const reference = fmDate ?? result.document.modified;
+    return reference.getTime() >= cutoff;
+  });
+}
+function entityProfilePath(vaultPath, entityName) {
+  const slug = entityName.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+  return path.join(vaultPath, "entities", `${slug}.md`);
+}
+function readEntityBrief(vaultPath, entityName) {
+  const filePath = entityProfilePath(vaultPath, entityName);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const parsed = matter(fs.readFileSync(filePath, "utf-8"));
+  const kind = typeof parsed.data.kind === "string" ? parsed.data.kind : "unknown";
+  const summary = parsed.content.split(/\r?\n/).map((line) => line.trim()).find((line) => line && !line.startsWith("#") && !line.startsWith("-")) ?? "";
+  const relationships = Array.isArray(parsed.data.relationships) ? parsed.data.relationships.slice(0, 4).map((entry) => {
+    if (typeof entry === "string") return entry;
+    if (!entry || typeof entry !== "object") return "";
+    const record = entry;
+    return typeof record.target === "string" ? record.target : "";
+  }).filter(Boolean) : [];
+  const relationshipChunk = relationships.length > 0 ? ` Relationships: ${relationships.join(", ")}.` : "";
+  return `Entity brief: ${entityName} (${kind}). ${summary}${relationshipChunk}`.trim();
+}
+function toRecallSource(result) {
+  return {
+    title: result.document.title,
+    path: result.document.id,
+    category: result.document.category,
+    score: Number(result.score.toFixed(4)),
+    snippet: compactSnippet(result.snippet || result.document.content),
+    modified: toIso(result.document.modified)
+  };
+}
+function uniqueEntityNames(results) {
+  const names = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    if (result.document.category === "people" || result.document.category === "projects" || result.document.category === "entities") {
+      names.add(result.document.title);
+    }
+    for (const link of result.document.links) {
+      if (link.trim()) names.add(link.trim());
+    }
+  }
+  return [...names];
+}
+function formatRecallContext(result, includeSources) {
+  const lines = [formatContextHeader(result.strategy, result.query), ""];
+  if (result.sources.length === 0) {
+    lines.push("No relevant memories found.");
+    return lines.join("\n");
+  }
+  if (result.strategy === "verification") {
+    lines.push("Verification-oriented evidence:");
+  } else if (result.strategy === "relationship") {
+    lines.push("Relationship-focused recall:");
+  } else if (result.strategy === "temporal") {
+    lines.push("Time-filtered recall:");
+  } else if (result.strategy === "entity" && result.entityName) {
+    lines.push(`Entity-focused recall for "${result.entityName}":`);
+  } else {
+    lines.push("Relevant recall:");
+  }
+  lines.push("");
+  for (const source of result.sources) {
+    const sourceTail = includeSources || result.strategy === "verification" ? ` [${source.path}]` : "";
+    lines.push(`- (${source.score.toFixed(2)}) ${source.title}${sourceTail}`);
+    lines.push(`  ${source.snippet}`);
+  }
+  return lines.join("\n").trim();
+}
+async function buildRecallResult(vault, query, options = {}) {
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const broadLimit = Math.max(limit * 4, limit);
+  const seededResults = await vault.find(query, {
+    limit: broadLimit,
+    temporalBoost: true,
+    ...options.searchOptions ?? {}
+  });
+  const knownEntityNames = uniqueEntityNames(seededResults);
+  const classification = classifyRecallQuery(query, knownEntityNames, options.strategy);
+  let scopedResults = seededResults;
+  if (classification.strategy === "entity" && classification.entityName) {
+    scopedResults = await vault.find(`"${classification.entityName}" ${query}`, {
+      limit: broadLimit,
+      temporalBoost: true,
+      ...options.searchOptions ?? {}
+    });
+  } else if (classification.strategy === "temporal") {
+    scopedResults = filterTemporalResults(scopedResults, classification.temporalDays);
+  } else if (classification.strategy === "relationship") {
+    scopedResults = scopedResults.filter((result) => isRelationshipResult(result));
+  } else if (classification.strategy === "verification") {
+    scopedResults = [...scopedResults].sort((left, right) => right.score - left.score);
+  }
+  const selected = scopedResults.slice(0, limit);
+  const sources = selected.map(toRecallSource);
+  const entityBrief = classification.entityName ? readEntityBrief(vault.getPath(), classification.entityName) : null;
+  const provisionalResult = {
+    query,
+    strategy: classification.strategy,
+    entityName: classification.entityName,
+    context: "",
+    sources,
+    rawResults: selected
+  };
+  const baseContext = formatRecallContext(provisionalResult, options.includeSources ?? false);
+  provisionalResult.context = entityBrief ? `${baseContext}
+
+${entityBrief}` : baseContext;
+  return provisionalResult;
+}
+
+export {
+  classifyRecallQuery,
+  buildRecallResult
+};

package/dist/{chunk-IIOU45CK.js → chunk-S7N7HI5E.js}

@@ -1,10 +1,10 @@
 import {
   resolveVaultPath
-} from "./chunk-GNJL4YGR.js";
+} from "./chunk-GJO3CFUN.js";
 import {
   buildOrUpdateMemoryGraphIndex,
   loadMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 
 // src/commands/graph.ts
 function formatGraphSummary(summary) {

package/dist/{chunk-ECRZL5XR.js → chunk-T7E764W3.js}

@@ -1,14 +1,15 @@
 import {
-  loadVaultQmdConfig
-} from "./chunk-WIOLLGAD.js";
+  loadVaultQmdConfig,
+  recoverQmdEmbeddingIfNeeded,
+  runCrashSafeQmdEmbed
+} from "./chunk-FZ5I2NF7.js";
 import {
   QmdUnavailableError,
-  hasQmd,
-  qmdEmbed
-} from "./chunk-5PJ4STIC.js";
+  hasQmd
+} from "./chunk-PTWPPVC7.js";
 import {
   resolveVaultPath
-} from "./chunk-GNJL4YGR.js";
+} from "./chunk-GJO3CFUN.js";
 
 // src/commands/embed.ts
 async function embedCommand(options = {}) {
@@ -18,12 +19,27 @@ async function embedCommand(options = {}) {
   const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
   const qmdConfig = loadVaultQmdConfig(vaultPath);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const recovery = recoverQmdEmbeddingIfNeeded({
+    vaultPath,
+    collection: qmdConfig.qmdCollection,
+    rootPath: qmdConfig.qmdRoot,
+    mode: "marker-or-empty",
+    onLog: options.quiet ? void 0 : (message) => console.log(message)
+  });
+  if (!options.quiet && recovery.recovered) {
+    const reasonLabel = recovery.reason === "interrupted_wal" ? "interrupted run" : "empty vector state";
+    console.log(`\u2713 Automatic qmd recovery completed (${reasonLabel}).`);
+  }
   if (!options.quiet) {
     console.log(
       `Embedding pending documents for collection "${qmdConfig.qmdCollection}" (root: ${qmdConfig.qmdRoot})...`
     );
   }
-  qmdEmbed(qmdConfig.qmdCollection);
+  runCrashSafeQmdEmbed({
+    vaultPath,
+    collection: qmdConfig.qmdCollection,
+    rootPath: qmdConfig.qmdRoot
+  });
   const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
   if (!options.quiet) {
     console.log(`\u2713 Embedding complete for "${qmdConfig.qmdCollection}"`);

package/dist/{chunk-MNPUYCHQ.js → chunk-TWMI3SNN.js}

@@ -1,14 +1,14 @@
-import {
-  normalizeObservationContent,
-  parseObservationMarkdown
-} from "./chunk-FHFUXL6G.js";
 import {
   requestLlmCompletion,
   resolveLlmProvider
-} from "./chunk-YXQCA6B7.js";
+} from "./chunk-DVOUSOR3.js";
 import {
   archiveObservations
 } from "./chunk-MQUJNOHK.js";
+import {
+  normalizeObservationContent,
+  parseObservationMarkdown
+} from "./chunk-FHFUXL6G.js";
 import {
   formatIsoWeekKey,
   getIsoWeek,
@@ -235,6 +235,7 @@ async function maybeGenerateLlmReflection(weekKey, sections) {
     const output = await requestLlmCompletion({
       provider,
       prompt,
+      tier: "default",
       temperature: 0.1,
       maxTokens: 1200
     });

package/dist/{chunk-2RAZ4ZFE.js → chunk-VBILES4B.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-MQUJNOHK.js";
 import {
   resolveVaultPath
-} from "./chunk-GNJL4YGR.js";
+} from "./chunk-GJO3CFUN.js";
 
 // src/commands/archive.ts
 function parsePositiveInteger(raw, label) {

package/dist/{chunk-PI4WMLMG.js → chunk-VXAGOLDP.js}

@@ -1,6 +1,6 @@
 import {
   Observer
-} from "./chunk-Y3TIJEBP.js";
+} from "./chunk-7SWP5FKU.js";
 import {
   getSessionsDir
 } from "./chunk-HRLWZGMA.js";

package/dist/{chunk-SS4B7P7V.js → chunk-YIDV4VV2.js}

@@ -1,6 +1,6 @@
 import {
   resolveVaultPath
-} from "./chunk-GNJL4YGR.js";
+} from "./chunk-GJO3CFUN.js";
 
 // src/commands/sync-bd.ts
 import * as fs from "fs";

package/dist/chunk-YTRZNA64.js

@@ -0,0 +1,37 @@
+import {
+  buildRecallResult
+} from "./chunk-RL2L6I6K.js";
+import {
+  ClawVault
+} from "./chunk-ECGJYWNA.js";
+import {
+  resolveVaultPath
+} from "./chunk-GJO3CFUN.js";
+
+// src/commands/recall.ts
+async function recallCommand(query, options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const vault = new ClawVault(vaultPath);
+  await vault.load();
+  const recallOptions = {
+    limit: options.limit,
+    strategy: options.strategy,
+    includeSources: options.includeSources
+  };
+  const result = await buildRecallResult(vault, query, recallOptions);
+  if (options.json) {
+    console.log(JSON.stringify({
+      strategy: result.strategy,
+      query: result.query,
+      sources: result.sources,
+      context: result.context
+    }, null, 2));
+    return result;
+  }
+  console.log(result.context);
+  return result;
+}
+
+export {
+  recallCommand
+};