clawvault 3.0.0 → 3.2.0

package/dist/commands/backlog.d.cts

@@ -1,53 +0,0 @@
-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/blocked.cjs

@@ -1,204 +0,0 @@
-"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

@@ -1,26 +0,0 @@
-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/checkpoint.cjs

@@ -1,244 +0,0 @@
-"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

@@ -1,41 +0,0 @@
-/**
- * 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 };