clawvault 2.4.6 → 2.4.7

package/dist/{chunk-6QLRSPLZ.js → chunk-IOALNTAN.js}

@@ -1,33 +1,182 @@
 // src/lib/task-utils.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import matter from "gray-matter";
+
+// src/lib/transition-ledger.ts
 import * as fs from "fs";
 import * as path from "path";
-import matter from "gray-matter";
+var REGRESSION_PAIRS = [
+  ["done", "open"],
+  ["done", "blocked"],
+  ["in-progress", "blocked"]
+];
+function isRegression(from, to) {
+  return REGRESSION_PAIRS.some(([f, t]) => f === from && t === to);
+}
+function getLedgerDir(vaultPath) {
+  return path.join(path.resolve(vaultPath), "ledger", "transitions");
+}
+function getTodayLedgerPath(vaultPath) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return path.join(getLedgerDir(vaultPath), `${date}.jsonl`);
+}
+var RETRYABLE_APPEND_CODES = /* @__PURE__ */ new Set(["ENOENT", "EAGAIN", "EBUSY"]);
+var MAX_APPEND_RETRIES = 2;
+function asErrno(error) {
+  if (!error || typeof error !== "object") {
+    return null;
+  }
+  return error;
+}
+function formatLedgerWriteError(filePath, error) {
+  const errno = asErrno(error);
+  const message = error instanceof Error ? error.message : String(error);
+  if (errno?.code === "ENOSPC") {
+    return new Error(`Failed to write transition ledger at ${filePath}: no space left on device.`);
+  }
+  if (errno?.code === "EACCES" || errno?.code === "EPERM") {
+    return new Error(`Failed to write transition ledger at ${filePath}: permission denied.`);
+  }
+  return new Error(`Failed to write transition ledger at ${filePath}: ${message}`);
+}
+function appendTransition(vaultPath, event) {
+  const ledgerDir = getLedgerDir(vaultPath);
+  try {
+    fs.mkdirSync(ledgerDir, { recursive: true });
+  } catch (error) {
+    throw formatLedgerWriteError(ledgerDir, error);
+  }
+  const filePath = getTodayLedgerPath(vaultPath);
+  const payload = JSON.stringify(event) + "\n";
+  for (let attempt = 0; attempt <= MAX_APPEND_RETRIES; attempt += 1) {
+    try {
+      fs.appendFileSync(filePath, payload);
+      return;
+    } catch (error) {
+      const errno = asErrno(error);
+      const code = errno?.code;
+      if (code === "ENOENT") {
+        try {
+          fs.mkdirSync(ledgerDir, { recursive: true });
+        } catch (mkdirError) {
+          throw formatLedgerWriteError(filePath, mkdirError);
+        }
+      }
+      if (code && RETRYABLE_APPEND_CODES.has(code) && attempt < MAX_APPEND_RETRIES) {
+        continue;
+      }
+      throw formatLedgerWriteError(filePath, error);
+    }
+  }
+}
+function buildTransitionEvent(taskId, fromStatus, toStatus, options = {}) {
+  const agentId = process.env.OPENCLAW_AGENT_ID || "manual";
+  const costTokensRaw = process.env.OPENCLAW_TOKEN_ESTIMATE;
+  const costTokens = costTokensRaw ? parseInt(costTokensRaw, 10) : null;
+  return {
+    task_id: taskId,
+    agent_id: agentId,
+    from_status: fromStatus,
+    to_status: toStatus,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    confidence: options.confidence ?? (agentId === "manual" ? 1 : 1),
+    cost_tokens: costTokens !== null && !isNaN(costTokens) ? costTokens : null,
+    reason: options.reason || null
+  };
+}
+function readAllTransitions(vaultPath) {
+  const ledgerDir = getLedgerDir(vaultPath);
+  if (!fs.existsSync(ledgerDir)) return [];
+  let files = [];
+  try {
+    files = fs.readdirSync(ledgerDir).filter((f) => f.endsWith(".jsonl")).sort();
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const file of files) {
+    let lines = [];
+    try {
+      lines = fs.readFileSync(path.join(ledgerDir, file), "utf-8").split("\n").filter((l) => l.trim());
+    } catch {
+      continue;
+    }
+    for (const line of lines) {
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+  }
+  return events;
+}
+function queryTransitions(vaultPath, filters = {}) {
+  let events = readAllTransitions(vaultPath);
+  if (filters.taskId) {
+    events = events.filter((e) => e.task_id === filters.taskId);
+  }
+  if (filters.agent) {
+    events = events.filter((e) => e.agent_id === filters.agent);
+  }
+  if (filters.failed) {
+    events = events.filter((e) => isRegression(e.from_status, e.to_status));
+  }
+  return events;
+}
+function countBlockedTransitions(vaultPath, taskId) {
+  const events = readAllTransitions(vaultPath);
+  return events.filter((e) => e.task_id === taskId && e.to_status === "blocked").length;
+}
+function formatTransitionsTable(events) {
+  if (events.length === 0) return "No transitions found.\n";
+  const headers = ["TIMESTAMP", "TASK", "FROM\u2192TO", "AGENT", "REASON"];
+  const widths = [20, 20, 24, 16, 30];
+  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
+  output += "-".repeat(widths.reduce((a, b) => a + b + 2, 0)) + "\n";
+  for (const e of events) {
+    const ts = e.timestamp.replace("T", " ").slice(0, 19);
+    const taskId = e.task_id.length > widths[1] ? e.task_id.slice(0, widths[1] - 3) + "..." : e.task_id;
+    const transition = `${e.from_status} \u2192 ${e.to_status}`;
+    const reason = e.reason ? e.reason.length > widths[4] ? e.reason.slice(0, widths[4] - 3) + "..." : e.reason : "-";
+    output += [
+      ts.padEnd(widths[0]),
+      taskId.padEnd(widths[1]),
+      transition.padEnd(widths[2]),
+      e.agent_id.padEnd(widths[3]),
+      reason
+    ].join("  ") + "\n";
+  }
+  return output;
+}
+
+// src/lib/task-utils.ts
 function slugify(text) {
   return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
 }
 function getTasksDir(vaultPath) {
-  return path.join(path.resolve(vaultPath), "tasks");
+  return path2.join(path2.resolve(vaultPath), "tasks");
 }
 function getBacklogDir(vaultPath) {
-  return path.join(path.resolve(vaultPath), "backlog");
+  return path2.join(path2.resolve(vaultPath), "backlog");
 }
 function ensureTasksDir(vaultPath) {
   const tasksDir = getTasksDir(vaultPath);
-  if (!fs.existsSync(tasksDir)) {
-    fs.mkdirSync(tasksDir, { recursive: true });
+  if (!fs2.existsSync(tasksDir)) {
+    fs2.mkdirSync(tasksDir, { recursive: true });
   }
 }
 function ensureBacklogDir(vaultPath) {
   const backlogDir = getBacklogDir(vaultPath);
-  if (!fs.existsSync(backlogDir)) {
-    fs.mkdirSync(backlogDir, { recursive: true });
+  if (!fs2.existsSync(backlogDir)) {
+    fs2.mkdirSync(backlogDir, { recursive: true });
   }
 }
 function getTaskPath(vaultPath, slug) {
-  return path.join(getTasksDir(vaultPath), `${slug}.md`);
+  return path2.join(getTasksDir(vaultPath), `${slug}.md`);
 }
 function getBacklogPath(vaultPath, slug) {
-  return path.join(getBacklogDir(vaultPath), `${slug}.md`);
+  return path2.join(getBacklogDir(vaultPath), `${slug}.md`);
 }
 function extractTitle(content) {
   const match = content.match(/^#\s+(.+)$/m);
@@ -43,13 +192,76 @@ function startOfToday() {
   const now = /* @__PURE__ */ new Date();
   return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
 }
+var VALID_TASK_STATUSES = /* @__PURE__ */ new Set([
+  "open",
+  "in-progress",
+  "blocked",
+  "done"
+]);
+function isTaskStatus(value) {
+  return typeof value === "string" && VALID_TASK_STATUSES.has(value);
+}
+function persistTaskFrontmatter(task, frontmatter) {
+  fs2.writeFileSync(task.path, matter.stringify(task.content, frontmatter));
+}
+function resolveStatusTransition(previousStatus, nextStatus) {
+  if (!isTaskStatus(previousStatus) || !isTaskStatus(nextStatus)) {
+    return null;
+  }
+  if (previousStatus === nextStatus) {
+    return null;
+  }
+  return { fromStatus: previousStatus, toStatus: nextStatus };
+}
+function logStatusTransition({
+  vaultPath,
+  task,
+  fromStatus,
+  toStatus,
+  frontmatter,
+  options
+}) {
+  const normalizedReason = typeof options.reason === "string" ? options.reason.trim() : "";
+  const reason = normalizedReason || (isRegression(fromStatus, toStatus) ? `regression: ${fromStatus} -> ${toStatus}` : void 0);
+  const event = buildTransitionEvent(task.slug, fromStatus, toStatus, {
+    confidence: options.confidence,
+    reason
+  });
+  try {
+    appendTransition(vaultPath, event);
+  } catch {
+    return frontmatter;
+  }
+  if (toStatus !== "blocked" || frontmatter.escalation) {
+    return frontmatter;
+  }
+  let blockedCount = 0;
+  try {
+    blockedCount = countBlockedTransitions(vaultPath, task.slug);
+  } catch {
+    return frontmatter;
+  }
+  if (blockedCount < 3) {
+    return frontmatter;
+  }
+  const escalatedFrontmatter = {
+    ...frontmatter,
+    escalation: true
+  };
+  try {
+    persistTaskFrontmatter(task, escalatedFrontmatter);
+    return escalatedFrontmatter;
+  } catch {
+    return frontmatter;
+  }
+}
 function readTask(vaultPath, slug) {
   const taskPath = getTaskPath(vaultPath, slug);
-  if (!fs.existsSync(taskPath)) {
+  if (!fs2.existsSync(taskPath)) {
     return null;
   }
   try {
-    const raw = fs.readFileSync(taskPath, "utf-8");
+    const raw = fs2.readFileSync(taskPath, "utf-8");
     const { data, content } = matter(raw);
     const title = extractTitle(content) || slug;
     return {
@@ -65,11 +277,11 @@ function readTask(vaultPath, slug) {
 }
 function readBacklogItem(vaultPath, slug) {
   const backlogPath = getBacklogPath(vaultPath, slug);
-  if (!fs.existsSync(backlogPath)) {
+  if (!fs2.existsSync(backlogPath)) {
     return null;
   }
   try {
-    const raw = fs.readFileSync(backlogPath, "utf-8");
+    const raw = fs2.readFileSync(backlogPath, "utf-8");
     const { data, content } = matter(raw);
     const title = extractTitle(content) || slug;
     return {
@@ -85,11 +297,11 @@ function readBacklogItem(vaultPath, slug) {
 }
 function listTasks(vaultPath, filters) {
   const tasksDir = getTasksDir(vaultPath);
-  if (!fs.existsSync(tasksDir)) {
+  if (!fs2.existsSync(tasksDir)) {
     return [];
   }
   const tasks = [];
-  const entries = fs.readdirSync(tasksDir, { withFileTypes: true });
+  const entries = fs2.readdirSync(tasksDir, { withFileTypes: true });
   const today = startOfToday();
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) {
@@ -145,11 +357,11 @@ function listTasks(vaultPath, filters) {
 }
 function listBacklogItems(vaultPath, filters) {
   const backlogDir = getBacklogDir(vaultPath);
-  if (!fs.existsSync(backlogDir)) {
+  if (!fs2.existsSync(backlogDir)) {
     return [];
   }
   const items = [];
-  const entries = fs.readdirSync(backlogDir, { withFileTypes: true });
+  const entries = fs2.readdirSync(backlogDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) {
       continue;
@@ -171,7 +383,7 @@ function createTask(vaultPath, title, options = {}) {
   ensureTasksDir(vaultPath);
   const slug = slugify(title);
   const taskPath = getTaskPath(vaultPath, slug);
-  if (fs.existsSync(taskPath)) {
+  if (fs2.existsSync(taskPath)) {
     throw new Error(`Task already exists: ${slug}`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -206,7 +418,7 @@ ${options.content}
 `;
   }
   const fileContent = matter.stringify(content, frontmatter);
-  fs.writeFileSync(taskPath, fileContent);
+  fs2.writeFileSync(taskPath, fileContent);
   return {
     slug,
     title,
@@ -215,13 +427,17 @@ ${options.content}
     path: taskPath
   };
 }
-function updateTask(vaultPath, slug, updates) {
+function updateTask(vaultPath, slug, updates, options = {}) {
   const task = readTask(vaultPath, slug);
   if (!task) {
     throw new Error(`Task not found: ${slug}`);
   }
+  if (updates.status !== void 0 && !isTaskStatus(updates.status)) {
+    throw new Error(`Invalid task status: ${String(updates.status)}`);
+  }
+  const previousStatus = task.frontmatter.status;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const newFrontmatter = {
+  let newFrontmatter = {
     ...task.frontmatter,
     updated: now
   };
@@ -348,41 +564,39 @@ function updateTask(vaultPath, slug, updates) {
     } else {
       newFrontmatter.blocked_by = updates.blocked_by;
     }
-  } else if (updates.status && updates.status !== "blocked") {
+  } else if (updates.status !== void 0 && updates.status !== "blocked") {
     delete newFrontmatter.blocked_by;
   }
-  const fileContent = matter.stringify(task.content, newFrontmatter);
-  fs.writeFileSync(task.path, fileContent);
-  return {
-    ...task,
-    frontmatter: newFrontmatter
-  };
-}
-function completeTask(vaultPath, slug) {
-  const task = readTask(vaultPath, slug);
-  if (!task) {
-    throw new Error(`Task not found: ${slug}`);
+  persistTaskFrontmatter(task, newFrontmatter);
+  const transition = options.skipTransition ? null : resolveStatusTransition(previousStatus, newFrontmatter.status);
+  if (transition) {
+    const confidence = options.confidence ?? (typeof updates.confidence === "number" ? updates.confidence : void 0);
+    const reason = options.reason ?? updates.reason ?? null;
+    newFrontmatter = logStatusTransition({
+      vaultPath,
+      task,
+      fromStatus: transition.fromStatus,
+      toStatus: transition.toStatus,
+      frontmatter: newFrontmatter,
+      options: {
+        confidence,
+        reason
+      }
+    });
   }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const newFrontmatter = {
-    ...task.frontmatter,
-    status: "done",
-    updated: now,
-    completed: now
-  };
-  delete newFrontmatter.blocked_by;
-  const fileContent = matter.stringify(task.content, newFrontmatter);
-  fs.writeFileSync(task.path, fileContent);
   return {
     ...task,
     frontmatter: newFrontmatter
   };
 }
+function completeTask(vaultPath, slug, options = {}) {
+  return updateTask(vaultPath, slug, { status: "done" }, options);
+}
 function createBacklogItem(vaultPath, title, options = {}) {
   ensureBacklogDir(vaultPath);
   const slug = slugify(title);
   const backlogPath = getBacklogPath(vaultPath, slug);
-  if (fs.existsSync(backlogPath)) {
+  if (fs2.existsSync(backlogPath)) {
     throw new Error(`Backlog item already exists: ${slug}`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -408,7 +622,7 @@ ${options.content}
 `;
   }
   const fileContent = matter.stringify(content, frontmatter);
-  fs.writeFileSync(backlogPath, fileContent);
+  fs2.writeFileSync(backlogPath, fileContent);
   return {
     slug,
     title,
@@ -430,7 +644,7 @@ function updateBacklogItem(vaultPath, slug, updates) {
   if (updates.tags !== void 0) newFrontmatter.tags = updates.tags;
   if (updates.lastSeen !== void 0) newFrontmatter.lastSeen = updates.lastSeen;
   const fileContent = matter.stringify(backlogItem.content, newFrontmatter);
-  fs.writeFileSync(backlogItem.path, fileContent);
+  fs2.writeFileSync(backlogItem.path, fileContent);
   return {
     ...backlogItem,
     frontmatter: newFrontmatter
@@ -450,7 +664,7 @@ function promoteBacklogItem(vaultPath, slug, options = {}) {
     // Remove title from content
     tags: backlogItem.frontmatter.tags
   });
-  fs.unlinkSync(backlogItem.path);
+  fs2.unlinkSync(backlogItem.path);
   return task;
 }
 function getBlockedTasks(vaultPath, project) {
@@ -509,6 +723,13 @@ function getStatusDisplay(status) {
 }
 
 export {
+  isRegression,
+  appendTransition,
+  buildTransitionEvent,
+  readAllTransitions,
+  queryTransitions,
+  countBlockedTransitions,
+  formatTransitionsTable,
   slugify,
   getTasksDir,
   getBacklogDir,