clawvault 3.2.0 → 3.3.0

package/dist/{chunk-NCKFNBHJ.js → chunk-DVOUSOR3.js}

@@ -10,6 +10,8 @@ var DEFAULT_MODELS = {
   openclaw: "gpt-4o-mini"
 };
 var XAI_BASE_URL = "https://api.x.ai/v1";
+var VAULT_CONFIG_FILE = ".clawvault.json";
+var LLM_MODEL_TIERS = ["background", "default", "complex"];
 function resolveOpenClawHome() {
   return process.env.OPENCLAW_HOME?.trim() || path.join(os.homedir(), ".openclaw");
 }
@@ -88,6 +90,78 @@ function resolveLlmProvider() {
   }
   return null;
 }
+function resolveNearestVaultPath(startPath) {
+  let current = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(current, VAULT_CONFIG_FILE))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveVaultPathForModelConfig() {
+  const configuredVaultPath = process.env.CLAWVAULT_PATH?.trim();
+  if (configuredVaultPath) {
+    return path.resolve(configuredVaultPath);
+  }
+  return resolveNearestVaultPath(process.cwd());
+}
+function readTieredModelConfig() {
+  const vaultPath = resolveVaultPathForModelConfig();
+  if (!vaultPath) {
+    return null;
+  }
+  const configPath = path.join(vaultPath, VAULT_CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const models = parsed.models;
+    if (!models || typeof models !== "object" || Array.isArray(models)) {
+      return null;
+    }
+    const normalized = {};
+    for (const tier of LLM_MODEL_TIERS) {
+      const candidate = models[tier];
+      if (typeof candidate === "string" && candidate.trim()) {
+        normalized[tier] = candidate.trim();
+      }
+    }
+    return Object.keys(normalized).length > 0 ? normalized : null;
+  } catch {
+    return null;
+  }
+}
+function resolveTieredModel(tier) {
+  const tieredConfig = readTieredModelConfig();
+  if (!tieredConfig) {
+    return null;
+  }
+  return tieredConfig[tier] ?? tieredConfig.default ?? null;
+}
+function resolveRequestModel(options, fallbackModel) {
+  if (typeof options.model === "string" && options.model.trim()) {
+    return options.model.trim();
+  }
+  const tier = options.tier ?? "default";
+  const configuredTierModel = resolveTieredModel(tier);
+  if (configuredTierModel) {
+    return configuredTierModel;
+  }
+  const envModel = process.env.CLAWVAULT_MODEL?.trim();
+  if (envModel) {
+    return envModel;
+  }
+  return fallbackModel;
+}
 async function requestLlmCompletion(options) {
   const provider = options.provider ?? resolveLlmProvider();
   if (!provider) {
@@ -121,7 +195,7 @@ async function callAnthropic(options, provider) {
       "anthropic-version": "2023-06-01"
     },
     body: JSON.stringify({
-      model: options.model ?? DEFAULT_MODELS[provider],
+      model: resolveRequestModel(options, DEFAULT_MODELS[provider]),
       temperature: options.temperature ?? 0.1,
       max_tokens: options.maxTokens ?? 1200,
       messages: [{ role: "user", content: options.prompt }]
@@ -151,7 +225,7 @@ async function callOpenAI(options, provider) {
       authorization: `Bearer ${apiKey}`
     },
     body: JSON.stringify({
-      model: options.model ?? DEFAULT_MODELS[provider],
+      model: resolveRequestModel(options, DEFAULT_MODELS[provider]),
       temperature: options.temperature ?? 0.1,
       max_tokens: options.maxTokens ?? 1200,
       messages
@@ -181,7 +255,7 @@ async function callXAI(options, provider) {
       authorization: `Bearer ${apiKey}`
     },
     body: JSON.stringify({
-      model: options.model ?? DEFAULT_MODELS[provider],
+      model: resolveRequestModel(options, DEFAULT_MODELS[provider]),
       temperature: options.temperature ?? 0.1,
       max_tokens: options.maxTokens ?? 1200,
       messages
@@ -199,7 +273,7 @@ async function callGemini(options, provider) {
     return "";
   }
   const fetchImpl = options.fetchImpl ?? fetch;
-  const model = options.model ?? DEFAULT_MODELS[provider];
+  const model = resolveRequestModel(options, DEFAULT_MODELS[provider]);
   const response = await fetchImpl(
     `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
     {
@@ -238,7 +312,7 @@ async function callOpenClaw(options) {
       authorization: `Bearer ${config.apiKey}`
     },
     body: JSON.stringify({
-      model: options.model ?? config.defaultModel,
+      model: resolveRequestModel(options, config.defaultModel),
       temperature: options.temperature ?? 0.1,
       max_tokens: options.maxTokens ?? 1200,
       messages

package/dist/{chunk-CLJTREDS.js → chunk-ECGJYWNA.js}

@@ -1,20 +1,19 @@
+import {
+  DEFAULT_CATEGORIES,
+  TYPE_TO_CATEGORY
+} from "./chunk-2CDEETQN.js";
 import {
   loadVaultQmdConfig,
   recoverQmdEmbeddingIfNeeded
-} from "./chunk-6FH3IULF.js";
+} from "./chunk-FZ5I2NF7.js";
 import {
-  QmdUnavailableError,
   SearchEngine,
   extractTags,
   extractWikiLinks,
   hasQmd,
   qmdEmbed,
   qmdUpdate
-} from "./chunk-EK6S23ZB.js";
-import {
-  DEFAULT_CATEGORIES,
-  TYPE_TO_CATEGORY
-} from "./chunk-2CDEETQN.js";
+} from "./chunk-PTWPPVC7.js";
 import {
   buildOrUpdateMemoryGraphIndex
 } from "./chunk-33DOSHTA.js";
@@ -35,17 +34,16 @@ var ClawVault = class {
     if (typeof vaultPath !== "string" || !vaultPath.trim()) {
       throw new Error(`Invalid vault path: expected a non-empty string, received ${typeof vaultPath}`);
     }
-    if (!hasQmd()) {
-      const error = new QmdUnavailableError("NOT_INSTALLED");
-      console.error(error.toUserMessage());
-      throw error;
-    }
     this.config = {
       path: path.resolve(vaultPath),
       name: path.basename(vaultPath),
       categories: DEFAULT_CATEGORIES,
       qmdCollection: void 0,
-      qmdRoot: void 0
+      qmdRoot: void 0,
+      search: {
+        backend: "in-process",
+        qmdFallback: true
+      }
     };
     this.search = new SearchEngine();
     this.applyQmdConfig();
@@ -54,11 +52,6 @@ var ClawVault = class {
    * Initialize a new vault
    */
   async init(options = {}, initFlags) {
-    if (!hasQmd()) {
-      const error = new QmdUnavailableError("NOT_INSTALLED");
-      console.error(error.toUserMessage());
-      throw error;
-    }
     const vaultPath = this.config.path;
     const flags = initFlags || {};
     this.config = { ...this.config, ...options };
@@ -99,7 +92,8 @@ var ClawVault = class {
       categories: this.config.categories,
       documentCount: 0,
       qmdCollection: this.getQmdCollection(),
-      qmdRoot: this.getQmdRoot()
+      qmdRoot: this.getQmdRoot(),
+      search: this.config.search ?? { backend: "in-process", qmdFallback: true }
     };
     fs.writeFileSync(configPath, JSON.stringify(meta, null, 2));
     if (!flags.skipBases && this.config.categories.includes("tasks")) {
@@ -210,11 +204,6 @@ var ClawVault = class {
    * Load an existing vault
    */
   async load() {
-    if (!hasQmd()) {
-      const error = new QmdUnavailableError("NOT_INSTALLED");
-      console.error(error.toUserMessage());
-      throw error;
-    }
     const vaultPath = this.config.path;
     const configPath = path.join(vaultPath, CONFIG_FILE);
     if (!fs.existsSync(configPath)) {
@@ -225,27 +214,30 @@ var ClawVault = class {
     this.config.categories = Array.isArray(meta.categories) ? meta.categories : this.config.categories;
     this.config.qmdCollection = typeof meta.qmdCollection === "string" ? meta.qmdCollection : void 0;
     this.config.qmdRoot = typeof meta.qmdRoot === "string" ? meta.qmdRoot : void 0;
+    this.config.search = meta.search && typeof meta.search === "object" && !Array.isArray(meta.search) ? meta.search : this.config.search;
     if (!meta.qmdCollection || !meta.qmdRoot) {
       meta.qmdCollection = meta.qmdCollection || meta.name;
       meta.qmdRoot = meta.qmdRoot || this.config.path;
       fs.writeFileSync(configPath, JSON.stringify(meta, null, 2));
     }
     this.applyQmdConfig(meta);
-    try {
-      const recovery = recoverQmdEmbeddingIfNeeded({
-        vaultPath: this.config.path,
-        collection: this.getQmdCollection(),
-        rootPath: this.getQmdRoot(),
-        mode: "marker-only",
-        onLog: (message) => console.warn(`[clawvault] ${message}`)
-      });
-      if (recovery.recovered) {
-        console.warn(`[clawvault] qmd embedding recovery finished for "${this.getQmdCollection()}".`);
+    if (hasQmd()) {
+      try {
+        const recovery = recoverQmdEmbeddingIfNeeded({
+          vaultPath: this.config.path,
+          collection: this.getQmdCollection(),
+          rootPath: this.getQmdRoot(),
+          mode: "marker-only",
+          onLog: (message) => console.warn(`[clawvault] ${message}`)
+        });
+        if (recovery.recovered) {
+          console.warn(`[clawvault] qmd embedding recovery finished for "${this.getQmdCollection()}".`);
+        }
+      } catch (err) {
+        console.warn(
+          `[clawvault] qmd embedding recovery failed: ${err?.message || "unknown error"}`
+        );
       }
-    } catch (err) {
-      console.warn(
-        `[clawvault] qmd embedding recovery failed: ${err?.message || "unknown error"}`
-      );
     }
     await this.reindex();
     this.initialized = true;
@@ -342,6 +334,28 @@ var ClawVault = class {
     }
     return doc;
   }
+  /**
+   * Patch an existing document and incrementally refresh index state for that file only.
+   */
+  async patch(options) {
+    const relativePath = this.resolveDocumentRelativePath(options.idOrPath);
+    const absolutePath = path.join(this.config.path, relativePath);
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Document not found: ${options.idOrPath}`);
+    }
+    const raw = fs.readFileSync(absolutePath, "utf-8");
+    const { frontmatter, body } = this.splitFrontmatter(raw);
+    const updatedBody = this.applyPatchToBody(body, options);
+    if (updatedBody === body) {
+      throw new Error("Patch made no changes to the document body.");
+    }
+    fs.writeFileSync(absolutePath, `${frontmatter}${updatedBody}`);
+    const doc = await this.reindexDocument(relativePath);
+    if (!doc) {
+      throw new Error(`Failed to reload patched document: ${options.idOrPath}`);
+    }
+    return doc;
+  }
   /**
    * Quick store to inbox
    */
@@ -354,19 +368,19 @@ var ClawVault = class {
     });
   }
   /**
-   * Search the vault (BM25 via qmd)
+   * Search the vault (in-process hybrid by default, qmd fallback optional)
    */
   async find(query, options = {}) {
     return this.search.search(query, options);
   }
   /**
-   * Semantic/vector search (via qmd vsearch)
+   * Semantic/vector search (hosted embeddings, qmd fallback optional)
    */
   async vsearch(query, options = {}) {
     return this.search.vsearch(query, options);
   }
   /**
-   * Combined search with query expansion (via qmd query)
+   * Combined search entrypoint (currently aliases hybrid search)
    */
   async query(query, options = {}) {
     return this.search.query(query, options);
@@ -743,6 +757,142 @@ var ClawVault = class {
     }
     return fallback || (/* @__PURE__ */ new Date()).toISOString();
   }
+  async reindexDocument(relativePath) {
+    const doc = await this.loadDocument(relativePath);
+    if (!doc) return null;
+    this.search.addDocument(doc);
+    await this.saveIndex();
+    await this.syncMemoryGraphIndex();
+    return doc;
+  }
+  resolveDocumentRelativePath(idOrPath) {
+    if (typeof idOrPath !== "string" || !idOrPath.trim()) {
+      throw new Error("idOrPath is required");
+    }
+    const trimmed = idOrPath.trim().replace(/^[\\/]+/, "");
+    const withExtension = trimmed.endsWith(".md") ? trimmed : `${trimmed}.md`;
+    const normalized = path.normalize(withExtension);
+    const resolved = path.resolve(this.config.path, normalized);
+    const relative2 = path.relative(this.config.path, resolved);
+    if (relative2.startsWith("..") || path.isAbsolute(relative2)) {
+      throw new Error(`Document path escapes vault: ${idOrPath}`);
+    }
+    return relative2;
+  }
+  splitFrontmatter(raw) {
+    const match = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+    if (!match) {
+      return { frontmatter: "", body: raw };
+    }
+    const frontmatter = match[0];
+    return {
+      frontmatter,
+      body: raw.slice(frontmatter.length)
+    };
+  }
+  applyPatchToBody(body, options) {
+    if (options.mode === "append") {
+      if (typeof options.append !== "string" || options.append.length === 0) {
+        throw new Error("Append mode requires non-empty append text.");
+      }
+      if (options.section) {
+        return this.patchMarkdownSection(
+          body,
+          options.section,
+          (sectionBody) => this.appendText(sectionBody, options.append)
+        );
+      }
+      return this.appendText(body, options.append);
+    }
+    if (options.mode === "replace") {
+      if (typeof options.replace !== "string" || options.replace.length === 0) {
+        throw new Error("Replace mode requires non-empty --replace text.");
+      }
+      if (typeof options.with !== "string") {
+        throw new Error("Replace mode requires --with text.");
+      }
+      if (options.section) {
+        return this.patchMarkdownSection(
+          body,
+          options.section,
+          (sectionBody) => this.replaceAllOccurrences(sectionBody, options.replace, options.with, `section "${options.section}"`)
+        );
+      }
+      return this.replaceAllOccurrences(body, options.replace, options.with, "document");
+    }
+    if (options.mode === "content") {
+      if (typeof options.content !== "string") {
+        throw new Error("Content mode requires --content text.");
+      }
+      if (options.section) {
+        return this.patchMarkdownSection(body, options.section, () => options.content);
+      }
+      return options.content;
+    }
+    throw new Error(`Unsupported patch mode: ${String(options.mode)}`);
+  }
+  appendText(existing, addition) {
+    if (addition.length === 0) return existing;
+    if (existing.length === 0) return addition;
+    return existing.endsWith("\n") ? `${existing}${addition}` : `${existing}
+${addition}`;
+  }
+  replaceAllOccurrences(input, searchText, replacement, scopeLabel) {
+    if (!input.includes(searchText)) {
+      throw new Error(`No matches found for "${searchText}" in ${scopeLabel}.`);
+    }
+    return input.split(searchText).join(replacement);
+  }
+  patchMarkdownSection(markdown, sectionName, applySectionPatch) {
+    const lines = markdown.split(/\r?\n/);
+    const normalize2 = (value) => value.replace(/^#+\s*/, "").trim().toLowerCase();
+    const targetName = normalize2(sectionName);
+    let sectionStart = -1;
+    let sectionLevel = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+      const line = lines[i];
+      const match = line.match(/^(#{1,6})\s+(.*?)\s*$/);
+      if (!match) continue;
+      const [, marks, heading] = match;
+      if (normalize2(heading) === targetName) {
+        sectionStart = i;
+        sectionLevel = marks.length;
+        break;
+      }
+    }
+    if (sectionStart < 0) {
+      throw new Error(`Section not found: ${sectionName}`);
+    }
+    let sectionEnd = lines.length;
+    for (let i = sectionStart + 1; i < lines.length; i += 1) {
+      const match = lines[i].match(/^(#{1,6})\s+(.*?)\s*$/);
+      if (!match) continue;
+      if (match[1].length <= sectionLevel) {
+        sectionEnd = i;
+        break;
+      }
+    }
+    const existingSectionBody = lines.slice(sectionStart + 1, sectionEnd).join("\n");
+    const updatedSectionBody = applySectionPatch(existingSectionBody);
+    const rebuiltSection = updatedSectionBody.length > 0 ? `${lines[sectionStart]}
+${updatedSectionBody}` : lines[sectionStart];
+    const head = lines.slice(0, sectionStart).join("\n");
+    const tail = lines.slice(sectionEnd).join("\n");
+    if (head.length > 0 && tail.length > 0) {
+      return `${head}
+${rebuiltSection}
+${tail}`;
+    }
+    if (head.length > 0) {
+      return `${head}
+${rebuiltSection}`;
+    }
+    if (tail.length > 0) {
+      return `${rebuiltSection}
+${tail}`;
+    }
+    return rebuiltSection;
+  }
   /**
    * Extract the date portion (YYYY-MM-DD) from an ISO date string or Date object.
    * Provides safe handling for various date formats.
@@ -765,9 +915,11 @@ var ClawVault = class {
     }
     this.config.qmdCollection = collection;
     this.config.qmdRoot = root;
+    this.config.search = meta?.search && typeof meta.search === "object" && !Array.isArray(meta.search) ? meta.search : this.config.search ?? { backend: "in-process", qmdFallback: true };
     this.search.setVaultPath(this.config.path);
     this.search.setCollection(collection);
     this.search.setCollectionRoot(root);
+    this.search.setSearchConfig(this.config.search);
   }
   slugify(text) {
     return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();

package/dist/{chunk-BUEW6IIK.js → chunk-EL6UBSX5.js}

@@ -1,10 +1,10 @@
-import {
-  hasQmd,
-  withQmdIndexArgs
-} from "./chunk-EK6S23ZB.js";
 import {
   DEFAULT_CATEGORIES
 } from "./chunk-2CDEETQN.js";
+import {
+  hasQmd,
+  withQmdIndexArgs
+} from "./chunk-PTWPPVC7.js";
 
 // src/commands/setup.ts
 import * as fs from "fs";
@@ -347,7 +347,7 @@ async function setupCommand(options = {}) {
       console.log("\u2298 qmd collection already exists.");
     }
   } else {
-    console.log("\u2298 qmd not found \u2014 skipping semantic search setup.");
+    console.log("\u2298 qmd not found \u2014 skipping optional qmd fallback setup.");
   }
   console.log("\nTip: add this to your shell config:");
   console.log(`  export CLAWVAULT_PATH="${target.vaultPath}"`);

package/dist/{chunk-6FH3IULF.js → chunk-FZ5I2NF7.js}

@@ -1,6 +1,6 @@
 import {
   withQmdIndexArgs
-} from "./chunk-EK6S23ZB.js";
+} from "./chunk-PTWPPVC7.js";
 
 // src/lib/qmd-collections.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-ZN54U2OZ.js → chunk-GFCHWMGD.js}

@@ -1,9 +1,9 @@
-import {
-  ClawVault
-} from "./chunk-CLJTREDS.js";
 import {
   FactStore
 } from "./chunk-BSJ6RIT7.js";
+import {
+  ClawVault
+} from "./chunk-ECGJYWNA.js";
 import {
   parseObservationMarkdown
 } from "./chunk-FHFUXL6G.js";

package/dist/{chunk-GNJL4YGR.js → chunk-GJO3CFUN.js}

@@ -44,9 +44,31 @@ function resolveAgentVaultPath(agentVaults, agentId) {
   if (!agentPath || typeof agentPath !== "string") return null;
   return validateVaultPath(agentPath);
 }
+function toNonEmptyPathString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function coercePathCandidate(value) {
+  const direct = toNonEmptyPathString(value);
+  if (direct) return direct;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const record = value;
+  const candidates = [record.explicitPath, record.vaultPath, record.path, record.vault];
+  for (const candidate of candidates) {
+    const normalized = toNonEmptyPathString(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return null;
+}
 function resolveVaultPath(options = {}) {
-  if (options.explicitPath) {
-    return path.resolve(options.explicitPath);
+  const explicitPath = coercePathCandidate(options.explicitPath);
+  if (explicitPath) {
+    return path.resolve(explicitPath);
   }
   if (options.agentId && options.pluginConfig?.agentVaults) {
     const agentVaultPath = resolveAgentVaultPath(
@@ -57,12 +79,14 @@ function resolveVaultPath(options = {}) {
       return agentVaultPath;
     }
   }
-  if (options.pluginConfig?.vaultPath) {
-    const validated = validateVaultPath(options.pluginConfig.vaultPath);
+  const configuredVaultPath = coercePathCandidate(options.pluginConfig?.vaultPath);
+  if (configuredVaultPath) {
+    const validated = validateVaultPath(configuredVaultPath);
     if (validated) return validated;
   }
-  if (process.env.CLAWVAULT_PATH) {
-    return path.resolve(process.env.CLAWVAULT_PATH);
+  const envVaultPath = toNonEmptyPathString(process.env.CLAWVAULT_PATH);
+  if (envVaultPath) {
+    return path.resolve(envVaultPath);
   }
   const discovered = findNearestVaultPath(options.cwd ?? process.cwd());
   if (discovered) {