clawvault 2.6.1 → 2.6.4

package/dist/{chunk-MAKNAHAW.js → chunk-5PJ4STIC.js}

@@ -4,12 +4,57 @@ 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_NOT_INSTALLED_MESSAGE = `ClawVault requires qmd. Install: ${QMD_INSTALL_COMMAND}`;
 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 {
-  constructor(message = QMD_NOT_INSTALLED_MESSAGE) {
-    super(message);
+  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) {
@@ -80,9 +125,39 @@ function parseQmdOutput(raw) {
 }
 function ensureQmdAvailable() {
   if (!hasQmd()) {
-    throw new QmdUnavailableError();
+    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);
@@ -96,17 +171,24 @@ function execQmd(args, indexName) {
     return parseQmdOutput(result);
   } catch (err) {
     if (err?.code === "ENOENT") {
-      throw new QmdUnavailableError();
+      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 message = err?.message ? `qmd failed: ${err.message}` : "qmd failed";
-    throw new Error(message);
+    const errorDetail = err?.message || "unknown error";
+    throw new QmdUnavailableError("EXECUTION_FAILED", errorDetail);
   }
 }
 function hasQmd() {
@@ -131,7 +213,7 @@ function qmdEmbed(collection, indexName) {
 }
 var SearchEngine = class {
   documents = /* @__PURE__ */ new Map();
-  collection = "clawvault";
+  collection = "";
   vaultPath = "";
   collectionRoot = "";
   qmdIndexName;
@@ -141,6 +223,12 @@ var SearchEngine = class {
   setCollection(name) {
     this.collection = name;
   }
+  /**
+   * Get the current collection name
+   */
+  getCollection() {
+    return this.collection;
+  }
   /**
    * Set the vault path for file resolution
    */
@@ -365,6 +453,8 @@ export {
   QMD_INSTALL_URL,
   QMD_INSTALL_COMMAND,
   QmdUnavailableError,
+  getQmdErrorDetails,
+  QmdConfigurationError,
   withQmdIndexArgs,
   hasQmd,
   qmdUpdate,

package/dist/{chunk-IEVLHNLU.js → chunk-627Q3QWK.js}

@@ -1,9 +1,9 @@
+import {
+  Observer
+} from "./chunk-OQGYFZ4A.js";
 import {
   getSessionsDir
 } from "./chunk-HRLWZGMA.js";
-import {
-  Observer
-} from "./chunk-Q2J5YTUF.js";
 
 // src/observer/active-session-observer.ts
 import * as fs from "fs";

package/dist/{chunk-R6SXNSFD.js → chunk-6NYYDNNG.js}

@@ -1,12 +1,12 @@
 import {
   runReflection
-} from "./chunk-T76H47ZS.js";
+} from "./chunk-MNPUYCHQ.js";
 import {
   Observer
-} from "./chunk-Q2J5YTUF.js";
+} from "./chunk-OQGYFZ4A.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/replay.ts
 import * as fs from "fs";

package/dist/chunk-ECRZL5XR.js

@@ -0,0 +1,50 @@
+import {
+  loadVaultQmdConfig
+} from "./chunk-WIOLLGAD.js";
+import {
+  QmdUnavailableError,
+  hasQmd,
+  qmdEmbed
+} from "./chunk-5PJ4STIC.js";
+import {
+  resolveVaultPath
+} from "./chunk-GNJL4YGR.js";
+
+// src/commands/embed.ts
+async function embedCommand(options = {}) {
+  if (!hasQmd()) {
+    throw new QmdUnavailableError();
+  }
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const qmdConfig = loadVaultQmdConfig(vaultPath);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!options.quiet) {
+    console.log(
+      `Embedding pending documents for collection "${qmdConfig.qmdCollection}" (root: ${qmdConfig.qmdRoot})...`
+    );
+  }
+  qmdEmbed(qmdConfig.qmdCollection);
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!options.quiet) {
+    console.log(`\u2713 Embedding complete for "${qmdConfig.qmdCollection}"`);
+  }
+  return {
+    vaultPath,
+    qmdCollection: qmdConfig.qmdCollection,
+    qmdRoot: qmdConfig.qmdRoot,
+    startedAt,
+    finishedAt
+  };
+}
+function registerEmbedCommand(program) {
+  program.command("embed").description("Run qmd embedding for pending vault documents").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await embedCommand({
+      vaultPath: rawOptions.vault
+    });
+  });
+}
+
+export {
+  embedCommand,
+  registerEmbedCommand
+};

package/dist/chunk-GNJL4YGR.js

@@ -0,0 +1,79 @@
+// src/lib/config.ts
+import * as fs from "fs";
+import * as path from "path";
+function getVaultPath() {
+  const vaultPath = process.env.CLAWVAULT_PATH;
+  if (!vaultPath) {
+    throw new Error("CLAWVAULT_PATH environment variable not set");
+  }
+  return path.resolve(vaultPath);
+}
+function findNearestVaultPath(startPath = process.cwd()) {
+  let current = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".clawvault.json"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function validateVaultPath(vaultPath) {
+  if (!vaultPath || typeof vaultPath !== "string") return null;
+  const resolved = path.resolve(vaultPath);
+  if (!path.isAbsolute(resolved)) return null;
+  try {
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) return null;
+  } catch {
+    return null;
+  }
+  const configPath = path.join(resolved, ".clawvault.json");
+  if (!fs.existsSync(configPath)) return null;
+  return resolved;
+}
+function resolveAgentVaultPath(agentVaults, agentId) {
+  if (!agentId || typeof agentId !== "string") return null;
+  if (!agentVaults || typeof agentVaults !== "object" || Array.isArray(agentVaults)) {
+    return null;
+  }
+  const agentPath = agentVaults[agentId];
+  if (!agentPath || typeof agentPath !== "string") return null;
+  return validateVaultPath(agentPath);
+}
+function resolveVaultPath(options = {}) {
+  if (options.explicitPath) {
+    return path.resolve(options.explicitPath);
+  }
+  if (options.agentId && options.pluginConfig?.agentVaults) {
+    const agentVaultPath = resolveAgentVaultPath(
+      options.pluginConfig.agentVaults,
+      options.agentId
+    );
+    if (agentVaultPath) {
+      return agentVaultPath;
+    }
+  }
+  if (options.pluginConfig?.vaultPath) {
+    const validated = validateVaultPath(options.pluginConfig.vaultPath);
+    if (validated) return validated;
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path.resolve(process.env.CLAWVAULT_PATH);
+  }
+  const discovered = findNearestVaultPath(options.cwd ?? process.cwd());
+  if (discovered) {
+    return discovered;
+  }
+  throw new Error("No vault path found. Set CLAWVAULT_PATH, use --vault, or run inside a vault.");
+}
+
+export {
+  getVaultPath,
+  findNearestVaultPath,
+  resolveAgentVaultPath,
+  resolveVaultPath
+};

package/dist/{chunk-OZ7RIXTO.js → chunk-IIOU45CK.js}

@@ -1,6 +1,6 @@
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   buildOrUpdateMemoryGraphIndex,
   loadMemoryGraphIndex

package/dist/chunk-L4HSSQ6T.js

@@ -0,0 +1,152 @@
+import {
+  getType,
+  loadRegistry
+} from "./chunk-MM6QGW3P.js";
+import {
+  append
+} from "./chunk-4BQTQMJP.js";
+import {
+  __export
+} from "./chunk-2ZDO52B4.js";
+
+// src/workgraph/store.ts
+var store_exports = {};
+__export(store_exports, {
+  activeThreads: () => activeThreads,
+  blockedThreads: () => blockedThreads,
+  create: () => create,
+  findByField: () => findByField,
+  list: () => list,
+  openThreads: () => openThreads,
+  read: () => read,
+  remove: () => remove,
+  update: () => update
+});
+import fs from "fs";
+import path from "path";
+import matter from "gray-matter";
+function create(vaultPath, typeName, fields, body, actor) {
+  const typeDef = getType(vaultPath, typeName);
+  if (!typeDef) {
+    throw new Error(`Unknown primitive type "${typeName}". Run \`clawvault primitive list\` to see available types, or \`clawvault primitive define\` to create one.`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const merged = applyDefaults(typeDef, {
+    ...fields,
+    created: fields.created ?? now,
+    updated: now
+  });
+  const slug = slugify(String(merged.title ?? merged.name ?? typeName));
+  const relDir = typeDef.directory;
+  const relPath = `${relDir}/${slug}.md`;
+  const absDir = path.join(vaultPath, relDir);
+  const absPath = path.join(vaultPath, relPath);
+  if (!fs.existsSync(absDir)) fs.mkdirSync(absDir, { recursive: true });
+  if (fs.existsSync(absPath)) {
+    throw new Error(`File already exists: ${relPath}. Use update instead.`);
+  }
+  const content = matter.stringify(body, stripUndefined(merged));
+  fs.writeFileSync(absPath, content, "utf-8");
+  append(vaultPath, actor, "create", relPath, typeName, {
+    title: merged.title ?? slug
+  });
+  return { path: relPath, type: typeName, fields: merged, body };
+}
+function read(vaultPath, relPath) {
+  const absPath = path.join(vaultPath, relPath);
+  if (!fs.existsSync(absPath)) return null;
+  const raw = fs.readFileSync(absPath, "utf-8");
+  const { data, content } = matter(raw);
+  const typeName = inferType(vaultPath, relPath);
+  return { path: relPath, type: typeName, fields: data, body: content.trim() };
+}
+function list(vaultPath, typeName) {
+  const typeDef = getType(vaultPath, typeName);
+  if (!typeDef) return [];
+  const dir = path.join(vaultPath, typeDef.directory);
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  const instances = [];
+  for (const file of files) {
+    const relPath = `${typeDef.directory}/${file}`;
+    const inst = read(vaultPath, relPath);
+    if (inst) instances.push(inst);
+  }
+  return instances;
+}
+function update(vaultPath, relPath, fieldUpdates, bodyUpdate, actor) {
+  const existing = read(vaultPath, relPath);
+  if (!existing) throw new Error(`Not found: ${relPath}`);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newFields = { ...existing.fields, ...fieldUpdates, updated: now };
+  const newBody = bodyUpdate ?? existing.body;
+  const absPath = path.join(vaultPath, relPath);
+  const content = matter.stringify(newBody, stripUndefined(newFields));
+  fs.writeFileSync(absPath, content, "utf-8");
+  append(vaultPath, actor, "update", relPath, existing.type, {
+    changed: Object.keys(fieldUpdates)
+  });
+  return { path: relPath, type: existing.type, fields: newFields, body: newBody };
+}
+function remove(vaultPath, relPath, actor) {
+  const absPath = path.join(vaultPath, relPath);
+  if (!fs.existsSync(absPath)) throw new Error(`Not found: ${relPath}`);
+  const archiveDir = path.join(vaultPath, ".clawvault", "archive");
+  if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
+  const archivePath = path.join(archiveDir, path.basename(relPath));
+  fs.renameSync(absPath, archivePath);
+  const typeName = inferType(vaultPath, relPath);
+  append(vaultPath, actor, "delete", relPath, typeName);
+}
+function findByField(vaultPath, typeName, field, value) {
+  return list(vaultPath, typeName).filter((inst) => inst.fields[field] === value);
+}
+function openThreads(vaultPath) {
+  return findByField(vaultPath, "thread", "status", "open");
+}
+function activeThreads(vaultPath) {
+  return findByField(vaultPath, "thread", "status", "active");
+}
+function blockedThreads(vaultPath) {
+  return findByField(vaultPath, "thread", "status", "blocked");
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+}
+function applyDefaults(typeDef, fields) {
+  const result = { ...fields };
+  for (const [key, def] of Object.entries(typeDef.fields)) {
+    if (result[key] === void 0 && def.default !== void 0) {
+      result[key] = def.default;
+    }
+  }
+  return result;
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) result[k] = v;
+  }
+  return result;
+}
+function inferType(vaultPath, relPath) {
+  const registry = loadRegistry(vaultPath);
+  const dir = relPath.split("/")[0];
+  for (const typeDef of Object.values(registry.types)) {
+    if (typeDef.directory === dir) return typeDef.name;
+  }
+  return "unknown";
+}
+
+export {
+  create,
+  read,
+  list,
+  update,
+  remove,
+  findByField,
+  openThreads,
+  activeThreads,
+  blockedThreads,
+  store_exports
+};

package/dist/{chunk-XAVB4GB4.js → chunk-LIGHWOH6.js}

@@ -1,6 +1,6 @@
 import {
   ClawVault
-} from "./chunk-KL4NAOMO.js";
+} from "./chunk-YDWHS4LJ.js";
 import {
   parseObservationMarkdown
 } from "./chunk-FHFUXL6G.js";

package/dist/{chunk-PBEE567J.js → chunk-LUBZXECN.js}

@@ -1,9 +1,9 @@
 import {
   Observer
-} from "./chunk-Q2J5YTUF.js";
+} from "./chunk-OQGYFZ4A.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   getLegacyObservationPath,
   getObservationPath,