clawvault 3.2.1 → 3.3.0

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

@@ -10,10 +10,43 @@ 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");
+}
+function resolveOpenClawGatewayProvider() {
+  try {
+    const configPath = path.join(resolveOpenClawHome(), "openclaw.json");
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const enabled = raw.gateway?.http?.endpoints?.chatCompletions?.enabled === true;
+    const apiKey = raw.gateway?.auth?.token?.trim();
+    const port = raw.gateway?.port;
+    if (!enabled || !apiKey || typeof port !== "number" || !Number.isFinite(port) || port <= 0) {
+      return null;
+    }
+    const defaultModel = raw.agents?.defaults?.model?.trim() || DEFAULT_MODELS.openclaw;
+    const host = raw.gateway?.bind === "loopback" ? "127.0.0.1" : "127.0.0.1";
+    return {
+      baseUrl: `http://${host}:${port}/v1`,
+      apiKey,
+      api: "openai-completions",
+      defaultModel
+    };
+  } catch {
+    return null;
+  }
+}
 function resolveOpenClawProvider() {
+  const gatewayProvider = resolveOpenClawGatewayProvider();
+  if (gatewayProvider) {
+    return gatewayProvider;
+  }
   try {
-    const openclawHome = process.env.OPENCLAW_HOME?.trim() || path.join(os.homedir(), ".openclaw");
-    const modelsPath = path.join(openclawHome, "agents", "main", "agent", "models.json");
+    const modelsPath = path.join(resolveOpenClawHome(), "agents", "main", "agent", "models.json");
     if (!fs.existsSync(modelsPath)) {
       return null;
     }
@@ -57,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) {
@@ -90,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 }]
@@ -120,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
@@ -150,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
@@ -168,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`,
     {
@@ -207,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-YDWHS4LJ.js → chunk-ECGJYWNA.js}

@@ -1,22 +1,22 @@
 import {
-  loadVaultQmdConfig
-} from "./chunk-WIOLLGAD.js";
+  DEFAULT_CATEGORIES,
+  TYPE_TO_CATEGORY
+} from "./chunk-2CDEETQN.js";
+import {
+  loadVaultQmdConfig,
+  recoverQmdEmbeddingIfNeeded
+} from "./chunk-FZ5I2NF7.js";
 import {
-  QmdUnavailableError,
   SearchEngine,
   extractTags,
   extractWikiLinks,
   hasQmd,
   qmdEmbed,
   qmdUpdate
-} from "./chunk-5PJ4STIC.js";
-import {
-  DEFAULT_CATEGORIES,
-  TYPE_TO_CATEGORY
-} from "./chunk-2CDEETQN.js";
+} from "./chunk-PTWPPVC7.js";
 import {
   buildOrUpdateMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 
 // src/lib/vault.ts
 import * as fs from "fs";
@@ -31,17 +31,19 @@ var ClawVault = class {
   search;
   initialized = false;
   constructor(vaultPath) {
-    if (!hasQmd()) {
-      const error = new QmdUnavailableError("NOT_INSTALLED");
-      console.error(error.toUserMessage());
-      throw error;
+    if (typeof vaultPath !== "string" || !vaultPath.trim()) {
+      throw new Error(`Invalid vault path: expected a non-empty string, received ${typeof vaultPath}`);
     }
     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();
@@ -50,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 };
@@ -95,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")) {
@@ -206,27 +204,41 @@ 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)) {
       throw new Error(`Not a ClawVault: ${vaultPath} (missing ${CONFIG_FILE})`);
     }
     const meta = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    this.config.name = meta.name;
-    this.config.categories = meta.categories;
-    this.config.qmdCollection = meta.qmdCollection;
-    this.config.qmdRoot = meta.qmdRoot;
+    this.config.name = typeof meta.name === "string" ? meta.name : this.config.name;
+    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);
+    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"}`
+        );
+      }
+    }
     await this.reindex();
     this.initialized = true;
   }
@@ -322,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
    */
@@ -334,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);
@@ -723,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.
@@ -739,15 +909,17 @@ var ClawVault = class {
     const explicitRoot = meta?.qmdRoot || this.config.qmdRoot || this.config.path;
     const qmdConfig = loadVaultQmdConfig(this.config.path);
     const collection = explicitCollection || qmdConfig.qmdCollection || this.config.name;
-    const root = explicitRoot || qmdConfig.qmdRoot;
+    const root = (typeof explicitRoot === "string" ? explicitRoot : void 0) || qmdConfig.qmdRoot || this.config.path;
     if (qmdConfig.autoDetected) {
       console.warn(`[clawvault] Auto-detected qmd collection: ${collection}`);
     }
     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-QMHPQYUV.js → chunk-EL6UBSX5.js}

@@ -1,10 +1,10 @@
-import {
-  hasQmd,
-  withQmdIndexArgs
-} from "./chunk-5PJ4STIC.js";
 import {
   DEFAULT_CATEGORIES
 } from "./chunk-2CDEETQN.js";
+import {
+  hasQmd,
+  withQmdIndexArgs
+} from "./chunk-PTWPPVC7.js";
 
 // src/commands/setup.ts
 import * as fs from "fs";
@@ -339,14 +339,15 @@ async function setupCommand(options = {}) {
     const { collection, root } = getQmdConfig(target.vaultPath);
     try {
       execFileSync("qmd", withQmdIndexArgs(["collection", "add", root, "--name", collection, "--mask", "**/*.md"], options.qmdIndexName), {
-        stdio: "ignore"
+        stdio: "ignore",
+        shell: process.platform === "win32"
       });
       console.log(`\u2713 qmd collection ready: ${collection}`);
     } catch {
       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}"`);