clawvault 3.1.0 → 3.2.1

package/dist/plugin/observe.cjs

@@ -1,631 +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/observe.ts
-var observe_exports = {};
-__export(observe_exports, {
-  detectCategory: () => detectCategory,
-  extractObservations: () => extractObservations,
-  extractPreferences: () => extractPreferences,
-  extractSearchTerms: () => extractSearchTerms,
-  isObservable: () => isObservable,
-  processMessageForObservations: () => processMessageForObservations
-});
-module.exports = __toCommonJS(observe_exports);
-
-// 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);
-  }
-}
-
-// src/plugin/observe.ts
-function isObservable(text) {
-  if (!text || text.length < 20 || text.length > 5e3) return false;
-  if (text.includes("<relevant-memories>")) return false;
-  if (text.startsWith("[System")) return false;
-  if (text.includes("HEARTBEAT")) return false;
-  if (text.startsWith("NO_REPLY")) return false;
-  if (text.startsWith("{") && text.includes('"')) return false;
-  const markdownDensity = (text.match(/[#*`\-|>]/g) || []).length / text.length;
-  if (markdownDensity > 0.15) return false;
-  return true;
-}
-var OBSERVATION_PATTERNS = [
-  // Preferences
-  { pattern: /\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i, weight: 2 },
-  // Decisions
-  { pattern: /\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it|go with)\b/i, weight: 2 },
-  // Facts about people/things
-  { pattern: /\b(my .+ is|his .+ is|her .+ is|their .+ is|works at|lives in|born in)\b/i, weight: 1.5 },
-  // Contact info
-  { pattern: /[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/i, weight: 2 },
-  // Explicit memory request
-  { pattern: /\b(remember|don't forget|keep in mind|note that|important:)\b/i, weight: 2.5 },
-  // Deadlines/dates
-  { pattern: /\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i, weight: 1.5 },
-  // Lessons learned
-  { pattern: /\b(i learned|we learned|lesson|realized|discovered|found out)\b/i, weight: 1.5 },
-  // Tasks
-  { pattern: /\b(need to|should|must|have to|todo|task)\b/i, weight: 1 },
-  // Projects
-  { pattern: /\b(working on|building|developing|project|initiative)\b/i, weight: 1 }
-];
-function extractObservations(text) {
-  const observations = [];
-  const sentences = splitIntoSentences(text);
-  const now = /* @__PURE__ */ new Date();
-  for (const sentence of sentences) {
-    if (sentence.length < 15) continue;
-    let totalWeight = 0;
-    for (const { pattern, weight } of OBSERVATION_PATTERNS) {
-      if (pattern.test(sentence)) {
-        totalWeight += weight;
-      }
-    }
-    if (totalWeight < 1) continue;
-    const classification = classifyText(sentence);
-    const category = deriveCategoryFromPrimitive(classification.primitiveType, sentence);
-    const tags = generateTags(classification, sentence);
-    observations.push({
-      text: sentence.trim(),
-      primitiveType: classification.primitiveType,
-      confidence: classification.confidence,
-      matchedKeywords: classification.matchedKeywords,
-      category,
-      tags,
-      extractedAt: now
-    });
-  }
-  return observations;
-}
-function splitIntoSentences(text) {
-  const raw = text.split(/(?<=[.!?\n])\s+/);
-  const sentences = [];
-  for (const s of raw) {
-    const trimmed = s.trim();
-    if (trimmed.length > 0) {
-      sentences.push(trimmed);
-    }
-  }
-  return sentences;
-}
-function deriveCategoryFromPrimitive(primitiveType, text) {
-  const lower = text.toLowerCase();
-  if (primitiveType === "memory_event") {
-    if (/prefer|like|love|hate|want|need|always|never/i.test(lower)) {
-      return "preference";
-    }
-    if (/remember|don't forget|keep in mind|note that/i.test(lower)) {
-      return "note";
-    }
-    return "fact";
-  }
-  const categoryMap = {
-    person: "entity",
-    decision: "decision",
-    task: "task",
-    project: "project",
-    lesson: "lesson",
-    trigger: "automation",
-    run: "execution",
-    checkpoint: "checkpoint",
-    handoff: "handoff",
-    "daily-note": "daily",
-    daily: "daily",
-    party: "entity",
-    workspace: "workspace"
-  };
-  return categoryMap[primitiveType] ?? "fact";
-}
-function generateTags(classification, text) {
-  const tags = [classification.primitiveType];
-  const lower = text.toLowerCase();
-  if (/prefer|like|love/i.test(lower)) tags.push("positive");
-  if (/hate|dislike|don't like/i.test(lower)) tags.push("negative");
-  if (/deadline|due|by tomorrow|by tonight/i.test(lower)) tags.push("time-sensitive");
-  if (/important|critical|urgent/i.test(lower)) tags.push("high-priority");
-  if (/email|phone|contact/i.test(lower)) tags.push("contact-info");
-  if (/decided|chose|approved/i.test(lower)) tags.push("finalized");
-  if (/proposed|considering|might/i.test(lower)) tags.push("tentative");
-  return [...new Set(tags)];
-}
-function processMessageForObservations(content, options = {}) {
-  if (!isObservable(content)) {
-    return {
-      observations: [],
-      skipped: 1,
-      reason: "Content not observable"
-    };
-  }
-  const observations = extractObservations(content);
-  const maxObservations = 5;
-  const limited = observations.slice(0, maxObservations);
-  const skipped = observations.length - limited.length;
-  return {
-    observations: limited,
-    skipped,
-    reason: skipped > 0 ? `Limited to ${maxObservations} observations` : void 0
-  };
-}
-function detectCategory(text) {
-  const classification = classifyText(text);
-  return deriveCategoryFromPrimitive(classification.primitiveType, text);
-}
-function extractPreferences(text) {
-  const preferences = [];
-  const patterns = [
-    { regex: /i (?:really )?(?:like|love|enjoy|prefer)\s+(.+?)(?:\.|,|$)/gi, sentiment: "positive" },
-    { regex: /i (?:don't|do not|hate|dislike)\s+(.+?)(?:\.|,|$)/gi, sentiment: "negative" },
-    { regex: /my favorite\s+(.+?)\s+is\s+(.+?)(?:\.|,|$)/gi, sentiment: "positive", hasCategory: true },
-    { regex: /i prefer\s+(.+?)\s+over\s+(.+?)(?:\.|,|$)/gi, sentiment: "positive" }
-  ];
-  for (const { regex, sentiment, hasCategory } of patterns) {
-    let match;
-    regex.lastIndex = 0;
-    while ((match = regex.exec(text)) !== null) {
-      if (hasCategory && match[2]) {
-        preferences.push({
-          category: normalizeCategory(match[1]),
-          item: match[2].trim(),
-          sentiment,
-          confidence: 0.8,
-          source: text.slice(0, 100)
-        });
-      } else if (match[1]) {
-        const item = match[1].trim();
-        preferences.push({
-          category: inferCategory(item),
-          item,
-          sentiment,
-          confidence: 0.7,
-          source: text.slice(0, 100)
-        });
-      }
-    }
-  }
-  return preferences;
-}
-function normalizeCategory(category) {
-  return category.toLowerCase().trim().replace(/\s+/g, "_");
-}
-function inferCategory(item) {
-  const itemLower = item.toLowerCase();
-  const categoryKeywords = {
-    food: ["pizza", "coffee", "tea", "food", "restaurant", "cuisine", "dish", "meal", "drink"],
-    technology: ["programming", "code", "software", "app", "technology", "framework", "language", "tool"],
-    entertainment: ["movie", "music", "book", "game", "show", "series", "film", "song", "album"],
-    work: ["meeting", "project", "task", "deadline", "team", "client"],
-    communication: ["email", "slack", "chat", "call", "message"]
-  };
-  for (const [category, keywords] of Object.entries(categoryKeywords)) {
-    if (keywords.some((k) => itemLower.includes(k))) {
-      return category;
-    }
-  }
-  return "general";
-}
-function extractSearchTerms(input) {
-  const noise = /\b(hey|hi|hello|um|uh|like|just|so|well|you know|i mean|basically|actually|really|very|pretty|quite|how does it feel|how do you|can you|could you|would you|do you|what do you think|tell me about)\b/gi;
-  let cleaned = input.replace(noise, " ").replace(/\s+/g, " ").trim();
-  if (cleaned.length < 5) cleaned = input.trim();
-  return cleaned;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectCategory,
-  extractObservations,
-  extractPreferences,
-  extractSearchTerms,
-  isObservable,
-  processMessageForObservations
-});

package/dist/plugin/observe.d.cts

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