clawvault 3.2.0 → 3.3.0

package/dist/chunk-33VSQP4J.js

@@ -1,37 +0,0 @@
-import {
-  registerTailscaleCommands
-} from "./chunk-Y6VJKXGL.js";
-import {
-  registerWorkgraphCommands
-} from "./chunk-GGA32J2R.js";
-import {
-  registerObserveCommand
-} from "./chunk-23YDQ3QU.js";
-import {
-  registerReflectCommand
-} from "./chunk-SLXOR3CC.js";
-import {
-  registerContextCommand
-} from "./chunk-ZN54U2OZ.js";
-import {
-  registerEmbedCommand
-} from "./chunk-PBACDKKP.js";
-import {
-  registerInjectCommand
-} from "./chunk-W4SPAEE7.js";
-
-// src/cli/index.ts
-function registerCliCommands(program) {
-  registerContextCommand(program);
-  registerInjectCommand(program);
-  registerObserveCommand(program);
-  registerReflectCommand(program);
-  registerEmbedCommand(program);
-  registerTailscaleCommands(program);
-  registerWorkgraphCommands(program);
-  return program;
-}
-
-export {
-  registerCliCommands
-};

package/dist/chunk-4BQTQMJP.js

@@ -1,93 +0,0 @@
-import {
-  __export
-} from "./chunk-2ZDO52B4.js";
-
-// src/workgraph/ledger.ts
-var ledger_exports = {};
-__export(ledger_exports, {
-  activityOf: () => activityOf,
-  allClaims: () => allClaims,
-  append: () => append,
-  currentOwner: () => currentOwner,
-  historyOf: () => historyOf,
-  isClaimed: () => isClaimed,
-  ledgerPath: () => ledgerPath,
-  readAll: () => readAll,
-  readSince: () => readSince,
-  recent: () => recent
-});
-import fs from "fs";
-import path from "path";
-var LEDGER_FILE = ".clawvault/ledger.jsonl";
-function ledgerPath(vaultPath) {
-  return path.join(vaultPath, LEDGER_FILE);
-}
-function append(vaultPath, actor, op, target, type, data) {
-  const entry = {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    actor,
-    op,
-    target,
-    ...type ? { type } : {},
-    ...data && Object.keys(data).length > 0 ? { data } : {}
-  };
-  const lPath = ledgerPath(vaultPath);
-  const dir = path.dirname(lPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.appendFileSync(lPath, JSON.stringify(entry) + "\n", "utf-8");
-  return entry;
-}
-function readAll(vaultPath) {
-  const lPath = ledgerPath(vaultPath);
-  if (!fs.existsSync(lPath)) return [];
-  const lines = fs.readFileSync(lPath, "utf-8").split("\n").filter(Boolean);
-  return lines.map((line) => JSON.parse(line));
-}
-function readSince(vaultPath, since) {
-  return readAll(vaultPath).filter((e) => e.ts >= since);
-}
-function currentOwner(vaultPath, target) {
-  const entries = readAll(vaultPath).filter((e) => e.target === target);
-  let owner = null;
-  for (const e of entries) {
-    if (e.op === "claim") owner = e.actor;
-    if (e.op === "release" || e.op === "done" || e.op === "cancel") owner = null;
-  }
-  return owner;
-}
-function isClaimed(vaultPath, target) {
-  return currentOwner(vaultPath, target) !== null;
-}
-function historyOf(vaultPath, target) {
-  return readAll(vaultPath).filter((e) => e.target === target);
-}
-function activityOf(vaultPath, actor) {
-  return readAll(vaultPath).filter((e) => e.actor === actor);
-}
-function allClaims(vaultPath) {
-  const claims = /* @__PURE__ */ new Map();
-  const entries = readAll(vaultPath);
-  for (const e of entries) {
-    if (e.op === "claim") claims.set(e.target, e.actor);
-    if (e.op === "release" || e.op === "done" || e.op === "cancel") claims.delete(e.target);
-  }
-  return claims;
-}
-function recent(vaultPath, count = 20) {
-  const all = readAll(vaultPath);
-  return all.slice(-count);
-}
-
-export {
-  ledgerPath,
-  append,
-  readAll,
-  readSince,
-  currentOwner,
-  isClaimed,
-  historyOf,
-  activityOf,
-  allClaims,
-  recent,
-  ledger_exports
-};

package/dist/chunk-EK6S23ZB.js

@@ -1,469 +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
-      shell: process.platform === "win32"
-    });
-    return parseQmdOutput(result);
-  } catch (err) {
-    if (err?.code === "ENOENT") {
-      throw new QmdUnavailableError("NOT_INSTALLED");
-    }
-    if (err?.status === 1 && err?.stdout) {
-      return parseQmdOutput(err.stdout);
-    }
-    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", shell: process.platform === "win32" });
-  return !result.error && (result.status === 0 || result.status === 1);
-}
-function qmdUpdate(collection, indexName) {
-  ensureQmdAvailable();
-  const args = ["update"];
-  if (collection) {
-    args.push("-c", collection);
-  }
-  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit", shell: process.platform === "win32" });
-}
-function qmdEmbed(collection, indexName) {
-  ensureQmdAvailable();
-  const args = ["embed"];
-  if (collection) {
-    args.push("-c", collection);
-  }
-  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit", shell: process.platform === "win32" });
-}
-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
-};