clawvault 2.6.1 → 3.0.0-beta.2

package/dist/{chunk-QVMXF7FY.js → chunk-3D6BCTP6.js}

@@ -24,6 +24,19 @@ function findPackageRoot() {
   }
   return path.dirname(fileURLToPath(import.meta.url));
 }
+function resolveOpenClawHooksDir() {
+  const candidates = [
+    path.join(process.env.HOME || "", ".openclaw", "hooks", "clawvault"),
+    path.join(process.env.OPENCLAW_HOME || "", "hooks", "clawvault"),
+    path.join(process.env.OPENCLAW_STATE_DIR || "", "hooks", "clawvault")
+  ].filter((p) => p && !p.startsWith(path.sep + "hooks"));
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 function resolveProjectFile(relativePath, baseDir) {
   if (baseDir) {
     return path.resolve(baseDir, relativePath);
@@ -32,6 +45,20 @@ function resolveProjectFile(relativePath, baseDir) {
   if (fs.existsSync(fromCwd)) {
     return fromCwd;
   }
+  if (relativePath.startsWith("hooks/clawvault/")) {
+    const hooksDir = resolveOpenClawHooksDir();
+    if (hooksDir) {
+      const hookRelative = relativePath.replace("hooks/clawvault/", "");
+      const fromHooks = path.resolve(hooksDir, hookRelative);
+      if (fs.existsSync(fromHooks)) {
+        return fromHooks;
+      }
+      const fromNestedHooks = path.resolve(hooksDir, "hooks", "clawvault", hookRelative);
+      if (fs.existsSync(fromNestedHooks)) {
+        return fromNestedHooks;
+      }
+    }
+  }
   return path.resolve(findPackageRoot(), relativePath);
 }
 function checkOpenClawCli() {
@@ -63,7 +90,18 @@ function checkOpenClawCli() {
   return { label: "openclaw CLI available", status: "ok" };
 }
 function checkPackageHookRegistration(options) {
-  const packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  let packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  if (packageRaw && !options.baseDir) {
+    try {
+      const parsed = JSON.parse(packageRaw);
+      if (!parsed.openclaw?.hooks) {
+        const fallbackPath = path.resolve(findPackageRoot(), "package.json");
+        const fallbackRaw = readOptionalFile(fallbackPath);
+        if (fallbackRaw) packageRaw = fallbackRaw;
+      }
+    } catch {
+    }
+  }
   if (!packageRaw) {
     return {
       label: "package hook registration",

package/dist/{chunk-R2MIW5G7.js → chunk-3DHXQHYG.js}

@@ -8,7 +8,7 @@ import {
   queryTransitions,
   readTask,
   updateTask
-} from "./chunk-QWQ3TIKS.js";
+} from "./chunk-N2AXRYLC.js";
 
 // src/commands/task.ts
 function taskAdd(vaultPath, title, options = {}) {

package/dist/{chunk-Q2J5YTUF.js → chunk-3NSBOUT3.js}

@@ -1,6 +1,21 @@
 import {
   listProjects
-} from "./chunk-AZYOKJYC.js";
+} from "./chunk-62YTUT6J.js";
+import {
+  listConfig,
+  listRouteRules,
+  matchRouteRule
+} from "./chunk-ITPEXLHA.js";
+import {
+  resolveClaudeOAuthToken
+} from "./chunk-PAH27GSN.js";
+import {
+  createBacklogItem,
+  listBacklogItems,
+  listTasks,
+  updateBacklogItem,
+  updateTask
+} from "./chunk-N2AXRYLC.js";
 import {
   DATE_HEADING_RE,
   inferObservationType,
@@ -9,12 +24,7 @@ import {
   parseObservationMarkdown,
   renderObservationMarkdown,
   renderScoredObservationLine
-} from "./chunk-FHFUXL6G.js";
-import {
-  listConfig,
-  listRouteRules,
-  matchRouteRule
-} from "./chunk-ITPEXLHA.js";
+} from "./chunk-QK3UCXWL.js";
 import {
   ensureLedgerStructure,
   ensureParentDir,
@@ -23,19 +33,12 @@ import {
   getRawTranscriptPath,
   toDateKey
 } from "./chunk-Z2XBWN7A.js";
-import {
-  createBacklogItem,
-  listBacklogItems,
-  listTasks,
-  updateBacklogItem,
-  updateTask
-} from "./chunk-QWQ3TIKS.js";
 
 // src/observer/compressor.ts
 var OPENAI_BASE_URL = "https://api.openai.com/v1";
 var OLLAMA_BASE_URL = "http://localhost:11434/v1";
 var DEFAULT_PROVIDER_MODELS = {
-  anthropic: "claude-3-5-haiku-latest",
+  anthropic: "claude-haiku-4-5",
   openai: "gpt-4o-mini",
   gemini: "gemini-2.0-flash",
   "openai-compatible": "gpt-4o-mini",
@@ -69,7 +72,7 @@ var Compressor = class {
       return existingObservations.trim();
     }
     const prompt = this.buildPrompt(cleanedMessages, existingObservations);
-    const backend = this.resolveProvider();
+    const backend = await this.resolveProvider();
     if (backend) {
       try {
         const llmOutput = backend.provider === "anthropic" ? await this.callAnthropic(prompt, backend) : backend.provider === "gemini" ? await this.callGemini(prompt, backend) : backend.provider === "openai" ? await this.callOpenAI(prompt, backend) : await this.callOpenAICompatible(prompt, backend);
@@ -83,16 +86,16 @@ var Compressor = class {
     const fallback = this.fallbackCompression(cleanedMessages);
     return this.mergeObservations(existingObservations, fallback);
   }
-  resolveProvider() {
+  async resolveProvider() {
     if (process.env.CLAWVAULT_NO_LLM) return null;
     if (this.provider) {
       const configured = this.resolveConfiguredProvider(this.provider);
       if (configured) {
         return configured;
       }
-      return this.resolveProviderFromEnv(false);
+      return await this.resolveProviderFromEnv(false);
     }
-    return this.resolveProviderFromEnv(true);
+    return await this.resolveProviderFromEnv(true);
   }
   resolveConfiguredProvider(provider) {
     const model = this.resolveModel(provider);
@@ -138,14 +141,21 @@ var Compressor = class {
       baseUrl: this.resolveBaseUrl(provider)
     };
   }
-  resolveProviderFromEnv(allowConfiguredModel) {
+  async resolveProviderFromEnv(allowConfiguredModel) {
+    const anthropicModel = allowConfiguredModel ? this.resolveModel("anthropic") : DEFAULT_PROVIDER_MODELS.anthropic;
+    const oauthEnvToken = this.readEnvValue("ANTHROPIC_OAUTH_TOKEN");
+    if (oauthEnvToken) {
+      return { provider: "anthropic", model: anthropicModel, apiKey: oauthEnvToken, isOAuth: true };
+    }
     const anthropicApiKey = this.readEnvValue("ANTHROPIC_API_KEY");
     if (anthropicApiKey) {
-      return {
-        provider: "anthropic",
-        model: allowConfiguredModel ? this.resolveModel("anthropic") : DEFAULT_PROVIDER_MODELS.anthropic,
-        apiKey: anthropicApiKey
-      };
+      return { provider: "anthropic", model: anthropicModel, apiKey: anthropicApiKey };
+    }
+    if (this.readEnvValue("CLAWVAULT_CLAUDE_AUTH")) {
+      const oauthToken = await resolveClaudeOAuthToken();
+      if (oauthToken) {
+        return { provider: "anthropic", model: anthropicModel, apiKey: oauthToken, isOAuth: true };
+      }
     }
     const openAiApiKey = this.readEnvValue("OPENAI_API_KEY");
     if (openAiApiKey) {
@@ -215,6 +225,17 @@ var Compressor = class {
       "- Confidence c reflects extraction certainty, not importance.",
       "- Preserve source tags when present (e.g., [main], [telegram-dm], [discord], [telegram-group]).",
       "",
+      "PREFERENCE & PERSONAL CONTEXT EXTRACTION (critical for personalization):",
+      "- Emit [preference] for ANY personal detail that reveals tastes, habits, equipment, or context:",
+      '  * Explicit: "I prefer X", "I like Y", "I always use Z"',
+      '  * Ownership: "my Sony A7R IV", "I have a...", "I use...", "I own..."',
+      '  * Habits/routines: "I usually...", "every morning I...", "I tend to..."',
+      "  * Interests: topics the user is enthusiastic about, hobbies mentioned in passing",
+      "  * Constraints: dietary restrictions, allergies, phobias, limitations",
+      `  * Goals: "I'm trying to...", "I want to learn..."`,
+      "- These are HIGH VALUE observations (i >= 0.60) \u2014 they enable personalized responses.",
+      "- When in doubt between [preference] and [task], choose [preference] if it describes a lasting trait.",
+      "",
       "TASK EXTRACTION (required):",
       `- Emit [todo] for explicit TODO phrasing: "TODO:", "we need to", "don't forget", "remember to", "make sure to".`,
       `- Emit [task] for commitments/action intent: "I'll", "I will", "let me", "going to", "plan to", "should".`,
@@ -293,19 +314,35 @@ var Compressor = class {
     if (!backend.apiKey) {
       return "";
     }
+    const isOAuth = backend.isOAuth || backend.apiKey.includes("sk-ant-oat");
+    const headers = isOAuth ? {
+      "content-type": "application/json",
+      "authorization": `Bearer ${backend.apiKey}`,
+      "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": backend.apiKey,
+      "anthropic-version": "2023-06-01"
+    };
+    const body = isOAuth ? {
+      model: backend.model,
+      temperature: 0.1,
+      max_tokens: 1400,
+      system: [{ type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." }],
+      messages: [{ role: "user", content: prompt }]
+    } : {
+      model: backend.model,
+      temperature: 0.1,
+      max_tokens: 1400,
+      messages: [{ role: "user", content: prompt }]
+    };
     const response = await this.fetchImpl("https://api.anthropic.com/v1/messages", {
       method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-api-key": backend.apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: backend.model,
-        temperature: 0.1,
-        max_tokens: 1400,
-        messages: [{ role: "user", content: prompt }]
-      })
+      headers,
+      body: JSON.stringify(body)
     });
     if (!response.ok) {
       throw new Error(`Anthropic request failed (${response.status})`);

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/{chunk-AZYOKJYC.js → chunk-62YTUT6J.js}

@@ -1,11 +1,11 @@
 import {
   listTasks,
   slugify
-} from "./chunk-QWQ3TIKS.js";
+} from "./chunk-N2AXRYLC.js";
 import {
   loadSchemaTemplateDefinition,
   renderDocumentFromTemplate
-} from "./chunk-MFAWT5O5.js";
+} from "./chunk-LYHGEHXG.js";
 
 // src/lib/project-utils.ts
 import * as fs from "fs";

package/dist/chunk-6U6MK36V.js

@@ -0,0 +1,205 @@
+import {
+  classifyText
+} from "./chunk-GQSLDZTS.js";
+
+// 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;
+}
+
+export {
+  isObservable,
+  extractObservations,
+  processMessageForObservations,
+  detectCategory,
+  extractPreferences,
+  extractSearchTerms
+};

package/dist/{chunk-4QYGFWRM.js → chunk-7R7O6STJ.js}

@@ -1,11 +1,11 @@
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
 import {
   QmdUnavailableError,
   hasQmd,
   qmdEmbed
-} from "./chunk-MAKNAHAW.js";
-import {
-  resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-K234IDRJ.js";
 
 // src/lib/vault-qmd-config.ts
 import * as fs from "fs";

package/dist/{chunk-VXEOHTSL.js → chunk-C7OK5WKP.js}

@@ -1,11 +1,11 @@
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
 import {
   DATE_HEADING_RE,
   parseObservationLine,
   renderScoredObservationLine
-} from "./chunk-FHFUXL6G.js";
-import {
-  resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-QK3UCXWL.js";
 import {
   listObservationFiles
 } from "./chunk-Z2XBWN7A.js";