clawvault 3.0.0 → 3.2.0

package/dist/plugin/index.d.cts

@@ -1,36 +0,0 @@
-import { TemplateRegistry } from './templates.cjs';
-export { classifyText, getAllSchemas, getSchema, getSchemaNames, initializeTemplateRegistry } from './templates.cjs';
-export { detectCategory, extractObservations, extractSearchTerms, isObservable, processMessageForObservations } from './observe.cjs';
-export { buildFullContext, buildPreferenceContext, buildSessionRecap, formatMemoriesForContext, formatSearchResults, scanVaultFiles } from './inject.cjs';
-export { appendToLedger, batchWriteObservations, ensureVaultStructure, writeObservation, writeVaultFile } from './vault.cjs';
-
-/**
- * ClawVault OpenClaw Plugin v2.2.0
- *
- * Memory slot provider for OpenClaw. Template-driven observational memory architecture:
- * memories are captured automatically from conversations, classified against template
- * schemas, and stored with proper frontmatter validation.
- *
- * Architecture:
- *   ClawVault (engine) ←→ Plugin (integration) ←→ OpenClaw (agent platform)
- *   - ClawVault = vault, observations, search index, knowledge graph
- *   - Plugin = auto-recall, auto-capture, search tools, lifecycle hooks
- *   - OpenClaw = agent runtime, sessions, tools, channels
- *   - Templates = schema definitions for primitive types
- *
- * The plugin does NOT give the agent a "store memory" tool. Memory is
- * observational: the system watches conversations and captures automatically.
- * The agent searches memory; it doesn't manage it.
- */
-
-declare function getTemplateRegistry(): TemplateRegistry | null;
-declare const clawvaultPlugin: {
-    id: string;
-    name: string;
-    description: string;
-    version: string;
-    kind: "memory";
-    register(api: any): void;
-};
-
-export { clawvaultPlugin as default, getTemplateRegistry };

package/dist/plugin/index.d.ts

@@ -1,36 +0,0 @@
-import { TemplateRegistry } from './templates.js';
-export { classifyText, getAllSchemas, getSchema, getSchemaNames, initializeTemplateRegistry } from './templates.js';
-export { detectCategory, extractObservations, extractSearchTerms, isObservable, processMessageForObservations } from './observe.js';
-export { buildFullContext, buildPreferenceContext, buildSessionRecap, formatMemoriesForContext, formatSearchResults, scanVaultFiles } from './inject.js';
-export { appendToLedger, batchWriteObservations, ensureVaultStructure, writeObservation, writeVaultFile } from './vault.js';
-
-/**
- * ClawVault OpenClaw Plugin v2.2.0
- *
- * Memory slot provider for OpenClaw. Template-driven observational memory architecture:
- * memories are captured automatically from conversations, classified against template
- * schemas, and stored with proper frontmatter validation.
- *
- * Architecture:
- *   ClawVault (engine) ←→ Plugin (integration) ←→ OpenClaw (agent platform)
- *   - ClawVault = vault, observations, search index, knowledge graph
- *   - Plugin = auto-recall, auto-capture, search tools, lifecycle hooks
- *   - OpenClaw = agent runtime, sessions, tools, channels
- *   - Templates = schema definitions for primitive types
- *
- * The plugin does NOT give the agent a "store memory" tool. Memory is
- * observational: the system watches conversations and captures automatically.
- * The agent searches memory; it doesn't manage it.
- */
-
-declare function getTemplateRegistry(): TemplateRegistry | null;
-declare const clawvaultPlugin: {
-    id: string;
-    name: string;
-    description: string;
-    version: string;
-    kind: "memory";
-    register(api: any): void;
-};
-
-export { clawvaultPlugin as default, getTemplateRegistry };

package/dist/plugin/index.js

@@ -1,572 +0,0 @@
-import {
-  appendToLedger,
-  batchWriteObservations,
-  ensureVaultStructure,
-  writeObservation,
-  writeVaultFile
-} from "../chunk-MFM6K7PU.js";
-import {
-  buildFullContext,
-  buildPreferenceContext,
-  buildSessionRecap,
-  formatMemoriesForContext,
-  formatSearchResults,
-  scanVaultFiles
-} from "../chunk-CMB7UL7C.js";
-import {
-  detectCategory,
-  extractObservations,
-  extractSearchTerms,
-  isObservable,
-  processMessageForObservations
-} from "../chunk-6U6MK36V.js";
-import {
-  classifyText,
-  getAllSchemas,
-  getSchema,
-  getSchemaNames,
-  initializeTemplateRegistry
-} from "../chunk-GQSLDZTS.js";
-import {
-  __require
-} from "../chunk-3RG5ZIWI.js";
-
-// src/plugin/index.ts
-import { execFileSync, execFile } from "child_process";
-import { existsSync, readFileSync, mkdirSync } from "fs";
-import { join, basename } from "path";
-import { Type } from "@sinclair/typebox";
-function resolveVaultPath(cfg) {
-  if (cfg?.vaultPath) return cfg.vaultPath;
-  if (process.env.CLAWVAULT_PATH) return process.env.CLAWVAULT_PATH;
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
-  for (const candidate of [`${home}/clawvault`, `${home}/.clawvault`]) {
-    if (existsSync(join(candidate, ".clawvault.json"))) return candidate;
-  }
-  return `${home}/.clawvault`;
-}
-function getVaultConfig(vaultPath) {
-  const configPath = join(vaultPath, ".clawvault.json");
-  if (!existsSync(configPath)) return null;
-  try {
-    return JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function qmdHybridSearch(query, collection, limit = 10) {
-  const sanitized = query.replace(/['']/g, " ").replace(/[^\w\s\-.,?!]/g, " ").trim();
-  if (!sanitized) return [];
-  try {
-    const result = execFileSync("qmd", [
-      "query",
-      sanitized,
-      "-n",
-      String(limit),
-      "--json",
-      "-c",
-      collection
-    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024, timeout: 3e4 });
-    const parsed = JSON.parse(result);
-    if (Array.isArray(parsed) && parsed.length > 0) return parsed;
-  } catch (err) {
-    if (err?.stdout) {
-      try {
-        const parsed = JSON.parse(err.stdout);
-        if (Array.isArray(parsed) && parsed.length > 0) return parsed;
-      } catch {
-      }
-    }
-  }
-  try {
-    const result = execFileSync("qmd", [
-      "search",
-      sanitized,
-      "-n",
-      String(limit),
-      "--json",
-      "-c",
-      collection
-    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024, timeout: 15e3 });
-    return JSON.parse(result);
-  } catch (err) {
-    if (err?.stdout) {
-      try {
-        return JSON.parse(err.stdout);
-      } catch {
-      }
-    }
-    return [];
-  }
-}
-function observe(vaultPath, content, meta = {}) {
-  try {
-    const args = ["observe", "--content", content];
-    if (meta.tags?.length) args.push("--tags", meta.tags.join(","));
-    execFile("clawvault", args, { cwd: vaultPath, timeout: 15e3 }, () => {
-    });
-  } catch {
-  }
-}
-function qmdUpdateAsync(collection) {
-  try {
-    execFile("qmd", ["update", "-c", collection], { timeout: 3e4 }, () => {
-    });
-    execFile("qmd", ["embed", "-c", collection], { timeout: 6e4 }, () => {
-    });
-  } catch {
-  }
-}
-var templateRegistry = null;
-function getTemplateRegistry() {
-  return templateRegistry;
-}
-var clawvaultPlugin = {
-  id: "clawvault",
-  name: "ClawVault Memory",
-  description: "Template-driven observational memory with hybrid search. Memories are captured automatically from conversations and classified against template schemas.",
-  version: "2.2.0",
-  kind: "memory",
-  register(api) {
-    const vaultPath = resolveVaultPath(api.pluginConfig);
-    const collection = api.pluginConfig?.collection || "clawvault";
-    const autoRecall = api.pluginConfig?.autoRecall !== false;
-    const autoCapture = api.pluginConfig?.autoCapture !== false;
-    const recallLimit = api.pluginConfig?.recallLimit || 5;
-    const templatesDir = api.pluginConfig?.templatesDir ?? join(vaultPath, "..", "..", "templates");
-    templateRegistry = initializeTemplateRegistry(templatesDir);
-    api.logger.info(`[clawvault] Template registry initialized with ${templateRegistry.schemas.size} schemas`);
-    if (!existsSync(join(vaultPath, ".clawvault.json"))) {
-      api.logger.warn(`[clawvault] Vault not found at ${vaultPath}`);
-      return;
-    }
-    ensureVaultStructure(vaultPath);
-    api.logger.info(`[clawvault] v2.2.0 vault=${vaultPath} collection=${collection} recall=${autoRecall} capture=${autoCapture}`);
-    api.registerTool({
-      name: "memory_search",
-      label: "Memory Search",
-      description: "Search through long-term memories using ClawVault. Supports preferences, temporal queries, and multi-session knowledge retrieval.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Search query \u2014 natural language question or keyword search" }),
-        limit: Type.Optional(Type.Number({ description: "Max results (default: 10)" })),
-        queryType: Type.Optional(Type.Union([
-          Type.Literal("preference"),
-          Type.Literal("temporal"),
-          Type.Literal("knowledge"),
-          Type.Literal("general")
-        ], { description: "Force query type (auto-detected if omitted)" }))
-      }),
-      async execute(_id, params) {
-        try {
-          let searchQuery = params.query;
-          if (params.queryType === "preference") searchQuery = `preference: ${searchQuery}`;
-          else if (params.queryType === "temporal") searchQuery = `when: ${searchQuery}`;
-          const limit = params.limit || 10;
-          const results = qmdHybridSearch(searchQuery, collection, limit);
-          if (results.length === 0) {
-            return {
-              content: [{ type: "text", text: "No relevant memories found." }],
-              details: { count: 0, provider: "clawvault" }
-            };
-          }
-          return {
-            content: [{ type: "text", text: formatSearchResults(results, collection) }],
-            details: { count: results.length, provider: "clawvault" }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory search error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_get",
-      label: "Memory Get",
-      description: "Get vault status or stored preferences.",
-      parameters: Type.Object({
-        action: Type.Union([
-          Type.Literal("status"),
-          Type.Literal("preferences")
-        ], { description: "What to retrieve" })
-      }),
-      async execute(_id, params) {
-        try {
-          if (params.action === "status") {
-            const config = getVaultConfig(vaultPath);
-            let docCount = 0;
-            let vectorCount = 0;
-            try {
-              const stats = execFileSync("qmd", ["status", "--json", "-c", collection], {
-                encoding: "utf-8",
-                timeout: 5e3,
-                stdio: ["ignore", "pipe", "pipe"]
-              });
-              const parsed = JSON.parse(stats);
-              docCount = parsed.documents ?? parsed.doc_count ?? 0;
-              vectorCount = parsed.vectors ?? parsed.vector_count ?? 0;
-            } catch {
-            }
-            return {
-              content: [{ type: "text", text: JSON.stringify({
-                vault: vaultPath,
-                name: config?.name || "clawvault",
-                collection,
-                documents: docCount,
-                vectors: vectorCount,
-                autoRecall,
-                autoCapture,
-                version: "2.2.0",
-                templateSchemas: templateRegistry?.schemas.size ?? 0
-              }, null, 2) }]
-            };
-          }
-          const prefContext = buildPreferenceContext(vaultPath, { limit: 20 });
-          if (prefContext.preferenceCount === 0) {
-            const results = qmdHybridSearch("user preference likes dislikes prefers wants", collection, 20);
-            const prefResults = results.filter(
-              (r) => r.file?.includes("preference") || r.snippet?.toLowerCase().match(/prefer|like|want|hate|love|always|never/)
-            );
-            if (prefResults.length === 0) {
-              return { content: [{ type: "text", text: "No preferences found in vault." }] };
-            }
-            const text = prefResults.map((r, i) => {
-              const file = (r.file || "").replace(`qmd://${collection}/`, "");
-              const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title;
-              return `${i + 1}. [${file}] ${snippet}`;
-            }).join("\n");
-            return { content: [{ type: "text", text }] };
-          }
-          return { content: [{ type: "text", text: prefContext.xml }] };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory get error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_store",
-      label: "Memory Store",
-      description: "Save important information in long-term memory. Use for preferences, facts, decisions, or anything worth remembering.",
-      parameters: Type.Object({
-        text: Type.String({ description: "Information to remember" }),
-        category: Type.Optional(Type.Union([
-          Type.Literal("preference"),
-          Type.Literal("fact"),
-          Type.Literal("decision"),
-          Type.Literal("entity"),
-          Type.Literal("event"),
-          Type.Literal("other")
-        ], { description: "Memory category (auto-detected if omitted)" })),
-        tags: Type.Optional(Type.Array(Type.String(), { description: "Tags for organization" }))
-      }),
-      async execute(_id, params) {
-        try {
-          const classification = classifyText(params.text);
-          const category = params.category || detectCategory(params.text);
-          const tags = params.tags || [category, ...classification.matchedKeywords.slice(0, 3)];
-          const result = writeVaultFile(vaultPath, {
-            primitiveType: classification.primitiveType,
-            title: params.text.slice(0, 80),
-            content: params.text,
-            extraFields: {
-              type: category,
-              confidence: classification.confidence,
-              tags
-            },
-            source: "openclaw"
-          });
-          appendToLedger(vaultPath, {
-            timestamp: /* @__PURE__ */ new Date(),
-            category,
-            content: params.text,
-            primitiveType: classification.primitiveType,
-            tags
-          });
-          qmdUpdateAsync(collection);
-          return {
-            content: [{ type: "text", text: `Stored: "${params.text.slice(0, 100)}${params.text.length > 100 ? "..." : ""}" [${classification.primitiveType}/${category}]` }],
-            details: {
-              action: result.created ? "created" : "updated",
-              category,
-              primitiveType: classification.primitiveType,
-              path: result.path
-            }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory store error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_forget",
-      label: "Memory Forget",
-      description: "Delete specific memories from the vault.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Search query to find the memory to delete" }),
-        confirm: Type.Optional(Type.Boolean({ description: "Set true to confirm deletion of first match" }))
-      }),
-      async execute(_id, params) {
-        try {
-          const results = qmdHybridSearch(params.query, collection, 5);
-          if (results.length === 0) {
-            return {
-              content: [{ type: "text", text: "No matching memories found." }],
-              details: { found: 0 }
-            };
-          }
-          if (!params.confirm) {
-            const list = results.map((r, i) => {
-              const file2 = (r.file || "").replace(`qmd://${collection}/`, "");
-              const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim().slice(0, 80);
-              return `${i + 1}. [${file2}] ${snippet}`;
-            }).join("\n");
-            return {
-              content: [{ type: "text", text: `Found ${results.length} candidates:
-${list}
-
-Call again with confirm=true to delete the top match.` }],
-              details: { action: "candidates", count: results.length }
-            };
-          }
-          const target = results[0];
-          const file = (target.file || "").replace(`qmd://${collection}/`, "");
-          const fullPath = join(vaultPath, file);
-          if (existsSync(fullPath)) {
-            const trashDir = join(vaultPath, ".trash");
-            if (!existsSync(trashDir)) mkdirSync(trashDir, { recursive: true });
-            const trashPath = join(trashDir, `${Date.now()}-${basename(file)}`);
-            const { renameSync } = __require("fs");
-            renameSync(fullPath, trashPath);
-            qmdUpdateAsync(collection);
-            return {
-              content: [{ type: "text", text: `Forgotten: [${file}] (moved to .trash)` }],
-              details: { action: "deleted", file, trashPath }
-            };
-          }
-          return {
-            content: [{ type: "text", text: `File not found on disk: ${file}` }],
-            details: { action: "not_found", file }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory forget error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    if (autoRecall) {
-      api.on("before_agent_start", async (event) => {
-        if (!event.prompt || event.prompt.length < 10) return;
-        if (event.prompt.includes("HEARTBEAT") || event.prompt.startsWith("[System")) return;
-        try {
-          const contextParts = [];
-          const recap = buildSessionRecap(vaultPath, {
-            maxAge: 24 * 60 * 60 * 1e3,
-            // 24 hours
-            limit: 10,
-            includeContent: true
-          });
-          if (recap.xml) {
-            contextParts.push(recap.xml);
-          }
-          const searchTerms = extractSearchTerms(event.prompt);
-          const results = qmdHybridSearch(searchTerms, collection, recallLimit);
-          if (results.length > 0) {
-            const topScore = results[0]?.score ?? 0;
-            if (topScore >= 0.25) {
-              contextParts.push(formatMemoriesForContext(results, collection));
-              api.logger.info(`[clawvault] auto-recall: ${results.length} memories (top: ${(topScore * 100).toFixed(0)}%, query: "${searchTerms.slice(0, 60)}")`);
-            }
-          }
-          if (contextParts.length === 0) return;
-          return {
-            prependContext: contextParts.join("\n\n")
-          };
-        } catch (err) {
-          api.logger.warn(`[clawvault] auto-recall failed: ${String(err)}`);
-        }
-      }, { priority: 10 });
-    }
-    if (autoCapture) {
-      api.on("message_received", async (event) => {
-        if (!event.content || !isObservable(event.content)) return;
-        try {
-          const result = processMessageForObservations(event.content, {
-            from: event.from,
-            sessionId: event.sessionId
-          });
-          if (result.observations.length === 0) return;
-          const writeResult = batchWriteObservations(vaultPath, result.observations, {
-            source: "openclaw",
-            sessionId: event.sessionId,
-            actor: event.from || "user",
-            writeLedger: true,
-            writeFiles: false
-            // Only write to ledger for speed
-          });
-          api.logger.info(`[clawvault] auto-captured ${writeResult.successful} observations from incoming message`);
-        } catch (err) {
-          api.logger.warn(`[clawvault] message capture failed: ${String(err)}`);
-        }
-      });
-      api.on("agent_end", async (event) => {
-        if (!event.success || !event.messages?.length) return;
-        try {
-          let captured = 0;
-          for (const msg of event.messages) {
-            if (!msg || typeof msg !== "object") continue;
-            if (msg.role === "user") {
-              const content = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((b) => b?.type === "text").map((b) => b.text).join(" ") : "";
-              if (isObservable(content)) {
-                const result = processMessageForObservations(content);
-                for (const obs of result.observations) {
-                  observe(vaultPath, obs.text, { tags: obs.tags });
-                  captured++;
-                }
-              }
-            }
-          }
-          if (captured > 0) {
-            api.logger.info(`[clawvault] agent_end: captured ${captured} observations`);
-            qmdUpdateAsync(collection);
-          }
-        } catch (err) {
-          api.logger.warn(`[clawvault] agent_end capture failed: ${String(err)}`);
-        }
-      });
-    }
-    api.on("before_compaction", async () => {
-      try {
-        execFileSync("qmd", ["update", "-c", collection], {
-          timeout: 15e3,
-          encoding: "utf-8",
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        api.logger.info("[clawvault] pre-compaction index update complete");
-      } catch (err) {
-        api.logger.warn(`[clawvault] pre-compaction update failed: ${String(err)}`);
-      }
-    });
-    api.registerService({
-      id: "clawvault",
-      start: () => {
-        api.logger.info(`[clawvault] service started \u2014 vault=${vaultPath}`);
-        qmdUpdateAsync(collection);
-      },
-      stop: () => {
-        api.logger.info("[clawvault] service stopped");
-      }
-    });
-    api.registerCli(
-      ({ program }) => {
-        const cmd = program.command("vault").description("ClawVault memory commands");
-        cmd.command("status").action(() => {
-          const config = getVaultConfig(vaultPath);
-          console.log(JSON.stringify({
-            vault: vaultPath,
-            version: "2.2.0",
-            templateSchemas: templateRegistry?.schemas.size ?? 0,
-            ...config
-          }, null, 2));
-        });
-        cmd.command("search <query>").option("-n, --limit <n>", "Max results", "10").action((query, opts) => {
-          const results = qmdHybridSearch(query, collection, parseInt(opts.limit));
-          console.log(formatSearchResults(results, collection));
-        });
-        cmd.command("templates").action(() => {
-          const schemas = getAllSchemas();
-          console.log("Registered template schemas:");
-          for (const schema of schemas) {
-            console.log(`  - ${schema.primitive}: ${schema.description || "(no description)"}`);
-            console.log(`    Fields: ${Object.keys(schema.fields).join(", ")}`);
-          }
-        });
-        cmd.command("classify <text>").action((text) => {
-          const result = classifyText(text);
-          console.log(JSON.stringify(result, null, 2));
-        });
-      },
-      { commands: ["vault"] }
-    );
-    api.registerCommand({
-      name: "vault",
-      description: "ClawVault status and quick search",
-      acceptsArgs: true,
-      requireAuth: true,
-      handler: (ctx) => {
-        const args = (ctx.args || "").trim();
-        if (!args || args === "status") {
-          const config = getVaultConfig(vaultPath);
-          let docCount = 0, vectorCount = 0;
-          try {
-            const stats = execFileSync("qmd", ["status", "--json", "-c", collection], {
-              encoding: "utf-8",
-              timeout: 5e3,
-              stdio: ["ignore", "pipe", "pipe"]
-            });
-            const p = JSON.parse(stats);
-            docCount = p.documents ?? p.doc_count ?? 0;
-            vectorCount = p.vectors ?? p.vector_count ?? 0;
-          } catch {
-          }
-          return {
-            text: `\u{1F9E0} ClawVault v2.2.0
-Vault: ${vaultPath}
-Docs: ${docCount} | Vectors: ${vectorCount}
-Recall: ${autoRecall ? "\u2705" : "\u274C"} | Capture: ${autoCapture ? "\u2705" : "\u274C"}
-Templates: ${templateRegistry?.schemas.size ?? 0} schemas`
-          };
-        }
-        if (args.startsWith("search ")) {
-          const query = args.slice(7).trim();
-          const results = qmdHybridSearch(query, collection, 5);
-          return { text: formatSearchResults(results, collection) };
-        }
-        if (args === "templates") {
-          const names = getSchemaNames();
-          return { text: `Template schemas: ${names.join(", ")}` };
-        }
-        if (args === "recap") {
-          const recap = buildSessionRecap(vaultPath, { limit: 10, includeContent: true });
-          return { text: recap.xml || "No recent activity found." };
-        }
-        return { text: "Usage: /vault [status|search <query>|templates|recap]" };
-      }
-    });
-    console.log(`[clawvault] v2.2.0 registered \u2014 vault=${vaultPath} templates=${templateRegistry?.schemas.size ?? 0}`);
-  }
-};
-var plugin_default = clawvaultPlugin;
-export {
-  appendToLedger,
-  batchWriteObservations,
-  buildFullContext,
-  buildPreferenceContext,
-  buildSessionRecap,
-  classifyText,
-  plugin_default as default,
-  detectCategory,
-  ensureVaultStructure,
-  extractObservations,
-  extractSearchTerms,
-  formatMemoriesForContext,
-  formatSearchResults,
-  getAllSchemas,
-  getSchema,
-  getSchemaNames,
-  getTemplateRegistry,
-  initializeTemplateRegistry,
-  isObservable,
-  processMessageForObservations,
-  scanVaultFiles,
-  writeObservation,
-  writeVaultFile
-};