clawvault 2.6.0 → 3.0.0

package/dist/lib/project-utils.d.cts

@@ -0,0 +1,97 @@
+import { Task } from './task-utils.cjs';
+
+/**
+ * Project utilities for ClawVault project tracking
+ * Handles project definition and activity file read/write/query operations
+ */
+
+type ProjectStatus = 'active' | 'paused' | 'completed' | 'archived';
+interface ProjectFrontmatter {
+    type: 'project';
+    status: ProjectStatus;
+    created: string;
+    updated: string;
+    owner?: string;
+    team?: string[];
+    client?: string;
+    tags?: string[];
+    description?: string;
+    started?: string;
+    deadline?: string;
+    repo?: string;
+    url?: string;
+    completed?: string;
+    reason?: string;
+}
+interface Project {
+    slug: string;
+    title: string;
+    content: string;
+    frontmatter: ProjectFrontmatter;
+}
+interface ProjectFilterOptions {
+    status?: ProjectStatus;
+    owner?: string;
+    client?: string;
+    tag?: string;
+}
+interface CreateProjectOptions {
+    status?: ProjectStatus;
+    owner?: string;
+    team?: string[];
+    client?: string;
+    tags?: string[];
+    description?: string;
+    started?: string;
+    deadline?: string;
+    repo?: string;
+    url?: string;
+    completed?: string;
+    reason?: string;
+    content?: string;
+}
+interface UpdateProjectOptions {
+    status?: ProjectStatus;
+    owner?: string | null;
+    team?: string[] | null;
+    client?: string | null;
+    tags?: string[] | null;
+    description?: string | null;
+    started?: string | null;
+    deadline?: string | null;
+    repo?: string | null;
+    url?: string | null;
+    completed?: string | null;
+    reason?: string | null;
+}
+/**
+ * List all project definition files in the vault.
+ * Includes only root-level projects/*.md files with type: project frontmatter.
+ */
+declare function listProjects(vaultPath: string, filters?: ProjectFilterOptions): Project[];
+/**
+ * Read a project definition file from projects/{slug}.md
+ */
+declare function readProject(vaultPath: string, slug: string): Project | null;
+/**
+ * Create a new project definition at projects/{slug}.md
+ */
+declare function createProject(vaultPath: string, title: string, options?: CreateProjectOptions): Project;
+/**
+ * Update an existing project's frontmatter
+ */
+declare function updateProject(vaultPath: string, slug: string, updates: UpdateProjectOptions): Project;
+/**
+ * Archive a project with optional reason and completion date
+ */
+declare function archiveProject(vaultPath: string, slug: string, reason?: string): Project;
+/**
+ * List tasks linked to a project by task.frontmatter.project === project slug
+ */
+declare function getProjectTasks(vaultPath: string, slug: string): Task[];
+/**
+ * List files in projects/{slug}/ sorted by date (newest first)
+ */
+declare function getProjectActivity(vaultPath: string, slug: string): string[];
+
+export { type CreateProjectOptions, type Project, type ProjectFilterOptions, type ProjectFrontmatter, type ProjectStatus, type UpdateProjectOptions, archiveProject, createProject, getProjectActivity, getProjectTasks, listProjects, readProject, updateProject };

package/dist/lib/project-utils.js

@@ -6,10 +6,11 @@ import {
   listProjects,
   readProject,
   updateProject
-} from "../chunk-AZYOKJYC.js";
-import "../chunk-QWQ3TIKS.js";
-import "../chunk-MFAWT5O5.js";
+} from "../chunk-62YTUT6J.js";
+import "../chunk-N2AXRYLC.js";
+import "../chunk-LYHGEHXG.js";
 import "../chunk-7766SIJP.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   archiveProject,
   createProject,

package/dist/lib/session-repair.cjs

@@ -0,0 +1,239 @@
+"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/lib/session-repair.ts
+var session_repair_exports = {};
+__export(session_repair_exports, {
+  analyzeSession: () => analyzeSession,
+  computeParentRelinks: () => computeParentRelinks,
+  extractToolUses: () => extractToolUses,
+  findCorruptedEntries: () => findCorruptedEntries,
+  parseTranscript: () => parseTranscript,
+  repairSession: () => repairSession
+});
+module.exports = __toCommonJS(session_repair_exports);
+var fs = __toESM(require("fs"), 1);
+function parseTranscript(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim());
+  const entries = [];
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    try {
+      const entry = JSON.parse(raw);
+      entries.push({ line: i + 1, entry, raw });
+    } catch {
+      console.warn(`Warning: Could not parse line ${i + 1}`);
+    }
+  }
+  return entries;
+}
+function extractToolUses(entries) {
+  const toolUses = /* @__PURE__ */ new Map();
+  for (const { line, entry } of entries) {
+    if (entry.type !== "message") continue;
+    if (entry.message?.role !== "assistant") continue;
+    const isAborted = entry.message.stopReason === "aborted";
+    const content = entry.message.content || [];
+    for (const block of content) {
+      if (block.type === "toolCall" || block.type === "tool_use" || block.type === "functionCall") {
+        if (block.id) {
+          const isPartial = !!block.partialJson;
+          toolUses.set(block.id, {
+            id: block.id,
+            lineNumber: line,
+            entryId: entry.id,
+            isAborted: isAborted || isPartial,
+            isPartial,
+            name: block.name
+          });
+        }
+      }
+    }
+  }
+  return toolUses;
+}
+function findCorruptedEntries(entries, toolUses) {
+  const corrupted = [];
+  const entriesToRemove = /* @__PURE__ */ new Set();
+  for (const [toolId, info] of toolUses) {
+    if (info.isAborted) {
+      corrupted.push({
+        lineNumber: info.lineNumber,
+        entryId: info.entryId,
+        type: "aborted_tool_use",
+        toolUseId: toolId,
+        description: `Aborted tool_use${info.name ? ` (${info.name})` : ""} with id: ${toolId}`
+      });
+      entriesToRemove.add(info.entryId);
+    }
+  }
+  for (const { line, entry } of entries) {
+    if (entry.type !== "message") continue;
+    if (entry.message?.role !== "toolResult") continue;
+    const content = entry.message.content || [];
+    let toolCallId;
+    const msg = entry.message;
+    toolCallId = msg.toolCallId || msg.toolUseId;
+    if (!toolCallId) {
+      for (const block of content) {
+        if (block.toolCallId || block.toolUseId) {
+          toolCallId = block.toolCallId || block.toolUseId;
+          break;
+        }
+      }
+    }
+    if (!toolCallId) continue;
+    const toolUse = toolUses.get(toolCallId);
+    if (!toolUse || toolUse.isAborted) {
+      corrupted.push({
+        lineNumber: line,
+        entryId: entry.id,
+        type: "orphaned_tool_result",
+        toolUseId: toolCallId,
+        description: toolUse ? `Orphaned tool_result references aborted tool_use: ${toolCallId}` : `Orphaned tool_result references non-existent tool_use: ${toolCallId}`
+      });
+      entriesToRemove.add(entry.id);
+    }
+  }
+  return { corrupted, entriesToRemove };
+}
+function computeParentRelinks(entries, entriesToRemove) {
+  const relinks = [];
+  const entryParents = /* @__PURE__ */ new Map();
+  for (const { entry } of entries) {
+    entryParents.set(entry.id, entry.parentId);
+  }
+  for (const { line, entry } of entries) {
+    if (entriesToRemove.has(entry.id)) continue;
+    if (!entry.parentId) continue;
+    if (!entriesToRemove.has(entry.parentId)) continue;
+    let newParentId = entry.parentId;
+    while (newParentId && entriesToRemove.has(newParentId)) {
+      newParentId = entryParents.get(newParentId) || null;
+    }
+    if (newParentId !== entry.parentId) {
+      relinks.push({
+        lineNumber: line,
+        entryId: entry.id,
+        oldParentId: entry.parentId,
+        newParentId: newParentId || "null"
+      });
+    }
+  }
+  return relinks;
+}
+function analyzeSession(filePath) {
+  const entries = parseTranscript(filePath);
+  const sessionEntry = entries.find((e) => e.entry.type === "session");
+  const sessionId = sessionEntry?.entry.id || "unknown";
+  const toolUses = extractToolUses(entries);
+  const { corrupted, entriesToRemove } = findCorruptedEntries(entries, toolUses);
+  const parentRelinks = computeParentRelinks(entries, entriesToRemove);
+  return {
+    sessionId,
+    totalLines: entries.length,
+    corruptedEntries: corrupted,
+    parentRelinks,
+    removedCount: entriesToRemove.size,
+    relinkedCount: parentRelinks.length,
+    repaired: false
+  };
+}
+function repairSession(filePath, options = {}) {
+  const { backup = true, dryRun = false } = options;
+  const entries = parseTranscript(filePath);
+  const sessionEntry = entries.find((e) => e.entry.type === "session");
+  const sessionId = sessionEntry?.entry.id || "unknown";
+  const toolUses = extractToolUses(entries);
+  const { corrupted, entriesToRemove } = findCorruptedEntries(entries, toolUses);
+  const parentRelinks = computeParentRelinks(entries, entriesToRemove);
+  if (corrupted.length === 0) {
+    return {
+      sessionId,
+      totalLines: entries.length,
+      corruptedEntries: [],
+      parentRelinks: [],
+      removedCount: 0,
+      relinkedCount: 0,
+      repaired: false
+    };
+  }
+  if (dryRun) {
+    return {
+      sessionId,
+      totalLines: entries.length,
+      corruptedEntries: corrupted,
+      parentRelinks,
+      removedCount: entriesToRemove.size,
+      relinkedCount: parentRelinks.length,
+      repaired: false
+    };
+  }
+  let backupPath;
+  if (backup) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "-").slice(0, 15);
+    backupPath = `${filePath}.backup-${timestamp}`;
+    fs.copyFileSync(filePath, backupPath);
+  }
+  const relinkMap = /* @__PURE__ */ new Map();
+  for (const relink of parentRelinks) {
+    relinkMap.set(relink.entryId, relink.newParentId === "null" ? null : relink.newParentId);
+  }
+  const repairedLines = [];
+  for (const { entry, raw } of entries) {
+    if (entriesToRemove.has(entry.id)) continue;
+    if (relinkMap.has(entry.id)) {
+      const newEntry = { ...entry, parentId: relinkMap.get(entry.id) };
+      repairedLines.push(JSON.stringify(newEntry));
+    } else {
+      repairedLines.push(raw);
+    }
+  }
+  fs.writeFileSync(filePath, repairedLines.join("\n") + "\n");
+  return {
+    sessionId,
+    totalLines: entries.length,
+    corruptedEntries: corrupted,
+    parentRelinks,
+    removedCount: entriesToRemove.size,
+    relinkedCount: parentRelinks.length,
+    backupPath,
+    repaired: true
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeSession,
+  computeParentRelinks,
+  extractToolUses,
+  findCorruptedEntries,
+  parseTranscript,
+  repairSession
+});

package/dist/lib/session-repair.d.cts

@@ -0,0 +1,110 @@
+/**
+ * Session transcript repair logic
+ *
+ * Repairs corrupted OpenClaw session transcripts by:
+ * 1. Finding aborted tool_use blocks (stopReason: "aborted", partialJson present)
+ * 2. Finding orphaned tool_result messages that reference non-existent tool_use IDs
+ * 3. Removing both the aborted entries and orphaned results
+ * 4. Relinking parent chain references
+ */
+interface TranscriptEntry {
+    type: 'session' | 'message' | 'compaction' | 'custom' | 'thinking_level_change' | string;
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    message?: {
+        role: 'user' | 'assistant' | 'toolResult' | 'system';
+        content: Array<{
+            type: string;
+            id?: string;
+            name?: string;
+            arguments?: unknown;
+            toolCallId?: string;
+            toolUseId?: string;
+            partialJson?: string;
+            text?: string;
+        }>;
+        stopReason?: string;
+        errorMessage?: string;
+    };
+    summary?: string;
+    customType?: string;
+    data?: unknown;
+    thinkingLevel?: string;
+}
+interface ToolUseInfo {
+    id: string;
+    lineNumber: number;
+    entryId: string;
+    isAborted: boolean;
+    isPartial: boolean;
+    name?: string;
+}
+interface CorruptedEntry {
+    lineNumber: number;
+    entryId: string;
+    type: 'aborted_tool_use' | 'orphaned_tool_result';
+    toolUseId: string;
+    description: string;
+}
+interface ParentRelink {
+    lineNumber: number;
+    entryId: string;
+    oldParentId: string;
+    newParentId: string;
+}
+interface RepairResult {
+    sessionId: string;
+    totalLines: number;
+    corruptedEntries: CorruptedEntry[];
+    parentRelinks: ParentRelink[];
+    removedCount: number;
+    relinkedCount: number;
+    backupPath?: string;
+    repaired: boolean;
+}
+/**
+ * Parse a JSONL file into transcript entries with line numbers
+ */
+declare function parseTranscript(filePath: string): Array<{
+    line: number;
+    entry: TranscriptEntry;
+    raw: string;
+}>;
+/**
+ * Extract all tool_use IDs from assistant messages
+ */
+declare function extractToolUses(entries: Array<{
+    line: number;
+    entry: TranscriptEntry;
+}>): Map<string, ToolUseInfo>;
+/**
+ * Find orphaned tool_result messages that reference non-existent or aborted tool_use IDs
+ */
+declare function findCorruptedEntries(entries: Array<{
+    line: number;
+    entry: TranscriptEntry;
+}>, toolUses: Map<string, ToolUseInfo>): {
+    corrupted: CorruptedEntry[];
+    entriesToRemove: Set<string>;
+};
+/**
+ * Compute parent chain relinks after removing entries
+ */
+declare function computeParentRelinks(entries: Array<{
+    line: number;
+    entry: TranscriptEntry;
+}>, entriesToRemove: Set<string>): ParentRelink[];
+/**
+ * Analyze a session transcript for corruption without modifying it
+ */
+declare function analyzeSession(filePath: string): RepairResult;
+/**
+ * Repair a session transcript
+ */
+declare function repairSession(filePath: string, options?: {
+    backup?: boolean;
+    dryRun?: boolean;
+}): RepairResult;
+
+export { type CorruptedEntry, type ParentRelink, type RepairResult, type ToolUseInfo, type TranscriptEntry, analyzeSession, computeParentRelinks, extractToolUses, findCorruptedEntries, parseTranscript, repairSession };

package/dist/lib/session-repair.js

@@ -6,6 +6,7 @@ import {
   parseTranscript,
   repairSession
 } from "../chunk-L53L5FCL.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   analyzeSession,
   computeParentRelinks,

package/dist/lib/session-utils.cjs

@@ -0,0 +1,209 @@
+"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/lib/session-utils.ts
+var session_utils_exports = {};
+__export(session_utils_exports, {
+  backupSession: () => backupSession,
+  findMainSession: () => findMainSession,
+  findSessionById: () => findSessionById,
+  getOpenClawAgentsDir: () => getOpenClawAgentsDir,
+  getOpenClawDir: () => getOpenClawDir,
+  getSessionFilePath: () => getSessionFilePath,
+  getSessionsDir: () => getSessionsDir,
+  getSessionsJsonPath: () => getSessionsJsonPath,
+  listAgents: () => listAgents,
+  listSessions: () => listSessions,
+  loadSessionsStore: () => loadSessionsStore
+});
+module.exports = __toCommonJS(session_utils_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+function validateEnvPath(envValue) {
+  if (!envValue) return null;
+  const trimmed = envValue.trim();
+  if (!trimmed) return null;
+  const resolved = path.resolve(trimmed);
+  if (!path.isAbsolute(resolved)) return null;
+  return resolved;
+}
+function getOpenClawDir() {
+  const customHome = validateEnvPath(process.env.OPENCLAW_HOME);
+  if (customHome) {
+    return customHome;
+  }
+  return path.join(os.homedir(), ".openclaw");
+}
+function getOpenClawAgentsDir() {
+  const stateDir = validateEnvPath(process.env.OPENCLAW_STATE_DIR);
+  if (stateDir) {
+    return path.join(stateDir, "agents");
+  }
+  return path.join(getOpenClawDir(), "agents");
+}
+function getSessionsDir(agentId) {
+  return path.join(getOpenClawAgentsDir(), agentId, "sessions");
+}
+function getSessionsJsonPath(agentId) {
+  return path.join(getSessionsDir(agentId), "sessions.json");
+}
+function getSessionFilePath(agentId, sessionId) {
+  return path.join(getSessionsDir(agentId), `${sessionId}.jsonl`);
+}
+function listAgents() {
+  const agentsDir = getOpenClawAgentsDir();
+  try {
+    if (!fs.existsSync(agentsDir)) {
+      return [];
+    }
+    const stat = fs.statSync(agentsDir);
+    if (!stat.isDirectory()) {
+      return [];
+    }
+    return fs.readdirSync(agentsDir).filter((name) => {
+      try {
+        const sessionsDir = getSessionsDir(name);
+        return fs.existsSync(sessionsDir) && fs.statSync(sessionsDir).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function loadSessionsStore(agentId) {
+  const sessionsJsonPath = getSessionsJsonPath(agentId);
+  if (!fs.existsSync(sessionsJsonPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(sessionsJsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function findMainSession(agentId) {
+  const store = loadSessionsStore(agentId);
+  if (!store) return null;
+  const mainKey = `agent:${agentId}:main`;
+  const entry = store[mainKey];
+  if (entry?.sessionId) {
+    const filePath = getSessionFilePath(agentId, entry.sessionId);
+    if (fs.existsSync(filePath)) {
+      return {
+        sessionId: entry.sessionId,
+        sessionKey: mainKey,
+        agentId,
+        filePath,
+        updatedAt: entry.updatedAt
+      };
+    }
+  }
+  return null;
+}
+function findSessionById(agentId, sessionId) {
+  const filePath = getSessionFilePath(agentId, sessionId);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const store = loadSessionsStore(agentId);
+  let sessionKey;
+  let updatedAt;
+  if (store) {
+    for (const [key, entry] of Object.entries(store)) {
+      if (entry.sessionId === sessionId) {
+        sessionKey = key;
+        updatedAt = entry.updatedAt;
+        break;
+      }
+    }
+  }
+  return {
+    sessionId,
+    sessionKey: sessionKey || `agent:${agentId}:unknown`,
+    agentId,
+    filePath,
+    updatedAt
+  };
+}
+function listSessions(agentId) {
+  const sessionsDir = getSessionsDir(agentId);
+  if (!fs.existsSync(sessionsDir)) {
+    return [];
+  }
+  const store = loadSessionsStore(agentId);
+  const sessions = [];
+  const files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl") && !f.includes(".backup") && !f.includes(".deleted") && !f.includes(".corrupted"));
+  for (const file of files) {
+    const sessionId = file.replace(".jsonl", "");
+    const filePath = path.join(sessionsDir, file);
+    let sessionKey = `agent:${agentId}:unknown`;
+    let updatedAt;
+    if (store) {
+      for (const [key, entry] of Object.entries(store)) {
+        if (entry.sessionId === sessionId) {
+          sessionKey = key;
+          updatedAt = entry.updatedAt;
+          break;
+        }
+      }
+    }
+    sessions.push({
+      sessionId,
+      sessionKey,
+      agentId,
+      filePath,
+      updatedAt
+    });
+  }
+  return sessions.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+}
+function backupSession(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "-").slice(0, 15);
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  backupSession,
+  findMainSession,
+  findSessionById,
+  getOpenClawAgentsDir,
+  getOpenClawDir,
+  getSessionFilePath,
+  getSessionsDir,
+  getSessionsJsonPath,
+  listAgents,
+  listSessions,
+  loadSessionsStore
+});