clawvault 3.1.0 → 3.2.0

package/dist/{chunk-WAZ3NLWL.js → chunk-F55HGNU4.js}

@@ -7,8 +7,6 @@ var CHECKPOINT_FILE = "last-checkpoint.json";
 var SESSION_STATE_FILE = "session-state.json";
 var DIRTY_DEATH_FLAG = "dirty-death.flag";
 var CHECKPOINT_HISTORY_DIR = "checkpoints";
-var CHECKPOINT_RETENTION_MAX_COUNT = 50;
-var CHECKPOINT_RETENTION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var pendingCheckpoint = null;
 var pendingData = null;
 function ensureClawvaultDir(vaultPath) {
@@ -18,50 +16,6 @@ function ensureClawvaultDir(vaultPath) {
   }
   return dir;
 }
-function readCheckpointHistoryEntries(historyDir) {
-  const entries = [];
-  const files = fs.readdirSync(historyDir).filter((entry) => entry.endsWith(".json"));
-  for (const fileName of files) {
-    const filePath = path.join(historyDir, fileName);
-    try {
-      const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        continue;
-      }
-      const timestamp = typeof parsed.timestamp === "string" ? parsed.timestamp : "";
-      const timestampMs = Date.parse(timestamp);
-      if (Number.isNaN(timestampMs)) {
-        continue;
-      }
-      entries.push({ filePath, timestampMs });
-    } catch {
-    }
-  }
-  return entries.sort((left, right) => {
-    if (right.timestampMs !== left.timestampMs) {
-      return right.timestampMs - left.timestampMs;
-    }
-    return right.filePath.localeCompare(left.filePath);
-  });
-}
-function pruneCheckpointHistory(historyDir, nowMs) {
-  if (!fs.existsSync(historyDir)) {
-    return;
-  }
-  const entries = readCheckpointHistoryEntries(historyDir);
-  if (entries.length <= CHECKPOINT_RETENTION_MAX_COUNT) {
-    return;
-  }
-  for (let index = CHECKPOINT_RETENTION_MAX_COUNT; index < entries.length; index += 1) {
-    const ageMs = nowMs - entries[index].timestampMs;
-    if (ageMs > CHECKPOINT_RETENTION_MAX_AGE_MS) {
-      try {
-        fs.unlinkSync(entries[index].filePath);
-      } catch {
-      }
-    }
-  }
-}
 function writeCheckpointToDisk(dir, data) {
   const checkpointPath = path.join(dir, CHECKPOINT_FILE);
   fs.writeFileSync(checkpointPath, JSON.stringify(data, null, 2));
@@ -70,7 +24,6 @@ function writeCheckpointToDisk(dir, data) {
   const historyFileName = `${data.timestamp.replace(/[:.]/g, "-")}.json`;
   const historyPath = path.join(historyDir, historyFileName);
   fs.writeFileSync(historyPath, JSON.stringify(data, null, 2));
-  pruneCheckpointHistory(historyDir, Date.now());
   const flagPath = path.join(dir, DIRTY_DEATH_FLAG);
   fs.writeFileSync(flagPath, data.timestamp);
 }

package/dist/{chunk-QK3UCXWL.js → chunk-FHFUXL6G.js}

@@ -3,7 +3,7 @@ var DATE_HEADING_RE = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
 var SCORED_LINE_RE = /^(?:-\s*)?\[(decision|preference|fact|commitment|task|todo|commitment-unresolved|milestone|lesson|relationship|project)\|c=(0(?:\.\d+)?|1(?:\.0+)?)\|i=(0(?:\.\d+)?|1(?:\.0+)?)\]\s+(.+)$/i;
 var EMOJI_LINE_RE = /^(?:-\s*)?(🔴|🟡|🟢)\s+(\d{2}:\d{2})?\s*(.+)$/u;
 var DECISION_RE = /\b(decis(?:ion|ions)?|decid(?:e|ed|ing)|chose|selected|opted|went with|picked)\b/i;
-var PREFERENCE_RE = /\b(prefer(?:ence|s|red)?|likes?|dislikes?|default to|always use|never use|enjoys?|loves?|favou?rite|fan of|interested in|go-to|tend(?:s)? to use|passionate about|hobby|hobbies|(?:I|my|our)\s+(?:own|have|use|got|bought|drive|wear|eat|drink|cook|play|watch|read|listen)|(?:I(?:'m| am))\s+(?:a |an |into |allergic|vegetarian|vegan|gluten|lactose|trying to|learning)|usually|every (?:morning|evening|night|day|week)|routine)\b/i;
+var PREFERENCE_RE = /\b(prefer(?:ence|s|red)?|likes?|dislikes?|default to|always use|never use)\b/i;
 var COMMITMENT_RE = /\b(commit(?:ment|ted)?|promised|deadline|due|scheduled|will deliver|agreed to)\b/i;
 var TODO_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bremember to\b|\bmake sure to\b)/i;
 var COMMITMENT_TASK_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
@@ -33,10 +33,10 @@ function inferObservationType(content) {
   if (DECISION_RE.test(content)) return "decision";
   if (UNRESOLVED_RE.test(content)) return "commitment-unresolved";
   if (TODO_RE.test(content)) return "todo";
-  if (PREFERENCE_RE.test(content)) return "preference";
   if (COMMITMENT_TASK_RE.test(content) || DEADLINE_RE.test(content)) return "task";
   if (COMMITMENT_RE.test(content)) return "commitment";
   if (MILESTONE_RE.test(content)) return "milestone";
+  if (PREFERENCE_RE.test(content)) return "preference";
   if (LESSON_RE.test(content)) return "lesson";
   if (RELATIONSHIP_RE.test(content)) return "relationship";
   if (PROJECT_RE.test(content)) return "project";

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

@@ -1,25 +1,31 @@
+import {
+  scanVaultLinks
+} from "./chunk-7YZWHM36.js";
 import {
   formatAge
 } from "./chunk-7ZRP733D.js";
 import {
-  scanVaultLinks
-} from "./chunk-4VQTUVH7.js";
+  checkOpenClawCompatibility
+} from "./chunk-X3SPPUFG.js";
 import {
   getObserverStaleness
-} from "./chunk-LNJA2UGL.js";
-import {
-  checkOpenClawCompatibility
-} from "./chunk-33UGEQRT.js";
+} from "./chunk-ESFLMDRB.js";
 import {
   ClawVault,
   findVault
-} from "./chunk-LI4O6NVK.js";
+} from "./chunk-CLJTREDS.js";
 import {
+  listQmdCollections,
+  loadVaultQmdConfig
+} from "./chunk-6FH3IULF.js";
+import {
+  QMD_INSTALL_COMMAND,
+  QMD_INSTALL_URL,
   hasQmd
-} from "./chunk-D2H45LON.js";
+} from "./chunk-EK6S23ZB.js";
 import {
   loadMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.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 {