clawvault 2.6.0 → 3.0.0

package/dist/chunk-6U6MK36V.js

@@ -0,0 +1,205 @@
+import {
+  classifyText
+} from "./chunk-GQSLDZTS.js";
+
+// src/plugin/observe.ts
+function isObservable(text) {
+  if (!text || text.length < 20 || text.length > 5e3) return false;
+  if (text.includes("<relevant-memories>")) return false;
+  if (text.startsWith("[System")) return false;
+  if (text.includes("HEARTBEAT")) return false;
+  if (text.startsWith("NO_REPLY")) return false;
+  if (text.startsWith("{") && text.includes('"')) return false;
+  const markdownDensity = (text.match(/[#*`\-|>]/g) || []).length / text.length;
+  if (markdownDensity > 0.15) return false;
+  return true;
+}
+var OBSERVATION_PATTERNS = [
+  // Preferences
+  { pattern: /\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i, weight: 2 },
+  // Decisions
+  { pattern: /\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it|go with)\b/i, weight: 2 },
+  // Facts about people/things
+  { pattern: /\b(my .+ is|his .+ is|her .+ is|their .+ is|works at|lives in|born in)\b/i, weight: 1.5 },
+  // Contact info
+  { pattern: /[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/i, weight: 2 },
+  // Explicit memory request
+  { pattern: /\b(remember|don't forget|keep in mind|note that|important:)\b/i, weight: 2.5 },
+  // Deadlines/dates
+  { pattern: /\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i, weight: 1.5 },
+  // Lessons learned
+  { pattern: /\b(i learned|we learned|lesson|realized|discovered|found out)\b/i, weight: 1.5 },
+  // Tasks
+  { pattern: /\b(need to|should|must|have to|todo|task)\b/i, weight: 1 },
+  // Projects
+  { pattern: /\b(working on|building|developing|project|initiative)\b/i, weight: 1 }
+];
+function extractObservations(text) {
+  const observations = [];
+  const sentences = splitIntoSentences(text);
+  const now = /* @__PURE__ */ new Date();
+  for (const sentence of sentences) {
+    if (sentence.length < 15) continue;
+    let totalWeight = 0;
+    for (const { pattern, weight } of OBSERVATION_PATTERNS) {
+      if (pattern.test(sentence)) {
+        totalWeight += weight;
+      }
+    }
+    if (totalWeight < 1) continue;
+    const classification = classifyText(sentence);
+    const category = deriveCategoryFromPrimitive(classification.primitiveType, sentence);
+    const tags = generateTags(classification, sentence);
+    observations.push({
+      text: sentence.trim(),
+      primitiveType: classification.primitiveType,
+      confidence: classification.confidence,
+      matchedKeywords: classification.matchedKeywords,
+      category,
+      tags,
+      extractedAt: now
+    });
+  }
+  return observations;
+}
+function splitIntoSentences(text) {
+  const raw = text.split(/(?<=[.!?\n])\s+/);
+  const sentences = [];
+  for (const s of raw) {
+    const trimmed = s.trim();
+    if (trimmed.length > 0) {
+      sentences.push(trimmed);
+    }
+  }
+  return sentences;
+}
+function deriveCategoryFromPrimitive(primitiveType, text) {
+  const lower = text.toLowerCase();
+  if (primitiveType === "memory_event") {
+    if (/prefer|like|love|hate|want|need|always|never/i.test(lower)) {
+      return "preference";
+    }
+    if (/remember|don't forget|keep in mind|note that/i.test(lower)) {
+      return "note";
+    }
+    return "fact";
+  }
+  const categoryMap = {
+    person: "entity",
+    decision: "decision",
+    task: "task",
+    project: "project",
+    lesson: "lesson",
+    trigger: "automation",
+    run: "execution",
+    checkpoint: "checkpoint",
+    handoff: "handoff",
+    "daily-note": "daily",
+    daily: "daily",
+    party: "entity",
+    workspace: "workspace"
+  };
+  return categoryMap[primitiveType] ?? "fact";
+}
+function generateTags(classification, text) {
+  const tags = [classification.primitiveType];
+  const lower = text.toLowerCase();
+  if (/prefer|like|love/i.test(lower)) tags.push("positive");
+  if (/hate|dislike|don't like/i.test(lower)) tags.push("negative");
+  if (/deadline|due|by tomorrow|by tonight/i.test(lower)) tags.push("time-sensitive");
+  if (/important|critical|urgent/i.test(lower)) tags.push("high-priority");
+  if (/email|phone|contact/i.test(lower)) tags.push("contact-info");
+  if (/decided|chose|approved/i.test(lower)) tags.push("finalized");
+  if (/proposed|considering|might/i.test(lower)) tags.push("tentative");
+  return [...new Set(tags)];
+}
+function processMessageForObservations(content, options = {}) {
+  if (!isObservable(content)) {
+    return {
+      observations: [],
+      skipped: 1,
+      reason: "Content not observable"
+    };
+  }
+  const observations = extractObservations(content);
+  const maxObservations = 5;
+  const limited = observations.slice(0, maxObservations);
+  const skipped = observations.length - limited.length;
+  return {
+    observations: limited,
+    skipped,
+    reason: skipped > 0 ? `Limited to ${maxObservations} observations` : void 0
+  };
+}
+function detectCategory(text) {
+  const classification = classifyText(text);
+  return deriveCategoryFromPrimitive(classification.primitiveType, text);
+}
+function extractPreferences(text) {
+  const preferences = [];
+  const patterns = [
+    { regex: /i (?:really )?(?:like|love|enjoy|prefer)\s+(.+?)(?:\.|,|$)/gi, sentiment: "positive" },
+    { regex: /i (?:don't|do not|hate|dislike)\s+(.+?)(?:\.|,|$)/gi, sentiment: "negative" },
+    { regex: /my favorite\s+(.+?)\s+is\s+(.+?)(?:\.|,|$)/gi, sentiment: "positive", hasCategory: true },
+    { regex: /i prefer\s+(.+?)\s+over\s+(.+?)(?:\.|,|$)/gi, sentiment: "positive" }
+  ];
+  for (const { regex, sentiment, hasCategory } of patterns) {
+    let match;
+    regex.lastIndex = 0;
+    while ((match = regex.exec(text)) !== null) {
+      if (hasCategory && match[2]) {
+        preferences.push({
+          category: normalizeCategory(match[1]),
+          item: match[2].trim(),
+          sentiment,
+          confidence: 0.8,
+          source: text.slice(0, 100)
+        });
+      } else if (match[1]) {
+        const item = match[1].trim();
+        preferences.push({
+          category: inferCategory(item),
+          item,
+          sentiment,
+          confidence: 0.7,
+          source: text.slice(0, 100)
+        });
+      }
+    }
+  }
+  return preferences;
+}
+function normalizeCategory(category) {
+  return category.toLowerCase().trim().replace(/\s+/g, "_");
+}
+function inferCategory(item) {
+  const itemLower = item.toLowerCase();
+  const categoryKeywords = {
+    food: ["pizza", "coffee", "tea", "food", "restaurant", "cuisine", "dish", "meal", "drink"],
+    technology: ["programming", "code", "software", "app", "technology", "framework", "language", "tool"],
+    entertainment: ["movie", "music", "book", "game", "show", "series", "film", "song", "album"],
+    work: ["meeting", "project", "task", "deadline", "team", "client"],
+    communication: ["email", "slack", "chat", "call", "message"]
+  };
+  for (const [category, keywords] of Object.entries(categoryKeywords)) {
+    if (keywords.some((k) => itemLower.includes(k))) {
+      return category;
+    }
+  }
+  return "general";
+}
+function extractSearchTerms(input) {
+  const noise = /\b(hey|hi|hello|um|uh|like|just|so|well|you know|i mean|basically|actually|really|very|pretty|quite|how does it feel|how do you|can you|could you|would you|do you|what do you think|tell me about)\b/gi;
+  let cleaned = input.replace(noise, " ").replace(/\s+/g, " ").trim();
+  if (cleaned.length < 5) cleaned = input.trim();
+  return cleaned;
+}
+
+export {
+  isObservable,
+  extractObservations,
+  processMessageForObservations,
+  detectCategory,
+  extractPreferences,
+  extractSearchTerms
+};

package/dist/{chunk-4QYGFWRM.js → chunk-7R7O6STJ.js}

@@ -1,11 +1,11 @@
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
 import {
   QmdUnavailableError,
   hasQmd,
   qmdEmbed
-} from "./chunk-MAKNAHAW.js";
-import {
-  resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-K234IDRJ.js";
 
 // src/lib/vault-qmd-config.ts
 import * as fs from "fs";

package/dist/{chunk-VXEOHTSL.js → chunk-C7OK5WKP.js}

@@ -1,11 +1,11 @@
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
 import {
   DATE_HEADING_RE,
   parseObservationLine,
   renderScoredObservationLine
-} from "./chunk-FHFUXL6G.js";
-import {
-  resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-QK3UCXWL.js";
 import {
   listObservationFiles
 } from "./chunk-Z2XBWN7A.js";

package/dist/chunk-CMB7UL7C.js

@@ -0,0 +1,327 @@
+// src/plugin/inject.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join, relative } from "path";
+function parseYamlFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  const yamlContent = match[1];
+  const body = match[2];
+  try {
+    const frontmatter = parseSimpleYaml(yamlContent);
+    return { frontmatter, body };
+  } catch {
+    return null;
+  }
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const valueStr = line.slice(colonIndex + 1).trim();
+    if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
+    result[key] = parseYamlValue(valueStr);
+  }
+  return result;
+}
+function parseYamlValue(value) {
+  if (value === "" || value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function scanVaultFiles(vaultPath, options = {}) {
+  const files = [];
+  const maxAge = options.maxAge ?? 7 * 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 100;
+  const now = Date.now();
+  const cutoff = now - maxAge;
+  const dirsToScan = findVaultDirectories(vaultPath);
+  for (const dir of dirsToScan) {
+    if (!existsSync(dir)) continue;
+    try {
+      scanDirectory(dir, vaultPath, files, cutoff, options.primitiveTypes);
+    } catch {
+    }
+  }
+  files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+  return files.slice(0, limit);
+}
+function findVaultDirectories(vaultPath) {
+  const dirs = [];
+  dirs.push(vaultPath);
+  const commonDirs = [
+    "tasks",
+    "projects",
+    "decisions",
+    "people",
+    "persons",
+    "notes",
+    "daily",
+    "journal",
+    "ledger",
+    "memory",
+    "memories",
+    "observations",
+    "lessons",
+    "triggers",
+    "runs",
+    "checkpoints",
+    "handoffs",
+    "workspaces",
+    "parties"
+  ];
+  for (const subdir of commonDirs) {
+    const fullPath = join(vaultPath, subdir);
+    if (existsSync(fullPath)) {
+      dirs.push(fullPath);
+    }
+  }
+  try {
+    const entries = readdirSync(vaultPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
+        const fullPath = join(vaultPath, entry.name);
+        if (!dirs.includes(fullPath)) {
+          dirs.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return dirs;
+}
+function scanDirectory(dir, vaultPath, files, cutoff, primitiveTypes) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const depth = fullPath.replace(vaultPath, "").split("/").length;
+      if (depth <= 3) {
+        scanDirectory(fullPath, vaultPath, files, cutoff, primitiveTypes);
+      }
+    } else if (entry.name.endsWith(".md")) {
+      try {
+        const stat = statSync(fullPath);
+        if (stat.mtimeMs < cutoff) continue;
+        const content = readFileSync(fullPath, "utf-8");
+        const parsed = parseYamlFrontmatter(content);
+        if (!parsed) continue;
+        const primitiveType = detectPrimitiveType(parsed.frontmatter, fullPath);
+        if (primitiveTypes && !primitiveTypes.includes(primitiveType)) continue;
+        files.push({
+          path: fullPath,
+          relativePath: relative(vaultPath, fullPath),
+          primitiveType,
+          frontmatter: parsed.frontmatter,
+          content: parsed.body,
+          modifiedAt: stat.mtime,
+          createdAt: stat.birthtime
+        });
+      } catch {
+      }
+    }
+  }
+}
+function detectPrimitiveType(frontmatter, filePath) {
+  if (frontmatter.primitive) return String(frontmatter.primitive);
+  if (frontmatter.type) return String(frontmatter.type);
+  const pathLower = filePath.toLowerCase();
+  if (pathLower.includes("/tasks/")) return "task";
+  if (pathLower.includes("/projects/")) return "project";
+  if (pathLower.includes("/decisions/")) return "decision";
+  if (pathLower.includes("/people/") || pathLower.includes("/persons/")) return "person";
+  if (pathLower.includes("/daily/") || pathLower.includes("/journal/")) return "daily-note";
+  if (pathLower.includes("/lessons/")) return "lesson";
+  if (pathLower.includes("/triggers/")) return "trigger";
+  if (pathLower.includes("/runs/")) return "run";
+  if (pathLower.includes("/checkpoints/")) return "checkpoint";
+  if (pathLower.includes("/handoffs/")) return "handoff";
+  if (pathLower.includes("/ledger/")) return "memory_event";
+  if (pathLower.includes("/memory/") || pathLower.includes("/memories/")) return "memory_event";
+  return "unknown";
+}
+function buildSessionRecap(vaultPath, options = {}) {
+  const maxAge = options.maxAge ?? 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 20;
+  const includeContent = options.includeContent ?? false;
+  const files = scanVaultFiles(vaultPath, { maxAge, limit });
+  if (files.length === 0) {
+    return {
+      xml: "",
+      fileCount: 0,
+      primitiveGroups: {},
+      timeRange: null
+    };
+  }
+  const groups = {};
+  for (const file of files) {
+    const type = file.primitiveType;
+    if (!groups[type]) groups[type] = [];
+    groups[type].push(file);
+  }
+  const lines = ["<session-recap>"];
+  lines.push(`<summary>Found ${files.length} recent items across ${Object.keys(groups).length} categories</summary>`);
+  for (const [primitiveType, groupFiles] of Object.entries(groups)) {
+    lines.push(`<${primitiveType}-items count="${groupFiles.length}">`);
+    for (const file of groupFiles.slice(0, 5)) {
+      const title = file.frontmatter.title || file.frontmatter.summary || file.relativePath;
+      const status = file.frontmatter.status || "";
+      const modified = file.modifiedAt.toISOString().slice(0, 16).replace("T", " ");
+      lines.push(`  <item path="${file.relativePath}" modified="${modified}"${status ? ` status="${status}"` : ""}>`);
+      lines.push(`    <title>${escapeXml(String(title))}</title>`);
+      if (includeContent && file.content) {
+        const snippet = file.content.slice(0, 200).replace(/\n/g, " ").trim();
+        if (snippet) {
+          lines.push(`    <snippet>${escapeXml(snippet)}</snippet>`);
+        }
+      }
+      lines.push("  </item>");
+    }
+    if (groupFiles.length > 5) {
+      lines.push(`  <more count="${groupFiles.length - 5}" />`);
+    }
+    lines.push(`</${primitiveType}-items>`);
+  }
+  lines.push("</session-recap>");
+  const sortedByTime = [...files].sort((a, b) => a.modifiedAt.getTime() - b.modifiedAt.getTime());
+  const timeRange = {
+    oldest: sortedByTime[0].modifiedAt,
+    newest: sortedByTime[sortedByTime.length - 1].modifiedAt
+  };
+  const primitiveGroups = {};
+  for (const [type, groupFiles] of Object.entries(groups)) {
+    primitiveGroups[type] = groupFiles.length;
+  }
+  return {
+    xml: lines.join("\n"),
+    fileCount: files.length,
+    primitiveGroups,
+    timeRange
+  };
+}
+function buildPreferenceContext(vaultPath, options = {}) {
+  const maxAge = options.maxAge ?? 30 * 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 50;
+  const files = scanVaultFiles(vaultPath, { maxAge, limit: limit * 2 });
+  const preferenceFiles = files.filter((file) => {
+    if (file.frontmatter.type === "preference") return true;
+    if (file.primitiveType === "memory_event" && file.frontmatter.type === "preference") return true;
+    const content = (file.content || "").toLowerCase();
+    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/.test(content)) {
+      return true;
+    }
+    return false;
+  }).slice(0, limit);
+  if (preferenceFiles.length === 0) {
+    return {
+      xml: "",
+      preferenceCount: 0,
+      categories: []
+    };
+  }
+  const categories = /* @__PURE__ */ new Set();
+  for (const file of preferenceFiles) {
+    if (file.frontmatter.category) {
+      categories.add(String(file.frontmatter.category));
+    }
+  }
+  const lines = ["<user-preferences>"];
+  for (const file of preferenceFiles) {
+    const summary = file.frontmatter.summary || file.frontmatter.title || extractPreferenceSummary(file.content);
+    if (!summary) continue;
+    const category = file.frontmatter.category || "general";
+    const sentiment = file.frontmatter.sentiment || inferSentiment(file.content);
+    lines.push(`  <preference category="${escapeXml(String(category))}" sentiment="${sentiment}">`);
+    lines.push(`    ${escapeXml(String(summary))}`);
+    lines.push("  </preference>");
+  }
+  lines.push("</user-preferences>");
+  return {
+    xml: lines.join("\n"),
+    preferenceCount: preferenceFiles.length,
+    categories: Array.from(categories)
+  };
+}
+function extractPreferenceSummary(content) {
+  if (!content) return "";
+  const sentences = content.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 10);
+  for (const sentence of sentences) {
+    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/i.test(sentence)) {
+      return sentence.slice(0, 150);
+    }
+  }
+  return sentences[0]?.slice(0, 150) || "";
+}
+function inferSentiment(content) {
+  if (!content) return "neutral";
+  const lower = content.toLowerCase();
+  if (/\b(love|like|prefer|enjoy|want|need|always)\b/.test(lower)) return "positive";
+  if (/\b(hate|dislike|don't like|never|avoid)\b/.test(lower)) return "negative";
+  return "neutral";
+}
+function formatMemoriesForContext(results, collection) {
+  if (results.length === 0) return "";
+  const lines = results.map((r, i) => {
+    const file = (r.file || "").replace(`qmd://${collection}/`, "");
+    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "";
+    return `${i + 1}. [${file}] ${snippet}`;
+  });
+  return `<relevant-memories>
+These are recalled from long-term vault memory. Treat as historical context.
+${lines.join("\n")}
+</relevant-memories>`;
+}
+function formatSearchResults(results, collection) {
+  if (results.length === 0) return "No relevant memories found.";
+  return results.map((r, i) => {
+    const file = (r.file || "").replace(`qmd://${collection}/`, "");
+    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "(no content)";
+    const score = ((r.score ?? 0) * 100).toFixed(0);
+    return `${i + 1}. [${file}] ${snippet} (${score}%)`;
+  }).join("\n");
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildFullContext(vaultPath, options = {}) {
+  const parts = [];
+  if (options.includeRecap !== false) {
+    const recap = buildSessionRecap(vaultPath, {
+      maxAge: options.recapMaxAge ?? 24 * 60 * 60 * 1e3,
+      limit: 15,
+      includeContent: true
+    });
+    if (recap.xml) {
+      parts.push(recap.xml);
+    }
+  }
+  if (options.includePreferences !== false) {
+    const prefs = buildPreferenceContext(vaultPath, {
+      maxAge: options.preferenceMaxAge ?? 30 * 24 * 60 * 60 * 1e3,
+      limit: 20
+    });
+    if (prefs.xml) {
+      parts.push(prefs.xml);
+    }
+  }
+  return parts.join("\n\n");
+}
+
+export {
+  scanVaultFiles,
+  buildSessionRecap,
+  buildPreferenceContext,
+  formatMemoriesForContext,
+  formatSearchResults,
+  buildFullContext
+};