clawvault 3.2.0 → 3.3.0

package/dist/chunk-GAOWA7GR.js

@@ -1,501 +0,0 @@
-import {
-  scanVaultLinks
-} from "./chunk-7YZWHM36.js";
-import {
-  formatAge
-} from "./chunk-7ZRP733D.js";
-import {
-  checkOpenClawCompatibility
-} from "./chunk-X3SPPUFG.js";
-import {
-  getObserverStaleness
-} from "./chunk-ESFLMDRB.js";
-import {
-  ClawVault,
-  findVault
-} from "./chunk-CLJTREDS.js";
-import {
-  listQmdCollections,
-  loadVaultQmdConfig
-} from "./chunk-6FH3IULF.js";
-import {
-  QMD_INSTALL_COMMAND,
-  QMD_INSTALL_URL,
-  hasQmd
-} from "./chunk-EK6S23ZB.js";
-import {
-  loadMemoryGraphIndex
-} from "./chunk-33DOSHTA.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;
-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));
-}
-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;
-}
-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));
-    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 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.",
-      category: "system"
-    });
-    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.",
-      category: "system"
-    });
-    warnings++;
-  } else {
-    checks.push({
-      label: "OpenClaw compatibility",
-      status: "ok",
-      category: "system"
-    });
-  }
-  if (hasQmd()) {
-    checks.push({ label: "qmd installed", status: "ok", category: "system" });
-  } else {
-    checks.push({
-      label: "qmd installed",
-      status: "error",
-      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++;
-  }
-  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(", "),
-      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.",
-      category: "system"
-    });
-    warnings++;
-  }
-  if (!hasQmd()) {
-    return { vaultPath, checks, warnings, errors, migrationIssues };
-  }
-  let vault;
-  try {
-    vault = await resolveVault(vaultPath);
-    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",
-      category: "system"
-    });
-    errors++;
-    return { vaultPath, checks, warnings, errors, migrationIssues };
-  }
-  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, category: "system" });
-  } else {
-    checks.push({
-      label: "qmd collection configured",
-      status: "warn",
-      hint: "Set qmd collection in .clawvault.json or run `clawvault migrate`.",
-      category: "system"
-    });
-    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.",
-      category: "health"
-    });
-    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.",
-        category: "health"
-      });
-      warnings++;
-    } else {
-      checks.push({
-        label: "memory graph index",
-        status: "ok",
-        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`,
-        category: "health"
-      });
-    }
-  }
-  let lastHandoffAge = null;
-  if (handoffs.length === 0) {
-    checks.push({
-      label: "recent handoff",
-      status: "warn",
-      hint: "Run `clawvault sleep` at the end of sessions.",
-      category: "health"
-    });
-    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.",
-        category: "health"
-      });
-      warnings++;
-    } else {
-      checks.push({
-        label: "recent handoff",
-        status: "ok",
-        detail: `Last handoff ${ageLabel} ago`,
-        category: "health"
-      });
-    }
-  }
-  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,
-      category: "health"
-    });
-    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,
-      category: "health"
-    });
-  } 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.",
-        category: "health"
-      });
-      warnings++;
-    } else {
-      checks.push({
-        label: "checkpoint freshness",
-        status: "ok",
-        detail: `Last checkpoint ${ageLabel} ago`,
-        category: "health"
-      });
-    }
-  }
-  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.",
-      category: "health"
-    });
-    warnings++;
-  } else {
-    checks.push({
-      label: "observer freshness",
-      status: "ok",
-      category: "health"
-    });
-  }
-  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.",
-      category: "health"
-    });
-    warnings++;
-  } else {
-    checks.push({
-      label: "orphan links",
-      status: "ok",
-      detail: `${linkScan.orphans.length} orphan link(s)`,
-      category: "health"
-    });
-  }
-  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.",
-      category: "health"
-    });
-    warnings++;
-  } else {
-    checks.push({
-      label: "inbox backlog",
-      status: "ok",
-      detail: `${inbox.length} inbox item(s) pending`,
-      category: "health"
-    });
-  }
-  if (stats.documents < 5) {
-    checks.push({
-      label: "vault activity",
-      status: "warn",
-      detail: `${stats.documents} total documents`,
-      hint: "Start capturing decisions, lessons, and projects.",
-      category: "health"
-    });
-    warnings++;
-  }
-  return { vaultPath: vault.getPath(), checks, warnings, errors, migrationIssues };
-}
-
-export {
-  doctor
-};