clawvault 3.0.0 → 3.2.0

package/dist/chunk-GQSLDZTS.js

@@ -1,560 +0,0 @@
-// 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
-};