clawvault 2.6.1 → 3.0.0-beta.2

package/dist/chunk-CMB7UL7C.js

@@ -0,0 +1,327 @@
+// src/plugin/inject.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join, relative } from "path";
+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");
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const valueStr = line.slice(colonIndex + 1).trim();
+    if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
+    result[key] = parseYamlValue(valueStr);
+  }
+  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;
+}
+function scanVaultFiles(vaultPath, options = {}) {
+  const files = [];
+  const maxAge = options.maxAge ?? 7 * 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 100;
+  const now = Date.now();
+  const cutoff = now - maxAge;
+  const dirsToScan = findVaultDirectories(vaultPath);
+  for (const dir of dirsToScan) {
+    if (!existsSync(dir)) continue;
+    try {
+      scanDirectory(dir, vaultPath, files, cutoff, options.primitiveTypes);
+    } catch {
+    }
+  }
+  files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+  return files.slice(0, limit);
+}
+function findVaultDirectories(vaultPath) {
+  const dirs = [];
+  dirs.push(vaultPath);
+  const commonDirs = [
+    "tasks",
+    "projects",
+    "decisions",
+    "people",
+    "persons",
+    "notes",
+    "daily",
+    "journal",
+    "ledger",
+    "memory",
+    "memories",
+    "observations",
+    "lessons",
+    "triggers",
+    "runs",
+    "checkpoints",
+    "handoffs",
+    "workspaces",
+    "parties"
+  ];
+  for (const subdir of commonDirs) {
+    const fullPath = join(vaultPath, subdir);
+    if (existsSync(fullPath)) {
+      dirs.push(fullPath);
+    }
+  }
+  try {
+    const entries = readdirSync(vaultPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
+        const fullPath = join(vaultPath, entry.name);
+        if (!dirs.includes(fullPath)) {
+          dirs.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return dirs;
+}
+function scanDirectory(dir, vaultPath, files, cutoff, primitiveTypes) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const depth = fullPath.replace(vaultPath, "").split("/").length;
+      if (depth <= 3) {
+        scanDirectory(fullPath, vaultPath, files, cutoff, primitiveTypes);
+      }
+    } else if (entry.name.endsWith(".md")) {
+      try {
+        const stat = statSync(fullPath);
+        if (stat.mtimeMs < cutoff) continue;
+        const content = readFileSync(fullPath, "utf-8");
+        const parsed = parseYamlFrontmatter(content);
+        if (!parsed) continue;
+        const primitiveType = detectPrimitiveType(parsed.frontmatter, fullPath);
+        if (primitiveTypes && !primitiveTypes.includes(primitiveType)) continue;
+        files.push({
+          path: fullPath,
+          relativePath: relative(vaultPath, fullPath),
+          primitiveType,
+          frontmatter: parsed.frontmatter,
+          content: parsed.body,
+          modifiedAt: stat.mtime,
+          createdAt: stat.birthtime
+        });
+      } catch {
+      }
+    }
+  }
+}
+function detectPrimitiveType(frontmatter, filePath) {
+  if (frontmatter.primitive) return String(frontmatter.primitive);
+  if (frontmatter.type) return String(frontmatter.type);
+  const pathLower = filePath.toLowerCase();
+  if (pathLower.includes("/tasks/")) return "task";
+  if (pathLower.includes("/projects/")) return "project";
+  if (pathLower.includes("/decisions/")) return "decision";
+  if (pathLower.includes("/people/") || pathLower.includes("/persons/")) return "person";
+  if (pathLower.includes("/daily/") || pathLower.includes("/journal/")) return "daily-note";
+  if (pathLower.includes("/lessons/")) return "lesson";
+  if (pathLower.includes("/triggers/")) return "trigger";
+  if (pathLower.includes("/runs/")) return "run";
+  if (pathLower.includes("/checkpoints/")) return "checkpoint";
+  if (pathLower.includes("/handoffs/")) return "handoff";
+  if (pathLower.includes("/ledger/")) return "memory_event";
+  if (pathLower.includes("/memory/") || pathLower.includes("/memories/")) return "memory_event";
+  return "unknown";
+}
+function buildSessionRecap(vaultPath, options = {}) {
+  const maxAge = options.maxAge ?? 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 20;
+  const includeContent = options.includeContent ?? false;
+  const files = scanVaultFiles(vaultPath, { maxAge, limit });
+  if (files.length === 0) {
+    return {
+      xml: "",
+      fileCount: 0,
+      primitiveGroups: {},
+      timeRange: null
+    };
+  }
+  const groups = {};
+  for (const file of files) {
+    const type = file.primitiveType;
+    if (!groups[type]) groups[type] = [];
+    groups[type].push(file);
+  }
+  const lines = ["<session-recap>"];
+  lines.push(`<summary>Found ${files.length} recent items across ${Object.keys(groups).length} categories</summary>`);
+  for (const [primitiveType, groupFiles] of Object.entries(groups)) {
+    lines.push(`<${primitiveType}-items count="${groupFiles.length}">`);
+    for (const file of groupFiles.slice(0, 5)) {
+      const title = file.frontmatter.title || file.frontmatter.summary || file.relativePath;
+      const status = file.frontmatter.status || "";
+      const modified = file.modifiedAt.toISOString().slice(0, 16).replace("T", " ");
+      lines.push(`  <item path="${file.relativePath}" modified="${modified}"${status ? ` status="${status}"` : ""}>`);
+      lines.push(`    <title>${escapeXml(String(title))}</title>`);
+      if (includeContent && file.content) {
+        const snippet = file.content.slice(0, 200).replace(/\n/g, " ").trim();
+        if (snippet) {
+          lines.push(`    <snippet>${escapeXml(snippet)}</snippet>`);
+        }
+      }
+      lines.push("  </item>");
+    }
+    if (groupFiles.length > 5) {
+      lines.push(`  <more count="${groupFiles.length - 5}" />`);
+    }
+    lines.push(`</${primitiveType}-items>`);
+  }
+  lines.push("</session-recap>");
+  const sortedByTime = [...files].sort((a, b) => a.modifiedAt.getTime() - b.modifiedAt.getTime());
+  const timeRange = {
+    oldest: sortedByTime[0].modifiedAt,
+    newest: sortedByTime[sortedByTime.length - 1].modifiedAt
+  };
+  const primitiveGroups = {};
+  for (const [type, groupFiles] of Object.entries(groups)) {
+    primitiveGroups[type] = groupFiles.length;
+  }
+  return {
+    xml: lines.join("\n"),
+    fileCount: files.length,
+    primitiveGroups,
+    timeRange
+  };
+}
+function buildPreferenceContext(vaultPath, options = {}) {
+  const maxAge = options.maxAge ?? 30 * 24 * 60 * 60 * 1e3;
+  const limit = options.limit ?? 50;
+  const files = scanVaultFiles(vaultPath, { maxAge, limit: limit * 2 });
+  const preferenceFiles = files.filter((file) => {
+    if (file.frontmatter.type === "preference") return true;
+    if (file.primitiveType === "memory_event" && file.frontmatter.type === "preference") return true;
+    const content = (file.content || "").toLowerCase();
+    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/.test(content)) {
+      return true;
+    }
+    return false;
+  }).slice(0, limit);
+  if (preferenceFiles.length === 0) {
+    return {
+      xml: "",
+      preferenceCount: 0,
+      categories: []
+    };
+  }
+  const categories = /* @__PURE__ */ new Set();
+  for (const file of preferenceFiles) {
+    if (file.frontmatter.category) {
+      categories.add(String(file.frontmatter.category));
+    }
+  }
+  const lines = ["<user-preferences>"];
+  for (const file of preferenceFiles) {
+    const summary = file.frontmatter.summary || file.frontmatter.title || extractPreferenceSummary(file.content);
+    if (!summary) continue;
+    const category = file.frontmatter.category || "general";
+    const sentiment = file.frontmatter.sentiment || inferSentiment(file.content);
+    lines.push(`  <preference category="${escapeXml(String(category))}" sentiment="${sentiment}">`);
+    lines.push(`    ${escapeXml(String(summary))}`);
+    lines.push("  </preference>");
+  }
+  lines.push("</user-preferences>");
+  return {
+    xml: lines.join("\n"),
+    preferenceCount: preferenceFiles.length,
+    categories: Array.from(categories)
+  };
+}
+function extractPreferenceSummary(content) {
+  if (!content) return "";
+  const sentences = content.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 10);
+  for (const sentence of sentences) {
+    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/i.test(sentence)) {
+      return sentence.slice(0, 150);
+    }
+  }
+  return sentences[0]?.slice(0, 150) || "";
+}
+function inferSentiment(content) {
+  if (!content) return "neutral";
+  const lower = content.toLowerCase();
+  if (/\b(love|like|prefer|enjoy|want|need|always)\b/.test(lower)) return "positive";
+  if (/\b(hate|dislike|don't like|never|avoid)\b/.test(lower)) return "negative";
+  return "neutral";
+}
+function formatMemoriesForContext(results, collection) {
+  if (results.length === 0) return "";
+  const lines = results.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}`;
+  });
+  return `<relevant-memories>
+These are recalled from long-term vault memory. Treat as historical context.
+${lines.join("\n")}
+</relevant-memories>`;
+}
+function formatSearchResults(results, collection) {
+  if (results.length === 0) return "No relevant memories found.";
+  return results.map((r, i) => {
+    const file = (r.file || "").replace(`qmd://${collection}/`, "");
+    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "(no content)";
+    const score = ((r.score ?? 0) * 100).toFixed(0);
+    return `${i + 1}. [${file}] ${snippet} (${score}%)`;
+  }).join("\n");
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildFullContext(vaultPath, options = {}) {
+  const parts = [];
+  if (options.includeRecap !== false) {
+    const recap = buildSessionRecap(vaultPath, {
+      maxAge: options.recapMaxAge ?? 24 * 60 * 60 * 1e3,
+      limit: 15,
+      includeContent: true
+    });
+    if (recap.xml) {
+      parts.push(recap.xml);
+    }
+  }
+  if (options.includePreferences !== false) {
+    const prefs = buildPreferenceContext(vaultPath, {
+      maxAge: options.preferenceMaxAge ?? 30 * 24 * 60 * 60 * 1e3,
+      limit: 20
+    });
+    if (prefs.xml) {
+      parts.push(prefs.xml);
+    }
+  }
+  return parts.join("\n\n");
+}
+
+export {
+  scanVaultFiles,
+  buildSessionRecap,
+  buildPreferenceContext,
+  formatMemoriesForContext,
+  formatSearchResults,
+  buildFullContext
+};

package/dist/{chunk-HIHOUSXS.js → chunk-E7MFQB6D.js}

@@ -1,14 +1,36 @@
+import {
+  resolveClaudeOAuthToken
+} from "./chunk-PAH27GSN.js";
+
 // src/lib/llm-provider.ts
 var DEFAULT_MODELS = {
-  anthropic: "claude-3-5-haiku-latest",
+  anthropic: "claude-haiku-4-5",
   openai: "gpt-4o-mini",
   gemini: "gemini-2.0-flash"
 };
-function resolveLlmProvider() {
+async function resolveAnthropicAuth(fetchImpl) {
+  const oauthEnvToken = process.env.ANTHROPIC_OAUTH_TOKEN?.trim();
+  if (oauthEnvToken) {
+    return { token: oauthEnvToken, isOAuth: true };
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY?.trim();
+  if (apiKey) {
+    return { token: apiKey, isOAuth: false };
+  }
+  if (process.env.CLAWVAULT_CLAUDE_AUTH) {
+    const oauthToken = await resolveClaudeOAuthToken({ fetchImpl });
+    if (oauthToken) {
+      return { token: oauthToken, isOAuth: true };
+    }
+  }
+  return null;
+}
+async function resolveLlmProvider(fetchImpl) {
   if (process.env.CLAWVAULT_NO_LLM) {
     return null;
   }
-  if (process.env.ANTHROPIC_API_KEY) {
+  const anthropicAuth = await resolveAnthropicAuth(fetchImpl);
+  if (anthropicAuth) {
     return "anthropic";
   }
   if (process.env.OPENAI_API_KEY) {
@@ -20,7 +42,7 @@ function resolveLlmProvider() {
   return null;
 }
 async function requestLlmCompletion(options) {
-  const provider = options.provider ?? resolveLlmProvider();
+  const provider = options.provider ?? await resolveLlmProvider(options.fetchImpl);
   if (!provider) {
     return "";
   }
@@ -33,24 +55,43 @@ async function requestLlmCompletion(options) {
   return callOpenAI(options, provider);
 }
 async function callAnthropic(options, provider) {
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const auth = await resolveAnthropicAuth(fetchImpl);
+  if (!auth) {
     return "";
   }
-  const fetchImpl = options.fetchImpl ?? fetch;
+  const headers = auth.isOAuth ? {
+    "content-type": "application/json",
+    "authorization": `Bearer ${auth.token}`,
+    "anthropic-version": "2023-06-01",
+    "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
+    "x-app": "cli",
+    "user-agent": "claude-cli/1.0.0 (external, cli)"
+  } : {
+    "content-type": "application/json",
+    "x-api-key": auth.token,
+    "anthropic-version": "2023-06-01"
+  };
+  const systemMessages = [];
+  if (auth.isOAuth) {
+    systemMessages.push({ type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." });
+  }
+  if (options.systemPrompt?.trim()) {
+    systemMessages.push({ type: "text", text: options.systemPrompt.trim() });
+  }
+  const body = {
+    model: options.model ?? DEFAULT_MODELS[provider],
+    temperature: options.temperature ?? 0.1,
+    max_tokens: options.maxTokens ?? 1200,
+    messages: [{ role: "user", content: options.prompt }]
+  };
+  if (systemMessages.length > 0) {
+    body.system = systemMessages;
+  }
   const response = await fetchImpl("https://api.anthropic.com/v1/messages", {
     method: "POST",
-    headers: {
-      "content-type": "application/json",
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01"
-    },
-    body: JSON.stringify({
-      model: options.model ?? DEFAULT_MODELS[provider],
-      temperature: options.temperature ?? 0.1,
-      max_tokens: options.maxTokens ?? 1200,
-      messages: [{ role: "user", content: options.prompt }]
-    })
+    headers,
+    body: JSON.stringify(body)
   });
   if (!response.ok) {
     throw new Error(`Anthropic request failed (${response.status})`);

package/dist/{chunk-ME37YNW3.js → chunk-F2JEUD4J.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-P5EPF6MB.js";
 import {
   observeActiveSessions
-} from "./chunk-IEVLHNLU.js";
+} from "./chunk-LNJA2UGL.js";
 import {
   Observer
-} from "./chunk-Q2J5YTUF.js";
+} from "./chunk-3NSBOUT3.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";
@@ -291,7 +291,8 @@ async function observeCommand(options) {
       threshold: options.threshold,
       reflectThreshold: options.reflectThreshold,
       model: options.model,
-      extractTasks: options.extractTasks
+      extractTasks: options.extractTasks,
+      maxSessions: options.maxSessions
     });
     const failedSessionCount = result.failedSessionCount ?? 0;
     if (options.cron) {
@@ -379,7 +380,7 @@ async function observeCommand(options) {
   await watchSessions(observer, watchPath);
 }
 function registerObserveCommand(program) {
-  program.command("observe").description("Observe session files and build observational memory").option("--watch <path>", "Watch session file or directory").option("--active", "Observe active OpenClaw sessions incrementally").option("--cron", "Run one-shot active observation for cron hooks").option("--agent <id>", "OpenClaw agent ID (default: OPENCLAW_AGENT_ID or clawdious)").option("--min-new <bytes>", "Override minimum new-content threshold in bytes").option("--sessions-dir <path>", "Override OpenClaw sessions directory").option("--dry-run", "Show active observation candidates without compressing").option("--threshold <n>", "Compression token threshold", "30000").option("--reflect-threshold <n>", "Reflection token threshold", "40000").option("--model <model>", "LLM model override").option("--extract-tasks", "Extract task-like observations into backlog", true).option("--no-extract-tasks", "Disable task extraction from observations").option("--compress <file>", "One-shot compression for a conversation file").option("--daemon", "Run in detached background mode").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+  program.command("observe").description("Observe session files and build observational memory").option("--watch <path>", "Watch session file or directory").option("--active", "Observe active OpenClaw sessions incrementally").option("--cron", "Run one-shot active observation for cron hooks").option("--agent <id>", "OpenClaw agent ID (default: OPENCLAW_AGENT_ID or clawdious)").option("--min-new <bytes>", "Override minimum new-content threshold in bytes").option("--sessions-dir <path>", "Override OpenClaw sessions directory").option("--dry-run", "Show active observation candidates without compressing").option("--max-sessions <n>", "Limit number of sessions to observe (recommended: 10)").option("--threshold <n>", "Compression token threshold", "30000").option("--reflect-threshold <n>", "Reflection token threshold", "40000").option("--model <model>", "LLM model override").option("--extract-tasks", "Extract task-like observations into backlog", true).option("--no-extract-tasks", "Disable task extraction from observations").option("--compress <file>", "One-shot compression for a conversation file").option("--daemon", "Run in detached background mode").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
     await observeCommand({
       watch: rawOptions.watch,
       active: rawOptions.active,
@@ -388,6 +389,7 @@ function registerObserveCommand(program) {
       minNew: rawOptions.minNew ? parsePositiveInteger(rawOptions.minNew, "min-new") : void 0,
       sessionsDir: rawOptions.sessionsDir,
       dryRun: rawOptions.dryRun,
+      maxSessions: rawOptions.maxSessions ? parsePositiveInteger(rawOptions.maxSessions, "max-sessions") : void 0,
       threshold: parsePositiveInteger(rawOptions.threshold, "threshold"),
       reflectThreshold: parsePositiveInteger(rawOptions.reflectThreshold, "reflect-threshold"),
       model: rawOptions.model,

package/dist/chunk-GAJV4IGR.js

@@ -0,0 +1,82 @@
+import {
+  registerTailscaleCommands
+} from "./chunk-THRJVD4L.js";
+import {
+  registerObserveCommand
+} from "./chunk-F2JEUD4J.js";
+import {
+  registerReflectCommand
+} from "./chunk-SJSFRIYS.js";
+import {
+  registerEmbedCommand
+} from "./chunk-7R7O6STJ.js";
+import {
+  registerInjectCommand
+} from "./chunk-U55BGUAU.js";
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
+import {
+  registerContextCommand
+} from "./chunk-ZVVFWOLW.js";
+import {
+  reweave
+} from "./chunk-K234IDRJ.js";
+
+// src/commands/reweave.ts
+async function reweaveCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const result = reweave({
+    vaultPath,
+    since: options.since,
+    dryRun: options.dryRun,
+    similarityThreshold: options.threshold
+  });
+  console.log(`Reweave: scanned ${result.filesScanned} files, checked ${result.observationsChecked} observations`);
+  if (result.supersessions.length === 0) {
+    console.log("No knowledge updates detected.");
+    return;
+  }
+  console.log(`
+Found ${result.supersessions.length} supersession(s):`);
+  for (const s of result.supersessions) {
+    console.log(`
+  OLD [${s.oldObservation.date}] ${s.oldObservation.content.slice(0, 80)}`);
+    console.log(`  NEW [${s.newObservation.date}] ${s.newObservation.content.slice(0, 80)}`);
+    console.log(`  Reason: ${s.reason}`);
+  }
+  if (result.dryRun) {
+    console.log("\n(dry run \u2014 no files modified)");
+  } else {
+    console.log(`
+${result.supersessions.length} observation(s) marked as superseded.`);
+  }
+}
+function registerReweaveCommand(program) {
+  program.command("reweave").description("Backward memory consolidation \u2014 detect and mark superseded observations").option("--since <date>", "Only check observations since this date (YYYY-MM-DD)").option("--dry-run", "Show what would be superseded without writing").option("--threshold <n>", "Entity similarity threshold (0-1, default 0.3)", "0.3").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await reweaveCommand({
+      vaultPath: rawOptions.vault,
+      since: rawOptions.since,
+      dryRun: rawOptions.dryRun,
+      threshold: parseFloat(rawOptions.threshold)
+    });
+  });
+}
+
+// src/cli/index.ts
+function registerCliCommands(program) {
+  registerContextCommand(program);
+  registerInjectCommand(program);
+  registerObserveCommand(program);
+  registerReflectCommand(program);
+  registerEmbedCommand(program);
+  registerReweaveCommand(program);
+  registerTailscaleCommands(program);
+  return program;
+}
+
+export {
+  reweaveCommand,
+  registerReweaveCommand,
+  registerCliCommands
+};