clawvault 3.0.0 → 3.2.0

package/dist/chunk-6FH3IULF.js

@@ -0,0 +1,352 @@
+import {
+  withQmdIndexArgs
+} from "./chunk-EK6S23ZB.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
+};