atom-agent 1.3.0 → 1.5.0

package/dist/ui/transcript.js

@@ -5,7 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 // All paint comes from ui/theme tokens — no literal colors or glyphs here.
 import React from "react";
 import { Box, Static, Text } from "ink";
-import { SideBySideDiffView, TRANSCRIPT_DIFF_MAX_LINES } from "./side-by-side.js";
+import { SideBySideDiffView } from "./side-by-side.js";
 import { ErrorCard, classifyToolError } from "./errors.js";
 import { MarkdownText, ToolLine } from "./markdown.js";
 import { theme } from "./theme.js";
@@ -53,10 +53,13 @@ export function renderTranscriptItem(item) {
         return _jsx(StartupBanner, {}, item.id);
     const t = item.turn;
     const i = item.id;
-    // Committed thinking blocks read as quiet annotations (never confused
-    // with answers): dim label plus the raw reasoning text, verbatim.
+    // Committed thinking blocks read as one grouped unit (never confused
+    // with answers): dim labeled header plus quoteBar-prefixed body lines —
+    // the same visual language as the live thinking block. The divider lives
+    // inside this row's own box (no extra Static rows), all dim per theme law.
     if (t.thinking === true) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " thinking"] }), _jsx(Text, { dimColor: true, children: t.content })] }, i));
+        const bodyLines = t.content.split("\n");
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " thinking"] }), bodyLines.map((line, idx) => (_jsx(Text, { dimColor: true, children: `${theme.symbol.quoteBar} ${line}` }, idx)))] }, i));
     }
     // Conversation turns (user/assistant) breathe: one blank line after each,
     // so the eye lands on the next turn. Tool/status lines stay dense — they
@@ -73,9 +76,9 @@ export function renderTranscriptItem(item) {
             // write/edit label swallowed by pairing (success line immediately
             // followed by an error line) keeps its committed diff above the card.
             const labelDiff = item.label?.diff;
-            return (_jsxs(React.Fragment, { children: [item.label ? _jsx(ToolLine, { content: item.label.content, ms: item.label.ms }) : null, labelDiff && !item.label?.error ? (_jsx(SideBySideDiffView, { oldText: labelDiff.oldText, newText: labelDiff.newText, lang: labelDiff.lang, maxRows: TRANSCRIPT_DIFF_MAX_LINES })) : null, _jsx(ErrorCard, { classified: classified })] }, i));
+            return (_jsxs(React.Fragment, { children: [item.label ? _jsx(ToolLine, { content: item.label.content, ms: item.label.ms, via: item.label.approvalVia }) : null, labelDiff && !item.label?.error ? (_jsx(SideBySideDiffView, { oldText: labelDiff.oldText, newText: labelDiff.newText, lang: labelDiff.lang, path: labelDiff.path })) : null, _jsx(ErrorCard, { classified: classified })] }, i));
         }
-        return (_jsxs(React.Fragment, { children: [_jsx(ToolLine, { content: t.content, error: t.error, ms: t.ms }), t.diff && !t.error ? (_jsx(SideBySideDiffView, { oldText: t.diff.oldText, newText: t.diff.newText, lang: t.diff.lang, maxRows: TRANSCRIPT_DIFF_MAX_LINES })) : null] }, i));
+        return (_jsxs(React.Fragment, { children: [_jsx(ToolLine, { content: t.content, error: t.error, ms: t.ms, via: t.approvalVia }), t.diff && !t.error ? (_jsx(SideBySideDiffView, { oldText: t.diff.oldText, newText: t.diff.newText, lang: t.diff.lang, path: t.diff.path })) : null] }, i));
     }
     return (_jsxs(Box, { flexDirection: "column", marginBottom: theme.spacing.turnGap, children: [_jsx(Text, { children: _jsxs(Text, { color: theme.color.assistant, bold: true, children: [theme.symbol.speakerAssistant, " "] }) }), _jsx(MarkdownText, { text: t.content })] }, i));
 }

package/dist/web/events.js

@@ -0,0 +1,93 @@
+// WebUI event protocol: the SSE vocabulary the browser consumes.
+//
+// Every kind maps 1:1 to an existing ATOM callback or sink — nothing is
+// invented. The runtime (./runtime.js) translates, this module only defines
+// and serializes:
+//
+// - token / thinking  ← StreamCallbacks.onToken / onThinking (accumulated
+//   text, same value the TUI renders in its live tail)
+// - phase             ← StreamCallbacks.onPhase ("thinking" | "streaming" |
+//   "tool" | "retry" | "done", detail carries the tool name / retry summary)
+// - tool_delta        ← StreamCallbacks.onToolDelta (name revealed mid-stream)
+// - tool_started /
+//   tool_finished      ← TurnEventsSink.onToolStarted / onToolFinished
+//   (stable toolCallId + name + index / isError — never display labels)
+// - tool_call          ← the approve() gate decision (name + effective args +
+//   description + decision + provenance — the only pre-execution arg source)
+// - tool_activity     ← AgenticOpts.onToolActivity (label + result + isError)
+// - tool_result        ← AgenticOpts.onToolResult (name + effective args +
+//   result + isError for EVERY committed call, including read-only tools
+//   that never consult approve; result text capped, see truncateEventText)
+// - file_diff          ← write/edit commits only: op (created/modified) +
+//   pre-computed unified hunks + side-by-side rows from src/ui/diff.ts
+//   (the same engine the TUI approval preview uses), all text-capped.
+//   ATOM has no delete tool and bash side effects are opaque by design
+//   (see src/rollback.ts), so deletions never appear as file events.
+// - usage             ← AgenticOpts.onUsage (API-reported tokens only)
+// - reasoning         ← AgenticOpts.onReasoning (per-POST reasoning label)
+// - warning           ← StreamCallbacks.onWarning
+// - approval_request /
+//   approval_resolved  ← the approve() gate (write/edit/bash in normal mode;
+//   the turn blocks until the browser POSTs a decision)
+// - question_request /
+//   question_resolved  ← the askUser() hook (ask_question tool; same blocking
+//   contract as approvals)
+// - message           ← committed transcript turns (user/assistant/tool rows)
+// - error             ← failed POST / tool-throw abort (caller rolls back)
+// - done / cancelled  ← clean turn end / LoopCancelledError rollback
+//
+// Pure module: types + SSE serialization only. No I/O, no loop imports.
+export function createWebEvent(seq, kind, data) {
+    return {
+        seq,
+        at: new Date().toISOString(),
+        kind,
+        data: data ?? {},
+    };
+}
+// Serialize one event as an SSE frame. `id:` carries the sequence so an
+// EventSource client resumes without gaps; `event:` carries the kind so the
+// browser dispatches without parsing the body first.
+export function formatSSE(event) {
+    return `id: ${event.seq}\nevent: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`;
+}
+// SSE response headers shared by every event stream on the server.
+export function sseHeaders() {
+    return {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+        Connection: "keep-alive",
+    };
+}
+// Parse one SSE frame back (tests + future resumable clients). Returns null
+// for heartbeats/comments or malformed frames — never throws.
+export function parseSSEFrame(frame) {
+    try {
+        const lines = frame.split("\n");
+        const dataLine = lines.find((l) => l.startsWith("data:"));
+        if (!dataLine)
+            return null;
+        const parsed = JSON.parse(dataLine.slice("data:".length).trim());
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const o = parsed;
+        if (typeof o["seq"] !== "number" || typeof o["kind"] !== "string")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+// Reconnect replay: events after the client's last seen id, oldest first.
+// Pure (unit-tested); the runtime and the SSE route share it.
+export function eventsAfter(log, lastEventId) {
+    if (typeof lastEventId !== "number" || !Number.isFinite(lastEventId))
+        return [];
+    return log.filter((e) => e.seq > lastEventId);
+}
+// Heartbeat comment (keeps proxies/load-balancers from closing idle turns).
+export function sseHeartbeat() {
+    return `: ping\n\n`;
+}