clawvault 2.6.3 → 2.6.4

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

@@ -3,13 +3,13 @@ import {
 } from "./chunk-P5EPF6MB.js";
 import {
   observeActiveSessions
-} from "./chunk-IEVLHNLU.js";
+} from "./chunk-627Q3QWK.js";
 import {
   Observer
-} from "./chunk-Q2J5YTUF.js";
+} from "./chunk-OQGYFZ4A.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   getObservationPath
 } from "./chunk-Z2XBWN7A.js";

package/dist/chunk-RHISK3SZ.js

@@ -0,0 +1,189 @@
+import {
+  create,
+  read,
+  update
+} from "./chunk-L4HSSQ6T.js";
+import {
+  THREAD_STATUS_TRANSITIONS
+} from "./chunk-WMGIIABP.js";
+import {
+  append,
+  currentOwner
+} from "./chunk-4BQTQMJP.js";
+import {
+  __export
+} from "./chunk-2ZDO52B4.js";
+
+// src/workgraph/thread.ts
+var thread_exports = {};
+__export(thread_exports, {
+  block: () => block,
+  cancel: () => cancel,
+  claim: () => claim,
+  createThread: () => createThread,
+  decompose: () => decompose,
+  done: () => done,
+  release: () => release,
+  unblock: () => unblock
+});
+function createThread(vaultPath, title, goal, actor, opts = {}) {
+  return create(vaultPath, "thread", {
+    title,
+    goal,
+    status: "open",
+    priority: opts.priority ?? "medium",
+    deps: opts.deps ?? [],
+    parent: opts.parent,
+    context_refs: opts.context_refs ?? [],
+    tags: opts.tags ?? []
+  }, `## Goal
+
+${goal}
+`, actor);
+}
+function claim(vaultPath, threadPath, actor) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  const status = thread.fields.status;
+  if (status !== "open") {
+    throw new Error(`Cannot claim thread in "${status}" state. Only "open" threads can be claimed.`);
+  }
+  const owner = currentOwner(vaultPath, threadPath);
+  if (owner) {
+    throw new Error(`Thread already claimed by "${owner}". Wait for release or use a different thread.`);
+  }
+  append(vaultPath, actor, "claim", threadPath, "thread");
+  return update(vaultPath, threadPath, {
+    status: "active",
+    owner: actor
+  }, void 0, actor);
+}
+function release(vaultPath, threadPath, actor, reason) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertOwner(vaultPath, threadPath, actor);
+  append(
+    vaultPath,
+    actor,
+    "release",
+    threadPath,
+    "thread",
+    reason ? { reason } : void 0
+  );
+  return update(vaultPath, threadPath, {
+    status: "open",
+    owner: null
+  }, void 0, actor);
+}
+function block(vaultPath, threadPath, actor, blockedBy, reason) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "blocked");
+  append(vaultPath, actor, "block", threadPath, "thread", {
+    blocked_by: blockedBy,
+    ...reason ? { reason } : {}
+  });
+  const currentDeps = thread.fields.deps ?? [];
+  const updatedDeps = currentDeps.includes(blockedBy) ? currentDeps : [...currentDeps, blockedBy];
+  return update(vaultPath, threadPath, {
+    status: "blocked",
+    deps: updatedDeps
+  }, void 0, actor);
+}
+function unblock(vaultPath, threadPath, actor) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "active");
+  append(vaultPath, actor, "unblock", threadPath, "thread");
+  return update(vaultPath, threadPath, {
+    status: "active"
+  }, void 0, actor);
+}
+function done(vaultPath, threadPath, actor, output) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "done");
+  assertOwner(vaultPath, threadPath, actor);
+  append(
+    vaultPath,
+    actor,
+    "done",
+    threadPath,
+    "thread",
+    output ? { output } : void 0
+  );
+  const newBody = output ? `${thread.body}
+
+## Output
+
+${output}
+` : thread.body;
+  return update(vaultPath, threadPath, {
+    status: "done"
+  }, newBody, actor);
+}
+function cancel(vaultPath, threadPath, actor, reason) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "cancelled");
+  append(
+    vaultPath,
+    actor,
+    "cancel",
+    threadPath,
+    "thread",
+    reason ? { reason } : void 0
+  );
+  return update(vaultPath, threadPath, {
+    status: "cancelled",
+    owner: null
+  }, void 0, actor);
+}
+function decompose(vaultPath, parentPath, subthreads, actor) {
+  const parent = read(vaultPath, parentPath);
+  if (!parent) throw new Error(`Thread not found: ${parentPath}`);
+  const created = [];
+  for (const sub of subthreads) {
+    const inst = createThread(vaultPath, sub.title, sub.goal, actor, {
+      parent: parentPath,
+      deps: sub.deps
+    });
+    created.push(inst);
+  }
+  const childRefs = created.map((c) => `[[${c.path}]]`);
+  const decomposeNote = `
+
+## Sub-threads
+
+${childRefs.map((r) => `- ${r}`).join("\n")}
+`;
+  update(vaultPath, parentPath, {}, parent.body + decomposeNote, actor);
+  append(vaultPath, actor, "decompose", parentPath, "thread", {
+    children: created.map((c) => c.path)
+  });
+  return created;
+}
+function assertTransition(from, to) {
+  const allowed = THREAD_STATUS_TRANSITIONS[from];
+  if (!allowed?.includes(to)) {
+    throw new Error(`Invalid transition: "${from}" \u2192 "${to}". Allowed: ${allowed?.join(", ") ?? "none"}`);
+  }
+}
+function assertOwner(vaultPath, threadPath, actor) {
+  const owner = currentOwner(vaultPath, threadPath);
+  if (owner && owner !== actor) {
+    throw new Error(`Thread is owned by "${owner}", not "${actor}". Only the owner can perform this action.`);
+  }
+}
+
+export {
+  createThread,
+  claim,
+  release,
+  block,
+  unblock,
+  done,
+  cancel,
+  decompose,
+  thread_exports
+};

package/dist/{chunk-3BTHWPMB.js → chunk-S5OJEGFG.js}

@@ -1,9 +1,9 @@
 import {
   runReflection
-} from "./chunk-T76H47ZS.js";
+} from "./chunk-MNPUYCHQ.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/reflect.ts
 function parsePositiveInteger(raw, label) {

package/dist/{chunk-MGDEINGP.js → chunk-SS4B7P7V.js}

@@ -1,6 +1,6 @@
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/sync-bd.ts
 import * as fs from "fs";

package/dist/chunk-U4O6C46S.js

@@ -0,0 +1,154 @@
+// src/lib/hybrid-search.ts
+import * as fs from "fs";
+import * as path from "path";
+var embeddingPipeline = null;
+var pipelineLoading = null;
+async function getEmbeddingPipeline() {
+  if (embeddingPipeline) return embeddingPipeline;
+  if (pipelineLoading) return pipelineLoading;
+  pipelineLoading = (async () => {
+    const { pipeline } = await import("./transformers.node-A2ZRORSQ.js");
+    embeddingPipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+      dtype: "fp32"
+    });
+    return embeddingPipeline;
+  })();
+  return pipelineLoading;
+}
+async function embed(text) {
+  const pipe = await getEmbeddingPipeline();
+  const result = await pipe(text, { pooling: "mean", normalize: true });
+  return new Float32Array(result.data);
+}
+async function embedBatch(texts) {
+  const pipe = await getEmbeddingPipeline();
+  const results = [];
+  const batchSize = 32;
+  for (let i = 0; i < texts.length; i += batchSize) {
+    const batch = texts.slice(i, i + batchSize);
+    for (const text of batch) {
+      const result = await pipe(text, { pooling: "mean", normalize: true });
+      results.push(new Float32Array(result.data));
+    }
+  }
+  return results;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+var EmbeddingCache = class {
+  cachePath;
+  cache = /* @__PURE__ */ new Map();
+  dirty = false;
+  constructor(vaultPath) {
+    this.cachePath = path.join(vaultPath, ".clawvault", "embeddings.bin");
+  }
+  /**
+   * Load cache from disk
+   */
+  load() {
+    try {
+      if (!fs.existsSync(this.cachePath)) return;
+      const data = JSON.parse(fs.readFileSync(this.cachePath + ".json", "utf-8"));
+      for (const [key, arr] of Object.entries(data)) {
+        this.cache.set(key, new Float32Array(arr));
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save cache to disk
+   */
+  save() {
+    if (!this.dirty) return;
+    const dir = path.dirname(this.cachePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const data = {};
+    for (const [key, arr] of this.cache.entries()) {
+      data[key] = Array.from(arr);
+    }
+    fs.writeFileSync(this.cachePath + ".json", JSON.stringify(data));
+    this.dirty = false;
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, embedding) {
+    this.cache.set(key, embedding);
+    this.dirty = true;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+function reciprocalRankFusion(list1, list2, k = 60) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let rank = 0; rank < list1.length; rank++) {
+    const { id } = list1[rank];
+    scores.set(id, (scores.get(id) || 0) + 1 / (k + rank + 1));
+  }
+  for (let rank = 0; rank < list2.length; rank++) {
+    const { id } = list2[rank];
+    scores.set(id, (scores.get(id) || 0) + 1 / (k + rank + 1));
+  }
+  return Array.from(scores.entries()).map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score);
+}
+async function semanticSearch(query, cache, topK = 20) {
+  const queryEmb = await embed(query);
+  const results = [];
+  for (const [id, docEmb] of cache.entries()) {
+    results.push({ id, score: cosineSimilarity(queryEmb, docEmb) });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topK);
+}
+async function hybridSearch(query, bm25Results, cache, options = {}) {
+  const { topK = 20, rrfK = 60 } = options;
+  const bm25Ranked = bm25Results.map((r) => ({ id: r.document.path || r.document.id, score: r.score }));
+  const semanticRanked = await semanticSearch(query, cache, topK);
+  const fused = reciprocalRankFusion(bm25Ranked, semanticRanked, rrfK);
+  const bm25Map = new Map(bm25Results.map((r) => [r.document.path || r.document.id, r]));
+  return fused.slice(0, topK).map(({ id, score }) => {
+    const existing = bm25Map.get(id);
+    if (existing) {
+      return { ...existing, score };
+    }
+    const minimalDoc = {
+      id: id.replace(/\.md$/, ""),
+      path: id.endsWith(".md") ? id : id + ".md",
+      title: (id.split("/").pop() || id).replace(/\.md$/, ""),
+      content: "",
+      category: id.split("/")[0] || "root",
+      frontmatter: {},
+      links: [],
+      tags: [],
+      modified: /* @__PURE__ */ new Date()
+    };
+    return {
+      document: minimalDoc,
+      score,
+      snippet: "",
+      matchedTerms: []
+    };
+  });
+}
+
+export {
+  embed,
+  embedBatch,
+  cosineSimilarity,
+  EmbeddingCache,
+  reciprocalRankFusion,
+  semanticSearch,
+  hybridSearch
+};

package/dist/{chunk-ITPEXLHA.js → chunk-URXDAUVH.js}

@@ -6,16 +6,21 @@ import {
 import * as fs from "fs";
 import * as path from "path";
 var CONFIG_FILE = ".clawvault.json";
-var OBSERVE_PROVIDERS = ["anthropic", "openai", "gemini"];
+var OBSERVE_PROVIDERS = ["anthropic", "openai", "gemini", "xai", "openclaw"];
 var OBSERVER_COMPRESSION_PROVIDERS = [
   "anthropic",
   "openai",
   "gemini",
+  "xai",
   "openai-compatible",
-  "ollama"
+  "ollama",
+  "openclaw",
+  "minimax",
+  "zai"
 ];
 var THEMES = ["neural", "minimal", "none"];
 var CONTEXT_PROFILES = ["default", "planning", "incident", "handoff", "auto"];
+var FACT_EXTRACTION_MODES = ["off", "rule", "llm", "hybrid"];
 var SUPPORTED_CONFIG_KEYS = [
   "name",
   "categories",
@@ -26,6 +31,7 @@ var SUPPORTED_CONFIG_KEYS = [
   "observer.compression.model",
   "observer.compression.baseUrl",
   "observer.compression.apiKey",
+  "observer.factExtractionMode",
   "context.maxResults",
   "context.defaultProfile",
   "graph.maxHops",
@@ -36,6 +42,7 @@ var SUPPORTED_CONFIG_KEYS = [
 var DEFAULT_THEME = "none";
 var DEFAULT_OBSERVE_MODEL = "gemini-2.0-flash";
 var DEFAULT_OBSERVE_PROVIDER = "gemini";
+var DEFAULT_FACT_EXTRACTION_MODE = "llm";
 var DEFAULT_CONTEXT_MAX_RESULTS = 5;
 var DEFAULT_CONTEXT_PROFILE = "default";
 var DEFAULT_GRAPH_MAX_HOPS = 2;
@@ -113,6 +120,9 @@ function isTheme(value) {
 function isContextProfile(value) {
   return typeof value === "string" && CONTEXT_PROFILES.includes(value);
 }
+function isFactExtractionMode(value) {
+  return typeof value === "string" && FACT_EXTRACTION_MODES.includes(value);
+}
 function normalizeRouteTarget(target) {
   const trimmed = target.trim().replace(/^\/+/, "").replace(/\/+$/, "");
   if (!trimmed) {
@@ -196,7 +206,8 @@ function withDefaults(vaultPath, config) {
       provider: DEFAULT_OBSERVE_PROVIDER
     },
     observer: {
-      compression: {}
+      compression: {},
+      factExtractionMode: DEFAULT_FACT_EXTRACTION_MODE
     },
     context: {
       maxResults: DEFAULT_CONTEXT_MAX_RESULTS,
@@ -247,7 +258,8 @@ function withDefaults(vaultPath, config) {
     },
     observer: {
       ...observerRecord,
-      compression: normalizedCompression
+      compression: normalizedCompression,
+      factExtractionMode: isFactExtractionMode(observerRecord.factExtractionMode) ? observerRecord.factExtractionMode : defaults.observer.factExtractionMode
     },
     context: {
       ...contextRecord,
@@ -335,6 +347,12 @@ function coerceManagedValue(key, value) {
     }
     return value.trim();
   }
+  if (key === "observer.factExtractionMode") {
+    if (!isFactExtractionMode(value)) {
+      throw new Error(`Config key "observer.factExtractionMode" must be one of: ${FACT_EXTRACTION_MODES.join(", ")}`);
+    }
+    return value;
+  }
   if (key === "context.maxResults") {
     const parsed = asPositiveInteger(value);
     if (parsed === null) {
@@ -424,7 +442,8 @@ function resetConfig(vaultPath) {
   const observerRecord = document.observer && typeof document.observer === "object" && !Array.isArray(document.observer) ? document.observer : {};
   document.observer = {
     ...observerRecord,
-    compression: {}
+    compression: {},
+    factExtractionMode: DEFAULT_FACT_EXTRACTION_MODE
   };
   document.context = {
     maxResults: DEFAULT_CONTEXT_MAX_RESULTS,

package/dist/chunk-WIOLLGAD.js

@@ -0,0 +1,190 @@
+// src/lib/qmd-collections.ts
+import { execFileSync } from "child_process";
+var COLLECTION_HEADER_RE = /^(\S+)\s+\(qmd:\/\/([^)]+)\)\s*$/;
+var DETAIL_LINE_RE = /^\s+([A-Za-z][A-Za-z0-9 _-]*):\s*(.+)\s*$/;
+function normalizeDetailKey(value) {
+  return value.trim().toLowerCase().replace(/[ -]+/g, "_");
+}
+function parseCount(raw) {
+  if (!raw) return void 0;
+  const match = raw.match(/-?\d[\d,]*/);
+  if (!match) return void 0;
+  const parsed = Number.parseInt(match[0].replace(/,/g, ""), 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function pickDetail(details, keys) {
+  for (const key of keys) {
+    const value = details[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function pickCount(details, keys) {
+  for (const key of keys) {
+    const parsed = parseCount(details[key]);
+    if (parsed !== void 0) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function parseQmdCollectionList(raw) {
+  const collections = [];
+  let current = null;
+  for (const line of raw.split(/\r?\n/)) {
+    const headerMatch = line.match(COLLECTION_HEADER_RE);
+    if (headerMatch) {
+      current = {
+        name: headerMatch[1],
+        uri: headerMatch[2],
+        details: {}
+      };
+      collections.push(current);
+      continue;
+    }
+    if (!current) continue;
+    const detailMatch = line.match(DETAIL_LINE_RE);
+    if (!detailMatch) continue;
+    const key = normalizeDetailKey(detailMatch[1]);
+    current.details[key] = detailMatch[2].trim();
+  }
+  for (const collection of collections) {
+    const root = pickDetail(collection.details, ["root", "path", "directory"]);
+    if (root) {
+      collection.root = root;
+    }
+    collection.files = pickCount(collection.details, ["files", "documents", "docs"]);
+    collection.vectors = pickCount(collection.details, ["vectors", "embeddings", "vector_embeddings"]);
+    collection.pendingEmbeddings = pickCount(collection.details, [
+      "pending",
+      "pending_vectors",
+      "pending_embeddings",
+      "unembedded",
+      "without_embeddings"
+    ]);
+    if (collection.pendingEmbeddings === void 0 && collection.files !== void 0 && collection.vectors !== void 0) {
+      collection.pendingEmbeddings = Math.max(collection.files - collection.vectors, 0);
+    }
+  }
+  return collections;
+}
+function listQmdCollections() {
+  const output = execFileSync("qmd", ["collection", "list"], {
+    encoding: "utf-8"
+  });
+  return parseQmdCollectionList(output);
+}
+function removeQmdCollection(name) {
+  try {
+    execFileSync("qmd", ["collection", "remove", name], { stdio: "ignore" });
+    return;
+  } catch {
+    execFileSync("qmd", ["collection", "rm", name], { stdio: "ignore" });
+  }
+}
+function collectionExists(name) {
+  try {
+    const collections = listQmdCollections();
+    return collections.some((c) => c.name === name);
+  } catch {
+    return false;
+  }
+}
+function findCollectionByRoot(rootPath) {
+  try {
+    const collections = listQmdCollections();
+    const normalizedRoot = rootPath.replace(/\/$/, "");
+    return collections.find((c) => {
+      if (!c.root) return false;
+      const normalizedCollectionRoot = c.root.replace(/\/$/, "");
+      return normalizedCollectionRoot === normalizedRoot;
+    });
+  } catch {
+    return void 0;
+  }
+}
+function getFirstCollection() {
+  try {
+    const collections = listQmdCollections();
+    return collections[0];
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib/vault-qmd-config.ts
+import * as fs from "fs";
+import * as path from "path";
+var CONFIG_FILE = ".clawvault.json";
+function readTrimmedString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function autoDetectCollection(vaultPath, fallbackName) {
+  const byRoot = findCollectionByRoot(vaultPath);
+  if (byRoot) {
+    return { collection: byRoot.name, autoDetected: true };
+  }
+  if (collectionExists(fallbackName)) {
+    return { collection: fallbackName, autoDetected: false };
+  }
+  const first = getFirstCollection();
+  if (first) {
+    return { collection: first.name, autoDetected: true };
+  }
+  return { collection: fallbackName, autoDetected: false };
+}
+function loadVaultQmdConfig(vaultPath) {
+  const resolvedVaultPath = path.resolve(vaultPath);
+  const fallbackName = path.basename(resolvedVaultPath);
+  const fallbackRoot = resolvedVaultPath;
+  const configPath = path.join(resolvedVaultPath, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    const { collection, autoDetected } = autoDetectCollection(resolvedVaultPath, fallbackName);
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: collection,
+      qmdRoot: fallbackRoot,
+      autoDetected
+    };
+  }
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    const configuredName = readTrimmedString(raw.name) ?? fallbackName;
+    const configuredCollection = readTrimmedString(raw.qmdCollection);
+    const rawRoot = readTrimmedString(raw.qmdRoot) ?? fallbackRoot;
+    const qmdRoot = path.isAbsolute(rawRoot) ? path.resolve(rawRoot) : path.resolve(resolvedVaultPath, rawRoot);
+    if (configuredCollection && collectionExists(configuredCollection)) {
+      return {
+        vaultPath: resolvedVaultPath,
+        qmdCollection: configuredCollection,
+        qmdRoot
+      };
+    }
+    const { collection, autoDetected } = autoDetectCollection(qmdRoot, configuredCollection ?? configuredName);
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: collection,
+      qmdRoot,
+      autoDetected
+    };
+  } catch {
+    const { collection, autoDetected } = autoDetectCollection(resolvedVaultPath, fallbackName);
+    return {
+      vaultPath: resolvedVaultPath,
+      qmdCollection: collection,
+      qmdRoot: fallbackRoot,
+      autoDetected
+    };
+  }
+}
+
+export {
+  parseQmdCollectionList,
+  listQmdCollections,
+  removeQmdCollection,
+  loadVaultQmdConfig
+};

package/dist/chunk-WMGIIABP.js

@@ -0,0 +1,15 @@
+// src/workgraph/types.ts
+var THREAD_STATUS_TRANSITIONS = {
+  open: ["active", "cancelled"],
+  active: ["blocked", "done", "cancelled", "open"],
+  // open = release
+  blocked: ["active", "cancelled"],
+  done: [],
+  // terminal
+  cancelled: ["open"]
+  // can be reopened
+};
+
+export {
+  THREAD_STATUS_TRANSITIONS
+};