clawvault 3.2.1 → 3.4.0

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}"`);

package/dist/chunk-FZ5I2NF7.js

@@ -0,0 +1,352 @@
+import {
+  withQmdIndexArgs
+} from "./chunk-PTWPPVC7.js";
+
+// 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*$/;
+var QMD_INDEX_ENV_VAR = "CLAWVAULT_QMD_INDEX";
+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 resolveQmdIndexName(indexName) {
+  const explicit = indexName?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const fromEnv = process.env[QMD_INDEX_ENV_VAR]?.trim();
+  return fromEnv || void 0;
+}
+function withQmdIndexArgs2(args, indexName) {
+  if (args.includes("--index")) {
+    return [...args];
+  }
+  const resolvedIndexName = resolveQmdIndexName(indexName);
+  if (!resolvedIndexName) {
+    return [...args];
+  }
+  return ["--index", resolvedIndexName, ...args];
+}
+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(indexName) {
+  const output = execFileSync("qmd", withQmdIndexArgs2(["collection", "list"], indexName), {
+    encoding: "utf-8",
+    shell: process.platform === "win32"
+  });
+  return parseQmdCollectionList(output);
+}
+function removeQmdCollection(name, indexName) {
+  try {
+    execFileSync("qmd", withQmdIndexArgs2(["collection", "remove", name], indexName), { stdio: "ignore", shell: process.platform === "win32" });
+    return;
+  } catch {
+    execFileSync("qmd", withQmdIndexArgs2(["collection", "rm", name], indexName), { stdio: "ignore", shell: process.platform === "win32" });
+  }
+}
+function collectionExists(name, indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    return collections.some((c) => c.name === name);
+  } catch {
+    return false;
+  }
+}
+function getCollectionByName(name, indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    return collections.find((collection) => collection.name === name);
+  } catch {
+    return void 0;
+  }
+}
+function findCollectionByRoot(rootPath, indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    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(indexName) {
+  try {
+    const collections = listQmdCollections(indexName);
+    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
+    };
+  }
+}
+
+// src/lib/qmd-embedding-recovery.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var CLAWVAULT_DIR = ".clawvault";
+var QMD_EMBED_WAL_FILE = "qmd-embed.wal.json";
+var WALK_SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", ".trash", ".clawvault", "node_modules"]);
+function getQmdEmbedWalPath(vaultPath) {
+  return path2.join(vaultPath, CLAWVAULT_DIR, QMD_EMBED_WAL_FILE);
+}
+function writeJsonAtomic(filePath, value) {
+  const dir = path2.dirname(filePath);
+  fs2.mkdirSync(dir, { recursive: true });
+  const tmpPath = path2.join(
+    dir,
+    `${path2.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
+  );
+  try {
+    fs2.writeFileSync(tmpPath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+    fs2.renameSync(tmpPath, filePath);
+  } finally {
+    if (fs2.existsSync(tmpPath)) {
+      fs2.rmSync(tmpPath, { force: true });
+    }
+  }
+}
+function runQmdCommand(args, indexName) {
+  execFileSync2("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit", shell: process.platform === "win32" });
+}
+function runQmdEmbedForce(collection, indexName) {
+  try {
+    runQmdCommand(["embed", "-f", "-c", collection], indexName);
+  } catch {
+    runQmdCommand(["embed", "-c", collection], indexName);
+  }
+}
+function countMarkdownFiles(rootPath) {
+  let total = 0;
+  const stack = [rootPath];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries;
+    try {
+      entries = fs2.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || WALK_SKIP_DIRS.has(entry.name)) {
+          continue;
+        }
+        stack.push(entryPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".md") && !entry.name.startsWith(".")) {
+        total += 1;
+      }
+    }
+  }
+  return total;
+}
+function shouldRecoverEmptyVectors(collectionInfo, markdownCount) {
+  if (!collectionInfo) return false;
+  if (markdownCount === 0) return false;
+  if (collectionInfo.vectors === void 0) return false;
+  if (collectionInfo.vectors > 0) return false;
+  if (collectionInfo.pendingEmbeddings !== void 0 && collectionInfo.pendingEmbeddings > 0) {
+    return false;
+  }
+  return true;
+}
+function hasWalMarker(vaultPath) {
+  return fs2.existsSync(getQmdEmbedWalPath(vaultPath));
+}
+function clearQmdEmbedWalRecord(vaultPath) {
+  const walPath = getQmdEmbedWalPath(vaultPath);
+  if (fs2.existsSync(walPath)) {
+    fs2.rmSync(walPath, { force: true });
+  }
+}
+function writeQmdEmbedWalRecord(options) {
+  const wal = {
+    version: 1,
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    collection: options.collection,
+    rootPath: options.rootPath,
+    indexName: options.indexName
+  };
+  writeJsonAtomic(getQmdEmbedWalPath(options.vaultPath), wal);
+}
+function runCrashSafeQmdEmbed(options) {
+  writeQmdEmbedWalRecord(options);
+  try {
+    runQmdCommand(["embed", "-c", options.collection], options.indexName);
+    clearQmdEmbedWalRecord(options.vaultPath);
+  } catch (err) {
+    throw err;
+  }
+}
+function recoverQmdEmbeddingIfNeeded(options) {
+  const mode = options.mode ?? "marker-or-empty";
+  let reason;
+  if (hasWalMarker(options.vaultPath)) {
+    reason = "interrupted_wal";
+  } else if (mode === "marker-or-empty") {
+    const collectionInfo = getCollectionByName(options.collection, options.indexName);
+    const markdownCount = countMarkdownFiles(options.rootPath);
+    if (shouldRecoverEmptyVectors(collectionInfo, markdownCount)) {
+      reason = "empty_vectors";
+    }
+  }
+  if (!reason) {
+    return { recovered: false };
+  }
+  options.onLog?.(
+    reason === "interrupted_wal" ? `Detected interrupted qmd embedding run for "${options.collection}". Rebuilding...` : `Detected empty qmd vector state for "${options.collection}". Rebuilding...`
+  );
+  runQmdCommand(["update", "-c", options.collection], options.indexName);
+  runQmdEmbedForce(options.collection, options.indexName);
+  clearQmdEmbedWalRecord(options.vaultPath);
+  return { recovered: true, reason };
+}
+
+export {
+  parseQmdCollectionList,
+  listQmdCollections,
+  removeQmdCollection,
+  loadVaultQmdConfig,
+  runCrashSafeQmdEmbed,
+  recoverQmdEmbeddingIfNeeded
+};

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

@@ -1,15 +1,15 @@
-import {
-  ClawVault
-} from "./chunk-YDWHS4LJ.js";
 import {
   FactStore
 } from "./chunk-BSJ6RIT7.js";
+import {
+  ClawVault
+} from "./chunk-ECGJYWNA.js";
 import {
   parseObservationMarkdown
 } from "./chunk-FHFUXL6G.js";
 import {
   getMemoryGraph
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 import {
   listObservationFiles
 } from "./chunk-Z2XBWN7A.js";
@@ -144,7 +144,56 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "why",
   "with",
   "you",
-  "your"
+  "your",
+  "\u0438",
+  "\u0432",
+  "\u0432\u043E",
+  "\u043D\u0430",
+  "\u043F\u043E",
+  "\u0441",
+  "\u0441\u043E",
+  "\u043A",
+  "\u043A\u043E",
+  "\u0443",
+  "\u043E",
+  "\u043E\u0431",
+  "\u043E\u0442",
+  "\u0434\u043E",
+  "\u0437\u0430",
+  "\u0438\u0437",
+  "\u043F\u043E\u0434",
+  "\u043D\u0430\u0434",
+  "\u043D\u0435",
+  "\u043D\u043E",
+  "\u0430",
+  "\u0438\u043B\u0438",
+  "\u0447\u0442\u043E",
+  "\u043A\u0430\u043A",
+  "\u044D\u0442\u043E",
+  "\u0442\u043E",
+  "\u0436\u0435",
+  "\u043B\u0438",
+  "\u0434\u043B\u044F",
+  "\u043F\u0440\u0438",
+  "\u043F\u0440\u043E",
+  "\u043C\u044B",
+  "\u0432\u044B",
+  "\u043E\u043D\u0438",
+  "\u043E\u043D",
+  "\u043E\u043D\u0430",
+  "\u043E\u043D\u043E",
+  "\u044F",
+  "\u0442\u044B",
+  "\u043C\u043E\u0439",
+  "\u043C\u043E\u044F",
+  "\u043C\u043E\u0451",
+  "\u043C\u043E\u0438",
+  "\u0442\u0432\u043E\u0439",
+  "\u0442\u0432\u043E\u044F",
+  "\u0442\u0432\u043E\u0438",
+  "\u043D\u0430\u0448",
+  "\u043D\u0430\u0448\u0430",
+  "\u0438\u0445"
 ]);
 function formatRelativeAge(date, now = Date.now()) {
   const ageMs = Math.max(0, now - date.getTime());
@@ -199,7 +248,7 @@ var PROFILE_ORDERING = {
   }
 };
 function extractKeywords(text) {
-  const raw = text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+  const raw = text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
   const seen = /* @__PURE__ */ new Set();
   const keywords = [];
   for (const token of raw) {

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) {