Files
streamline/.claude/skills/streamline-retro/digest.ts
T
2026-11-16 17:26:44 -08:00

158 lines
6.7 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env bun
// ---------------------------------------------------------------------------
// streamline-retro / digest.ts — collapse a claude stream-json session log into
// a readable timeline.
//
// bun digest.ts <session.jsonl> [--out timeline.md] [--full]
//
// Purely local file processing: no network, no DB. A 3-5 MB session.jsonl is
// ~95% base64 thinking signatures and repeated tool output; the timeline is the
// 1% you actually read when asking "what did the agent do, and where did it go
// wrong". Errors are hoisted to the top so the failure point is the first thing
// visible. Use --full to keep untruncated tool inputs/outputs.
// ---------------------------------------------------------------------------
import { basename } from "node:path";
const args = process.argv.slice(2);
const file = args.find((a) => !a.startsWith("--"));
if (!file) {
console.error("usage: bun digest.ts <session.jsonl> [--out timeline.md] [--full]");
process.exit(2);
}
const full = args.includes("--full");
const outIdx = args.indexOf("--out");
const outFile = outIdx >= 0 ? args[outIdx + 1] : file.replace(/\.jsonl$/, "") + "-timeline.md";
const CAP_IN = full ? 100_000 : 300; // tool_use input
const CAP_OUT = full ? 100_000 : 220; // tool_result output
const CAP_ERR = full ? 100_000 : 1_500; // errored tool_result
const CAP_TEXT = full ? 100_000 : 1_200; // assistant prose
const oneLine = (s: string, cap: number) => {
const t = String(s).replace(/\s+/g, " ").trim();
return t.length > cap ? t.slice(0, cap) + ` …(+${t.length - cap} chars)` : t;
};
const block = (s: string, cap: number) => {
const t = String(s).replace(/\r/g, "").trim();
return t.length > cap ? t.slice(0, cap) + `\n…(+${t.length - cap} chars, rerun with --full)` : t;
};
/** One-line gist of a tool call — the arg that identifies *which* call it was. */
function toolGist(name: string, input: any): string {
if (!input || typeof input !== "object") return "";
const pick = (...keys: string[]) => {
for (const k of keys) if (typeof input[k] === "string" && input[k]) return input[k];
return "";
};
switch (name) {
case "Bash": return oneLine(pick("command"), CAP_IN);
case "Read": case "Write": case "NotebookEdit": return pick("file_path", "notebook_path");
case "Edit": return `${pick("file_path")} ⟨${oneLine(pick("old_string"), 60)}⟩`;
case "Grep": return `${oneLine(pick("pattern"), 80)} in ${pick("path", "glob") || "."}`;
case "Glob": return pick("pattern");
case "Task": case "Agent": return oneLine(pick("description", "prompt"), CAP_IN);
case "TodoWrite": return oneLine(JSON.stringify(input.todos ?? input), 160);
default: return oneLine(JSON.stringify(input), CAP_IN);
}
}
const lines = (await Bun.file(file).text()).split("\n").filter((l) => l.trim());
const out: string[] = [];
const errors: string[] = [];
const statuses: string[] = [];
const toolCounts = new Map<string, number>();
const pendingTool = new Map<string, string>(); // tool_use_id -> "Name gist"
let sessions = 0;
let events = 0;
// The init event carries an empty `model` in stream mode; the first assistant
// message is where the real model id shows up, so patch the header line later.
let modelLineIdx = -1;
let model = "";
for (const raw of lines) {
events++;
let ev: any;
try { ev = JSON.parse(raw); } catch { out.push(`[#${events}] ⚠️ unparseable line`); continue; }
const tag = `[#${events}]`;
if (ev.type === "system" && ev.subtype === "init") {
sessions++;
model = ev.model || "";
out.push("", `## ── session ${sessions} · model=\`${model || "?"}\` · cwd=\`${ev.cwd || "?"}\` · sid=\`${ev.session_id || "?"}\``, "");
modelLineIdx = out.length - 2;
continue;
}
if (ev.type === "assistant" && !model && ev.message?.model && modelLineIdx >= 0) {
model = ev.message.model;
out[modelLineIdx] = out[modelLineIdx].replace("model=`?`", `model=\`${model}\``);
}
if (ev.type === "result") {
const dur = ev.duration_ms ? `${(ev.duration_ms / 60000).toFixed(1)}min` : "?";
const cost = ev.total_cost_usd != null ? `$${Number(ev.total_cost_usd).toFixed(2)}` : "?";
out.push("", `## ── result · subtype=\`${ev.subtype || "?"}\` · turns=${ev.num_turns ?? "?"} · ${dur} · ${cost}${ev.is_error ? " · **is_error**" : ""}`);
if (ev.result) out.push("", "```", block(ev.result, full ? 100_000 : 3_000), "```");
continue;
}
const content = ev.message?.content;
if (!Array.isArray(content)) continue;
for (const c of content) {
if (c.type === "thinking") {
// Signatures are noise; only the (usually empty in stream mode) text matters.
const t = String(c.thinking || "").trim();
if (t) out.push(`${tag} 💭 ${block(t, CAP_TEXT)}`);
continue;
}
if (c.type === "text") {
const t = String(c.text || "").trim();
if (!t) continue;
out.push(`${tag} 💬 ${block(t, CAP_TEXT)}`);
for (const m of t.matchAll(/STATUS:\s*([A-Z_]+)/g)) statuses.push(`${tag} STATUS: ${m[1]}`);
continue;
}
if (c.type === "tool_use") {
const gist = toolGist(c.name, c.input);
toolCounts.set(c.name, (toolCounts.get(c.name) ?? 0) + 1);
pendingTool.set(c.id, `${c.name}${gist ? " " + oneLine(gist, 120) : ""}`);
out.push(`${tag} 🔧 **${c.name}** \`${gist.replace(/`/g, "'")}\``);
continue;
}
if (c.type === "tool_result") {
const body = typeof c.content === "string"
? c.content
: Array.isArray(c.content) ? c.content.map((x: any) => x?.text ?? `[${x?.type}]`).join("\n") : "";
const who = pendingTool.get(c.tool_use_id) ?? "tool";
if (c.is_error) {
const rendered = `${tag} ❌ ${who}\n\`\`\`\n${block(body, CAP_ERR)}\n\`\`\``;
out.push(rendered);
errors.push(rendered);
} else {
out.push(`${tag} ↩︎ ${oneLine(body, CAP_OUT) || "(empty)"}`);
}
continue;
}
}
}
const tools = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]).map(([n, c]) => `${n}×${c}`).join(", ");
const header = [
`# session timeline — ${basename(file)}`,
"",
`- events: **${events}** · sessions(rounds): **${sessions}** · errored tool calls: **${errors.length}**`,
`- tools: ${tools || "(none)"}`,
statuses.length ? `- status sentinels: ${statuses.join(" · ")}` : `- status sentinels: (none found)`,
"",
];
if (errors.length) {
header.push(`## ❌ errored tool calls (${errors.length}) — read these first`, "", ...errors.slice(0, 40), "");
if (errors.length > 40) header.push(`…(+${errors.length - 40} more, see timeline below)`, "");
}
header.push("---", "", "# timeline");
await Bun.write(outFile, header.concat(out).join("\n") + "\n");
console.log(`wrote ${outFile} (${events} events, ${sessions} rounds, ${errors.length} errors, tools: ${tools || "none"})`);