clawvault 2.6.0 → 3.0.0

package/dist/plugin/observe.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Dynamic Observation Engine for ClawVault
+ *
+ * Replaces hardcoded categories with template-driven classification.
+ * Extracts observations from text and classifies them against the
+ * template registry using keyword/heuristic matching (no LLM calls).
+ */
+interface Observation {
+    text: string;
+    primitiveType: string;
+    confidence: number;
+    matchedKeywords: string[];
+    category: string;
+    tags: string[];
+    extractedAt: Date;
+}
+interface ObservationResult {
+    observations: Observation[];
+    skipped: number;
+    reason?: string;
+}
+declare function isObservable(text: string): boolean;
+declare function extractObservations(text: string): Observation[];
+declare function processMessageForObservations(content: string, options?: {
+    from?: string;
+    sessionId?: string;
+}): ObservationResult;
+declare function detectCategory(text: string): string;
+interface ExtractedPreference {
+    category: string;
+    item: string;
+    sentiment: 'positive' | 'negative' | 'neutral';
+    confidence: number;
+    source: string;
+}
+declare function extractPreferences(text: string): ExtractedPreference[];
+declare function extractSearchTerms(input: string): string;
+
+export { type ExtractedPreference, type Observation, type ObservationResult, detectCategory, extractObservations, extractPreferences, extractSearchTerms, isObservable, processMessageForObservations };

package/dist/plugin/observe.js

@@ -0,0 +1,18 @@
+import {
+  detectCategory,
+  extractObservations,
+  extractPreferences,
+  extractSearchTerms,
+  isObservable,
+  processMessageForObservations
+} from "../chunk-6U6MK36V.js";
+import "../chunk-GQSLDZTS.js";
+import "../chunk-3RG5ZIWI.js";
+export {
+  detectCategory,
+  extractObservations,
+  extractPreferences,
+  extractSearchTerms,
+  isObservable,
+  processMessageForObservations
+};

package/dist/plugin/templates.cjs

@@ -0,0 +1,593 @@
+"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/templates.ts
+var templates_exports = {};
+__export(templates_exports, {
+  classifyText: () => classifyText,
+  generateFrontmatter: () => generateFrontmatter,
+  getAllSchemas: () => getAllSchemas,
+  getSchema: () => getSchema,
+  getSchemaNames: () => getSchemaNames,
+  getTemplateRegistry: () => getTemplateRegistry,
+  initializeTemplateRegistry: () => initializeTemplateRegistry,
+  resetTemplateRegistry: () => resetTemplateRegistry,
+  serializeFrontmatter: () => serializeFrontmatter,
+  validateFrontmatter: () => validateFrontmatter
+});
+module.exports = __toCommonJS(templates_exports);
+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 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  classifyText,
+  generateFrontmatter,
+  getAllSchemas,
+  getSchema,
+  getSchemaNames,
+  getTemplateRegistry,
+  initializeTemplateRegistry,
+  resetTemplateRegistry,
+  serializeFrontmatter,
+  validateFrontmatter
+});