clawvault 3.1.0 → 3.2.1

package/dist/{chunk-H62BP7RI.js → chunk-QPDDIHXE.js}

@@ -6,20 +6,26 @@ import {
 } from "./chunk-4VQTUVH7.js";
 import {
   getObserverStaleness
-} from "./chunk-LNJA2UGL.js";
-import {
-  checkOpenClawCompatibility
-} from "./chunk-33UGEQRT.js";
+} from "./chunk-PI4WMLMG.js";
 import {
   ClawVault,
   findVault
-} from "./chunk-LI4O6NVK.js";
+} from "./chunk-YDWHS4LJ.js";
+import {
+  listQmdCollections,
+  loadVaultQmdConfig
+} from "./chunk-WIOLLGAD.js";
 import {
+  QMD_INSTALL_COMMAND,
+  QMD_INSTALL_URL,
   hasQmd
-} from "./chunk-D2H45LON.js";
+} from "./chunk-5PJ4STIC.js";
 import {
   loadMemoryGraphIndex
 } from "./chunk-ZZA73MFY.js";
+import {
+  checkOpenClawCompatibility
+} from "./chunk-X3SPPUFG.js";
 
 // src/commands/doctor.ts
 import * as fs from "fs";
@@ -29,6 +35,12 @@ var CLAWVAULT_DIR = ".clawvault";
 var CHECKPOINT_FILE = "last-checkpoint.json";
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var ACTIVE_USE_DAYS = 7;
+var V2_COLLECTION_PATTERNS = [
+  /^clawvault$/i,
+  /^vault$/i,
+  /^memory$/i,
+  /^notes$/i
+];
 function daysSince(date, now = Date.now()) {
   return Math.max(0, Math.floor((now - date.getTime()) / DAY_MS));
 }
@@ -51,7 +63,7 @@ function getShellConfigPaths(shellPath) {
   const home = os.homedir();
   const shellName = shellPath ? path.basename(shellPath) : "bash";
   if (shellName === "zsh") {
-    return [path.join(home, ".zshenv"), path.join(home, ".zshrc"), path.join(home, ".zprofile")];
+    return [path.join(home, ".zshrc"), path.join(home, ".zprofile")];
   }
   if (shellName === "fish") {
     return [path.join(home, ".config", "fish", "config.fish")];
@@ -71,6 +83,124 @@ function hasClawvaultPathConfig(paths) {
   }
   return false;
 }
+function isLikelyV2CollectionName(name) {
+  return V2_COLLECTION_PATTERNS.some((pattern) => pattern.test(name));
+}
+function checkQmdCollectionExists(collections, expectedName) {
+  const found = collections.find((c) => c.name === expectedName);
+  return { exists: !!found, collection: found };
+}
+function checkCollectionPathMatches(collection, expectedRoot) {
+  if (!collection.root) return false;
+  const normalizedCollectionRoot = path.resolve(collection.root);
+  const normalizedExpectedRoot = path.resolve(expectedRoot);
+  return normalizedCollectionRoot === normalizedExpectedRoot;
+}
+function detectMigrationIssues(vaultPath, configuredCollection, configuredRoot) {
+  const issues = [];
+  if (!hasQmd()) {
+    return issues;
+  }
+  let collections;
+  try {
+    collections = listQmdCollections();
+  } catch {
+    return issues;
+  }
+  const vaultConfig = loadVaultQmdConfig(vaultPath);
+  const expectedCollection = configuredCollection || vaultConfig.qmdCollection;
+  const expectedRoot = configuredRoot || vaultConfig.qmdRoot;
+  const { exists, collection } = checkQmdCollectionExists(collections, expectedCollection);
+  if (!exists) {
+    const potentialV2Collections = collections.filter(
+      (c) => isLikelyV2CollectionName(c.name) && c.root && path.resolve(c.root) === path.resolve(expectedRoot)
+    );
+    if (potentialV2Collections.length > 0) {
+      issues.push({
+        type: "stale_collection_name",
+        description: `Found v2-style collection "${potentialV2Collections[0].name}" that should be renamed to "${expectedCollection}"`,
+        autoFixable: true,
+        details: {
+          oldName: potentialV2Collections[0].name,
+          newName: expectedCollection,
+          root: potentialV2Collections[0].root
+        }
+      });
+    } else {
+      issues.push({
+        type: "missing_qmd_collection",
+        description: `qmd collection "${expectedCollection}" does not exist`,
+        autoFixable: true,
+        details: {
+          collectionName: expectedCollection,
+          expectedRoot
+        }
+      });
+    }
+  } else if (collection && !checkCollectionPathMatches(collection, expectedRoot)) {
+    issues.push({
+      type: "wrong_vault_path",
+      description: `Collection "${expectedCollection}" points to "${collection.root}" but vault is at "${expectedRoot}"`,
+      autoFixable: true,
+      details: {
+        collectionName: expectedCollection,
+        currentRoot: collection.root,
+        expectedRoot
+      }
+    });
+  }
+  const orphanedCollections = collections.filter((c) => {
+    if (c.name === expectedCollection) return false;
+    if (!c.root) return false;
+    const collectionRoot = path.resolve(c.root);
+    const vaultRoot = path.resolve(expectedRoot);
+    return collectionRoot === vaultRoot || collectionRoot.startsWith(vaultRoot + path.sep);
+  });
+  for (const orphan of orphanedCollections) {
+    issues.push({
+      type: "orphaned_collection",
+      description: `Orphaned collection "${orphan.name}" points to vault path but is not the configured collection`,
+      autoFixable: true,
+      details: {
+        collectionName: orphan.name,
+        root: orphan.root
+      }
+    });
+  }
+  const configPath = path.join(vaultPath, ".clawvault.json");
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      if (!config.qmdCollection || !config.qmdRoot) {
+        issues.push({
+          type: "missing_qmd_config",
+          description: "Vault config is missing qmdCollection or qmdRoot settings",
+          autoFixable: true,
+          details: {
+            hasQmdCollection: !!config.qmdCollection,
+            hasQmdRoot: !!config.qmdRoot
+          }
+        });
+      }
+    } catch {
+      issues.push({
+        type: "legacy_config_format",
+        description: "Unable to parse .clawvault.json - may need migration",
+        autoFixable: false
+      });
+    }
+  }
+  return issues;
+}
+function migrationIssuesToChecks(issues) {
+  return issues.map((issue) => ({
+    label: `migration: ${issue.type.replace(/_/g, " ")}`,
+    status: "warn",
+    detail: issue.description,
+    hint: issue.autoFixable ? "Run `clawvault migrate` to auto-fix this issue." : "Manual intervention required.",
+    category: "migration"
+  }));
+}
 async function resolveVault(vaultPath) {
   if (vaultPath) {
     const vault = new ClawVault(path.resolve(vaultPath));
@@ -89,19 +219,19 @@ async function resolveVault(vaultPath) {
   }
   return found;
 }
-async function doctor(options) {
-  const vaultPath = typeof options === "string" ? options : options?.vaultPath;
-  const _fix = typeof options === "object" ? options?.fix : false;
+async function doctor(vaultPath) {
   const checks = [];
   let warnings = 0;
   let errors = 0;
+  const migrationIssues = [];
   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."
+      hint: "Run `clawvault compat` for full compatibility diagnostics.",
+      category: "system"
     });
     errors++;
   } else if (compatReport.warnings > 0) {
@@ -109,22 +239,29 @@ async function doctor(options) {
       label: "OpenClaw compatibility",
       status: "warn",
       detail: `${compatReport.warnings} warning(s)`,
-      hint: "Run `clawvault compat` for full compatibility diagnostics."
+      hint: "Run `clawvault compat` for full compatibility diagnostics.",
+      category: "system"
     });
     warnings++;
   } else {
     checks.push({
       label: "OpenClaw compatibility",
-      status: "ok"
+      status: "ok",
+      category: "system"
     });
   }
   if (hasQmd()) {
-    checks.push({ label: "qmd installed", status: "ok" });
+    checks.push({ label: "qmd installed", status: "ok", category: "system" });
   } else {
     checks.push({
       label: "qmd installed",
       status: "error",
-      hint: "Install qmd to enable ClawVault commands."
+      detail: "qmd binary not found in PATH",
+      hint: `Install qmd to enable ClawVault search and indexing:
+  ${QMD_INSTALL_COMMAND}
+
+For more information: ${QMD_INSTALL_URL}`,
+      category: "system"
     });
     errors++;
   }
@@ -133,45 +270,57 @@ async function doctor(options) {
     checks.push({
       label: "CLAWVAULT_PATH in shell config",
       status: "ok",
-      detail: shellConfigs.map((p) => path.basename(p)).join(", ")
+      detail: shellConfigs.map((p) => path.basename(p)).join(", "),
+      category: "system"
     });
   } else {
     checks.push({
       label: "CLAWVAULT_PATH in shell config",
       status: "warn",
-      hint: "Run `clawvault shell-init` and add it to your shell rc."
+      hint: "Run `clawvault shell-init` and add it to your shell rc.",
+      category: "system"
     });
     warnings++;
   }
   if (!hasQmd()) {
-    return { vaultPath, checks, warnings, errors };
+    return { vaultPath, checks, warnings, errors, migrationIssues };
   }
   let vault;
   try {
     vault = await resolveVault(vaultPath);
-    checks.push({ label: "vault found", status: "ok", detail: vault.getPath() });
+    checks.push({ label: "vault found", status: "ok", detail: vault.getPath(), category: "system" });
   } catch (err) {
     checks.push({
       label: "vault found",
       status: "error",
-      detail: err?.message || "Unable to locate vault"
+      detail: err?.message || "Unable to locate vault",
+      category: "system"
     });
     errors++;
-    return { vaultPath, checks, warnings, errors };
+    return { vaultPath, checks, warnings, errors, migrationIssues };
   }
-  const qmdCollection = vault.getQmdCollection();
-  const qmdRoot = vault.getQmdRoot();
+  const detectedMigrationIssues = detectMigrationIssues(
+    vault.getPath(),
+    vault.getQmdCollection(),
+    vault.getQmdRoot()
+  );
+  migrationIssues.push(...detectedMigrationIssues);
+  const migrationChecks = migrationIssuesToChecks(detectedMigrationIssues);
+  checks.push(...migrationChecks);
+  warnings += migrationChecks.length;
   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 });
+    checks.push({ label: "qmd collection configured", status: "ok", detail: qmdCollection, category: "system" });
   } else {
     checks.push({
       label: "qmd collection configured",
       status: "warn",
-      hint: "Set qmd collection in .clawvault.json"
+      hint: "Set qmd collection in .clawvault.json or run `clawvault migrate`.",
+      category: "system"
     });
     warnings++;
   }
@@ -183,7 +332,8 @@ async function doctor(options) {
       label: "memory graph index",
       status: "warn",
       detail: "No graph index found",
-      hint: "Run `clawvault graph --refresh` to build .clawvault/graph-index.json."
+      hint: "Run `clawvault graph --refresh` to build .clawvault/graph-index.json.",
+      category: "health"
     });
     warnings++;
   } else {
@@ -195,14 +345,16 @@ async function doctor(options) {
         label: "memory graph index",
         status: "warn",
         detail: `Stale graph index (generated ${generatedAge} ago)`,
-        hint: "Run `clawvault graph --refresh` to resync index."
+        hint: "Run `clawvault graph --refresh` to resync index.",
+        category: "health"
       });
       warnings++;
     } else {
       checks.push({
         label: "memory graph index",
         status: "ok",
-        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`
+        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`,
+        category: "health"
       });
     }
   }
@@ -211,7 +363,8 @@ async function doctor(options) {
     checks.push({
       label: "recent handoff",
       status: "warn",
-      hint: "Run `clawvault sleep` at the end of sessions."
+      hint: "Run `clawvault sleep` at the end of sessions.",
+      category: "health"
     });
     warnings++;
   } else {
@@ -223,14 +376,16 @@ async function doctor(options) {
         label: "recent handoff",
         status: "warn",
         detail: `Last handoff ${ageLabel} ago`,
-        hint: "Run `clawvault sleep` before long pauses."
+        hint: "Run `clawvault sleep` before long pauses.",
+        category: "health"
       });
       warnings++;
     } else {
       checks.push({
         label: "recent handoff",
         status: "ok",
-        detail: `Last handoff ${ageLabel} ago`
+        detail: `Last handoff ${ageLabel} ago`,
+        category: "health"
       });
     }
   }
@@ -240,7 +395,8 @@ async function doctor(options) {
     checks.push({
       label: "checkpoint freshness",
       status: "warn",
-      detail: checkpointInfo.error
+      detail: checkpointInfo.error,
+      category: "health"
     });
     warnings++;
   } else if (!checkpointInfo.timestamp) {
@@ -250,7 +406,8 @@ async function doctor(options) {
       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
+      hint: activeUse ? "Run `clawvault checkpoint` during heavy work." : void 0,
+      category: "health"
     });
   } else {
     const checkpointDate = new Date(checkpointInfo.timestamp);
@@ -261,14 +418,16 @@ async function doctor(options) {
         label: "checkpoint freshness",
         status: "warn",
         detail: `Last checkpoint ${ageLabel} ago`,
-        hint: "Checkpoint at least once per active day."
+        hint: "Checkpoint at least once per active day.",
+        category: "health"
       });
       warnings++;
     } else {
       checks.push({
         label: "checkpoint freshness",
         status: "ok",
-        detail: `Last checkpoint ${ageLabel} ago`
+        detail: `Last checkpoint ${ageLabel} ago`,
+        category: "health"
       });
     }
   }
@@ -278,13 +437,15 @@ async function doctor(options) {
       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."
+      hint: "Run `clawvault observe --cron` and verify cron/hook scheduling.",
+      category: "health"
     });
     warnings++;
   } else {
     checks.push({
       label: "observer freshness",
-      status: "ok"
+      status: "ok",
+      category: "health"
     });
   }
   const linkScan = scanVaultLinks(vault.getPath());
@@ -293,14 +454,16 @@ async function doctor(options) {
       label: "orphan links",
       status: "warn",
       detail: `${linkScan.orphans.length} orphan link(s)`,
-      hint: "Run `clawvault link --orphans` to review."
+      hint: "Run `clawvault link --orphans` to review.",
+      category: "health"
     });
     warnings++;
   } else {
     checks.push({
       label: "orphan links",
       status: "ok",
-      detail: `${linkScan.orphans.length} orphan link(s)`
+      detail: `${linkScan.orphans.length} orphan link(s)`,
+      category: "health"
     });
   }
   if (inbox.length > 5) {
@@ -308,14 +471,16 @@ async function doctor(options) {
       label: "inbox backlog",
       status: "warn",
       detail: `${inbox.length} inbox item(s) pending`,
-      hint: "Process inbox items to keep memory tidy."
+      hint: "Process inbox items to keep memory tidy.",
+      category: "health"
     });
     warnings++;
   } else {
     checks.push({
       label: "inbox backlog",
       status: "ok",
-      detail: `${inbox.length} inbox item(s) pending`
+      detail: `${inbox.length} inbox item(s) pending`,
+      category: "health"
     });
   }
   if (stats.documents < 5) {
@@ -323,11 +488,12 @@ async function doctor(options) {
       label: "vault activity",
       status: "warn",
       detail: `${stats.documents} total documents`,
-      hint: "Start capturing decisions, lessons, and projects."
+      hint: "Start capturing decisions, lessons, and projects.",
+      category: "health"
     });
     warnings++;
   }
-  return { vaultPath: vault.getPath(), qmdCollection, qmdRoot, checks, warnings, errors };
+  return { vaultPath: vault.getPath(), checks, warnings, errors, migrationIssues };
 }
 
 export {

package/dist/{chunk-N2AXRYLC.js → chunk-QWQ3TIKS.js}

@@ -1,7 +1,7 @@
 import {
   loadSchemaTemplateDefinition,
   renderDocumentFromTemplate
-} from "./chunk-LYHGEHXG.js";
+} from "./chunk-MFAWT5O5.js";
 
 // src/lib/task-utils.ts
 import * as fs2 from "fs";

package/dist/{chunk-3DHXQHYG.js → chunk-R2MIW5G7.js}

@@ -8,7 +8,7 @@ import {
   queryTransitions,
   readTask,
   updateTask
-} from "./chunk-N2AXRYLC.js";
+} from "./chunk-QWQ3TIKS.js";
 
 // src/commands/task.ts
 function taskAdd(vaultPath, title, options = {}) {

package/dist/{chunk-SJSFRIYS.js → chunk-S5OJEGFG.js}

@@ -1,9 +1,9 @@
 import {
   runReflection
-} from "./chunk-H34S76MB.js";
+} from "./chunk-MNPUYCHQ.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/reflect.ts
 function parsePositiveInteger(raw, label) {

package/dist/chunk-SS4B7P7V.js

@@ -0,0 +1,99 @@
+import {
+  resolveVaultPath
+} from "./chunk-GNJL4YGR.js";
+
+// src/commands/sync-bd.ts
+import * as fs from "fs";
+import * as path from "path";
+import { spawnSync } from "child_process";
+function hasBdBinary() {
+  const probe = spawnSync("bd", ["--version"], { stdio: "ignore" });
+  return !probe.error;
+}
+function parseBdTasksFromJson(raw) {
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  return parsed.map((entry) => {
+    if (!entry || typeof entry !== "object") return null;
+    const record = entry;
+    const title = typeof record.title === "string" ? record.title.trim() : typeof record.name === "string" ? record.name.trim() : "";
+    const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : void 0;
+    if (!title) return null;
+    return status ? { title, status } : { title };
+  }).filter((entry) => entry !== null);
+}
+function loadActiveBdTasks() {
+  const jsonAttempt = spawnSync("bd", ["list", "--json"], { encoding: "utf-8" });
+  if (!jsonAttempt.error && typeof jsonAttempt.stdout === "string" && jsonAttempt.stdout.trim()) {
+    const tasks = parseBdTasksFromJson(jsonAttempt.stdout);
+    if (tasks.length > 0) {
+      return tasks.filter((task) => task.status !== "done" && task.status !== "completed" && task.status !== "closed");
+    }
+  }
+  const textAttempt = spawnSync("bd", ["list"], { encoding: "utf-8" });
+  if (textAttempt.error || typeof textAttempt.stdout !== "string") {
+    return [];
+  }
+  return textAttempt.stdout.split(/\r?\n/).map((line) => line.replace(/^\s*[-*]\s*/, "").trim()).filter(Boolean).map((title) => ({ title }));
+}
+function upsertSection(markdown, heading, bulletLines) {
+  const lines = markdown.split(/\r?\n/);
+  const headingIndex = lines.findIndex((line) => line.trim() === heading);
+  const sectionContent = [heading, ...bulletLines];
+  if (headingIndex === -1) {
+    const prefix = markdown.trim() ? `${markdown.trim()}
+
+` : "";
+    return `${prefix}${sectionContent.join("\n")}
+`;
+  }
+  let sectionEnd = lines.length;
+  for (let index = headingIndex + 1; index < lines.length; index += 1) {
+    if (lines[index].startsWith("## ")) {
+      sectionEnd = index;
+      break;
+    }
+  }
+  const updated = [
+    ...lines.slice(0, headingIndex),
+    ...sectionContent,
+    ...lines.slice(sectionEnd)
+  ];
+  return `${updated.join("\n").trim()}
+`;
+}
+async function syncBdCommand(options) {
+  if (!hasBdBinary()) {
+    console.log("bd binary not found; skipping sync-bd.");
+    return;
+  }
+  const tasks = loadActiveBdTasks();
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const nowViewPath = path.join(vaultPath, "views", "now.md");
+  const heading = "## Active Tasks (from bd)";
+  const bulletLines = tasks.length > 0 ? tasks.map((task) => `- ${task.title}`) : ["- No active bd tasks."];
+  const existing = fs.existsSync(nowViewPath) ? fs.readFileSync(nowViewPath, "utf-8") : "# Now\n";
+  const next = upsertSection(existing, heading, bulletLines);
+  if (options.dryRun) {
+    console.log(`Dry run: would sync ${tasks.length} active bd task(s) to views/now.md.`);
+    return;
+  }
+  fs.mkdirSync(path.dirname(nowViewPath), { recursive: true });
+  fs.writeFileSync(nowViewPath, next, "utf-8");
+  console.log(`Synced ${tasks.length} active bd task(s) to views/now.md.`);
+}
+function registerSyncBdCommand(program) {
+  program.command("sync-bd").description("Sync active bd tasks into views/now.md").option("--dry-run", "Show task sync output without writing").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await syncBdCommand({
+      vaultPath: rawOptions.vault,
+      dryRun: rawOptions.dryRun
+    });
+  });
+}
+
+export {
+  syncBdCommand,
+  registerSyncBdCommand
+};