clawvault 3.2.1 → 3.4.0

package/dist/{chunk-Y6VJKXGL.js → chunk-KCYWJDDW.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-TIGW564L.js";
 import {
   resolveVaultPath
-} from "./chunk-GNJL4YGR.js";
+} from "./chunk-GJO3CFUN.js";
 
 // src/commands/tailscale.ts
 import * as path from "path";

package/dist/{chunk-P5EPF6MB.js → chunk-MW5C6ZQA.js}

@@ -4,12 +4,100 @@ import * as path from "path";
 var JSONL_SAMPLE_LIMIT = 20;
 var MARKDOWN_SIGNAL_RE = /^(#{1,6}\s|[-*+]\s|>\s)/;
 var MARKDOWN_INLINE_RE = /(\[[^\]]+\]\([^)]+\)|[*_`~])/;
+var BASE64_DATA_URI_RE = /\bdata:[^;\s]+;base64,[A-Za-z0-9+/=]{24,}\b/gi;
+var LONG_BASE64_TOKEN_RE = /\b[A-Za-z0-9+/]{80,}={0,2}\b/g;
+var STRUCTURED_NOISE_MARKER_RE = /\b(?:tool[_-]?result|tool[_-]?use|toolcallid|tooluseid|function[_-]?(?:call|result)|stdout|stderr|exitcode|recordedat|trace(?:_|-)?id|parent(?:_|-)?id|session(?:_|-)?id|metadata|base64|mime(?:type)?)\b/i;
+var NOISY_PREFIX_RE = /^(?:metadata|system metadata|session metadata)\s*:/i;
+function normalizeToken(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, "");
+}
 function normalizeText(value) {
   return value.replace(/\s+/g, " ").trim();
 }
+function shouldDropRole(role) {
+  const normalized = normalizeToken(role);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "system" || normalized === "developer" || normalized === "metadata") {
+    return true;
+  }
+  return normalized.startsWith("tool");
+}
+function isConversationRolePrefix(role) {
+  const normalized = normalizeToken(role);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "user" || normalized === "assistant" || normalized === "system") {
+    return true;
+  }
+  if (normalized === "developer" || normalized === "metadata") {
+    return true;
+  }
+  return normalized.startsWith("tool");
+}
+function isNoisyBlockType(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const normalized = normalizeToken(value);
+  if (!normalized || normalized === "text" || normalized === "markdown") {
+    return false;
+  }
+  return normalized.includes("tool") || normalized.includes("functioncall") || normalized.includes("functionresult") || normalized.includes("thinking") || normalized.includes("reason") || normalized.includes("metadata");
+}
+function stripNoisyData(value) {
+  return normalizeText(
+    value.replace(BASE64_DATA_URI_RE, " ").replace(LONG_BASE64_TOKEN_RE, " ")
+  );
+}
+function isLikelyStructuredNoise(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return true;
+  }
+  if (NOISY_PREFIX_RE.test(trimmed)) {
+    return true;
+  }
+  const looksStructured = trimmed.startsWith("{") || trimmed.startsWith("[");
+  if (looksStructured && STRUCTURED_NOISE_MARKER_RE.test(trimmed) && trimmed.length >= 40) {
+    return true;
+  }
+  return false;
+}
+function sanitizeExtractedText(value) {
+  const stripped = stripNoisyData(value);
+  if (!stripped) {
+    return "";
+  }
+  if (isLikelyStructuredNoise(stripped)) {
+    return "";
+  }
+  return stripped;
+}
+function sanitizeParsedMessage(message) {
+  const normalized = normalizeText(message);
+  if (!normalized) {
+    return "";
+  }
+  const roleMatch = /^([a-z][a-z0-9_-]{1,31})\s*:\s*(.+)$/i.exec(normalized);
+  if (roleMatch && isConversationRolePrefix(roleMatch[1])) {
+    const role = normalizeRole(roleMatch[1]);
+    if (shouldDropRole(role)) {
+      return "";
+    }
+    const content = sanitizeExtractedText(roleMatch[2]);
+    if (!content) {
+      return "";
+    }
+    return role ? `${role}: ${content}` : content;
+  }
+  return sanitizeExtractedText(normalized);
+}
 function extractText(value) {
   if (typeof value === "string") {
-    return normalizeText(value);
+    return sanitizeExtractedText(value);
   }
   if (Array.isArray(value)) {
     const parts = [];
@@ -25,11 +113,17 @@ function extractText(value) {
     return "";
   }
   const record = value;
+  if (isNoisyBlockType(record.type)) {
+    return "";
+  }
   if (typeof record.text === "string") {
-    return normalizeText(record.text);
+    return sanitizeExtractedText(record.text);
   }
   if (typeof record.content === "string") {
-    return normalizeText(record.content);
+    return sanitizeExtractedText(record.content);
+  }
+  if (record.content !== void 0) {
+    return extractText(record.content);
   }
   return "";
 }
@@ -69,16 +163,18 @@ function parseJsonLine(line) {
   const entry = parsed;
   if ("role" in entry && "content" in entry) {
     const role = normalizeRole(entry.role);
+    if (shouldDropRole(role)) return "";
     const content = extractText(entry.content);
     if (!content) return "";
-    return role ? `${role}: ${content}` : content;
+    return sanitizeParsedMessage(role ? `${role}: ${content}` : content);
   }
   if (entry.type === "message" && entry.message && typeof entry.message === "object") {
     const message = entry.message;
     const role = normalizeRole(message.role);
+    if (shouldDropRole(role)) return "";
     const content = extractText(message.content);
     if (!content) return "";
-    return role ? `${role}: ${content}` : content;
+    return sanitizeParsedMessage(role ? `${role}: ${content}` : content);
   }
   return "";
 }
@@ -119,17 +215,21 @@ function parseMarkdown(raw) {
     if (roleMatch) {
       const role = normalizeRole(roleMatch[1]);
       const content = normalizeText(roleMatch[2]);
-      if (content) {
-        messages.push(`${role}: ${content}`);
+      const parsed2 = sanitizeParsedMessage(`${role}: ${content}`);
+      if (parsed2) {
+        messages.push(parsed2);
       }
       continue;
     }
-    messages.push(joined);
+    const parsed = sanitizeParsedMessage(joined);
+    if (parsed) {
+      messages.push(parsed);
+    }
   }
   return messages;
 }
 function parsePlainText(raw) {
-  return raw.split(/\r?\n/).map((line) => normalizeText(line)).filter(Boolean);
+  return raw.split(/\r?\n/).map((line) => sanitizeParsedMessage(line)).filter(Boolean);
 }
 function detectSessionFormat(raw, filePath) {
   const nonEmptyLines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -163,10 +263,7 @@ function parseSessionFile(filePath) {
   const raw = fs.readFileSync(resolved, "utf-8");
   const format = detectSessionFormat(raw, resolved);
   if (format === "jsonl") {
-    const parsed = parseJsonLines(raw);
-    if (parsed.length > 0) {
-      return parsed;
-    }
+    return parseJsonLines(raw);
   }
   if (format === "markdown") {
     const parsed = parseMarkdown(raw);

package/dist/chunk-NSXYM6EZ.js

@@ -0,0 +1,255 @@
+import {
+  ClawVault
+} from "./chunk-ECGJYWNA.js";
+
+// src/entities/synthesis.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+function slugify(value) {
+  return value.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+}
+function cleanEntityName(value) {
+  const stripped = value.replace(/[#*_`]/g, "").trim();
+  if (!stripped) return stripped;
+  if (/[A-Z]/.test(stripped)) {
+    return stripped;
+  }
+  return stripped.replace(/[-_]+/g, " ").split(/\s+/).filter(Boolean).map((token) => token.charAt(0).toUpperCase() + token.slice(1)).join(" ");
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    const normalized = value.trim();
+    if (!normalized) continue;
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(normalized);
+  }
+  return out;
+}
+function extractBestSnippet(document) {
+  const content = document.content.replace(/\s+/g, " ").trim();
+  if (!content) return `Referenced in ${document.id}`;
+  return content.slice(0, 180);
+}
+function inferEntityKind(name, mentions) {
+  const categoryCounts = /* @__PURE__ */ new Map();
+  for (const mention of mentions) {
+    categoryCounts.set(
+      mention.document.category,
+      (categoryCounts.get(mention.document.category) ?? 0) + 1
+    );
+  }
+  if ((categoryCounts.get("people") ?? 0) >= (categoryCounts.get("projects") ?? 0) && (categoryCounts.get("people") ?? 0) > 0) {
+    return "person";
+  }
+  if ((categoryCounts.get("projects") ?? 0) > 0) {
+    return "project";
+  }
+  if (/\b(inc|corp|llc|ltd|org|foundation|company)\b/i.test(name)) {
+    return "org";
+  }
+  if (/\b(city|county|street|park|mount|river|lake|bay)\b/i.test(name)) {
+    return "place";
+  }
+  return "unknown";
+}
+function buildSummary(name, mentions) {
+  if (mentions.length === 0) {
+    return `${name} is tracked in ClawVault memories.`;
+  }
+  const newest = [...mentions].sort(
+    (left, right) => right.document.modified.getTime() - left.document.modified.getTime()
+  )[0];
+  const snippet = newest?.snippet ?? `${name} is referenced in memory files.`;
+  return snippet.endsWith(".") ? snippet : `${snippet}.`;
+}
+function toIsoDate(value) {
+  return value.toISOString();
+}
+function buildRelationshipGraph(entityMentions) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const [entityName, mentions] of entityMentions.entries()) {
+    for (const mention of mentions) {
+      const coMentioned = uniqueStrings(
+        mention.document.links.map((link) => cleanEntityName(link))
+      ).filter((candidate) => candidate.toLowerCase() !== entityName.toLowerCase());
+      if (coMentioned.length === 0) continue;
+      if (!graph.has(entityName)) {
+        graph.set(entityName, /* @__PURE__ */ new Map());
+      }
+      const adjacency = graph.get(entityName);
+      for (const related of coMentioned) {
+        const current = adjacency.get(related) ?? {
+          target: related,
+          count: 0,
+          evidence: /* @__PURE__ */ new Set()
+        };
+        current.count += 1;
+        current.evidence.add(mention.document.id);
+        adjacency.set(related, current);
+      }
+    }
+  }
+  return graph;
+}
+function toRelationships(accumulator) {
+  if (!accumulator) return [];
+  return [...accumulator.values()].sort((left, right) => right.count - left.count).slice(0, 8).map((entry) => ({
+    target: entry.target,
+    strength: entry.count,
+    evidence: [...entry.evidence].slice(0, 5)
+  }));
+}
+function renderEntityProfileMarkdown(profile) {
+  const frontmatter = {
+    title: profile.name,
+    aliases: profile.aliases,
+    kind: profile.kind,
+    lastMentioned: profile.lastMentioned,
+    relationships: profile.relationships.map((relationship) => ({
+      target: relationship.target,
+      strength: relationship.strength,
+      evidence: relationship.evidence
+    }))
+  };
+  const relationshipLines = profile.relationships.length > 0 ? profile.relationships.map((relationship) => `- [[${relationship.target}]] (strength: ${relationship.strength})`).join("\n") : "- No relationships recorded yet.";
+  const body = [
+    `# ${profile.name}`,
+    "",
+    profile.summary,
+    "",
+    "## Relationships",
+    relationshipLines,
+    "",
+    "## Metadata",
+    `- Kind: ${profile.kind}`,
+    `- Last mentioned: ${profile.lastMentioned}`
+  ].join("\n");
+  return matter.stringify(body, frontmatter);
+}
+function parseEntityProfile(filePath) {
+  const parsed = matter(fs.readFileSync(filePath, "utf-8"));
+  const title = typeof parsed.data.title === "string" ? parsed.data.title : path.basename(filePath, ".md");
+  const aliases = Array.isArray(parsed.data.aliases) ? parsed.data.aliases.map((value) => String(value)) : [title];
+  const kind = typeof parsed.data.kind === "string" ? parsed.data.kind : "unknown";
+  const relationships = Array.isArray(parsed.data.relationships) ? parsed.data.relationships.map((value) => {
+    if (!value || typeof value !== "object") return null;
+    const record = value;
+    if (typeof record.target !== "string") return null;
+    const strengthValue = typeof record.strength === "number" ? record.strength : Number.parseFloat(String(record.strength ?? "1"));
+    return {
+      target: record.target,
+      strength: Number.isFinite(strengthValue) ? strengthValue : 1,
+      evidence: Array.isArray(record.evidence) ? record.evidence.map((entry) => String(entry)) : []
+    };
+  }).filter((value) => Boolean(value)) : [];
+  const summary = parsed.content.split(/\r?\n/).map((line) => line.trim()).find((line) => line && !line.startsWith("#") && !line.startsWith("-")) ?? `${title} profile`;
+  const lastMentioned = typeof parsed.data.lastMentioned === "string" ? parsed.data.lastMentioned : (/* @__PURE__ */ new Date(0)).toISOString();
+  return {
+    name: title,
+    aliases: uniqueStrings([title, ...aliases]),
+    kind,
+    summary,
+    relationships,
+    lastMentioned
+  };
+}
+async function collectEntityMentions(vaultPath) {
+  const vault = new ClawVault(vaultPath);
+  await vault.load();
+  const docs = await vault.list();
+  const map = /* @__PURE__ */ new Map();
+  for (const document of docs) {
+    const names = uniqueStrings(
+      document.category === "people" || document.category === "projects" ? [document.title, ...document.links.map((link) => cleanEntityName(link))] : document.links.map((link) => cleanEntityName(link))
+    );
+    for (const name of names) {
+      if (!map.has(name)) {
+        map.set(name, []);
+      }
+      map.get(name).push({
+        document,
+        snippet: extractBestSnippet(document)
+      });
+    }
+  }
+  return map;
+}
+async function synthesizeEntityProfiles(vaultPath, options = {}) {
+  const mentions = await collectEntityMentions(vaultPath);
+  const relationshipGraph = buildRelationshipGraph(mentions);
+  const profiles = [];
+  for (const [name, records] of mentions.entries()) {
+    const kind = inferEntityKind(name, records);
+    const relationships = toRelationships(relationshipGraph.get(name));
+    const aliases = uniqueStrings([
+      name,
+      slugify(name).replace(/-/g, " ")
+    ]);
+    const lastMentioned = toIsoDate(
+      records.reduce(
+        (latest, record) => record.document.modified.getTime() > latest.getTime() ? record.document.modified : latest,
+        /* @__PURE__ */ new Date(0)
+      )
+    );
+    profiles.push({
+      name,
+      aliases,
+      kind,
+      summary: buildSummary(name, records),
+      relationships,
+      lastMentioned
+    });
+  }
+  profiles.sort((left, right) => right.lastMentioned.localeCompare(left.lastMentioned));
+  if (options.writeFiles ?? true) {
+    const entitiesDir = path.join(vaultPath, "entities");
+    if (!fs.existsSync(entitiesDir)) {
+      fs.mkdirSync(entitiesDir, { recursive: true });
+    }
+    for (const profile of profiles) {
+      const targetPath = path.join(entitiesDir, `${slugify(profile.name)}.md`);
+      fs.writeFileSync(targetPath, renderEntityProfileMarkdown(profile), "utf-8");
+    }
+  }
+  return profiles;
+}
+function readEntityProfiles(vaultPath) {
+  const entitiesDir = path.join(vaultPath, "entities");
+  if (!fs.existsSync(entitiesDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(entitiesDir).filter((entry) => entry.endsWith(".md"));
+  return files.map((entry) => parseEntityProfile(path.join(entitiesDir, entry))).sort((left, right) => right.lastMentioned.localeCompare(left.lastMentioned));
+}
+async function ensureEntityProfiles(vaultPath) {
+  const existing = readEntityProfiles(vaultPath);
+  if (existing.length > 0) {
+    return existing;
+  }
+  return synthesizeEntityProfiles(vaultPath, { writeFiles: true });
+}
+async function readEntityProfile(vaultPath, name) {
+  const profiles = await ensureEntityProfiles(vaultPath);
+  const normalized = name.trim().toLowerCase();
+  for (const profile of profiles) {
+    if (profile.name.toLowerCase() === normalized) {
+      return profile;
+    }
+    if (profile.aliases.some((alias) => alias.toLowerCase() === normalized)) {
+      return profile;
+    }
+  }
+  return null;
+}
+
+export {
+  synthesizeEntityProfiles,
+  readEntityProfiles,
+  ensureEntityProfiles,
+  readEntityProfile
+};

package/dist/{chunk-YNIPYN4F.js → chunk-OFOCU2V4.js}

@@ -1,14 +1,14 @@
-import {
-  listConfig
-} from "./chunk-URXDAUVH.js";
 import {
   requestLlmCompletion,
   resolveLlmProvider
-} from "./chunk-YXQCA6B7.js";
+} from "./chunk-DVOUSOR3.js";
+import {
+  listConfig
+} from "./chunk-AXSJIFOJ.js";
 import {
   getMemoryGraph,
   loadMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 
 // src/commands/inject.ts
 import * as path2 from "path";
@@ -470,6 +470,7 @@ async function addLlmIntentMatches(params) {
     provider: params.provider,
     prompt,
     model: params.model,
+    tier: "complex",
     temperature: 0.1,
     maxTokens: 1200,
     fetchImpl: params.fetchImpl,

package/dist/{chunk-42MXU7A6.js → chunk-P62WHA27.js}

@@ -14,7 +14,7 @@ function findProtectedRanges(content) {
   while ((match = codeBlockRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
-  const inlineCodeRegex = /`[^`]+`/g;
+  const inlineCodeRegex = /(?<!`)`[^`\n]+`(?!`)/g;
   while ((match = inlineCodeRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
@@ -26,10 +26,51 @@ function findProtectedRanges(content) {
   while ((match = urlRegex.exec(content)) !== null) {
     ranges.push({ start: match.index, end: match.index + match[0].length });
   }
+  const filePathRegex = /(?:^|[\s([{"'])((?:~|\/)[^\s`<>\])}"']+|[A-Za-z]:\\[^\s`<>\])}"']+)/g;
+  while ((match = filePathRegex.exec(content)) !== null) {
+    const fullMatch = match[0];
+    const pathValue = match[1];
+    const start = match.index + fullMatch.indexOf(pathValue);
+    ranges.push({ start, end: start + pathValue.length });
+  }
   return ranges;
 }
-function isProtected(pos, ranges) {
-  return ranges.some((r) => pos >= r.start && pos < r.end);
+function isProtectedRange(start, end, ranges) {
+  return ranges.some((range) => start < range.end && end > range.start);
+}
+function createAliasRegex(alias) {
+  const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${escapedAlias}\\b`, "gi");
+}
+function formatWikiLink(path, originalText) {
+  return originalText.toLowerCase() === path.split("/").pop()?.toLowerCase() ? `[[${path}]]` : `[[${path}|${originalText}]]`;
+}
+function planLinks(content, index, protectedRanges) {
+  const sortedAliases = getSortedAliases(index);
+  const linkedEntities = /* @__PURE__ */ new Set();
+  const claimedRanges = [];
+  const plannedLinks = [];
+  for (const { alias, path } of sortedAliases) {
+    if (linkedEntities.has(path)) continue;
+    const regex = createAliasRegex(alias);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (isProtectedRange(start, end, protectedRanges)) continue;
+      if (isProtectedRange(start, end, claimedRanges)) continue;
+      plannedLinks.push({
+        start,
+        end,
+        originalText: match[0],
+        path
+      });
+      claimedRanges.push({ start, end });
+      linkedEntities.add(path);
+      break;
+    }
+  }
+  return plannedLinks;
 }
 function createLineLookup(content) {
   const lines = content.split("\n");
@@ -48,56 +89,24 @@ function createLineLookup(content) {
 }
 function autoLink(content, index) {
   const protectedRanges = findProtectedRanges(content);
-  const sortedAliases = getSortedAliases(index);
-  const linkedEntities = /* @__PURE__ */ new Set();
+  const plannedLinks = planLinks(content, index, protectedRanges);
   let result = content;
-  let offset = 0;
-  for (const { alias, path } of sortedAliases) {
-    if (linkedEntities.has(path)) continue;
-    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      const originalPos = match.index;
-      const adjustedPos = originalPos + offset;
-      if (isProtected(originalPos, protectedRanges)) continue;
-      const beforeMatch = result.substring(0, adjustedPos);
-      const openBrackets = (beforeMatch.match(/\[\[/g) || []).length;
-      const closeBrackets = (beforeMatch.match(/\]\]/g) || []).length;
-      if (openBrackets > closeBrackets) continue;
-      const originalText = match[0];
-      const replacement = originalText.toLowerCase() === path.split("/").pop()?.toLowerCase() ? `[[${path}]]` : `[[${path}|${originalText}]]`;
-      result = result.substring(0, adjustedPos) + replacement + result.substring(adjustedPos + originalText.length);
-      offset += replacement.length - originalText.length;
-      linkedEntities.add(path);
-      break;
-    }
+  const sortedByPosition = plannedLinks.slice().sort((a, b) => b.start - a.start);
+  for (const planned of sortedByPosition) {
+    const replacement = formatWikiLink(planned.path, planned.originalText);
+    result = result.substring(0, planned.start) + replacement + result.substring(planned.end);
   }
   return result;
 }
 function dryRunLink(content, index) {
   const protectedRanges = findProtectedRanges(content);
-  const sortedAliases = getSortedAliases(index);
-  const linkedEntities = /* @__PURE__ */ new Set();
-  const matches = [];
+  const plannedLinks = planLinks(content, index, protectedRanges);
   const getLineNumber = createLineLookup(content);
-  for (const { alias, path } of sortedAliases) {
-    if (linkedEntities.has(path)) continue;
-    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      if (isProtected(match.index, protectedRanges)) continue;
-      matches.push({
-        alias: match[0],
-        path,
-        line: getLineNumber(match.index)
-      });
-      linkedEntities.add(path);
-      break;
-    }
-  }
-  return matches;
+  return plannedLinks.map((planned) => ({
+    alias: planned.originalText,
+    path: planned.path,
+    line: getLineNumber(planned.start)
+  }));
 }
 function findUnlinkedMentions(content, index) {
   const protectedRanges = findProtectedRanges(content);
@@ -111,7 +120,9 @@ function findUnlinkedMentions(content, index) {
     const regex = new RegExp(`\\b${escapedAlias}\\b`, "gi");
     let match;
     while ((match = regex.exec(content)) !== null) {
-      if (isProtected(match.index, protectedRanges)) continue;
+      const start = match.index;
+      const end = start + match[0].length;
+      if (isProtectedRange(start, end, protectedRanges)) continue;
       matches.push({
         alias: match[0],
         path,