clawvault 3.1.0 → 3.2.1

package/dist/plugin/vault.cjs

@@ -1,927 +0,0 @@
-"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
-});