spexcode 0.6.8 → 0.7.0-next.1

package/node_modules/@spexcode/transcript/dist/parsers.js

@@ -0,0 +1,395 @@
+import { TranscriptReadError } from './turns.js';
+// ONE PARSER PER HARNESS. Each function turns one native record — a line of Claude's project JSONL (which is
+// also exactly what its `--output-format stream-json` prints), a Codex rollout line, a pi session line, an
+// OpenCode export — into the normalized event the interval collector consumes. The same parser serves a file
+// being tailed ([[transcript-reader]]) and an event stream held in memory ([[live-transcript]]): the source is
+// where bytes come from, the parser is what they mean, and neither knows the other.
+export const MAX_TURNS = 200;
+export const MAX_OUTPUT_BYTES = 64 * 1024;
+const object = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+const items = (value) => Array.isArray(value) ? value : [];
+const string = (value) => typeof value === 'string' && value.trim() ? value : null;
+const idOf = (value) => {
+    if (!value)
+        return null;
+    for (const key of ['id', 'uuid', 'message_id', 'messageId', 'call_id', 'callId', 'client_id', 'clientId']) {
+        const found = string(value[key]);
+        if (found)
+            return found;
+    }
+    return null;
+};
+const timestamp = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric))
+        return numeric;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+const at = (value) => {
+    if (!value)
+        return null;
+    for (const key of ['timestamp', 'created_at', 'createdAt', 'created', 'time']) {
+        const candidate = timestamp(value[key]);
+        if (candidate !== null)
+            return candidate;
+    }
+    return null;
+};
+const compact = (value) => {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const lineCount = (value) => value ? value.split(/\r?\n/).length : 0;
+// --- the seven native shapes -------------------------------------------------------------------------------
+export function claudeEvent(value) {
+    const entry = object(value);
+    const message = object(entry?.message);
+    if (!entry || !message)
+        return null;
+    const eventAt = at(entry) ?? at(message);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    if (entry.type === 'user' && message.role === 'user') {
+        const blocks = items(message.content);
+        const text = typeof message.content === 'string'
+            ? string(message.content)
+            : blocks.map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
+        const outputs = blocks.flatMap((block) => {
+            const b = object(block);
+            const id = string(b?.tool_use_id);
+            return b?.type === 'tool_result' && id ? [{ id, text: compact(b?.content ?? '') }] : [];
+        });
+        if (outputs.length)
+            return { at: eventAt, turn: null, toolOutputs: outputs };
+        if (text)
+            return { at: eventAt, turn: { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'user', text, tools: [] } };
+    }
+    if (entry.type === 'assistant' && message.role === 'assistant') {
+        const turn = { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'assistant', tools: [] };
+        for (const blockValue of items(message.content)) {
+            const block = object(blockValue);
+            if (block?.type === 'text')
+                turn.text = [turn.text, string(block.text)].filter(Boolean).join('\n') || undefined;
+            if (block?.type === 'tool_use') {
+                const id = string(block.id) ?? `tool-${turn.tools.length}`;
+                turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.input === undefined ? undefined : compact(block.input), outputLines: 0, outputBytes: 0 });
+            }
+        }
+        return { at: eventAt, turn };
+    }
+    return null;
+}
+export function codexEvent(value) {
+    const entry = object(value);
+    const payload = object(entry?.payload);
+    if (!entry || !payload)
+        return null;
+    const eventAt = at(payload) ?? at(entry);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    const type = string(payload.type);
+    if ((entry.type === 'event_msg' && type === 'user_message')
+        || (entry.type === 'response_item' && (type === 'message' || type === 'input_message') && payload.role === 'user')) {
+        const text = typeof payload.message === 'string' ? payload.message : compact(payload.message ?? payload.content ?? '');
+        return text ? { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'user', text, tools: [] } } : null;
+    }
+    // commentary AND the final answer are both what the agent said; only structured reasoning stays private
+    if (entry.type === 'event_msg' && type === 'agent_message') {
+        const text = string(payload.message ?? payload.text);
+        return text ? { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'assistant', text, tools: [] } } : null;
+    }
+    if (entry.type === 'response_item' && (type === 'custom_tool_call' || type === 'function_call')) {
+        const id = string(payload.call_id ?? payload.id) ?? 'tool';
+        return { at: eventAt, turn: { id: idOf(payload) ?? idOf(entry), at: eventAt, role: 'assistant', tools: [{ id, name: string(payload.name ?? payload.tool_name) ?? 'tool', input: payload.input === undefined && payload.arguments === undefined ? undefined : compact(payload.input ?? payload.arguments), outputLines: 0, outputBytes: 0 }] } };
+    }
+    if (entry.type === 'response_item' && (type === 'custom_tool_call_output' || type === 'function_call_output')) {
+        const id = string(payload.call_id ?? payload.id);
+        const output = payload.output ?? payload.result ?? '';
+        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: compact(output) }] } : null;
+    }
+    return null;
+}
+const blockText = (content) => typeof content === 'string'
+    ? string(content)
+    : items(content).map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
+export function piEvent(value) {
+    const entry = object(value);
+    const message = object(entry?.message);
+    if (!entry || entry.type !== 'message' || !message)
+        return null;
+    const eventAt = at(entry) ?? at(message);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    if (message.role === 'user') {
+        const text = blockText(message.content);
+        return text ? { at: eventAt, turn: { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'user', text, tools: [] } } : null;
+    }
+    if (message.role === 'assistant') {
+        const turn = { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'assistant', tools: [] };
+        for (const blockValue of items(message.content)) {
+            const block = object(blockValue);
+            if (block?.type === 'text')
+                turn.text = [turn.text, string(block.text)].filter(Boolean).join('\n') || undefined;
+            if (block?.type === 'toolCall') {
+                const id = string(block.id) ?? `tool-${turn.tools.length}`;
+                turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.arguments === undefined ? undefined : compact(block.arguments), outputLines: 0, outputBytes: 0 });
+            }
+        }
+        return { at: eventAt, turn };
+    }
+    if (message.role === 'toolResult') {
+        const id = string(message.toolCallId);
+        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? '') }] } : null;
+    }
+    return null;
+}
+export function geminiEvent(value) {
+    const entry = object(value);
+    const message = (entry?.type === 'user' || entry?.type === 'gemini')
+        ? entry
+        : object(items(entry?.messages)[0]) ?? object(items(object(entry?.$set)?.messages)[0]);
+    if (!entry || !message)
+        return null;
+    const eventAt = at(message) ?? at(entry);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    const content = message.content;
+    const blocks = items(content);
+    const outputs = blocks.flatMap((blockValue) => {
+        const block = object(blockValue);
+        const response = object(block?.functionResponse);
+        const id = string(response?.id);
+        return id ? [{ id, text: compact(response?.response ?? '') }] : [];
+    });
+    if (outputs.length)
+        return { at: eventAt, turn: null, toolOutputs: outputs };
+    if (message.type === 'user') {
+        const text = typeof content === 'string' ? string(content) : blocks.map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
+        return text ? { at: eventAt, turn: { id: idOf(message), at: eventAt, role: 'user', text, tools: [] } } : null;
+    }
+    if (message.type === 'gemini') {
+        const turn = { id: idOf(message), at: eventAt, role: 'assistant', tools: [] };
+        if (typeof content === 'string')
+            turn.text = string(content) ?? undefined;
+        for (const callValue of items(message.toolCalls)) {
+            const call = object(callValue);
+            const id = string(call?.id) ?? `tool-${turn.tools.length}`;
+            turn.tools.push({ id, name: string(call?.name) ?? 'tool', input: call?.args === undefined ? undefined : compact(call.args), outputLines: 0, outputBytes: 0 });
+        }
+        if (!turn.text && !turn.tools.length)
+            return null;
+        return { at: eventAt, turn };
+    }
+    return null;
+}
+export function openclawEvent(value) {
+    const entry = object(value);
+    const message = object(entry?.message);
+    if (!entry || entry.type !== 'message' || !message)
+        return null;
+    const eventAt = at(message) ?? at(entry);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    if (message.role === 'user') {
+        const text = blockText(message.content);
+        return text ? { at: eventAt, turn: { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'user', text, tools: [] } } : null;
+    }
+    if (message.role === 'toolResult') {
+        const id = string(message.toolCallId);
+        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? '') }] } : null;
+    }
+    if (message.role === 'assistant') {
+        const turn = { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'assistant', tools: [] };
+        for (const blockValue of items(message.content)) {
+            const block = object(blockValue);
+            if (block?.type === 'text')
+                turn.text = [turn.text, string(block.text)].filter(Boolean).join('\n') || undefined;
+            if (block?.type === 'toolCall') {
+                const id = string(block.id) ?? `tool-${turn.tools.length}`;
+                turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.arguments === undefined ? undefined : compact(block.arguments), outputLines: 0, outputBytes: 0 });
+            }
+        }
+        return turn.text || turn.tools.length ? { at: eventAt, turn } : null;
+    }
+    return null;
+}
+export function hermesEvents(value) {
+    const root = object(value);
+    const events = [];
+    for (const messageValue of items(root?.messages)) {
+        const message = object(messageValue);
+        if (!message)
+            continue;
+        const eventAt = at(message);
+        if (eventAt === null) {
+            events.push({ at: null, turn: null });
+            continue;
+        }
+        const role = message.role;
+        if (role === 'user') {
+            const text = string(message.content);
+            if (text)
+                events.push({ at: eventAt, turn: { id: idOf(message), at: eventAt, role: 'user', text, tools: [] } });
+        }
+        else if (role === 'assistant') {
+            const turn = { id: idOf(message), at: eventAt, role: 'assistant', tools: [] };
+            const text = string(message.content);
+            if (text)
+                turn.text = text;
+            for (const callValue of items(message.tool_calls)) {
+                const call = object(callValue);
+                const fn = object(call?.function);
+                const id = string(call?.id) ?? `tool-${turn.tools.length}`;
+                turn.tools.push({ id, name: string(fn?.name) ?? 'tool', input: fn?.arguments === undefined ? undefined : compact(fn.arguments), outputLines: 0, outputBytes: 0 });
+            }
+            if (turn.text || turn.tools.length)
+                events.push({ at: eventAt, turn });
+        }
+        else if (role === 'tool') {
+            const id = string(message.tool_call_id);
+            if (id)
+                events.push({ at: eventAt, turn: null, toolOutputs: [{ id, text: compact(message.content ?? '') }] });
+        }
+    }
+    return events;
+}
+// OpenCode's export is one JSON document, not a line stream: every message arrives with its parts, and a tool
+// part already carries its own result — so its turn is complete on arrival, and a part still running simply has
+// no output yet.
+export function opencodeEvents(value) {
+    const events = [];
+    for (const messageValue of items(object(value)?.messages)) {
+        const message = object(messageValue);
+        const info = object(message?.info);
+        if (!message || !info)
+            continue;
+        const eventAt = at(object(info.time)) ?? at(info);
+        if (eventAt === null) {
+            events.push({ at: null, turn: null });
+            continue;
+        }
+        const role = info.role === 'user' ? 'user' : info.role === 'assistant' ? 'assistant' : null;
+        if (!role)
+            continue;
+        const turn = { id: idOf(info) ?? idOf(message), at: eventAt, role, tools: [] };
+        for (const partValue of items(message.parts)) {
+            const part = object(partValue);
+            if (part?.type === 'text')
+                turn.text = [turn.text, string(part.text)].filter(Boolean).join('\n') || undefined;
+            if (part?.type === 'tool' && role === 'assistant') {
+                const state = object(part.state);
+                const status = (string(state?.status) ?? '').toLowerCase();
+                const tool = { id: string(part.callID ?? part.id) ?? `tool-${turn.tools.length}`, name: string(part.tool) ?? 'tool', input: state?.input === undefined ? undefined : compact(state.input), outputLines: 0, outputBytes: 0 };
+                if (/completed|error|cancelled/.test(status)) {
+                    const output = compact(state?.output ?? state?.error ?? '');
+                    tool.output = output.slice(0, MAX_OUTPUT_BYTES);
+                    tool.outputBytes = Buffer.byteLength(output);
+                    tool.outputLines = lineCount(output);
+                }
+                turn.tools.push(tool);
+            }
+        }
+        if (role === 'user' && !turn.text)
+            continue;
+        events.push({ at: eventAt, turn });
+    }
+    return events;
+}
+// --- reading an interval ------------------------------------------------------------------------------------
+// Collects the interval's turns from any event source. Caps keep the NEWEST turns, because a live tail and a
+// closed stretch are both read for what happened last; every dropped turn or byte is counted, never hidden.
+export class IntervalCollector {
+    turns = [];
+    byTool = new Map();
+    evicted = new Set();
+    synthesized = new Map(); // `<role>@<at>` → how many turns already wore it
+    sawTimestamp = false;
+    omittedTurns = 0;
+    omittedBytes = 0;
+    outOfOrderEvents = 0;
+    pastRange = false;
+    range;
+    constructor(range) { this.range = { from: range.from, to: range.to }; }
+    // the open interval's end is "now" and moves; extending it never revisits what was already collected
+    extend(to) { if (to > this.range.to)
+        this.range.to = to; }
+    // returns true once the source has moved past `to` (the caller may then bound its lookahead)
+    add(event) {
+        const eventAt = event.at;
+        if (eventAt === null)
+            return this.pastRange;
+        this.sawTimestamp = true;
+        if (!this.pastRange && eventAt > this.range.to)
+            this.pastRange = true;
+        else if (this.pastRange && eventAt <= this.range.to)
+            this.outOfOrderEvents++;
+        if (eventAt < this.range.from || eventAt > this.range.to)
+            return this.pastRange;
+        if (event.toolOutputs) {
+            for (const output of event.toolOutputs) {
+                const bytes = Buffer.byteLength(output.text);
+                const tool = this.byTool.get(output.id);
+                if (!tool || this.evicted.has(output.id)) {
+                    this.omittedBytes += bytes;
+                    continue;
+                }
+                tool.outputBytes += bytes;
+                tool.outputLines += lineCount(output.text);
+                if (tool.output === undefined)
+                    tool.output = '';
+                const remaining = Math.max(0, MAX_OUTPUT_BYTES - Buffer.byteLength(tool.output));
+                tool.output += output.text.slice(0, remaining);
+                if (bytes > remaining)
+                    this.omittedBytes += bytes - remaining;
+            }
+        }
+        else if (event.turn) {
+            // the parsed event is never written to: an in-memory source ([[live-transcript]]) collects the same
+            // event again on every read, so the collector works on its own copy of the turn and its calls
+            const turn = { ...event.turn, tools: event.turn.tools.map((tool) => ({ ...tool })) };
+            // a turn without a native id gets one from its place in the thread — deterministic across re-reads of an
+            // append-only source, which is what lets a subscriber match it between frames
+            if (turn.id === null) {
+                const base = `${turn.role}@${turn.at}`;
+                const seen = this.synthesized.get(base) ?? 0;
+                this.synthesized.set(base, seen + 1);
+                turn.id = seen ? `${base}#${seen}` : base;
+            }
+            this.turns.push(turn);
+            for (const tool of turn.tools)
+                this.byTool.set(tool.id, tool);
+            if (this.turns.length > MAX_TURNS) {
+                const dropped = this.turns.shift();
+                for (const tool of dropped.tools)
+                    this.evicted.add(tool.id);
+                this.omittedTurns++;
+            }
+        }
+        return this.pastRange;
+    }
+    finish(revision, harness) {
+        if (!this.sawTimestamp)
+            throw new TranscriptReadError('invalid', `${harness} transcript has no reliable timestamps; interval reads are unavailable`);
+        return {
+            revision,
+            from: this.range.from,
+            to: this.range.to,
+            turns: this.turns.map((turn) => ({ ...turn, id: turn.id, tools: turn.tools.length ? turn.tools.map((tool) => ({ ...tool })) : undefined })),
+            truncated: this.omittedTurns > 0 || this.omittedBytes > 0 || this.outOfOrderEvents > 0,
+            omittedTurns: this.omittedTurns,
+            omittedBytes: this.omittedBytes,
+            outOfOrderEvents: this.outOfOrderEvents,
+        };
+    }
+}

package/node_modules/@spexcode/transcript/dist/readers.d.ts

@@ -0,0 +1,16 @@
+import { type TranscriptReader } from './turns.js';
+export declare function claudeTranscriptPath(threadId: string, root?: string): string | null;
+export declare function codexRolloutPath(threadId: string, root?: string): string | null;
+export declare function piSessionPath(threadId: string, root?: string): string | null;
+export declare function geminiTranscriptPath(threadId: string, root?: string): string | null;
+export declare function openclawTranscriptPath(threadId: string, root?: string): string | null;
+export declare const claudeTranscript: TranscriptReader;
+export declare const codexTranscript: TranscriptReader;
+export declare const piTranscript: TranscriptReader;
+export declare const geminiTranscript: TranscriptReader;
+export declare const openclawTranscript: TranscriptReader;
+export declare function opencodeTranscriptReader(root?: string, load?: (threadId: string) => string): TranscriptReader;
+export declare const opencodeTranscript: TranscriptReader;
+export declare function hermesTranscriptReader(root?: string, load?: (threadId: string) => string): TranscriptReader;
+export declare const hermesTranscript: TranscriptReader;
+export declare function unsupportedTranscript(harness: string): TranscriptReader;