clawvault 2.5.1 → 2.5.3

package/dist/chunk-LMEMZGUV.js

@@ -0,0 +1,332 @@
+import {
+  formatAge
+} from "./chunk-7ZRP733D.js";
+import {
+  scanVaultLinks
+} from "./chunk-4VQTUVH7.js";
+import {
+  getObserverStaleness
+} from "./chunk-IZEY5S74.js";
+import {
+  ClawVault,
+  findVault
+} from "./chunk-AY4PGUVL.js";
+import {
+  hasQmd
+} from "./chunk-O7XHXF7F.js";
+import {
+  loadMemoryGraphIndex
+} from "./chunk-ZZA73MFY.js";
+import {
+  checkOpenClawCompatibility
+} from "./chunk-QVMXF7FY.js";
+
+// src/commands/doctor.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var CLAWVAULT_DIR = ".clawvault";
+var CHECKPOINT_FILE = "last-checkpoint.json";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var ACTIVE_USE_DAYS = 7;
+function daysSince(date, now = Date.now()) {
+  return Math.max(0, Math.floor((now - date.getTime()) / DAY_MS));
+}
+function describeAge(date, now = Date.now()) {
+  return formatAge(now - date.getTime());
+}
+function loadCheckpointTimestamp(vaultPath) {
+  const checkpointPath = path.join(vaultPath, CLAWVAULT_DIR, CHECKPOINT_FILE);
+  if (!fs.existsSync(checkpointPath)) {
+    return {};
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(checkpointPath, "utf-8"));
+    return { timestamp: data.timestamp };
+  } catch (err) {
+    return { error: err?.message || "Failed to parse checkpoint" };
+  }
+}
+function getShellConfigPaths(shellPath) {
+  const home = os.homedir();
+  const shellName = shellPath ? path.basename(shellPath) : "bash";
+  if (shellName === "zsh") {
+    return [path.join(home, ".zshrc"), path.join(home, ".zprofile")];
+  }
+  if (shellName === "fish") {
+    return [path.join(home, ".config", "fish", "config.fish")];
+  }
+  return [path.join(home, ".bashrc"), path.join(home, ".bash_profile"), path.join(home, ".profile")];
+}
+function hasClawvaultPathConfig(paths) {
+  for (const filePath of paths) {
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      if (/CLAWVAULT_PATH\s*=/.test(content)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function resolveVault(vaultPath) {
+  if (vaultPath) {
+    const vault = new ClawVault(path.resolve(vaultPath));
+    await vault.load();
+    return vault;
+  }
+  const envPath = process.env.CLAWVAULT_PATH;
+  if (envPath) {
+    const vault = new ClawVault(path.resolve(envPath));
+    await vault.load();
+    return vault;
+  }
+  const found = await findVault();
+  if (!found) {
+    throw new Error("No ClawVault found. Run `clawvault init` first.");
+  }
+  return found;
+}
+async function doctor(vaultPath) {
+  const checks = [];
+  let warnings = 0;
+  let errors = 0;
+  const compatReport = checkOpenClawCompatibility();
+  if (compatReport.errors > 0) {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "error",
+      detail: `${compatReport.errors} error(s), ${compatReport.warnings} warning(s)`,
+      hint: "Run `clawvault compat` for full compatibility diagnostics."
+    });
+    errors++;
+  } else if (compatReport.warnings > 0) {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "warn",
+      detail: `${compatReport.warnings} warning(s)`,
+      hint: "Run `clawvault compat` for full compatibility diagnostics."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "ok"
+    });
+  }
+  if (hasQmd()) {
+    checks.push({ label: "qmd installed", status: "ok" });
+  } else {
+    checks.push({
+      label: "qmd installed",
+      status: "error",
+      hint: "Install qmd to enable ClawVault commands."
+    });
+    errors++;
+  }
+  const shellConfigs = getShellConfigPaths(process.env.SHELL).filter(fs.existsSync);
+  if (hasClawvaultPathConfig(shellConfigs)) {
+    checks.push({
+      label: "CLAWVAULT_PATH in shell config",
+      status: "ok",
+      detail: shellConfigs.map((p) => path.basename(p)).join(", ")
+    });
+  } else {
+    checks.push({
+      label: "CLAWVAULT_PATH in shell config",
+      status: "warn",
+      hint: "Run `clawvault shell-init` and add it to your shell rc."
+    });
+    warnings++;
+  }
+  if (!hasQmd()) {
+    return { vaultPath, checks, warnings, errors };
+  }
+  let vault;
+  try {
+    vault = await resolveVault(vaultPath);
+    checks.push({ label: "vault found", status: "ok", detail: vault.getPath() });
+  } catch (err) {
+    checks.push({
+      label: "vault found",
+      status: "error",
+      detail: err?.message || "Unable to locate vault"
+    });
+    errors++;
+    return { vaultPath, checks, warnings, errors };
+  }
+  const stats = await vault.stats();
+  const documents = await vault.list();
+  const handoffs = await vault.list("handoffs");
+  const inbox = await vault.list("inbox");
+  const qmdCollection = vault.getQmdCollection();
+  if (qmdCollection) {
+    checks.push({ label: "qmd collection configured", status: "ok", detail: qmdCollection });
+  } else {
+    checks.push({
+      label: "qmd collection configured",
+      status: "warn",
+      hint: "Set qmd collection in .clawvault.json"
+    });
+    warnings++;
+  }
+  const latestDoc = documents.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime())[0];
+  const latestDocAge = latestDoc ? daysSince(latestDoc.modified) : null;
+  const graphIndex = loadMemoryGraphIndex(vault.getPath());
+  if (!graphIndex) {
+    checks.push({
+      label: "memory graph index",
+      status: "warn",
+      detail: "No graph index found",
+      hint: "Run `clawvault graph --refresh` to build .clawvault/graph-index.json."
+    });
+    warnings++;
+  } else {
+    const generatedAt = new Date(graphIndex.generatedAt);
+    const generatedAge = describeAge(generatedAt);
+    const latestDocIsNewer = latestDoc ? latestDoc.modified.getTime() > generatedAt.getTime() + 1e3 : false;
+    if (latestDocIsNewer) {
+      checks.push({
+        label: "memory graph index",
+        status: "warn",
+        detail: `Stale graph index (generated ${generatedAge} ago)`,
+        hint: "Run `clawvault graph --refresh` to resync index."
+      });
+      warnings++;
+    } else {
+      checks.push({
+        label: "memory graph index",
+        status: "ok",
+        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`
+      });
+    }
+  }
+  let lastHandoffAge = null;
+  if (handoffs.length === 0) {
+    checks.push({
+      label: "recent handoff",
+      status: "warn",
+      hint: "Run `clawvault sleep` at the end of sessions."
+    });
+    warnings++;
+  } else {
+    const latestHandoff = handoffs.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime())[0];
+    lastHandoffAge = daysSince(latestHandoff.modified);
+    const ageLabel = describeAge(latestHandoff.modified);
+    if (lastHandoffAge > 1) {
+      checks.push({
+        label: "recent handoff",
+        status: "warn",
+        detail: `Last handoff ${ageLabel} ago`,
+        hint: "Run `clawvault sleep` before long pauses."
+      });
+      warnings++;
+    } else {
+      checks.push({
+        label: "recent handoff",
+        status: "ok",
+        detail: `Last handoff ${ageLabel} ago`
+      });
+    }
+  }
+  const checkpointInfo = loadCheckpointTimestamp(vault.getPath());
+  const activeUse = latestDocAge !== null && latestDocAge <= ACTIVE_USE_DAYS || lastHandoffAge !== null && lastHandoffAge <= ACTIVE_USE_DAYS;
+  if (checkpointInfo.error) {
+    checks.push({
+      label: "checkpoint freshness",
+      status: "warn",
+      detail: checkpointInfo.error
+    });
+    warnings++;
+  } else if (!checkpointInfo.timestamp) {
+    const status = activeUse ? "warn" : "ok";
+    if (status === "warn") warnings++;
+    checks.push({
+      label: "checkpoint freshness",
+      status,
+      detail: activeUse ? "No checkpoint found" : "No checkpoint found (vault appears inactive)",
+      hint: activeUse ? "Run `clawvault checkpoint` during heavy work." : void 0
+    });
+  } else {
+    const checkpointDate = new Date(checkpointInfo.timestamp);
+    const checkpointAge = daysSince(checkpointDate);
+    const ageLabel = describeAge(checkpointDate);
+    if (activeUse && checkpointAge > 1) {
+      checks.push({
+        label: "checkpoint freshness",
+        status: "warn",
+        detail: `Last checkpoint ${ageLabel} ago`,
+        hint: "Checkpoint at least once per active day."
+      });
+      warnings++;
+    } else {
+      checks.push({
+        label: "checkpoint freshness",
+        status: "ok",
+        detail: `Last checkpoint ${ageLabel} ago`
+      });
+    }
+  }
+  const observerStaleness = getObserverStaleness(vault.getPath());
+  if (observerStaleness.staleCount > 0) {
+    checks.push({
+      label: "observer freshness",
+      status: "warn",
+      detail: `${observerStaleness.staleCount} stale session cursor(s); oldest ${formatAge(observerStaleness.oldestMs)} ago`,
+      hint: "Run `clawvault observe --cron` and verify cron/hook scheduling."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "observer freshness",
+      status: "ok"
+    });
+  }
+  const linkScan = scanVaultLinks(vault.getPath());
+  if (linkScan.orphans.length > 20) {
+    checks.push({
+      label: "orphan links",
+      status: "warn",
+      detail: `${linkScan.orphans.length} orphan link(s)`,
+      hint: "Run `clawvault link --orphans` to review."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "orphan links",
+      status: "ok",
+      detail: `${linkScan.orphans.length} orphan link(s)`
+    });
+  }
+  if (inbox.length > 5) {
+    checks.push({
+      label: "inbox backlog",
+      status: "warn",
+      detail: `${inbox.length} inbox item(s) pending`,
+      hint: "Process inbox items to keep memory tidy."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "inbox backlog",
+      status: "ok",
+      detail: `${inbox.length} inbox item(s) pending`
+    });
+  }
+  if (stats.documents < 5) {
+    checks.push({
+      label: "vault activity",
+      status: "warn",
+      detail: `${stats.documents} total documents`,
+      hint: "Start capturing decisions, lessons, and projects."
+    });
+    warnings++;
+  }
+  return { vaultPath: vault.getPath(), checks, warnings, errors };
+}
+
+export {
+  doctor
+};

package/dist/{chunk-6RQPD7X6.js → chunk-M25QVSJM.js}

@@ -1,6 +1,7 @@
 import {
-  hasQmd
-} from "./chunk-6B3JWM7J.js";
+  hasQmd,
+  withQmdIndexArgs
+} from "./chunk-O7XHXF7F.js";
 import {
   DEFAULT_CATEGORIES
 } from "./chunk-2CDEETQN.js";
@@ -337,7 +338,7 @@ async function setupCommand(options = {}) {
   if (hasQmd()) {
     const { collection, root } = getQmdConfig(target.vaultPath);
     try {
-      execFileSync("qmd", ["collection", "add", root, "--name", collection, "--mask", "**/*.md"], {
+      execFileSync("qmd", withQmdIndexArgs(["collection", "add", root, "--name", collection, "--mask", "**/*.md"], options.qmdIndexName), {
         stdio: "ignore"
       });
       console.log(`\u2713 qmd collection ready: ${collection}`);

package/dist/{chunk-6B3JWM7J.js → chunk-O7XHXF7F.js}

@@ -5,6 +5,7 @@ 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 QmdUnavailableError = class extends Error {
   constructor(message = QMD_NOT_INSTALLED_MESSAGE) {
     super(message);
@@ -14,6 +15,24 @@ var QmdUnavailableError = class extends Error {
 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);
@@ -64,9 +83,9 @@ function ensureQmdAvailable() {
     throw new QmdUnavailableError();
   }
 }
-function execQmd(args) {
+function execQmd(args, indexName) {
   ensureQmdAvailable();
-  const finalArgs = ensureJsonArgs(args);
+  const finalArgs = withQmdIndexArgs(ensureJsonArgs(args), indexName);
   try {
     const result = execFileSync("qmd", finalArgs, {
       encoding: "utf-8",
@@ -94,27 +113,28 @@ function hasQmd() {
   const result = spawnSync("qmd", ["--version"], { stdio: "ignore" });
   return !result.error;
 }
-function qmdUpdate(collection) {
+function qmdUpdate(collection, indexName) {
   ensureQmdAvailable();
   const args = ["update"];
   if (collection) {
     args.push("-c", collection);
   }
-  execFileSync("qmd", args, { stdio: "inherit" });
+  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
 }
-function qmdEmbed(collection) {
+function qmdEmbed(collection, indexName) {
   ensureQmdAvailable();
   const args = ["embed"];
   if (collection) {
     args.push("-c", collection);
   }
-  execFileSync("qmd", args, { stdio: "inherit" });
+  execFileSync("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
 }
 var SearchEngine = class {
   documents = /* @__PURE__ */ new Map();
   collection = "clawvault";
   vaultPath = "";
   collectionRoot = "";
+  qmdIndexName;
   /**
    * Set the collection name (usually vault name)
    */
@@ -133,6 +153,12 @@ var SearchEngine = class {
   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
@@ -189,7 +215,7 @@ var SearchEngine = class {
     if (this.collection) {
       args.push("-c", this.collection);
     }
-    const qmdResults = execQmd(args);
+    const qmdResults = execQmd(args, this.qmdIndexName);
     return this.convertResults(qmdResults, {
       limit,
       minScore,
@@ -339,6 +365,7 @@ export {
   QMD_INSTALL_URL,
   QMD_INSTALL_COMMAND,
   QmdUnavailableError,
+  withQmdIndexArgs,
   hasQmd,
   qmdUpdate,
   qmdEmbed,