openclaw-node-harness 2.0.0

package/workspace-bin/session-recap

@@ -0,0 +1,453 @@
+#!/usr/bin/env node
+/**
+ * session-recap — Extract a rolling digest from ANY frontend's JSONL transcripts.
+ *
+ * Reads conversation JSONLs, pulls user + assistant TEXT messages
+ * (skips tool calls/results), flattens to single-line entries, and writes a
+ * structured recap to memory/last-session-recap.md.
+ *
+ * Scans ALL transcript sources:
+ *   - Claude Code workspace sessions (~/.claude/projects/-Users-moltymac--openclaw-workspace/)
+ *   - Claude Code home sessions (~/.claude/projects/-Users-moltymac/)
+ *   - OpenClaw Gateway sessions (~/.openclaw/agents/main/sessions/)
+ *
+ * Handles both JSONL formats:
+ *   - Claude Code: {type: "user"/"assistant", message: {role, content}, timestamp}
+ *   - OpenClaw Gateway: {type: "message", message: {role, content}, timestamp}
+ *
+ * Keeps the last 2 session digests (rolling). Each digest is ~15 lines max.
+ * Total bootstrap read cost: ≤40 lines.
+ *
+ * FLAGS:
+ *   --previous    Digest the previous session (not current). Use at session start.
+ *   --all-recent  Digest the 3 most recent NON-current sessions. Full catch-up.
+ *   --list        Show recent JSONL files with sizes and dates.
+ *   (no flags)    Digest the current (most recent) session.
+ *
+ * BOOTSTRAP USAGE:
+ *   Run `bin/session-recap --previous` at the start of every new session.
+ *   This captures whatever the last session (any frontend) did.
+ *
+ * Token cost: ZERO — pure extraction, no AI calls.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// --- Config (portable — derives paths from script location) ---
+const SCRIPT_DIR = path.dirname(fs.realpathSync(__filename));
+const WORKSPACE = process.env.OPENCLAW_WORKSPACE || path.dirname(SCRIPT_DIR);
+const HOME = process.env.HOME || require("os").homedir();
+
+// --- Transcript source discovery ---
+// Primary: read from ~/.openclaw/config/transcript-sources.json (registry-driven)
+// Fallback: hardcoded paths + .config/transcript-sources.txt (legacy)
+const TRANSCRIPT_REGISTRY = path.join(HOME, ".openclaw/config/transcript-sources.json");
+const EXTRA_DIRS_FILE = path.join(WORKSPACE, ".config/transcript-sources.txt");
+
+function resolveSourcePath(p) {
+  if (p.startsWith("~")) return path.join(HOME, p.slice(1));
+  return p;
+}
+
+function loadTranscriptDirs() {
+  // Registry-driven (preferred)
+  if (fs.existsSync(TRANSCRIPT_REGISTRY)) {
+    try {
+      const reg = JSON.parse(fs.readFileSync(TRANSCRIPT_REGISTRY, "utf-8"));
+      return (reg.sources || [])
+        .filter(s => s.enabled !== false)
+        .map(s => resolveSourcePath(s.path));
+    } catch { /* fall through to legacy */ }
+  }
+
+  // Legacy fallback: hardcoded paths + .config/transcript-sources.txt
+  const WORKSPACE_ABS = fs.realpathSync(WORKSPACE);
+  const CLAUDE_PROJECT_SLUG = WORKSPACE_ABS.replace(/[/.]/g, "-");
+  const dirs = [
+    path.join(HOME, ".claude/projects", CLAUDE_PROJECT_SLUG),
+    path.join(HOME, ".claude/projects", "-" + path.basename(HOME)),
+    path.join(HOME, ".openclaw/agents/main/sessions"),
+  ];
+  if (fs.existsSync(EXTRA_DIRS_FILE)) {
+    const lines = fs.readFileSync(EXTRA_DIRS_FILE, "utf-8").split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) dirs.push(trimmed);
+    }
+  }
+  return dirs;
+}
+
+const OUTPUT_FILE = path.join(WORKSPACE, "memory/last-session-recap.md");
+const MAX_DIGESTS = 2;  // 2 sessions max (was 3) — tighter boot cost
+const MAX_TAIL_BYTES = 2 * 1024 * 1024; // 2MB tail — full session coverage (JSONL is mostly tool results)
+const MAX_MESSAGES = 15; // last N text messages to include (was 30) — keep it dense
+const MAX_MSG_LENGTH = 200; // truncate individual messages (was 300) — force concision
+
+// --- Find JSONL sessions across ALL transcript sources, sorted by mtime descending ---
+function findJsonlFiles() {
+  const dirs = loadTranscriptDirs();
+  const all = [];
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    const files = fs.readdirSync(dir).filter(f => f.endsWith(".jsonl"));
+    for (const f of files) {
+      const full = path.join(dir, f);
+      try {
+        const stat = fs.statSync(full);
+        // Skip tiny files (< 50KB) — empty/aborted/heartbeat-only sessions
+        if (stat.size < 50 * 1024) continue;
+        all.push({ name: f, path: full, mtime: stat.mtimeMs, size: stat.size, source: dir });
+      } catch { /* skip unreadable */ }
+    }
+  }
+  return all.sort((a, b) => b.mtime - a.mtime);
+}
+
+// --- Find JSONL by offset (0 = most recent, 1 = previous, etc.) ---
+function findJsonlByOffset(offset = 0) {
+  const files = findJsonlFiles();
+  return offset < files.length ? files[offset] : null;
+}
+
+// --- Find most recent JSONL (backward compat) ---
+function findLatestJsonl() {
+  return findJsonlByOffset(0);
+}
+
+// --- Tail a file (last N bytes) ---
+function tailFile(filePath, bytes) {
+  const stat = fs.statSync(filePath);
+  if (stat.size <= bytes) {
+    return fs.readFileSync(filePath, "utf-8");
+  }
+  const fd = fs.openSync(filePath, "r");
+  const buffer = Buffer.alloc(bytes);
+  fs.readSync(fd, buffer, 0, bytes, stat.size - bytes);
+  fs.closeSync(fd);
+  const text = buffer.toString("utf-8");
+  const firstNewline = text.indexOf("\n");
+  return firstNewline >= 0 ? text.slice(firstNewline + 1) : text;
+}
+
+// --- Flatten text to single line ---
+function flatten(text) {
+  return text.replace(/\n+/g, " ").replace(/\s+/g, " ").trim();
+}
+
+// --- Check if message is noise ---
+function isNoise(text) {
+  if (!text) return true;
+  // Heartbeats
+  if (/^HEARTBEAT_OK\.?\s*$/i.test(text)) return true;
+  if (text.startsWith("Read HEARTBEAT.md")) return true;
+  // Context continuations
+  if (text.startsWith("This session is being continued")) return true;
+  // System event notifications (kanban pushes bundled in user turns)
+  if (/^System:\s*\[/.test(text)) return true;
+  // system-reminder tags
+  if (text.includes("<system-reminder>")) return true;
+  // Queued messages wrapper
+  if (text.startsWith("[Queued messages")) return true;
+  // Task notification XML
+  if (text.startsWith("<task-notification>")) return true;
+  // File paths (screenshots, etc.) without real context
+  if (/^\/Volumes\//.test(text) || /^\/Users\/.*\.(png|jpg|jpeg|gif)$/i.test(text)) return true;
+  // Pure tool narration with no substance
+  if (/^(Let me |I'll |Now let me |Now )(read|check|look|run|search|verify|add|update|wire|build|test|kill|restart)/.test(text) && text.length < 80) return true;
+  // HEARTBEAT_OK embedded in longer text
+  if (text.startsWith("HEARTBEAT_OK") && text.length < 80) return true;
+  return false;
+}
+
+// --- Extract text messages from JSONL (handles both Claude Code and OpenClaw Gateway formats) ---
+function extractMessages(jsonlText) {
+  const lines = jsonlText.split("\n").filter(Boolean);
+  const messages = [];
+
+  // Entry types to skip (OpenClaw Gateway metadata entries)
+  const SKIP_TYPES = new Set([
+    "session", "model_change", "thinking_level_change", "custom",
+    "queue-operation", "tool_result"
+  ]);
+
+  for (const line of lines) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    // Skip non-message entries
+    if (SKIP_TYPES.has(obj.type)) continue;
+
+    // Unified role/content extraction across both JSONL formats:
+    //   Claude Code:      {type: "user"/"assistant", message: {role, content}, timestamp}
+    //   OpenClaw Gateway:  {type: "message", message: {role, content}, timestamp}
+    // Both share the same message.role + message.content structure.
+    const role = obj.message?.role;
+    const content = obj.message?.content;
+    const timestamp = obj.timestamp;
+
+    if (!role || !content || !timestamp) continue;
+
+    // Extract text: user messages are often plain strings, assistant messages are arrays
+    let textBlocks;
+    if (typeof content === "string") {
+      textBlocks = [content];
+    } else if (Array.isArray(content)) {
+      textBlocks = content.filter(b => b.type === "text").map(b => b.text);
+    } else {
+      textBlocks = [];
+    }
+
+    if (textBlocks.length === 0) continue;
+
+    let raw = textBlocks.join(" ").trim();
+
+    // Strip gateway metadata noise: "Conversation info (untrusted metadata): ```json {...} ```"
+    raw = raw.replace(/Conversation info \(untrusted metadata\):\s*```json\s*\{[^}]*\}\s*```\s*/g, '');
+    // Also strip timestamp headers left over from gateway: "[Mon 2026-... GMT-5]"
+    raw = raw.replace(/^\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}\s+GMT[+-]\d+\]\s*/g, '');
+
+    raw = raw.trim();
+    if (isNoise(raw)) continue;
+
+    const text = flatten(raw);
+    if (!text || text.length < 3) continue;
+
+    const truncated = text.length > MAX_MSG_LENGTH
+      ? text.substring(0, MAX_MSG_LENGTH) + "…"
+      : text;
+
+    messages.push({ role, timestamp, text: truncated });
+  }
+
+  return messages.slice(-MAX_MESSAGES);
+}
+
+// --- Format a digest ---
+function formatDigest(messages, sessionFile) {
+  const now = new Date();
+  const ts = now.toLocaleString("en-CA", {
+    timeZone: "America/Montreal",
+    year: "numeric", month: "2-digit", day: "2-digit",
+    hour: "2-digit", minute: "2-digit", hour12: false,
+  });
+
+  const sessionId = path.basename(sessionFile, ".jsonl").slice(0, 8);
+  const lines = [`### Session ${sessionId} — ${ts}`, ""];
+
+  // Collapse consecutive same-role entries (keep last)
+  let lastRole = null;
+  for (const msg of messages) {
+    const tag = msg.role === "user" ? "Gui" : "Daedalus";
+    const entry = `- **${tag}:** ${msg.text}`;
+
+    if (msg.role === lastRole && lines.length > 2) {
+      lines[lines.length - 1] = entry;
+    } else {
+      lines.push(entry);
+    }
+    lastRole = msg.role;
+  }
+
+  lines.push("", "---", "");
+  return lines.join("\n");
+}
+
+// --- Read existing digests, keep last N-1 ---
+function readExistingDigests() {
+  if (!fs.existsSync(OUTPUT_FILE)) return [];
+  const content = fs.readFileSync(OUTPUT_FILE, "utf-8");
+  // Strip the header, then split on session headers
+  const body = content.replace(/^#[^#].*?\n(?:>.*?\n)*/m, "").trim();
+  if (!body) return [];
+  const parts = body.split(/(?=^### Session )/m).filter(s => s.trim());
+  return parts;
+}
+
+// --- Build digest from a single JSONL file ---
+function buildDigest(file) {
+  const raw = tailFile(file.path, MAX_TAIL_BYTES);
+  const messages = extractMessages(raw);
+  if (messages.length === 0) return null;
+  return { digest: formatDigest(messages, file.name), file, msgCount: messages.length };
+}
+
+// --- Session Fingerprint (P4): extract structured tool usage from JSONL ---
+const FINGERPRINT_FILE = path.join(WORKSPACE, ".tmp/session-fingerprint.json");
+
+function extractFingerprint(jsonlText) {
+  const lines = jsonlText.split("\n").filter(Boolean);
+  const filesRead = new Set();
+  const filesEdited = new Set();
+  const commands = [];
+  const skills = new Set();
+  let turnCount = 0;
+  let firstTs = null;
+  let lastTs = null;
+
+  for (const line of lines) {
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+
+    // Track timestamps for duration
+    if (obj.timestamp) {
+      if (!firstTs) firstTs = obj.timestamp;
+      lastTs = obj.timestamp;
+    }
+
+    // Count conversation turns
+    if (obj.message?.role === "user") turnCount++;
+
+    // Extract tool usage from assistant content blocks
+    const content = obj.message?.content;
+    if (!Array.isArray(content)) continue;
+
+    for (const block of content) {
+      if (block.type !== "tool_use") continue;
+
+      const name = block.name;
+      const input = block.input || {};
+
+      if (name === "Read" && input.file_path) {
+        filesRead.add(input.file_path);
+      } else if ((name === "Edit" || name === "Write") && input.file_path) {
+        filesEdited.add(input.file_path);
+      } else if (name === "Bash" && input.command) {
+        const cmd = input.command.split(/\s+/).slice(0, 3).join(" ");
+        if (commands.length < 20) commands.push(cmd);
+      } else if (name === "Skill" && input.skill) {
+        skills.add(input.skill);
+      }
+    }
+  }
+
+  // Duration in minutes
+  let durationMin = 0;
+  if (firstTs && lastTs) {
+    durationMin = Math.round((new Date(lastTs) - new Date(firstTs)) / 60000);
+  }
+
+  return {
+    generatedAt: new Date().toISOString(),
+    turns: turnCount,
+    durationMin,
+    filesRead: [...filesRead].slice(0, 30),
+    filesEdited: [...filesEdited].slice(0, 20),
+    commands: commands.slice(0, 20),
+    skills: [...skills],
+  };
+}
+
+function writeFingerprint(file) {
+  try {
+    const raw = tailFile(file.path, MAX_TAIL_BYTES);
+    const fp = extractFingerprint(raw);
+    fp.sessionFile = path.basename(file.name);
+    fs.writeFileSync(FINGERPRINT_FILE, JSON.stringify(fp, null, 2));
+    console.log(`Fingerprint: ${fp.turns} turns, ${fp.filesEdited.length} files edited, ${fp.durationMin}min`);
+  } catch (e) {
+    // Non-blocking — fingerprint is best-effort
+    console.error(`Fingerprint failed: ${e.message}`);
+  }
+}
+
+// --- Main ---
+function main() {
+  const args = process.argv.slice(2);
+  const previousMode = args.includes("--previous");
+  const allRecentMode = args.includes("--all-recent");
+  const listMode = args.includes("--list");
+
+  // --list: show recent JSONL files with sizes and dates
+  if (listMode) {
+    const files = findJsonlFiles();
+    console.log(`Found ${files.length} JSONL transcripts:\n`);
+    files.slice(0, 10).forEach((f, i) => {
+      const date = new Date(f.mtime).toLocaleString("en-CA", {
+        timeZone: "America/Montreal", hour12: false,
+      });
+      const sizeKB = (f.size / 1024).toFixed(0);
+      const marker = i === 0 ? " ← current" : "";
+      console.log(`  [${i}] ${f.name.slice(0, 8)}… ${sizeKB}KB  ${date}${marker}`);
+    });
+    return;
+  }
+
+  // --all-recent: digest the 3 most recent sessions (skipping current)
+  // --previous: digest only the previous session (offset=1)
+  // default: digest the most recent (offset=0, current session)
+  let targets = [];
+  if (allRecentMode) {
+    // Skip offset 0 (current session), take next 3
+    for (let i = 1; i <= 3; i++) {
+      const f = findJsonlByOffset(i);
+      if (f) targets.push(f);
+    }
+  } else if (previousMode) {
+    const f = findJsonlByOffset(1);
+    if (f) targets.push(f);
+  } else {
+    const f = findJsonlByOffset(0);
+    if (f) targets.push(f);
+  }
+
+  if (targets.length === 0) {
+    console.error("No JSONL transcripts found for the requested range.");
+    process.exit(0);
+  }
+
+  // Build digests for each target
+  const newDigests = [];
+  for (const target of targets) {
+    const result = buildDigest(target);
+    if (result) {
+      newDigests.push(result);
+      console.log(`Recap: ${result.msgCount} msgs → session ${path.basename(target.name, ".jsonl").slice(0, 8)}`);
+    }
+  }
+
+  if (newDigests.length === 0) {
+    console.error("No text messages found in any target transcript.");
+    process.exit(0);
+  }
+
+  // Load existing digests, remove duplicates of sessions we just processed
+  const existing = readExistingDigests();
+  const processedPrefixes = newDigests.map(d =>
+    `### Session ${path.basename(d.file.name, ".jsonl").slice(0, 8)}`
+  );
+  const otherDigests = existing.filter(d =>
+    !processedPrefixes.some(prefix => d.startsWith(prefix))
+  );
+
+  // Combine: new digests first (most recent), then existing, cap at MAX_DIGESTS
+  const allDigests = [...newDigests.map(d => d.digest), ...otherDigests];
+  const kept = allDigests.slice(0, MAX_DIGESTS);
+
+  const header = [
+    "# Last Session Recap",
+    "> Auto-generated by `bin/session-recap`. Rolling buffer: last 2 sessions.",
+    "",
+  ].join("\n");
+
+  const outputDir = path.dirname(OUTPUT_FILE);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(OUTPUT_FILE, header + kept.join(""), "utf-8");
+  console.log(`Written: ${kept.length} digests to ${OUTPUT_FILE}`);
+
+  // Write session fingerprint sidecar (P4)
+  const currentSession = findJsonlByOffset(0);
+  if (currentSession) {
+    writeFingerprint(currentSession);
+  }
+}
+
+main();