clawvault 2.6.0 → 3.0.0

package/dist/commands/backlog.d.cts

@@ -0,0 +1,53 @@
+import { TaskPriority, BacklogItem, Task } from '../lib/task-utils.cjs';
+
+/**
+ * Backlog command for ClawVault
+ * Manages backlog add/list/promote operations
+ */
+
+interface BacklogAddOptions {
+    source?: string;
+    project?: string;
+    content?: string;
+    tags?: string[];
+}
+interface BacklogListOptions {
+    project?: string;
+    json?: boolean;
+}
+interface BacklogPromoteOptions {
+    owner?: string;
+    priority?: TaskPriority;
+    due?: string;
+}
+/**
+ * Add a new backlog item
+ */
+declare function backlogAdd(vaultPath: string, title: string, options?: BacklogAddOptions): BacklogItem;
+/**
+ * List backlog items with optional filters
+ */
+declare function backlogList(vaultPath: string, options?: BacklogListOptions): BacklogItem[];
+/**
+ * Promote a backlog item to a task
+ */
+declare function backlogPromote(vaultPath: string, slug: string, options?: BacklogPromoteOptions): Task;
+/**
+ * Format backlog list for terminal display
+ */
+declare function formatBacklogList(items: BacklogItem[]): string;
+/**
+ * Format backlog item details for display
+ */
+declare function formatBacklogDetails(item: BacklogItem): string;
+/**
+ * Backlog command handler for CLI
+ * Note: The CLI uses "clawvault backlog <title>" as shorthand for add
+ */
+declare function backlogCommand(vaultPath: string, action: 'add' | 'list' | 'promote', args: {
+    title?: string;
+    slug?: string;
+    options?: BacklogAddOptions & BacklogListOptions & BacklogPromoteOptions;
+}): Promise<void>;
+
+export { type BacklogAddOptions, type BacklogListOptions, type BacklogPromoteOptions, backlogAdd, backlogCommand, backlogList, backlogPromote, formatBacklogDetails, formatBacklogList };

package/dist/commands/backlog.js

@@ -2,9 +2,10 @@ import {
   createBacklogItem,
   listBacklogItems,
   promoteBacklogItem
-} from "../chunk-QWQ3TIKS.js";
-import "../chunk-MFAWT5O5.js";
+} from "../chunk-N2AXRYLC.js";
+import "../chunk-LYHGEHXG.js";
 import "../chunk-7766SIJP.js";
+import "../chunk-3RG5ZIWI.js";
 
 // src/commands/backlog.ts
 function toDateStr(val) {

package/dist/commands/blocked.cjs

@@ -0,0 +1,204 @@
+"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/blocked.ts
+var blocked_exports = {};
+__export(blocked_exports, {
+  blockedCommand: () => blockedCommand,
+  blockedList: () => blockedList,
+  formatBlockedList: () => formatBlockedList
+});
+module.exports = __toCommonJS(blocked_exports);
+
+// src/lib/task-utils.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+
+// src/lib/primitive-templates.ts
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// src/lib/task-utils.ts
+function getTasksDir(vaultPath) {
+  return path.join(path.resolve(vaultPath), "tasks");
+}
+function getTaskPath(vaultPath, slug) {
+  return path.join(getTasksDir(vaultPath), `${slug}.md`);
+}
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+function parseDueDate(value) {
+  if (!value) return null;
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) return null;
+  return timestamp;
+}
+function startOfToday() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+}
+function readTask(vaultPath, slug) {
+  const taskPath = getTaskPath(vaultPath, slug);
+  if (!fs.existsSync(taskPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(taskPath, "utf-8");
+    const { data, content } = (0, import_gray_matter2.default)(raw);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter: data,
+      path: taskPath
+    };
+  } catch {
+    return null;
+  }
+}
+function listTasks(vaultPath, filters) {
+  const tasksDir = getTasksDir(vaultPath);
+  if (!fs.existsSync(tasksDir)) {
+    return [];
+  }
+  const tasks = [];
+  const entries = fs.readdirSync(tasksDir, { withFileTypes: true });
+  const today = startOfToday();
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    const task = readTask(vaultPath, slug);
+    if (!task) continue;
+    if (filters) {
+      if (filters.status && task.frontmatter.status !== filters.status) continue;
+      if (filters.owner && task.frontmatter.owner !== filters.owner) continue;
+      if (filters.project && task.frontmatter.project !== filters.project) continue;
+      if (filters.priority && task.frontmatter.priority !== filters.priority) continue;
+      if (filters.due && !task.frontmatter.due) continue;
+      if (filters.tag) {
+        const tags = task.frontmatter.tags || [];
+        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
+        if (!hasTag) continue;
+      }
+      if (filters.overdue) {
+        const dueTime = parseDueDate(task.frontmatter.due);
+        if (task.frontmatter.status === "done" || dueTime === null || dueTime >= today) continue;
+      }
+    }
+    tasks.push(task);
+  }
+  const priorityOrder = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+  };
+  if (filters?.due || filters?.overdue) {
+    return tasks.sort((a, b) => {
+      const aDue = parseDueDate(a.frontmatter.due);
+      const bDue = parseDueDate(b.frontmatter.due);
+      if (aDue !== null && bDue !== null && aDue !== bDue) {
+        return aDue - bDue;
+      }
+      if (aDue !== null && bDue === null) return -1;
+      if (aDue === null && bDue !== null) return 1;
+      return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+    });
+  }
+  return tasks.sort((a, b) => {
+    const aPriority = priorityOrder[a.frontmatter.priority || "low"];
+    const bPriority = priorityOrder[b.frontmatter.priority || "low"];
+    if (aPriority !== bPriority) {
+      return aPriority - bPriority;
+    }
+    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+  });
+}
+function getBlockedTasks(vaultPath, project) {
+  const filters = { status: "blocked" };
+  if (project) filters.project = project;
+  return listTasks(vaultPath, filters);
+}
+
+// src/commands/blocked.ts
+function toDateStr(val) {
+  if (!val) return "unknown";
+  if (val instanceof Date) return val.toISOString().split("T")[0];
+  const s = String(val);
+  if (s.includes("T")) return s.split("T")[0];
+  return s;
+}
+function blockedList(vaultPath, options = {}) {
+  let tasks = getBlockedTasks(vaultPath, options.project);
+  if (options.escalated) {
+    tasks = tasks.filter((t) => t.frontmatter.escalation === true);
+  }
+  return tasks;
+}
+function formatBlockedList(tasks) {
+  if (tasks.length === 0) {
+    return "No blocked tasks.\n";
+  }
+  let output = `BLOCKED TASKS (${tasks.length})
+
+`;
+  for (const task of tasks) {
+    const owner = task.frontmatter.owner || "unassigned";
+    const project = task.frontmatter.project || "no project";
+    const blockedBy = task.frontmatter.blocked_by || "unknown";
+    const updatedDate = toDateStr(task.frontmatter.updated);
+    output += `\u25A0 ${task.title} (${owner}, ${project})
+`;
+    output += `  Blocked by: ${blockedBy}
+`;
+    output += `  Since: ${updatedDate}
+`;
+    output += "\n";
+  }
+  return output;
+}
+async function blockedCommand(vaultPath, options = {}) {
+  const tasks = blockedList(vaultPath, options);
+  if (options.json) {
+    console.log(JSON.stringify(tasks, null, 2));
+  } else {
+    console.log(formatBlockedList(tasks));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blockedCommand,
+  blockedList,
+  formatBlockedList
+});

package/dist/commands/blocked.d.cts

@@ -0,0 +1,26 @@
+import { Task } from '../lib/task-utils.cjs';
+
+/**
+ * Blocked command for ClawVault
+ * Quick view of blocked tasks
+ */
+
+interface BlockedOptions {
+    project?: string;
+    json?: boolean;
+    escalated?: boolean;
+}
+/**
+ * Get blocked tasks
+ */
+declare function blockedList(vaultPath: string, options?: BlockedOptions): Task[];
+/**
+ * Format blocked tasks for terminal display
+ */
+declare function formatBlockedList(tasks: Task[]): string;
+/**
+ * Blocked command handler for CLI
+ */
+declare function blockedCommand(vaultPath: string, options?: BlockedOptions): Promise<void>;
+
+export { type BlockedOptions, blockedCommand, blockedList, formatBlockedList };

package/dist/commands/blocked.js

@@ -1,8 +1,9 @@
 import {
   getBlockedTasks
-} from "../chunk-QWQ3TIKS.js";
-import "../chunk-MFAWT5O5.js";
+} from "../chunk-N2AXRYLC.js";
+import "../chunk-LYHGEHXG.js";
 import "../chunk-7766SIJP.js";
+import "../chunk-3RG5ZIWI.js";
 
 // src/commands/blocked.ts
 function toDateStr(val) {

package/dist/commands/checkpoint.cjs

@@ -0,0 +1,244 @@
+"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/checkpoint.ts
+var checkpoint_exports = {};
+__export(checkpoint_exports, {
+  checkDirtyDeath: () => checkDirtyDeath,
+  checkpoint: () => checkpoint,
+  cleanExit: () => cleanExit,
+  clearDirtyFlag: () => clearDirtyFlag,
+  flush: () => flush,
+  setSessionState: () => setSessionState
+});
+module.exports = __toCommonJS(checkpoint_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+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 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) {
+  const dir = path.join(vaultPath, CLAWVAULT_DIR);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  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));
+  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));
+  pruneCheckpointHistory(historyDir, Date.now());
+  const flagPath = path.join(dir, DIRTY_DEATH_FLAG);
+  fs.writeFileSync(flagPath, data.timestamp);
+}
+function parseTokenEstimate(raw) {
+  if (!raw) return void 0;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function loadSessionState(dir) {
+  const sessionStatePath = path.join(dir, SESSION_STATE_FILE);
+  if (!fs.existsSync(sessionStatePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(sessionStatePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getEnvSessionState() {
+  return {
+    sessionKey: process.env.OPENCLAW_SESSION_KEY,
+    model: process.env.OPENCLAW_MODEL,
+    tokenEstimate: parseTokenEstimate(
+      process.env.OPENCLAW_TOKEN_ESTIMATE || process.env.OPENCLAW_CONTEXT_TOKENS
+    )
+  };
+}
+function triggerUrgentWake(data) {
+  const summary = [
+    data.workingOn ? `Working on: ${data.workingOn}` : null,
+    data.focus ? `Focus: ${data.focus}` : null,
+    data.blocked ? `Blocked: ${data.blocked}` : null
+  ].filter(Boolean).join(" | ");
+  const text = summary ? `Urgent checkpoint saved. ${summary}` : "Urgent checkpoint saved.";
+  try {
+    (0, import_child_process.execFileSync)("openclaw", ["gateway", "wake", "--text", text, "--mode", "now"], {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      throw new Error("Urgent wake failed: openclaw CLI not found.");
+    }
+    throw new Error(`Urgent wake failed: ${err?.message || "unknown error"}`);
+  }
+}
+async function flush() {
+  if (pendingCheckpoint) {
+    clearTimeout(pendingCheckpoint);
+    pendingCheckpoint = null;
+  }
+  if (!pendingData) return null;
+  const { dir, data } = pendingData;
+  pendingData = null;
+  writeCheckpointToDisk(dir, data);
+  return data;
+}
+async function checkpoint(options) {
+  const dir = ensureClawvaultDir(options.vaultPath);
+  const data = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    workingOn: options.workingOn || null,
+    focus: options.focus || null,
+    blocked: options.blocked || null,
+    urgent: options.urgent || false
+  };
+  const sessionState = loadSessionState(dir);
+  const envState = getEnvSessionState();
+  data.sessionId = sessionState?.sessionId;
+  data.sessionKey = envState.sessionKey || sessionState?.sessionKey || sessionState?.sessionId;
+  data.model = envState.model || sessionState?.model;
+  data.tokenEstimate = envState.tokenEstimate ?? sessionState?.tokenEstimate;
+  data.sessionStartedAt = sessionState?.startedAt;
+  if (options.urgent) {
+    if (pendingCheckpoint) {
+      clearTimeout(pendingCheckpoint);
+      pendingCheckpoint = null;
+    }
+    pendingData = null;
+    writeCheckpointToDisk(dir, data);
+    triggerUrgentWake(data);
+  } else {
+    pendingData = { dir, data };
+    if (pendingCheckpoint) clearTimeout(pendingCheckpoint);
+    pendingCheckpoint = setTimeout(() => {
+      void flush();
+    }, 1e3);
+  }
+  return data;
+}
+async function clearDirtyFlag(vaultPath) {
+  const flagPath = path.join(vaultPath, CLAWVAULT_DIR, DIRTY_DEATH_FLAG);
+  if (fs.existsSync(flagPath)) {
+    fs.unlinkSync(flagPath);
+  }
+}
+async function cleanExit(vaultPath) {
+  await clearDirtyFlag(vaultPath);
+}
+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 checkpoint2 = null;
+  if (fs.existsSync(checkpointPath)) {
+    try {
+      checkpoint2 = JSON.parse(fs.readFileSync(checkpointPath, "utf-8"));
+    } catch {
+    }
+  }
+  return { died: true, checkpoint: checkpoint2, deathTime };
+}
+async function setSessionState(vaultPath, session) {
+  const dir = ensureClawvaultDir(vaultPath);
+  const sessionStatePath = path.join(dir, SESSION_STATE_FILE);
+  const state = typeof session === "string" ? { sessionId: session } : { ...session };
+  if (!state.startedAt) {
+    state.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  fs.writeFileSync(sessionStatePath, JSON.stringify(state, null, 2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkDirtyDeath,
+  checkpoint,
+  cleanExit,
+  clearDirtyFlag,
+  flush,
+  setSessionState
+});

package/dist/commands/checkpoint.d.cts

@@ -0,0 +1,41 @@
+/**
+ * Quick checkpoint command - fast state save for context death resilience
+ */
+interface CheckpointOptions {
+    workingOn?: string;
+    focus?: string;
+    blocked?: string;
+    vaultPath: string;
+    urgent?: boolean;
+}
+interface CheckpointData {
+    timestamp: string;
+    workingOn: string | null;
+    focus: string | null;
+    blocked: string | null;
+    sessionId?: string;
+    sessionKey?: string;
+    model?: string;
+    tokenEstimate?: number;
+    sessionStartedAt?: string;
+    urgent?: boolean;
+}
+interface SessionState {
+    sessionId?: string;
+    sessionKey?: string;
+    model?: string;
+    tokenEstimate?: number;
+    startedAt?: string;
+}
+declare function flush(): Promise<CheckpointData | null>;
+declare function checkpoint(options: CheckpointOptions): Promise<CheckpointData>;
+declare function clearDirtyFlag(vaultPath: string): Promise<void>;
+declare function cleanExit(vaultPath: string): Promise<void>;
+declare function checkDirtyDeath(vaultPath: string): Promise<{
+    died: boolean;
+    checkpoint: CheckpointData | null;
+    deathTime: string | null;
+}>;
+declare function setSessionState(vaultPath: string, session: string | SessionState): Promise<void>;
+
+export { type CheckpointData, type CheckpointOptions, type SessionState, checkDirtyDeath, checkpoint, cleanExit, clearDirtyFlag, flush, setSessionState };

package/dist/commands/checkpoint.js

@@ -5,7 +5,8 @@ import {
   clearDirtyFlag,
   flush,
   setSessionState
-} from "../chunk-F55HGNU4.js";
+} from "../chunk-WAZ3NLWL.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   checkDirtyDeath,
   checkpoint,