clawvault 2.4.4 → 2.4.5

package/dist/{chunk-FDJIZKCW.js → chunk-6B3JWM7J.js}

@@ -1,46 +1,3 @@
-// src/types.ts
-var DEFAULT_CATEGORIES = [
-  "preferences",
-  "decisions",
-  "patterns",
-  "people",
-  "projects",
-  "goals",
-  "transcripts",
-  "inbox",
-  "templates",
-  "lessons",
-  "agents",
-  "commitments",
-  "handoffs",
-  "research",
-  "tasks",
-  "backlog"
-];
-var MEMORY_TYPES = [
-  "fact",
-  "feeling",
-  "decision",
-  "lesson",
-  "commitment",
-  "preference",
-  "relationship",
-  "project"
-];
-var TYPE_TO_CATEGORY = {
-  fact: "facts",
-  feeling: "feelings",
-  decision: "decisions",
-  lesson: "lessons",
-  commitment: "commitments",
-  preference: "preferences",
-  relationship: "people",
-  project: "projects"
-};
-var DEFAULT_CONFIG = {
-  categories: DEFAULT_CATEGORIES
-};
-
 // src/lib/search.ts
 import { execFileSync, spawnSync } from "child_process";
 import * as fs from "fs";
@@ -71,8 +28,19 @@ function extractJsonPayload(raw) {
   if (end <= start) return null;
   return raw.slice(start, end + 1);
 }
+function stripQmdNoise(raw) {
+  return raw.split("\n").filter((line) => {
+    const t = line.trim();
+    if (!t) return true;
+    if (t.startsWith("[node-llama-cpp]")) return false;
+    if (t.startsWith("Expanding query")) return false;
+    if (t.startsWith("Searching ") && t.endsWith("queries...")) return false;
+    if (/^[├└─│]/.test(t)) return false;
+    return true;
+  }).join("\n");
+}
 function parseQmdOutput(raw) {
-  const trimmed = raw.trim();
+  const trimmed = stripQmdNoise(raw).trim();
   if (!trimmed) return [];
   const direct = tryParseJson(trimmed);
   const extracted = direct ? null : extractJsonPayload(trimmed);
@@ -368,10 +336,6 @@ function extractTags(content) {
 }
 
 export {
-  DEFAULT_CATEGORIES,
-  MEMORY_TYPES,
-  TYPE_TO_CATEGORY,
-  DEFAULT_CONFIG,
   QMD_INSTALL_URL,
   QMD_INSTALL_COMMAND,
   QmdUnavailableError,

package/dist/{chunk-SNEMCQP7.js → chunk-B3SMJZIZ.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-P5EPF6MB.js";
 import {
   Observer
-} from "./chunk-FEFPBHH4.js";
+} from "./chunk-RXEIQ3KQ.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

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

@@ -6,6 +6,7 @@ var CLAWVAULT_DIR = ".clawvault";
 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 pendingCheckpoint = null;
 var pendingData = null;
 function ensureClawvaultDir(vaultPath) {
@@ -18,6 +19,11 @@ function ensureClawvaultDir(vaultPath) {
 function writeCheckpointToDisk(dir, data) {
   const checkpointPath = path.join(dir, CHECKPOINT_FILE);
   fs.writeFileSync(checkpointPath, JSON.stringify(data, null, 2));
+  const historyDir = path.join(dir, CHECKPOINT_HISTORY_DIR);
+  fs.mkdirSync(historyDir, { recursive: true });
+  const historyFileName = `${data.timestamp.replace(/[:.]/g, "-")}.json`;
+  const historyPath = path.join(historyDir, historyFileName);
+  fs.writeFileSync(historyPath, JSON.stringify(data, null, 2));
   const flagPath = path.join(dir, DIRTY_DEATH_FLAG);
   fs.writeFileSync(flagPath, data.timestamp);
 }

package/dist/{chunk-BMOQI62Q.js → chunk-HNMFXFYP.js}

@@ -1,14 +1,16 @@
 import {
-  DEFAULT_CATEGORIES,
   QmdUnavailableError,
   SearchEngine,
-  TYPE_TO_CATEGORY,
   extractTags,
   extractWikiLinks,
   hasQmd,
   qmdEmbed,
   qmdUpdate
-} from "./chunk-FDJIZKCW.js";
+} from "./chunk-6B3JWM7J.js";
+import {
+  DEFAULT_CATEGORIES,
+  TYPE_TO_CATEGORY
+} from "./chunk-3PJIGGWV.js";
 import {
   buildOrUpdateMemoryGraphIndex
 } from "./chunk-ZZA73MFY.js";

package/dist/chunk-OIWVQYQF.js

@@ -0,0 +1,284 @@
+import {
+  formatAge
+} from "./chunk-7ZRP733D.js";
+import {
+  checkDirtyDeath,
+  clearDirtyFlag
+} from "./chunk-F55HGNU4.js";
+
+// src/commands/recover.ts
+import * as fs from "fs";
+import * as path from "path";
+var CLAWVAULT_DIR = ".clawvault";
+var CHECKPOINT_FILE = "last-checkpoint.json";
+var CHECKPOINT_HISTORY_DIR = "checkpoints";
+function parseCheckpointFile(filePath) {
+  try {
+    const parsed = JSON.parse(fs.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 = path.resolve(vaultPath);
+  const clawvaultDir = path.join(resolvedVaultPath, CLAWVAULT_DIR);
+  const historyDir = path.join(clawvaultDir, CHECKPOINT_HISTORY_DIR);
+  const checkpoints = [];
+  if (fs.existsSync(historyDir)) {
+    const files = fs.readdirSync(historyDir).filter((entry) => entry.endsWith(".json")).sort().reverse();
+    for (const fileName of files) {
+      const absolutePath = path.join(historyDir, fileName);
+      const parsed = parseCheckpointFile(absolutePath);
+      if (!parsed) {
+        continue;
+      }
+      checkpoints.push({
+        ...parsed,
+        filePath: absolutePath
+      });
+    }
+  }
+  if (checkpoints.length === 0) {
+    const latestCheckpointPath = path.join(clawvaultDir, CHECKPOINT_FILE);
+    if (fs.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 = path.join(vaultPath, "handoffs");
+  let handoffPath = null;
+  let handoffContent = null;
+  if (fs.existsSync(handoffsDir)) {
+    const files = fs.readdirSync(handoffsDir).filter((f) => f.startsWith("handoff-") && f.endsWith(".md")).sort().reverse();
+    if (files.length > 0) {
+      handoffPath = path.join(handoffsDir, files[0]);
+      handoffContent = fs.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:** ${path.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: path.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: ${path.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;
+}
+
+export {
+  checkRecoveryStatus,
+  listCheckpoints,
+  recover,
+  formatRecoveryCheckStatus,
+  formatCheckpointList,
+  formatRecoveryInfo
+};