clawvault 2.6.0 → 3.0.0

package/dist/commands/rebuild.d.cts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+
+interface RebuildCommandOptions {
+    vaultPath?: string;
+    from?: string;
+    to?: string;
+}
+declare function rebuildCommand(options: RebuildCommandOptions): Promise<void>;
+declare function registerRebuildCommand(program: Command): void;
+
+export { type RebuildCommandOptions, rebuildCommand, registerRebuildCommand };

package/dist/commands/rebuild.js

@@ -1,17 +1,19 @@
 import {
   rebuildCommand,
   registerRebuildCommand
-} from "../chunk-PBEE567J.js";
-import "../chunk-Q2J5YTUF.js";
-import "../chunk-AZYOKJYC.js";
-import "../chunk-FHFUXL6G.js";
+} from "../chunk-VGLOTGAS.js";
+import "../chunk-3NSBOUT3.js";
+import "../chunk-62YTUT6J.js";
 import "../chunk-ITPEXLHA.js";
-import "../chunk-2CDEETQN.js";
+import "../chunk-PAH27GSN.js";
 import "../chunk-MXSSG3QU.js";
-import "../chunk-Z2XBWN7A.js";
-import "../chunk-QWQ3TIKS.js";
-import "../chunk-MFAWT5O5.js";
+import "../chunk-N2AXRYLC.js";
+import "../chunk-LYHGEHXG.js";
 import "../chunk-7766SIJP.js";
+import "../chunk-2CDEETQN.js";
+import "../chunk-QK3UCXWL.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   rebuildCommand,
   registerRebuildCommand

package/dist/commands/recover.cjs

@@ -0,0 +1,361 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/recover.ts
+var recover_exports = {};
+__export(recover_exports, {
+  checkRecoveryStatus: () => checkRecoveryStatus,
+  formatCheckpointList: () => formatCheckpointList,
+  formatRecoveryCheckStatus: () => formatRecoveryCheckStatus,
+  formatRecoveryInfo: () => formatRecoveryInfo,
+  listCheckpoints: () => listCheckpoints,
+  recover: () => recover
+});
+module.exports = __toCommonJS(recover_exports);
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// src/commands/checkpoint.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var CLAWVAULT_DIR = ".clawvault";
+var CHECKPOINT_FILE = "last-checkpoint.json";
+var DIRTY_DEATH_FLAG = "dirty-death.flag";
+var CHECKPOINT_RETENTION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+async function clearDirtyFlag(vaultPath) {
+  const flagPath = path.join(vaultPath, CLAWVAULT_DIR, DIRTY_DEATH_FLAG);
+  if (fs.existsSync(flagPath)) {
+    fs.unlinkSync(flagPath);
+  }
+}
+async function checkDirtyDeath(vaultPath) {
+  const dir = path.join(vaultPath, CLAWVAULT_DIR);
+  const flagPath = path.join(dir, DIRTY_DEATH_FLAG);
+  const checkpointPath = path.join(dir, CHECKPOINT_FILE);
+  if (!fs.existsSync(flagPath)) {
+    return { died: false, checkpoint: null, deathTime: null };
+  }
+  const deathTime = fs.readFileSync(flagPath, "utf-8").trim();
+  let checkpoint = null;
+  if (fs.existsSync(checkpointPath)) {
+    try {
+      checkpoint = JSON.parse(fs.readFileSync(checkpointPath, "utf-8"));
+    } catch {
+    }
+  }
+  return { died: true, checkpoint, deathTime };
+}
+
+// src/lib/time.ts
+function formatAge(ms) {
+  if (!Number.isFinite(ms)) return "unknown";
+  const seconds = Math.max(0, Math.floor(ms / 1e3));
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+// src/commands/recover.ts
+var CLAWVAULT_DIR2 = ".clawvault";
+var CHECKPOINT_FILE2 = "last-checkpoint.json";
+var CHECKPOINT_HISTORY_DIR = "checkpoints";
+function parseCheckpointFile(filePath) {
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const record = parsed;
+    const timestamp = typeof record.timestamp === "string" ? record.timestamp.trim() : "";
+    if (!timestamp) {
+      return null;
+    }
+    const checkpoint = {
+      timestamp,
+      workingOn: typeof record.workingOn === "string" ? record.workingOn : null,
+      focus: typeof record.focus === "string" ? record.focus : null,
+      blocked: typeof record.blocked === "string" ? record.blocked : null
+    };
+    if (typeof record.sessionId === "string") {
+      checkpoint.sessionId = record.sessionId;
+    }
+    if (typeof record.sessionKey === "string") {
+      checkpoint.sessionKey = record.sessionKey;
+    }
+    if (typeof record.model === "string") {
+      checkpoint.model = record.model;
+    }
+    if (typeof record.tokenEstimate === "number" && Number.isFinite(record.tokenEstimate)) {
+      checkpoint.tokenEstimate = record.tokenEstimate;
+    }
+    if (typeof record.sessionStartedAt === "string") {
+      checkpoint.sessionStartedAt = record.sessionStartedAt;
+    }
+    if (typeof record.urgent === "boolean") {
+      checkpoint.urgent = record.urgent;
+    }
+    return checkpoint;
+  } catch {
+    return null;
+  }
+}
+function compareByTimestampDesc(left, right) {
+  const leftTime = Date.parse(left.timestamp);
+  const rightTime = Date.parse(right.timestamp);
+  if (!Number.isNaN(leftTime) && !Number.isNaN(rightTime)) {
+    return rightTime - leftTime;
+  }
+  return right.timestamp.localeCompare(left.timestamp);
+}
+async function checkRecoveryStatus(vaultPath) {
+  const { died, checkpoint, deathTime } = await checkDirtyDeath(vaultPath);
+  return { died, checkpoint, deathTime };
+}
+function listCheckpoints(vaultPath) {
+  const resolvedVaultPath = path2.resolve(vaultPath);
+  const clawvaultDir = path2.join(resolvedVaultPath, CLAWVAULT_DIR2);
+  const historyDir = path2.join(clawvaultDir, CHECKPOINT_HISTORY_DIR);
+  const checkpoints = [];
+  if (fs2.existsSync(historyDir)) {
+    const files = fs2.readdirSync(historyDir).filter((entry) => entry.endsWith(".json")).sort().reverse();
+    for (const fileName of files) {
+      const absolutePath = path2.join(historyDir, fileName);
+      const parsed = parseCheckpointFile(absolutePath);
+      if (!parsed) {
+        continue;
+      }
+      checkpoints.push({
+        ...parsed,
+        filePath: absolutePath
+      });
+    }
+  }
+  if (checkpoints.length === 0) {
+    const latestCheckpointPath = path2.join(clawvaultDir, CHECKPOINT_FILE2);
+    if (fs2.existsSync(latestCheckpointPath)) {
+      const fallback = parseCheckpointFile(latestCheckpointPath);
+      if (fallback) {
+        checkpoints.push({
+          ...fallback,
+          filePath: latestCheckpointPath
+        });
+      }
+    }
+  }
+  return checkpoints.sort(compareByTimestampDesc);
+}
+async function recover(vaultPath, options = {}) {
+  const { clearFlag = false } = options;
+  const { died, checkpoint, deathTime } = await checkRecoveryStatus(vaultPath);
+  if (!died) {
+    return {
+      died: false,
+      deathTime: null,
+      checkpoint: null,
+      handoffPath: null,
+      handoffContent: null,
+      recoveryMessage: "No context death detected. Clean startup."
+    };
+  }
+  const handoffsDir = path2.join(vaultPath, "handoffs");
+  let handoffPath = null;
+  let handoffContent = null;
+  if (fs2.existsSync(handoffsDir)) {
+    const files = fs2.readdirSync(handoffsDir).filter((f) => f.startsWith("handoff-") && f.endsWith(".md")).sort().reverse();
+    if (files.length > 0) {
+      handoffPath = path2.join(handoffsDir, files[0]);
+      handoffContent = fs2.readFileSync(handoffPath, "utf-8");
+    }
+  }
+  let message = "\u26A0\uFE0F **CONTEXT DEATH DETECTED**\n\n";
+  message += `Your previous session died at ${deathTime}.
+
+`;
+  if (checkpoint) {
+    message += "**Last known state:**\n";
+    if (checkpoint.workingOn) {
+      message += `- Working on: ${checkpoint.workingOn}
+`;
+    }
+    if (checkpoint.focus) {
+      message += `- Focus: ${checkpoint.focus}
+`;
+    }
+    if (checkpoint.blocked) {
+      message += `- Blocked: ${checkpoint.blocked}
+`;
+    }
+    message += "\n";
+  }
+  if (handoffPath) {
+    message += `**Last handoff:** ${path2.basename(handoffPath)}
+`;
+    message += "Review and resume from where you left off.\n";
+  } else {
+    message += "**No handoff found.** You may have lost context.\n";
+  }
+  if (clearFlag) {
+    await clearDirtyFlag(vaultPath);
+  }
+  return {
+    died: true,
+    deathTime,
+    checkpoint,
+    handoffPath,
+    handoffContent,
+    recoveryMessage: message
+  };
+}
+function formatRecoveryCheckStatus(info) {
+  if (!info.died) {
+    return "\u2713 Dirty death flag is clear.";
+  }
+  let output = "\u26A0\uFE0F Dirty death flag is set.\n";
+  output += `Death time: ${info.deathTime}
+`;
+  if (info.checkpoint?.timestamp) {
+    const age = formatAge(Date.now() - new Date(info.checkpoint.timestamp).getTime());
+    output += `Last checkpoint: ${info.checkpoint.timestamp} (${age} ago)
+`;
+  } else {
+    output += "Last checkpoint: unavailable\n";
+  }
+  output += "Use `clawvault recover --clear` after reviewing recovery details.";
+  return output;
+}
+function formatCheckpointList(checkpoints) {
+  if (checkpoints.length === 0) {
+    return "No checkpoints found.";
+  }
+  const headers = ["TIMESTAMP", "WORKING_ON", "FOCUS", "FILE"];
+  const rows = checkpoints.map((checkpoint) => ({
+    timestamp: checkpoint.timestamp,
+    workingOn: checkpoint.workingOn ?? "-",
+    focus: checkpoint.focus ?? "-",
+    file: path2.basename(checkpoint.filePath)
+  }));
+  const timestampWidth = Math.max(headers[0].length, ...rows.map((row) => row.timestamp.length));
+  const workingOnWidth = Math.max(headers[1].length, ...rows.map((row) => row.workingOn.length));
+  const focusWidth = Math.max(headers[2].length, ...rows.map((row) => row.focus.length));
+  const fileWidth = Math.max(headers[3].length, ...rows.map((row) => row.file.length));
+  const lines = [];
+  lines.push(
+    `${headers[0].padEnd(timestampWidth)}  ${headers[1].padEnd(workingOnWidth)}  ${headers[2].padEnd(focusWidth)}  ${headers[3].padEnd(fileWidth)}`
+  );
+  lines.push(
+    `${"-".repeat(timestampWidth)}  ${"-".repeat(workingOnWidth)}  ${"-".repeat(focusWidth)}  ${"-".repeat(fileWidth)}`
+  );
+  for (const row of rows) {
+    lines.push(
+      `${row.timestamp.padEnd(timestampWidth)}  ${row.workingOn.padEnd(workingOnWidth)}  ${row.focus.padEnd(focusWidth)}  ${row.file}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatRecoveryInfo(info, options = {}) {
+  const { verbose = false } = options;
+  if (!info.died) {
+    return "\u2713 Clean startup - no context death detected.";
+  }
+  let output = "\n\u26A0\uFE0F  CONTEXT DEATH DETECTED\n";
+  output += "\u2550".repeat(40) + "\n\n";
+  output += `Death time: ${info.deathTime}
+`;
+  if (info.checkpoint?.timestamp) {
+    const age = formatAge(Date.now() - new Date(info.checkpoint.timestamp).getTime());
+    output += `Checkpoint: ${info.checkpoint.timestamp} (${age} ago)
+`;
+  }
+  output += "\n";
+  if (info.checkpoint) {
+    output += "Last checkpoint:\n";
+    if (info.checkpoint.workingOn) {
+      output += `  \u2022 Working on: ${info.checkpoint.workingOn}
+`;
+    }
+    if (info.checkpoint.focus) {
+      output += `  \u2022 Focus: ${info.checkpoint.focus}
+`;
+    }
+    if (info.checkpoint.blocked) {
+      output += `  \u2022 Blocked: ${info.checkpoint.blocked}
+`;
+    }
+    if (info.checkpoint.sessionKey || info.checkpoint.model || info.checkpoint.tokenEstimate !== void 0) {
+      output += "  \u2022 Session:\n";
+      if (info.checkpoint.sessionKey) {
+        output += `    - Key: ${info.checkpoint.sessionKey}
+`;
+      }
+      if (info.checkpoint.model) {
+        output += `    - Model: ${info.checkpoint.model}
+`;
+      }
+      if (info.checkpoint.tokenEstimate !== void 0) {
+        output += `    - Token estimate: ${info.checkpoint.tokenEstimate}
+`;
+      }
+    }
+    output += "\n";
+  } else {
+    output += "No checkpoint data found.\n\n";
+  }
+  if (info.handoffPath) {
+    output += `Last handoff: ${path2.basename(info.handoffPath)}
+`;
+  } else {
+    output += "No handoff found - context may be lost.\n";
+  }
+  if (verbose) {
+    if (info.checkpoint) {
+      output += "\nCheckpoint JSON:\n";
+      output += JSON.stringify(info.checkpoint, null, 2) + "\n";
+    }
+    if (info.handoffContent) {
+      output += "\nHandoff content:\n";
+      output += info.handoffContent.trim() + "\n";
+    }
+  }
+  output += "\n" + "\u2550".repeat(40) + "\n";
+  output += "Run `clawvault recap` to see full context.\n";
+  return output;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkRecoveryStatus,
+  formatCheckpointList,
+  formatRecoveryCheckStatus,
+  formatRecoveryInfo,
+  listCheckpoints,
+  recover
+});

package/dist/commands/recover.d.cts

@@ -0,0 +1,38 @@
+import { CheckpointData } from './checkpoint.cjs';
+
+/**
+ * Recovery command - detect dirty death and provide recovery info
+ */
+
+interface RecoveryInfo {
+    died: boolean;
+    deathTime: string | null;
+    checkpoint: CheckpointData | null;
+    handoffPath: string | null;
+    handoffContent: string | null;
+    recoveryMessage: string;
+}
+interface RecoveryCheckInfo {
+    died: boolean;
+    deathTime: string | null;
+    checkpoint: CheckpointData | null;
+}
+interface ListedCheckpoint extends CheckpointData {
+    filePath: string;
+}
+declare function checkRecoveryStatus(vaultPath: string): Promise<RecoveryCheckInfo>;
+declare function listCheckpoints(vaultPath: string): ListedCheckpoint[];
+declare function recover(vaultPath: string, options?: {
+    clearFlag?: boolean;
+    verbose?: boolean;
+}): Promise<RecoveryInfo>;
+declare function formatRecoveryCheckStatus(info: RecoveryCheckInfo): string;
+declare function formatCheckpointList(checkpoints: ListedCheckpoint[]): string;
+/**
+ * Format recovery info for CLI output
+ */
+declare function formatRecoveryInfo(info: RecoveryInfo, options?: {
+    verbose?: boolean;
+}): string;
+
+export { type ListedCheckpoint, type RecoveryCheckInfo, type RecoveryInfo, checkRecoveryStatus, formatCheckpointList, formatRecoveryCheckStatus, formatRecoveryInfo, listCheckpoints, recover };

package/dist/commands/recover.js

@@ -5,9 +5,10 @@ import {
   formatRecoveryInfo,
   listCheckpoints,
   recover
-} from "../chunk-OIWVQYQF.js";
+} from "../chunk-QBLMXKF2.js";
 import "../chunk-7ZRP733D.js";
-import "../chunk-F55HGNU4.js";
+import "../chunk-WAZ3NLWL.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   checkRecoveryStatus,
   formatCheckpointList,