clawvault 3.2.1 → 3.3.0

package/dist/chunk-5PJ4STIC.js

@@ -1,465 +0,0 @@
-// src/lib/search.ts
-import { execFileSync, spawnSync } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-var QMD_INSTALL_URL = "https://github.com/tobi/qmd";
-var QMD_INSTALL_COMMAND = "bun install -g github:tobi/qmd";
-var QMD_INDEX_ENV_VAR = "CLAWVAULT_QMD_INDEX";
-var QMD_ERROR_MESSAGES = {
-  NOT_INSTALLED: {
-    code: "NOT_INSTALLED",
-    message: "qmd is not installed",
-    hint: `Install qmd to enable ClawVault search and indexing:
-  ${QMD_INSTALL_COMMAND}
-
-For more information: ${QMD_INSTALL_URL}`
-  },
-  NOT_CONFIGURED: {
-    code: "NOT_CONFIGURED",
-    message: "qmd collection is not configured",
-    hint: "Run `clawvault doctor` to diagnose configuration issues, or `clawvault migrate` to fix common setup problems."
-  },
-  COLLECTION_NOT_FOUND: {
-    code: "COLLECTION_NOT_FOUND",
-    message: "qmd collection not found",
-    hint: "The configured qmd collection does not exist. Run `clawvault migrate` to recreate it, or `qmd collection add <name> <path>` manually."
-  },
-  EXECUTION_FAILED: {
-    code: "EXECUTION_FAILED",
-    message: "qmd command failed",
-    hint: "Run `clawvault doctor` to diagnose qmd issues."
-  }
-};
-var QmdUnavailableError = class extends Error {
-  code;
-  hint;
-  constructor(code = "NOT_INSTALLED", additionalContext) {
-    const details = QMD_ERROR_MESSAGES[code];
-    const fullMessage = additionalContext ? `${details.message}: ${additionalContext}` : details.message;
-    super(fullMessage);
-    this.name = "QmdUnavailableError";
-    this.code = code;
-    this.hint = details.hint;
-  }
-  toUserMessage() {
-    return `Error: ${this.message}
-
-${this.hint}`;
-  }
-};
-function getQmdErrorDetails(code) {
-  return QMD_ERROR_MESSAGES[code];
-}
-var QmdConfigurationError = class extends Error {
-  constructor(message, hint) {
-    super(message);
-    this.hint = hint;
-    this.name = "QmdConfigurationError";
-  }
-};
-function ensureJsonArgs(args) {
-  return args.includes("--json") ? args : [...args, "--json"];
-}
-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 withQmdIndexArgs(args, indexName) {
-  if (args.includes("--index")) {
-    return [...args];
-  }
-  const resolvedIndexName = resolveQmdIndexName(indexName);
-  if (!resolvedIndexName) {
-    return [...args];
-  }
-  return ["--index", resolvedIndexName, ...args];
-}
-function tryParseJson(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function extractJsonPayload(raw) {
-  const start = raw.search(/[\[{]/);
-  if (start === -1) return null;
-  const end = Math.max(raw.lastIndexOf("]"), raw.lastIndexOf("}"));
-  if (end <= start) return null;
-  return raw.slice(start, end + 1);
-}
-function stripQmdNoise(raw) {
-  return raw.split("\n").filter((line) => {
-    const t = line.trim();
-    if (!t) return true;
-    if (t.startsWith("[node-llama-cpp]")) return false;
-    if (t.startsWith("Expanding query")) return false;
-    if (t.startsWith("Searching ") && t.endsWith("queries...")) return false;
-    if (/^[├└─│]/.test(t)) return false;
-    return true;
-  }).join("\n");
-}
-function parseQmdOutput(raw) {
-  const trimmed = stripQmdNoise(raw).trim();
-  if (!trimmed) return [];
-  const direct = tryParseJson(trimmed);
-  const extracted = direct ? null : extractJsonPayload(trimmed);
-  const parsed = direct ?? (extracted ? tryParseJson(extracted) : null);
-  if (!parsed) {
-    throw new Error("qmd returned non-JSON output. Ensure qmd supports --json.");
-  }
-  if (Array.isArray(parsed)) {
-    return parsed;
-  }
-  if (parsed && typeof parsed === "object") {
-    const candidate = parsed.results ?? parsed.items ?? parsed.data;
-    if (Array.isArray(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error("qmd returned an unexpected JSON shape.");
-}
-function ensureQmdAvailable() {
-  if (!hasQmd()) {
-    throw new QmdUnavailableError("NOT_INSTALLED");
-  }
-}
-function detectQmdError(output, args) {
-  const lowerOutput = output.toLowerCase();
-  if (lowerOutput.includes("missing required arguments") || lowerOutput.includes("unknown option")) {
-    return new QmdConfigurationError(
-      'qmd does not support the search command with the expected arguments. This may indicate an incompatible qmd version or a different tool named "qmd".',
-      `Ensure you have the correct qmd installed: ${QMD_INSTALL_COMMAND}`
-    );
-  }
-  if (lowerOutput.includes("collection not found") || lowerOutput.includes("no collection")) {
-    const collectionArg = args.findIndex((a) => a === "-c");
-    const collectionName = collectionArg >= 0 && args[collectionArg + 1] ? args[collectionArg + 1] : "unknown";
-    return new QmdConfigurationError(
-      `qmd collection "${collectionName}" not found.`,
-      'Run `qmd update -c <collection>` to create the collection, or check your vault\'s .clawvault.json "name" field.'
-    );
-  }
-  if (lowerOutput.includes("no index") || lowerOutput.includes("index not found")) {
-    return new QmdConfigurationError(
-      "qmd index not found. The vault may not be indexed yet.",
-      "Run `clawvault rebuild` or `qmd update` to build the search index."
-    );
-  }
-  if (lowerOutput.includes("embedding") && (lowerOutput.includes("not found") || lowerOutput.includes("missing"))) {
-    return new QmdConfigurationError(
-      "qmd embeddings not found. Vector search requires embeddings to be generated.",
-      "Run `clawvault embed` or `qmd embed` to generate embeddings for semantic search."
-    );
-  }
-  return null;
-}
-function execQmd(args, indexName) {
-  ensureQmdAvailable();
-  const finalArgs = withQmdIndexArgs(ensureJsonArgs(args), indexName);
-  try {
-    const result = execFileSync("qmd", finalArgs, {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "pipe"],
-      maxBuffer: 10 * 1024 * 1024
-      // 10MB
-    });
-    return parseQmdOutput(result);
-  } catch (err) {
-    if (err?.code === "ENOENT") {
-      throw new QmdUnavailableError("NOT_INSTALLED");
-    }
-    const output = [err?.stdout, err?.stderr].filter(Boolean).join("\n");
-    const detectedError = detectQmdError(output, finalArgs);
-    if (detectedError) {
-      throw detectedError;
-    }
-    if (output) {
-      try {
-        return parseQmdOutput(output);
-      } catch {
-      }
-      if (output.includes("collection not found") || output.includes("no such collection")) {
-        throw new QmdUnavailableError("COLLECTION_NOT_FOUND", output.trim());
-      }
-    }
-    const errorDetail = err?.message || "unknown error";
-    throw new QmdUnavailableError("EXECUTION_FAILED", errorDetail);
-  }
-}
-function hasQmd() {
-  const result = spawnSync("qmd", ["--version"], { stdio: "ignore" });
-  return !result.error;
-}
-function qmdUpdate(collection, indexName) {
-  ensureQmdAvailable();
-  const args = ["update"];
-  if (collection) {
-    args.push("-c", collection);
-  }
-  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
-}
-function qmdEmbed(collection, indexName) {
-  ensureQmdAvailable();
-  const args = ["embed"];
-  if (collection) {
-    args.push("-c", collection);
-  }
-  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
-}
-var SearchEngine = class {
-  documents = /* @__PURE__ */ new Map();
-  collection = "";
-  vaultPath = "";
-  collectionRoot = "";
-  qmdIndexName;
-  /**
-   * Set the collection name (usually vault name)
-   */
-  setCollection(name) {
-    this.collection = name;
-  }
-  /**
-   * Get the current collection name
-   */
-  getCollection() {
-    return this.collection;
-  }
-  /**
-   * Set the vault path for file resolution
-   */
-  setVaultPath(vaultPath) {
-    this.vaultPath = vaultPath;
-  }
-  /**
-   * Set the collection root for qmd:// URI resolution
-   */
-  setCollectionRoot(root) {
-    this.collectionRoot = path.resolve(root);
-  }
-  /**
-   * Set qmd index name (defaults to qmd global default when omitted)
-   */
-  setIndexName(indexName) {
-    this.qmdIndexName = indexName;
-  }
-  /**
-   * Add or update a document in the local cache
-   * Note: qmd indexing happens via qmd update command
-   */
-  addDocument(doc) {
-    this.documents.set(doc.id, doc);
-  }
-  /**
-   * Remove a document from the local cache
-   */
-  removeDocument(id) {
-    this.documents.delete(id);
-  }
-  /**
-   * No-op for qmd - indexing is managed externally
-   */
-  rebuildIDF() {
-  }
-  /**
-   * BM25 search via qmd
-   */
-  search(query, options = {}) {
-    return this.runQmdQuery("search", query, options);
-  }
-  /**
-   * Vector/semantic search via qmd vsearch
-   */
-  vsearch(query, options = {}) {
-    return this.runQmdQuery("vsearch", query, options);
-  }
-  /**
-   * Combined search with query expansion (qmd query command)
-   */
-  query(query, options = {}) {
-    return this.runQmdQuery("query", query, options);
-  }
-  runQmdQuery(command, query, options) {
-    const {
-      limit = 10,
-      minScore = 0,
-      category,
-      tags,
-      fullContent = false,
-      temporalBoost = false
-    } = options;
-    if (!query.trim()) return [];
-    const args = [
-      command,
-      query,
-      "-n",
-      String(limit * 2),
-      "--json"
-    ];
-    if (this.collection) {
-      args.push("-c", this.collection);
-    }
-    const qmdResults = execQmd(args, this.qmdIndexName);
-    return this.convertResults(qmdResults, {
-      limit,
-      minScore,
-      category,
-      tags,
-      fullContent,
-      temporalBoost
-    });
-  }
-  /**
-   * Convert qmd results to ClawVault SearchResult format
-   */
-  convertResults(qmdResults, options) {
-    const { limit = 10, minScore = 0, category, tags, fullContent = false, temporalBoost = false } = options;
-    const results = [];
-    const maxScore = qmdResults[0]?.score || 1;
-    for (const qr of qmdResults) {
-      const filePath = this.qmdUriToPath(qr.file);
-      const relativePath = this.vaultPath ? path.relative(this.vaultPath, filePath) : filePath;
-      const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-      if (normalizedRelativePath.startsWith("ledger/archive/") || normalizedRelativePath.includes("/ledger/archive/")) {
-        continue;
-      }
-      const docId = normalizedRelativePath.replace(/\.md$/, "");
-      let doc = this.documents.get(docId) ?? this.documents.get(docId.split("/").join(path.sep));
-      const modifiedAt = this.resolveModifiedAt(doc, filePath);
-      const parts = normalizedRelativePath.split("/");
-      const docCategory = parts.length > 1 ? parts[0] : "root";
-      if (category && docCategory !== category) continue;
-      if (tags && tags.length > 0 && doc) {
-        const docTags = new Set(doc.tags);
-        if (!tags.some((t) => docTags.has(t))) continue;
-      }
-      const normalizedScore = maxScore > 0 ? qr.score / maxScore : 0;
-      const finalScore = temporalBoost ? normalizedScore * this.getRecencyFactor(modifiedAt) : normalizedScore;
-      if (finalScore < minScore) continue;
-      if (!doc) {
-        doc = {
-          id: docId,
-          path: filePath,
-          category: docCategory,
-          title: qr.title || path.basename(relativePath, ".md"),
-          content: "",
-          // Content loaded separately if needed
-          frontmatter: {},
-          links: [],
-          tags: [],
-          modified: modifiedAt
-        };
-      }
-      results.push({
-        document: fullContent ? doc : { ...doc, content: "" },
-        score: finalScore,
-        snippet: this.cleanSnippet(qr.snippet),
-        matchedTerms: []
-        // qmd doesn't provide this
-      });
-    }
-    return results.sort((a, b) => b.score - a.score).slice(0, limit);
-  }
-  resolveModifiedAt(doc, filePath) {
-    if (doc) return doc.modified;
-    try {
-      return fs.statSync(filePath).mtime;
-    } catch {
-      return /* @__PURE__ */ new Date(0);
-    }
-  }
-  getRecencyFactor(modifiedAt) {
-    const ageMs = Math.max(0, Date.now() - modifiedAt.getTime());
-    const ageDays = ageMs / (24 * 60 * 60 * 1e3);
-    if (ageDays < 1) return 1;
-    if (ageDays <= 7) return 0.9;
-    return 0.7;
-  }
-  /**
-   * Convert qmd:// URI to file path
-   */
-  qmdUriToPath(uri) {
-    if (uri.startsWith("qmd://")) {
-      const withoutScheme = uri.slice(6);
-      const slashIndex = withoutScheme.indexOf("/");
-      if (slashIndex > -1) {
-        const relativePath = withoutScheme.slice(slashIndex + 1);
-        const root = this.collectionRoot || this.vaultPath;
-        if (root) {
-          return path.join(root, relativePath);
-        }
-        return relativePath;
-      }
-    }
-    return uri;
-  }
-  /**
-   * Clean up qmd snippet format
-   */
-  cleanSnippet(snippet) {
-    if (!snippet) return "";
-    return snippet.replace(/@@ [-+]?\d+,?\d* @@ \([^)]+\)/g, "").trim().split("\n").slice(0, 3).join("\n").slice(0, 300);
-  }
-  /**
-   * Get all cached documents
-   */
-  getAllDocuments() {
-    return [...this.documents.values()];
-  }
-  /**
-   * Get document count
-   */
-  get size() {
-    return this.documents.size;
-  }
-  /**
-   * Clear the local document cache
-   */
-  clear() {
-    this.documents.clear();
-  }
-  /**
-   * Export documents for persistence
-   */
-  export() {
-    return {
-      documents: [...this.documents.values()]
-    };
-  }
-  /**
-   * Import from persisted data
-   */
-  import(data) {
-    this.clear();
-    for (const doc of data.documents) {
-      this.addDocument(doc);
-    }
-  }
-};
-function extractWikiLinks(content) {
-  const matches = content.match(/\[\[([^\]]+)\]\]/g) || [];
-  return matches.map((m) => m.slice(2, -2).toLowerCase());
-}
-function extractTags(content) {
-  const matches = content.match(/#[\w-]+/g) || [];
-  return [...new Set(matches.map((m) => m.slice(1).toLowerCase()))];
-}
-
-export {
-  QMD_INSTALL_URL,
-  QMD_INSTALL_COMMAND,
-  QmdUnavailableError,
-  getQmdErrorDetails,
-  QmdConfigurationError,
-  withQmdIndexArgs,
-  hasQmd,
-  qmdUpdate,
-  qmdEmbed,
-  SearchEngine,
-  extractWikiLinks,
-  extractTags
-};

package/dist/chunk-ERNE2FZ5.js

@@ -1,189 +0,0 @@
-import {
-  create,
-  read,
-  update
-} from "./chunk-HR4KN6S2.js";
-import {
-  append,
-  currentOwner
-} from "./chunk-K7PNYS45.js";
-import {
-  THREAD_STATUS_TRANSITIONS
-} from "./chunk-WMGIIABP.js";
-import {
-  __export
-} from "./chunk-U67V476Y.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
-};