clawvault 3.2.1 → 3.4.0

package/dist/chunk-QPDDIHXE.js

@@ -1,501 +0,0 @@
-import {
-  formatAge
-} from "./chunk-7ZRP733D.js";
-import {
-  scanVaultLinks
-} from "./chunk-4VQTUVH7.js";
-import {
-  getObserverStaleness
-} from "./chunk-PI4WMLMG.js";
-import {
-  ClawVault,
-  findVault
-} from "./chunk-YDWHS4LJ.js";
-import {
-  listQmdCollections,
-  loadVaultQmdConfig
-} from "./chunk-WIOLLGAD.js";
-import {
-  QMD_INSTALL_COMMAND,
-  QMD_INSTALL_URL,
-  hasQmd
-} 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";
-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
-};

package/dist/chunk-WIOLLGAD.js

@@ -1,190 +0,0 @@
-// src/lib/qmd-collections.ts
-import { execFileSync } from "child_process";
-var COLLECTION_HEADER_RE = /^(\S+)\s+\(qmd:\/\/([^)]+)\)\s*$/;
-var DETAIL_LINE_RE = /^\s+([A-Za-z][A-Za-z0-9 _-]*):\s*(.+)\s*$/;
-function normalizeDetailKey(value) {
-  return value.trim().toLowerCase().replace(/[ -]+/g, "_");
-}
-function parseCount(raw) {
-  if (!raw) return void 0;
-  const match = raw.match(/-?\d[\d,]*/);
-  if (!match) return void 0;
-  const parsed = Number.parseInt(match[0].replace(/,/g, ""), 10);
-  return Number.isFinite(parsed) ? parsed : void 0;
-}
-function pickDetail(details, keys) {
-  for (const key of keys) {
-    const value = details[key];
-    if (typeof value === "string" && value.trim()) {
-      return value.trim();
-    }
-  }
-  return void 0;
-}
-function pickCount(details, keys) {
-  for (const key of keys) {
-    const parsed = parseCount(details[key]);
-    if (parsed !== void 0) {
-      return parsed;
-    }
-  }
-  return void 0;
-}
-function parseQmdCollectionList(raw) {
-  const collections = [];
-  let current = null;
-  for (const line of raw.split(/\r?\n/)) {
-    const headerMatch = line.match(COLLECTION_HEADER_RE);
-    if (headerMatch) {
-      current = {
-        name: headerMatch[1],
-        uri: headerMatch[2],
-        details: {}
-      };
-      collections.push(current);
-      continue;
-    }
-    if (!current) continue;
-    const detailMatch = line.match(DETAIL_LINE_RE);
-    if (!detailMatch) continue;
-    const key = normalizeDetailKey(detailMatch[1]);
-    current.details[key] = detailMatch[2].trim();
-  }
-  for (const collection of collections) {
-    const root = pickDetail(collection.details, ["root", "path", "directory"]);
-    if (root) {
-      collection.root = root;
-    }
-    collection.files = pickCount(collection.details, ["files", "documents", "docs"]);
-    collection.vectors = pickCount(collection.details, ["vectors", "embeddings", "vector_embeddings"]);
-    collection.pendingEmbeddings = pickCount(collection.details, [
-      "pending",
-      "pending_vectors",
-      "pending_embeddings",
-      "unembedded",
-      "without_embeddings"
-    ]);
-    if (collection.pendingEmbeddings === void 0 && collection.files !== void 0 && collection.vectors !== void 0) {
-      collection.pendingEmbeddings = Math.max(collection.files - collection.vectors, 0);
-    }
-  }
-  return collections;
-}
-function listQmdCollections() {
-  const output = execFileSync("qmd", ["collection", "list"], {
-    encoding: "utf-8"
-  });
-  return parseQmdCollectionList(output);
-}
-function removeQmdCollection(name) {
-  try {
-    execFileSync("qmd", ["collection", "remove", name], { stdio: "ignore" });
-    return;
-  } catch {
-    execFileSync("qmd", ["collection", "rm", name], { stdio: "ignore" });
-  }
-}
-function collectionExists(name) {
-  try {
-    const collections = listQmdCollections();
-    return collections.some((c) => c.name === name);
-  } catch {
-    return false;
-  }
-}
-function findCollectionByRoot(rootPath) {
-  try {
-    const collections = listQmdCollections();
-    const normalizedRoot = rootPath.replace(/\/$/, "");
-    return collections.find((c) => {
-      if (!c.root) return false;
-      const normalizedCollectionRoot = c.root.replace(/\/$/, "");
-      return normalizedCollectionRoot === normalizedRoot;
-    });
-  } catch {
-    return void 0;
-  }
-}
-function getFirstCollection() {
-  try {
-    const collections = listQmdCollections();
-    return collections[0];
-  } catch {
-    return void 0;
-  }
-}
-
-// src/lib/vault-qmd-config.ts
-import * as fs from "fs";
-import * as path from "path";
-var CONFIG_FILE = ".clawvault.json";
-function readTrimmedString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function autoDetectCollection(vaultPath, fallbackName) {
-  const byRoot = findCollectionByRoot(vaultPath);
-  if (byRoot) {
-    return { collection: byRoot.name, autoDetected: true };
-  }
-  if (collectionExists(fallbackName)) {
-    return { collection: fallbackName, autoDetected: false };
-  }
-  const first = getFirstCollection();
-  if (first) {
-    return { collection: first.name, autoDetected: true };
-  }
-  return { collection: fallbackName, autoDetected: false };
-}
-function loadVaultQmdConfig(vaultPath) {
-  const resolvedVaultPath = path.resolve(vaultPath);
-  const fallbackName = path.basename(resolvedVaultPath);
-  const fallbackRoot = resolvedVaultPath;
-  const configPath = path.join(resolvedVaultPath, CONFIG_FILE);
-  if (!fs.existsSync(configPath)) {
-    const { collection, autoDetected } = autoDetectCollection(resolvedVaultPath, fallbackName);
-    return {
-      vaultPath: resolvedVaultPath,
-      qmdCollection: collection,
-      qmdRoot: fallbackRoot,
-      autoDetected
-    };
-  }
-  try {
-    const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    const configuredName = readTrimmedString(raw.name) ?? fallbackName;
-    const configuredCollection = readTrimmedString(raw.qmdCollection);
-    const rawRoot = readTrimmedString(raw.qmdRoot) ?? fallbackRoot;
-    const qmdRoot = path.isAbsolute(rawRoot) ? path.resolve(rawRoot) : path.resolve(resolvedVaultPath, rawRoot);
-    if (configuredCollection && collectionExists(configuredCollection)) {
-      return {
-        vaultPath: resolvedVaultPath,
-        qmdCollection: configuredCollection,
-        qmdRoot
-      };
-    }
-    const { collection, autoDetected } = autoDetectCollection(qmdRoot, configuredCollection ?? configuredName);
-    return {
-      vaultPath: resolvedVaultPath,
-      qmdCollection: collection,
-      qmdRoot,
-      autoDetected
-    };
-  } catch {
-    const { collection, autoDetected } = autoDetectCollection(resolvedVaultPath, fallbackName);
-    return {
-      vaultPath: resolvedVaultPath,
-      qmdCollection: collection,
-      qmdRoot: fallbackRoot,
-      autoDetected
-    };
-  }
-}
-
-export {
-  parseQmdCollectionList,
-  listQmdCollections,
-  removeQmdCollection,
-  loadVaultQmdConfig
-};

package/dist/chunk-WMGIIABP.js

@@ -1,15 +0,0 @@
-// src/workgraph/types.ts
-var THREAD_STATUS_TRANSITIONS = {
-  open: ["active", "cancelled"],
-  active: ["blocked", "done", "cancelled", "open"],
-  // open = release
-  blocked: ["active", "cancelled"],
-  done: [],
-  // terminal
-  cancelled: ["open"]
-  // can be reopened
-};
-
-export {
-  THREAD_STATUS_TRANSITIONS
-};