clawvault 3.3.0 → 3.4.0

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
+};