clawvault 3.1.0 → 3.2.1

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-3WRJEKN4.js → chunk-WJVWINEM.js}

@@ -1,12 +1,15 @@
 import {
   ClawVault
-} from "./chunk-LI4O6NVK.js";
+} from "./chunk-YDWHS4LJ.js";
 import {
-  getMemoryGraph
-} from "./chunk-ZZA73MFY.js";
+  FactStore
+} from "./chunk-BSJ6RIT7.js";
 import {
   parseObservationMarkdown
-} from "./chunk-QK3UCXWL.js";
+} from "./chunk-FHFUXL6G.js";
+import {
+  getMemoryGraph
+} from "./chunk-ZZA73MFY.js";
 import {
   listObservationFiles
 } from "./chunk-Z2XBWN7A.js";
@@ -179,19 +182,19 @@ function formatContextMarkdown(task, entries) {
 }
 var PROFILE_ORDERING = {
   default: {
-    order: ["structural", "daily", "search", "graph", "potential", "contextual"],
+    order: ["structural", "fact", "daily", "search", "graph", "potential", "contextual"],
     caps: {}
   },
   planning: {
-    order: ["search", "graph", "structural", "potential", "daily", "contextual"],
+    order: ["fact", "search", "graph", "structural", "potential", "daily", "contextual"],
     caps: { observation: 12, graph: 12 }
   },
   incident: {
-    order: ["structural", "search", "potential", "daily", "graph", "contextual"],
+    order: ["structural", "fact", "search", "potential", "daily", "graph", "contextual"],
     caps: { observation: 20, graph: 8 }
   },
   handoff: {
-    order: ["daily", "structural", "potential", "search", "graph", "contextual"],
+    order: ["daily", "structural", "fact", "potential", "search", "graph", "contextual"],
     caps: { "daily-note": 2, observation: 15 }
   }
 };
@@ -369,6 +372,64 @@ function buildObservationContextItems(vaultPath, queryKeywords) {
   }
   return items;
 }
+var PREFERENCE_PATTERNS = /\b(prefer|like|favorite|favourit|enjoy|habit|allergy|allergic|diet|dislike|want|love|hate|routine)\b/i;
+var TEMPORAL_PATTERNS = /\b(yesterday|today|last\s+(?:week|month|year|monday|tuesday|wednesday|thursday|friday|saturday|sunday)|in\s+\d{4}|on\s+\w+\s+\d{1,2}|\d{4}-\d{2}-\d{2}|january|february|march|april|may|june|july|august|september|october|november|december)\b/i;
+function isPreferenceQuery(query) {
+  return PREFERENCE_PATTERNS.test(query);
+}
+function isTemporalQuery(query) {
+  return TEMPORAL_PATTERNS.test(query);
+}
+function buildFactContextItems(vaultPath, query, _queryKeywords) {
+  const factStore = new FactStore(vaultPath);
+  try {
+    factStore.load();
+  } catch {
+    return [];
+  }
+  const stats = factStore.stats();
+  if (stats.activeFacts === 0) return [];
+  const items = [];
+  const preferenceQuery = isPreferenceQuery(query);
+  const temporalQuery = isTemporalQuery(query);
+  const matchingFacts = factStore.searchFacts(query);
+  if (preferenceQuery) {
+    const prefs = factStore.getPreferences();
+    for (const pref of prefs) {
+      if (!matchingFacts.find((f) => f.id === pref.id)) {
+        matchingFacts.push(pref);
+      }
+    }
+  }
+  for (const fact of matchingFacts.slice(0, 10)) {
+    const factText = `${fact.entity} ${fact.relation} ${fact.value}`;
+    let score = fact.confidence * 0.8;
+    if (preferenceQuery && fact.category === "preference") {
+      score *= 1.5;
+    }
+    if (temporalQuery && (fact.relation.includes("_on") || fact.relation.includes("date") || fact.relation.includes("time"))) {
+      score *= 1.3;
+    }
+    const entry = {
+      title: `Fact: ${fact.entity} \u2192 ${fact.relation}`,
+      path: fact.source,
+      category: fact.category,
+      score: Math.min(1, score),
+      snippet: factText,
+      modified: fact.validFrom,
+      age: formatRelativeAge(new Date(fact.validFrom)),
+      source: "observation",
+      // Use 'observation' since ContextSource doesn't include 'fact'
+      signals: ["fact_store", fact.category],
+      rationale: `Extracted fact (${fact.category}, confidence: ${fact.confidence.toFixed(2)})`
+    };
+    items.push({
+      priority: preferenceQuery && fact.category === "preference" ? 1 : 2,
+      entry
+    });
+  }
+  return items;
+}
 function buildSearchContextItems(vault, results) {
   return results.map((result) => {
     const relativePath = path.relative(vault.getPath(), result.document.path).split(path.sep).join("/");
@@ -592,6 +653,7 @@ async function buildContext(task, options) {
   });
   const searchItems = buildSearchContextItems(vault, searchResults);
   const dailyItems = buildDailyContextItems(vault.getPath(), allDocuments);
+  const factItems = buildFactContextItems(vault.getPath(), normalizedTask, queryKeywords);
   const observationItems = includeObservations ? buildObservationContextItems(vault.getPath(), queryKeywords) : [];
   const graph = await getMemoryGraph(vault.getPath());
   const graphItems = buildGraphContextItems({
@@ -608,11 +670,13 @@ async function buildContext(task, options) {
   const contextualObservations = observationItems.filter((item) => item.priority === 5).sort(byScoreDesc);
   const sortedDailyItems = [...dailyItems].sort(byScoreDesc);
   const sortedSearchItems = [...searchItems].sort(byScoreDesc);
+  const sortedFactItems = [...factItems].sort(byScoreDesc);
   const sortedGraphItems = [...graphItems].sort(byScoreDesc);
   const grouped = {
     structural: structuralObservations,
     daily: sortedDailyItems,
     search: sortedSearchItems,
+    fact: sortedFactItems,
     graph: sortedGraphItems,
     potential: potentialObservations,
     contextual: contextualObservations

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