clawvault 2.6.0 → 3.0.0

package/dist/plugin/vault.cjs

@@ -0,0 +1,927 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugin/vault.ts
+var vault_exports = {};
+__export(vault_exports, {
+  appendObservationToLedger: () => appendObservationToLedger,
+  appendToLedger: () => appendToLedger,
+  batchWriteObservations: () => batchWriteObservations,
+  ensureVaultStructure: () => ensureVaultStructure,
+  getVaultStats: () => getVaultStats,
+  writeObservation: () => writeObservation,
+  writeObservations: () => writeObservations,
+  writeVaultFile: () => writeVaultFile
+});
+module.exports = __toCommonJS(vault_exports);
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+
+// src/plugin/templates.ts
+var import_node_fs = require("fs");
+var import_node_path = require("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] : [
+    (0, import_node_path.join)(process.cwd(), "templates"),
+    (0, import_node_path.join)(process.cwd(), "..", "..", "templates"),
+    (0, import_node_path.join)(process.env.HOME ?? ".", "clawvault", "templates"),
+    (0, import_node_path.join)(process.env.HOME ?? ".", ".clawvault", "templates")
+  ];
+  let loaded = false;
+  for (const dir of dirsToTry) {
+    if ((0, import_node_fs.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 = (0, import_node_fs.readdirSync)(dir).filter((f) => f.endsWith(".md"));
+  for (const file of files) {
+    const filePath = (0, import_node_path.join)(dir, file);
+    const content = (0, import_node_fs.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 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");
+}
+
+// src/plugin/vault.ts
+function writeVaultFile(vaultPath, options) {
+  const errors = [];
+  const primitiveType = options.primitiveType ?? classifyText(options.content ?? options.title ?? "").primitiveType;
+  const schema = getSchema(primitiveType);
+  const frontmatter = generateFrontmatter(primitiveType, {
+    title: options.title,
+    extraFields: options.extraFields,
+    source: options.source,
+    sessionId: options.sessionId
+  });
+  const validation = validateFrontmatter(primitiveType, frontmatter);
+  if (!validation.valid) {
+    errors.push(...validation.errors);
+  }
+  const directory = options.directory ?? getDefaultDirectory(vaultPath, primitiveType);
+  if (!(0, import_node_fs2.existsSync)(directory)) {
+    (0, import_node_fs2.mkdirSync)(directory, { recursive: true });
+  }
+  const filename = options.filename ?? generateFilename(primitiveType, options.title, frontmatter);
+  const filePath = (0, import_node_path2.join)(directory, filename);
+  const fileExists = (0, import_node_fs2.existsSync)(filePath);
+  if (fileExists && !options.overwrite) {
+    return updateVaultFile(filePath, frontmatter, options.content, primitiveType, errors);
+  }
+  const fileContent = buildFileContent(frontmatter, options.content, schema);
+  try {
+    (0, import_node_fs2.writeFileSync)(filePath, fileContent, "utf-8");
+    return {
+      success: errors.length === 0,
+      path: filePath,
+      primitiveType,
+      errors,
+      created: true,
+      updated: false
+    };
+  } catch (err) {
+    errors.push(`Failed to write file: ${String(err)}`);
+    return {
+      success: false,
+      path: filePath,
+      primitiveType,
+      errors,
+      created: false,
+      updated: false
+    };
+  }
+}
+function updateVaultFile(filePath, newFrontmatter, newContent, primitiveType, errors) {
+  try {
+    const existingContent = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+    const parsed = parseExistingFile(existingContent);
+    if (!parsed) {
+      errors.push("Failed to parse existing file");
+      return {
+        success: false,
+        path: filePath,
+        primitiveType,
+        errors,
+        created: false,
+        updated: false
+      };
+    }
+    const mergedFrontmatter = {
+      ...parsed.frontmatter,
+      ...newFrontmatter,
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (parsed.frontmatter.created) {
+      mergedFrontmatter.created = parsed.frontmatter.created;
+    }
+    const content = newContent ?? parsed.body;
+    const schema = getSchema(primitiveType);
+    const fileContent = buildFileContent(mergedFrontmatter, content, schema);
+    (0, import_node_fs2.writeFileSync)(filePath, fileContent, "utf-8");
+    return {
+      success: errors.length === 0,
+      path: filePath,
+      primitiveType,
+      errors,
+      created: false,
+      updated: true
+    };
+  } catch (err) {
+    errors.push(`Failed to update file: ${String(err)}`);
+    return {
+      success: false,
+      path: filePath,
+      primitiveType,
+      errors,
+      created: false,
+      updated: false
+    };
+  }
+}
+function parseExistingFile(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  try {
+    const frontmatter = parseSimpleYaml2(match[1]);
+    return { frontmatter, body: match[2] };
+  } catch {
+    return null;
+  }
+}
+function parseSimpleYaml2(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] = parseYamlValue2(valueStr);
+  }
+  return result;
+}
+function parseYamlValue2(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 getDefaultDirectory(vaultPath, primitiveType) {
+  const directoryMap = {
+    task: "tasks",
+    project: "projects",
+    decision: "decisions",
+    person: "people",
+    lesson: "lessons",
+    trigger: "triggers",
+    run: "runs",
+    checkpoint: "checkpoints",
+    handoff: "handoffs",
+    "daily-note": "daily",
+    daily: "daily",
+    party: "parties",
+    workspace: "workspaces",
+    memory_event: "memory"
+  };
+  const subdir = directoryMap[primitiveType] ?? "notes";
+  return (0, import_node_path2.join)(vaultPath, subdir);
+}
+function generateFilename(primitiveType, title, frontmatter) {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().split("T")[0];
+  const timeStr = now.toISOString().slice(11, 19).replace(/:/g, "");
+  if (title) {
+    const slug = slugify(title);
+    return `${dateStr}-${slug}.md`;
+  }
+  switch (primitiveType) {
+    case "daily-note":
+    case "daily":
+      return `${dateStr}.md`;
+    case "memory_event":
+      return `${dateStr}-${timeStr}.md`;
+    case "run":
+      return `run-${dateStr}-${timeStr}.md`;
+    case "checkpoint":
+      return `checkpoint-${dateStr}-${timeStr}.md`;
+    case "handoff":
+      return `handoff-${dateStr}-${timeStr}.md`;
+    default:
+      return `${primitiveType}-${dateStr}-${timeStr}.md`;
+  }
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function buildFileContent(frontmatter, content, schema) {
+  const parts = [];
+  parts.push(serializeFrontmatter(frontmatter));
+  parts.push("");
+  const title = frontmatter.title || frontmatter.summary;
+  if (title) {
+    parts.push(`# ${title}`);
+    parts.push("");
+  }
+  if (content) {
+    parts.push(content);
+  } else if (schema?.bodyTemplate) {
+    let body = schema.bodyTemplate;
+    body = body.replace(/\{\{title\}\}/g, String(title || "Untitled"));
+    body = body.replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
+    body = body.replace(/\{\{datetime\}\}/g, (/* @__PURE__ */ new Date()).toISOString());
+    body = body.replace(/\{\{links_line\}\}/g, "");
+    body = body.replace(/\{\{content\}\}/g, "");
+    parts.push(body.trim());
+  }
+  return parts.join("\n");
+}
+function writeObservation(vaultPath, observation, options = {}) {
+  return writeVaultFile(vaultPath, {
+    primitiveType: observation.primitiveType,
+    title: observation.text.slice(0, 80),
+    content: observation.text,
+    extraFields: {
+      type: observation.primitiveType === "memory_event" ? observation.category : observation.primitiveType,
+      confidence: observation.confidence,
+      tags: observation.tags,
+      observed_at: observation.extractedAt.toISOString()
+    },
+    source: options.source ?? "openclaw",
+    sessionId: options.sessionId
+  });
+}
+function writeObservations(vaultPath, observations, options = {}) {
+  return observations.map((obs) => writeObservation(vaultPath, obs, options));
+}
+function appendToLedger(vaultPath, entry) {
+  const dateStr = entry.timestamp.toISOString().slice(0, 10);
+  const ledgerDir = (0, import_node_path2.join)(vaultPath, "ledger");
+  if (!(0, import_node_fs2.existsSync)(ledgerDir)) {
+    (0, import_node_fs2.mkdirSync)(ledgerDir, { recursive: true });
+  }
+  const ledgerFile = (0, import_node_path2.join)(ledgerDir, `${dateStr}.md`);
+  const timeStr = entry.timestamp.toISOString().slice(11, 19);
+  const parts = [`[${timeStr}]`];
+  if (entry.category) parts.push(`[${entry.category}]`);
+  if (entry.actor) parts.push(`(${entry.actor})`);
+  parts.push(entry.content);
+  const line = `
+- ${parts.join(" ")}`;
+  if (!(0, import_node_fs2.existsSync)(ledgerFile)) {
+    const frontmatter = serializeFrontmatter({
+      type: "ledger",
+      date: dateStr,
+      created: entry.timestamp.toISOString()
+    });
+    (0, import_node_fs2.writeFileSync)(ledgerFile, `${frontmatter}
+
+# Observation Ledger \u2014 ${dateStr}
+${line}`, "utf-8");
+  } else {
+    (0, import_node_fs2.appendFileSync)(ledgerFile, line, "utf-8");
+  }
+}
+function appendObservationToLedger(vaultPath, observation, actor) {
+  appendToLedger(vaultPath, {
+    timestamp: observation.extractedAt,
+    category: observation.category,
+    actor,
+    content: observation.text,
+    primitiveType: observation.primitiveType,
+    tags: observation.tags
+  });
+}
+function batchWriteObservations(vaultPath, observations, options = {}) {
+  const results = [];
+  let successful = 0;
+  let failed = 0;
+  const writeLedger = options.writeLedger ?? true;
+  const writeFiles = options.writeFiles ?? false;
+  for (const observation of observations) {
+    if (writeLedger) {
+      try {
+        appendObservationToLedger(vaultPath, observation, options.actor);
+      } catch {
+      }
+    }
+    if (writeFiles) {
+      const result = writeObservation(vaultPath, observation, {
+        source: options.source,
+        sessionId: options.sessionId
+      });
+      results.push(result);
+      if (result.success) {
+        successful++;
+      } else {
+        failed++;
+      }
+    } else {
+      successful++;
+      results.push({
+        success: true,
+        path: (0, import_node_path2.join)(vaultPath, "ledger", `${observation.extractedAt.toISOString().slice(0, 10)}.md`),
+        primitiveType: observation.primitiveType,
+        errors: [],
+        created: false,
+        updated: true
+      });
+    }
+  }
+  return {
+    total: observations.length,
+    successful,
+    failed,
+    results
+  };
+}
+function ensureVaultStructure(vaultPath) {
+  const directories = [
+    "tasks",
+    "projects",
+    "decisions",
+    "people",
+    "lessons",
+    "memory",
+    "ledger",
+    "daily"
+  ];
+  for (const dir of directories) {
+    const fullPath = (0, import_node_path2.join)(vaultPath, dir);
+    if (!(0, import_node_fs2.existsSync)(fullPath)) {
+      (0, import_node_fs2.mkdirSync)(fullPath, { recursive: true });
+    }
+  }
+}
+function getVaultStats(vaultPath) {
+  const directories = [];
+  const primitiveTypes = {};
+  let fileCount = 0;
+  const { readdirSync: readdirSync2, statSync } = require("fs");
+  function scanDir(dir, depth = 0) {
+    if (depth > 2) return;
+    try {
+      const entries = readdirSync2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+        const fullPath = (0, import_node_path2.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+          directories.push(fullPath.replace(vaultPath + "/", ""));
+          scanDir(fullPath, depth + 1);
+        } else if (entry.name.endsWith(".md")) {
+          fileCount++;
+          try {
+            const content = (0, import_node_fs2.readFileSync)(fullPath, "utf-8");
+            const match = content.match(/^---\n[\s\S]*?type:\s*(\S+)/);
+            if (match) {
+              const type = match[1];
+              primitiveTypes[type] = (primitiveTypes[type] ?? 0) + 1;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  scanDir(vaultPath);
+  return { directories, fileCount, primitiveTypes };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendObservationToLedger,
+  appendToLedger,
+  batchWriteObservations,
+  ensureVaultStructure,
+  getVaultStats,
+  writeObservation,
+  writeObservations,
+  writeVaultFile
+});