clawvault 3.1.0 → 3.2.0

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-VSL7KY3M.js

@@ -0,0 +1,189 @@
+import {
+  create,
+  read,
+  update
+} from "./chunk-QVEERJSP.js";
+import {
+  append,
+  currentOwner
+} from "./chunk-4BQTQMJP.js";
+import {
+  THREAD_STATUS_TRANSITIONS
+} from "./chunk-WMGIIABP.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-U55BGUAU.js → chunk-W4SPAEE7.js}

@@ -1,14 +1,14 @@
+import {
+  listConfig
+} from "./chunk-URXDAUVH.js";
 import {
   requestLlmCompletion,
   resolveLlmProvider
-} from "./chunk-E7MFQB6D.js";
-import {
-  listConfig
-} from "./chunk-ITPEXLHA.js";
+} from "./chunk-NCKFNBHJ.js";
 import {
   getMemoryGraph,
   loadMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 
 // src/commands/inject.ts
 import * as path2 from "path";
@@ -563,7 +563,7 @@ async function runPromptInjection(vaultPathInput, message, options = {}) {
   const deterministicMs = Date.now() - startDeterministic;
   let llmProvider = null;
   if (useLlm) {
-    llmProvider = await resolveLlmProvider();
+    llmProvider = resolveLlmProvider();
     if (llmProvider) {
       try {
         matches = await addLlmIntentMatches({

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
+};