clawvault 2.6.1 → 3.0.0

package/dist/chunk-GQSLDZTS.js

@@ -0,0 +1,560 @@
+// src/plugin/templates.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var DEFAULT_SCHEMAS = [
+  {
+    primitive: "memory_event",
+    description: "General memory event for observations",
+    fields: {
+      type: { type: "string", required: true, default: "memory_event" },
+      status: { type: "string", required: true, default: "recorded", enum: ["recorded", "superseded", "corrected"] },
+      created: { type: "datetime", required: true, default: "{{datetime}}" },
+      observed_at: { type: "datetime", required: true },
+      source: { type: "string", required: true, enum: ["openclaw", "claude-code", "replay", "manual-correction"] },
+      summary: { type: "string", required: true },
+      confidence: { type: "number" },
+      importance: { type: "number" }
+    },
+    keywords: ["preference", "like", "hate", "want", "need", "always", "never", "remember", "note"]
+  },
+  {
+    primitive: "person",
+    description: "People and relationship notes",
+    fields: {
+      title: { type: "string", required: true, default: "{{title}}" },
+      date: { type: "date", required: true, default: "{{date}}" },
+      type: { type: "string", required: true, default: "person" },
+      relationship: { type: "string", default: "contact" }
+    },
+    keywords: ["person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is"]
+  },
+  {
+    primitive: "decision",
+    description: "Decision records",
+    fields: {
+      title: { type: "string", required: true, default: "{{title}}" },
+      date: { type: "date", required: true, default: "{{date}}" },
+      type: { type: "string", required: true, default: "decision" },
+      status: { type: "string", default: "decided", enum: ["proposed", "decided", "superseded"] }
+    },
+    keywords: ["decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected"]
+  },
+  {
+    primitive: "task",
+    description: "Task primitives",
+    fields: {
+      status: { type: "string", required: true, default: "open", enum: ["open", "in-progress", "blocked", "done"] },
+      created: { type: "datetime", required: true, default: "{{datetime}}" },
+      updated: { type: "datetime", required: true, default: "{{datetime}}" },
+      priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
+      due: { type: "date" }
+    },
+    keywords: ["task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight"]
+  },
+  {
+    primitive: "project",
+    description: "Project definition documents",
+    fields: {
+      type: { type: "string", required: true, default: "project" },
+      status: { type: "string", required: true, default: "active", enum: ["active", "paused", "completed", "archived"] },
+      created: { type: "datetime", required: true, default: "{{datetime}}" },
+      updated: { type: "datetime", required: true, default: "{{datetime}}" }
+    },
+    keywords: ["project", "initiative", "working on", "building", "developing"]
+  },
+  {
+    primitive: "lesson",
+    description: "Lessons learned",
+    fields: {
+      title: { type: "string", required: true, default: "{{title}}" },
+      date: { type: "date", required: true, default: "{{date}}" },
+      type: { type: "string", required: true, default: "lesson" }
+    },
+    keywords: ["learned", "lesson", "insight", "realized", "discovered", "found out"]
+  }
+];
+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");
+  let currentKey = "";
+  let currentIndent = 0;
+  let nestedObject = null;
+  let nestedKey = "";
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const indent = line.search(/\S/);
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ")) {
+      const value = trimmed.slice(2).trim();
+      if (nestedObject && nestedKey) {
+        const arr = nestedObject[nestedKey];
+        if (Array.isArray(arr)) {
+          arr.push(parseYamlValue(value));
+        }
+      } else if (currentKey && result[currentKey]) {
+        const arr = result[currentKey];
+        if (Array.isArray(arr)) {
+          arr.push(parseYamlValue(value));
+        }
+      }
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    const valueStr = trimmed.slice(colonIndex + 1).trim();
+    if (indent === 0) {
+      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
+        if (key === "fields") {
+          result[key] = {};
+          nestedObject = result[key];
+          nestedKey = "";
+        } else {
+          result[key] = {};
+          nestedObject = null;
+        }
+      } else {
+        result[key] = parseYamlValue(valueStr);
+        nestedObject = null;
+      }
+      currentKey = key;
+      currentIndent = indent;
+    } else if (nestedObject && indent > 0) {
+      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
+        nestedObject[key] = {};
+        nestedKey = key;
+      } else if (nestedKey && indent > 2) {
+        const fieldObj = nestedObject[nestedKey];
+        if (fieldObj) {
+          if (key === "enum") {
+            fieldObj[key] = [];
+          } else {
+            fieldObj[key] = parseYamlValue(valueStr);
+          }
+        }
+      } else {
+        nestedObject[key] = parseYamlValue(valueStr);
+        nestedKey = key;
+      }
+    }
+  }
+  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;
+}
+var registry = null;
+function getTemplateRegistry() {
+  if (!registry) {
+    registry = {
+      schemas: /* @__PURE__ */ new Map(),
+      keywordIndex: /* @__PURE__ */ new Map(),
+      initialized: false
+    };
+  }
+  return registry;
+}
+function initializeTemplateRegistry(templatesDir) {
+  const reg = getTemplateRegistry();
+  if (reg.initialized) {
+    return reg;
+  }
+  const dirsToTry = templatesDir ? [templatesDir] : [
+    join(process.cwd(), "templates"),
+    join(process.cwd(), "..", "..", "templates"),
+    join(process.env.HOME ?? ".", "clawvault", "templates"),
+    join(process.env.HOME ?? ".", ".clawvault", "templates")
+  ];
+  let loaded = false;
+  for (const dir of dirsToTry) {
+    if (existsSync(dir)) {
+      try {
+        loadTemplatesFromDirectory(dir, reg);
+        loaded = true;
+        break;
+      } catch {
+      }
+    }
+  }
+  if (!loaded || reg.schemas.size === 0) {
+    loadDefaultSchemas(reg);
+  }
+  buildKeywordIndex(reg);
+  reg.initialized = true;
+  return reg;
+}
+function loadTemplatesFromDirectory(dir, reg) {
+  const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parseYamlFrontmatter(content);
+    if (!parsed?.frontmatter?.primitive) continue;
+    const schema = convertFrontmatterToSchema(parsed.frontmatter, parsed.body);
+    if (schema) {
+      reg.schemas.set(schema.primitive, schema);
+    }
+  }
+}
+function convertFrontmatterToSchema(fm, body) {
+  const primitive = fm.primitive;
+  if (!primitive) return null;
+  const fields = {};
+  const fmFields = fm.fields;
+  if (fmFields) {
+    for (const [fieldName, fieldDef] of Object.entries(fmFields)) {
+      if (typeof fieldDef === "object" && fieldDef !== null) {
+        const def = fieldDef;
+        fields[fieldName] = {
+          type: def.type || "string",
+          required: def.required,
+          default: def.default,
+          enum: def.enum,
+          description: def.description
+        };
+      }
+    }
+  }
+  const keywords = extractKeywordsFromSchema(primitive, fm.description, fields);
+  return {
+    primitive,
+    description: fm.description,
+    fields,
+    bodyTemplate: body,
+    keywords
+  };
+}
+function extractKeywordsFromSchema(primitive, description, fields) {
+  const keywords = [primitive];
+  keywords.push(primitive.replace(/-/g, " "));
+  keywords.push(primitive.replace(/_/g, " "));
+  switch (primitive) {
+    case "memory_event":
+      keywords.push("preference", "like", "hate", "want", "need", "always", "never", "remember", "note");
+      break;
+    case "person":
+      keywords.push("person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is");
+      break;
+    case "decision":
+      keywords.push("decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected");
+      break;
+    case "task":
+      keywords.push("task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight");
+      break;
+    case "project":
+      keywords.push("project", "initiative", "working on", "building", "developing");
+      break;
+    case "lesson":
+      keywords.push("learned", "lesson", "insight", "realized", "discovered", "found out");
+      break;
+    case "trigger":
+      keywords.push("trigger", "schedule", "cron", "automated", "recurring");
+      break;
+    case "run":
+      keywords.push("run", "execution", "job", "started", "finished", "failed");
+      break;
+    case "checkpoint":
+      keywords.push("checkpoint", "snapshot", "state", "progress");
+      break;
+    case "handoff":
+      keywords.push("handoff", "transition", "context", "resume");
+      break;
+    case "daily-note":
+    case "daily":
+      keywords.push("daily", "today", "journal", "log");
+      break;
+    case "party":
+      keywords.push("party", "agent", "human", "runtime", "service");
+      break;
+    case "workspace":
+      keywords.push("workspace", "shared", "collaboration");
+      break;
+  }
+  if (fields.status?.enum) {
+    keywords.push(...fields.status.enum);
+  }
+  return [...new Set(keywords)];
+}
+function loadDefaultSchemas(reg) {
+  for (const schema of DEFAULT_SCHEMAS) {
+    reg.schemas.set(schema.primitive, schema);
+  }
+}
+function buildKeywordIndex(reg) {
+  reg.keywordIndex.clear();
+  for (const [primitive, schema] of reg.schemas) {
+    const keywords = schema.keywords ?? [primitive];
+    for (const keyword of keywords) {
+      const lower = keyword.toLowerCase();
+      const existing = reg.keywordIndex.get(lower) ?? [];
+      if (!existing.includes(primitive)) {
+        existing.push(primitive);
+      }
+      reg.keywordIndex.set(lower, existing);
+    }
+  }
+}
+function classifyText(text) {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) {
+    initializeTemplateRegistry();
+  }
+  const lower = text.toLowerCase();
+  const scores = /* @__PURE__ */ new Map();
+  for (const [keyword, primitives] of reg.keywordIndex) {
+    if (lower.includes(keyword)) {
+      for (const primitive of primitives) {
+        const existing = scores.get(primitive) ?? { score: 0, keywords: [] };
+        existing.score += getKeywordWeight(keyword, primitive);
+        existing.keywords.push(keyword);
+        scores.set(primitive, existing);
+      }
+    }
+  }
+  applyPatternScoring(lower, scores);
+  let bestPrimitive = "memory_event";
+  let bestScore = 0;
+  let bestKeywords = [];
+  for (const [primitive, data] of scores) {
+    if (data.score > bestScore) {
+      bestScore = data.score;
+      bestPrimitive = primitive;
+      bestKeywords = data.keywords;
+    }
+  }
+  const confidence = Math.min(1, bestScore / 5);
+  return {
+    primitiveType: bestPrimitive,
+    confidence,
+    matchedKeywords: [...new Set(bestKeywords)]
+  };
+}
+function getKeywordWeight(keyword, primitive) {
+  if (keyword === primitive || keyword === primitive.replace(/-/g, " ")) {
+    return 3;
+  }
+  const strongIndicators = {
+    person: ["works at", "lives in", "email", "phone", "name is"],
+    decision: ["decided", "chose", "will use", "go with"],
+    task: ["deadline", "due", "by tomorrow", "by tonight"],
+    memory_event: ["preference", "remember", "note"]
+  };
+  if (strongIndicators[primitive]?.includes(keyword)) {
+    return 2;
+  }
+  return 1;
+}
+function applyPatternScoring(text, scores) {
+  if (/\b(my .+ is|his .+ is|her .+ is|their .+ is)\b/i.test(text)) {
+    const existing = scores.get("person") ?? { score: 0, keywords: [] };
+    existing.score += 2;
+    existing.keywords.push("possessive pattern");
+    scores.set("person", existing);
+  }
+  if (/[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/.test(text)) {
+    const existing = scores.get("person") ?? { score: 0, keywords: [] };
+    existing.score += 3;
+    existing.keywords.push("contact info");
+    scores.set("person", existing);
+  }
+  if (/\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i.test(text)) {
+    const existing = scores.get("memory_event") ?? { score: 0, keywords: [] };
+    existing.score += 3;
+    existing.keywords.push("preference pattern");
+    scores.set("memory_event", existing);
+  }
+  if (/\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it)\b/i.test(text)) {
+    const existing = scores.get("decision") ?? { score: 0, keywords: [] };
+    existing.score += 3;
+    existing.keywords.push("decision pattern");
+    scores.set("decision", existing);
+  }
+  if (/\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i.test(text)) {
+    const existing = scores.get("task") ?? { score: 0, keywords: [] };
+    existing.score += 2;
+    existing.keywords.push("deadline pattern");
+    scores.set("task", existing);
+  }
+}
+function getSchema(primitiveType) {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) {
+    initializeTemplateRegistry();
+  }
+  return reg.schemas.get(primitiveType);
+}
+function getAllSchemas() {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) {
+    initializeTemplateRegistry();
+  }
+  return Array.from(reg.schemas.values());
+}
+function getSchemaNames() {
+  const reg = getTemplateRegistry();
+  if (!reg.initialized) {
+    initializeTemplateRegistry();
+  }
+  return Array.from(reg.schemas.keys());
+}
+function generateFrontmatter(primitiveType, options = {}) {
+  const schema = getSchema(primitiveType);
+  if (!schema) {
+    return {
+      type: primitiveType,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const frontmatter = {};
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().split("T")[0];
+  const datetimeStr = now.toISOString();
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    if (options.extraFields?.[fieldName] !== void 0) {
+      const value = options.extraFields[fieldName];
+      if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
+        frontmatter[fieldName] = fieldDef.default ?? fieldDef.enum[0];
+      } else {
+        frontmatter[fieldName] = value;
+      }
+      continue;
+    }
+    if (fieldDef.default !== void 0) {
+      let defaultValue = fieldDef.default;
+      if (typeof defaultValue === "string") {
+        defaultValue = defaultValue.replace("{{datetime}}", datetimeStr).replace("{{date}}", dateStr).replace("{{title}}", options.title ?? "Untitled");
+      }
+      frontmatter[fieldName] = defaultValue;
+    } else if (fieldDef.required) {
+      switch (fieldDef.type) {
+        case "datetime":
+          frontmatter[fieldName] = datetimeStr;
+          break;
+        case "date":
+          frontmatter[fieldName] = dateStr;
+          break;
+        case "string":
+          if (fieldDef.enum?.length) {
+            frontmatter[fieldName] = fieldDef.enum[0];
+          } else {
+            frontmatter[fieldName] = "";
+          }
+          break;
+        case "number":
+          frontmatter[fieldName] = 0;
+          break;
+        case "boolean":
+          frontmatter[fieldName] = false;
+          break;
+      }
+    }
+  }
+  if (options.source && schema.fields.source) {
+    frontmatter.source = options.source;
+  }
+  if (options.sessionId && schema.fields.session_id) {
+    frontmatter.session_id = options.sessionId;
+  }
+  return frontmatter;
+}
+function validateFrontmatter(primitiveType, frontmatter) {
+  const schema = getSchema(primitiveType);
+  if (!schema) {
+    return { valid: true, errors: [] };
+  }
+  const errors = [];
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    const value = frontmatter[fieldName];
+    if (fieldDef.required && (value === void 0 || value === null || value === "")) {
+      errors.push(`Missing required field: ${fieldName}`);
+      continue;
+    }
+    if (value === void 0 || value === null) continue;
+    if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
+      errors.push(`Invalid value for ${fieldName}: "${value}". Must be one of: ${fieldDef.enum.join(", ")}`);
+    }
+    switch (fieldDef.type) {
+      case "number":
+        if (typeof value !== "number" && isNaN(Number(value))) {
+          errors.push(`Field ${fieldName} must be a number`);
+        }
+        break;
+      case "boolean":
+        if (typeof value !== "boolean" && value !== "true" && value !== "false") {
+          errors.push(`Field ${fieldName} must be a boolean`);
+        }
+        break;
+      case "datetime":
+        if (typeof value === "string" && isNaN(Date.parse(value))) {
+          errors.push(`Field ${fieldName} must be a valid datetime`);
+        }
+        break;
+      case "date":
+        if (typeof value === "string" && !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+          errors.push(`Field ${fieldName} must be a valid date (YYYY-MM-DD)`);
+        }
+        break;
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function serializeFrontmatter(frontmatter) {
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - ${item}`);
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${key}: ${JSON.stringify(value)}`);
+    } else if (typeof value === "string" && value.includes("\n")) {
+      lines.push(`${key}: |`);
+      for (const line of value.split("\n")) {
+        lines.push(`  ${line}`);
+      }
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function resetTemplateRegistry() {
+  registry = null;
+}
+
+export {
+  getTemplateRegistry,
+  initializeTemplateRegistry,
+  classifyText,
+  getSchema,
+  getAllSchemas,
+  getSchemaNames,
+  generateFrontmatter,
+  validateFrontmatter,
+  serializeFrontmatter,
+  resetTemplateRegistry
+};

package/dist/{chunk-4OXMU5S2.js → chunk-GUKMRGM7.js}

@@ -2,7 +2,7 @@ import {
   listTasks,
   readTask,
   updateTask
-} from "./chunk-QWQ3TIKS.js";
+} from "./chunk-N2AXRYLC.js";
 
 // src/commands/kanban.ts
 import * as fs from "fs";

package/dist/{chunk-T76H47ZS.js → chunk-H34S76MB.js}

@@ -1,14 +1,14 @@
-import {
-  normalizeObservationContent,
-  parseObservationMarkdown
-} from "./chunk-FHFUXL6G.js";
 import {
   requestLlmCompletion,
   resolveLlmProvider
-} from "./chunk-HIHOUSXS.js";
+} from "./chunk-E7MFQB6D.js";
 import {
   archiveObservations
 } from "./chunk-MQUJNOHK.js";
+import {
+  normalizeObservationContent,
+  parseObservationMarkdown
+} from "./chunk-QK3UCXWL.js";
 import {
   formatIsoWeekKey,
   getIsoWeek,
@@ -213,7 +213,7 @@ function promoteWeekRecords(records) {
   return promoted;
 }
 async function maybeGenerateLlmReflection(weekKey, sections) {
-  const provider = resolveLlmProvider();
+  const provider = await resolveLlmProvider();
   if (!provider) {
     return null;
   }

package/dist/{chunk-R6SXNSFD.js → chunk-JY6FYXIT.js}

@@ -1,9 +1,9 @@
 import {
   runReflection
-} from "./chunk-T76H47ZS.js";
+} from "./chunk-H34S76MB.js";
 import {
   Observer
-} from "./chunk-Q2J5YTUF.js";
+} from "./chunk-3NSBOUT3.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";
@@ -135,7 +135,8 @@ function pushMessage(destination, conversationId, record) {
   if (!text) {
     return;
   }
-  const role = typeof record.role === "string" ? record.role.trim().toLowerCase() : void 0;
+  const rawRole = typeof record.role === "string" ? record.role : typeof record.sender === "string" ? record.sender : void 0;
+  const role = rawRole ? rawRole.trim().toLowerCase() : void 0;
   destination.push({
     source: "claude",
     conversationId,
@@ -151,8 +152,9 @@ function normalizeClaudeExport(input) {
       if (!item || typeof item !== "object") continue;
       const record = item;
       const conversationId = typeof record.id === "string" ? record.id : typeof record.uuid === "string" ? record.uuid : void 0;
-      if (Array.isArray(record.messages)) {
-        for (const message of record.messages) {
+      const recordMessages = Array.isArray(record.messages) ? record.messages : Array.isArray(record.chat_messages) ? record.chat_messages : void 0;
+      if (recordMessages) {
+        for (const message of recordMessages) {
           if (!message || typeof message !== "object") continue;
           pushMessage(messages, conversationId, message);
         }
@@ -170,6 +172,9 @@ function normalizeClaudeExport(input) {
     if (Array.isArray(root.messages)) {
       return normalizeClaudeExport([{ id: root.id, messages: root.messages }]);
     }
+    if (Array.isArray(root.chat_messages)) {
+      return normalizeClaudeExport([{ id: root.id, chat_messages: root.chat_messages }]);
+    }
   }
   return messages;
 }