atom-agent 1.0.0 → 1.1.0

package/dist/ui/side-by-side.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Side-by-side diff view for write/edit results: BEFORE pane (left) vs
+// AFTER pane (right), aligned rows, preserved line numbers.
+//
+// Requirements it answers (presentation only — data comes from the
+// existing approve-time preview / commit slot, tool behavior untouched):
+// - left = original, right = result; additions right, removals left,
+//   context on both sides; paired changes share ONE row so corresponding
+//   lines align; changed regions pop via the existing word-background +
+//   add/del line-number treatment; syntax colors reused per cell.
+// - hunks only (configurable context in the engine) — never whole files.
+// - width-aware: panes split the measured terminal (useStdout, same
+//   pattern as App's termColumns); long lines truncate per pane with …
+//   (code-point safe); below NARROW_COLUMNS the view degrades to the
+//   stacked unified DiffView instead of destroying the layout.
+// - computed once per mount (useMemo, keyed on inputs + pane width) and
+//   capped (maxRows + trailer) — never recomputed per tick, never floods.
+// All paint comes from ui/theme tokens.
+import React from "react";
+import { Box, Text } from "ink";
+import { useStdout } from "ink";
+import { computeSideBySide, wordRuns } from "./diff.js";
+import { DiffView, LineBody } from "./diff-view.js";
+import { theme } from "./theme.js";
+// Below this width two panes cannot breathe — stack unified instead.
+export const SBS_NARROW_COLUMNS = 70;
+// Committed-transcript cap (rows, context + change): the scrollback shows
+// the reviewable head; the file on disk is the whole truth. The engine
+// still truncates past 400 changed lines with its own notice.
+export const TRANSCRIPT_DIFF_MAX_LINES = 120;
+function truncateTo(s, width) {
+    const chars = [...s];
+    if (chars.length <= width)
+        return s;
+    if (width < 4)
+        return "";
+    return chars.slice(0, width - 1).join("") + theme.symbol.ellipsis;
+}
+// Fit engine rows to a pane content width: truncate cell texts (with …)
+// and re-derive word runs on the truncated pair so offsets always tile
+// the displayed text. Runs once per mount/width — never per tick.
+function fitRows(rows, contentW) {
+    return rows.map((r) => {
+        if (r.kind === "context") {
+            return {
+                kind: "context",
+                left: { no: r.oldNo, text: truncateTo(r.text, contentW) },
+                right: { no: r.newNo, text: truncateTo(r.text, contentW) },
+            };
+        }
+        const tOld = r.oldText !== null ? truncateTo(r.oldText, contentW) : null;
+        const tNew = r.newText !== null ? truncateTo(r.newText, contentW) : null;
+        let oldRuns = [];
+        let newRuns = [];
+        if (tOld !== null && tNew !== null) {
+            const w = wordRuns(tOld, tNew);
+            oldRuns = w.del;
+            newRuns = w.add;
+        }
+        else if (tOld !== null) {
+            oldRuns = tOld === "" ? [] : [{ text: tOld, changed: false }];
+        }
+        else if (tNew !== null) {
+            newRuns = tNew === "" ? [] : [{ text: tNew, changed: false }];
+        }
+        const changed = oldRuns.some((x) => x.changed) ||
+            newRuns.some((x) => x.changed) ||
+            (r.oldText === null) !== (r.newText === null);
+        return {
+            kind: "change",
+            changed,
+            left: tOld !== null ? { no: r.oldNo, text: tOld, runs: oldRuns } : null,
+            right: tNew !== null ? { no: r.newNo, text: tNew, runs: newRuns } : null,
+        };
+    });
+}
+function padEnd(s, width) {
+    const len = [...s].length;
+    if (len >= width)
+        return s;
+    return s + " ".repeat(width - len);
+}
+function SideBySideInner({ oldText, newText, lang = null, maxRows = Infinity, columns, }) {
+    let stdoutCols;
+    try {
+        stdoutCols = useStdout()?.stdout?.columns;
+    }
+    catch {
+        stdoutCols = undefined;
+    }
+    const totalW = columns ?? stdoutCols ?? 100;
+    const sbs = React.useMemo(() => computeSideBySide(oldText, newText), [oldText, newText]);
+    if (sbs.kind === "same") {
+        return _jsx(Text, { dimColor: true, children: "(no changes \u2014 file unchanged)" });
+    }
+    if (sbs.kind === "binary") {
+        return _jsx(Text, { dimColor: true, children: "binary file changed" });
+    }
+    if (sbs.kind === "skipped") {
+        return _jsx(Text, { dimColor: true, children: sbs.reason });
+    }
+    // Graceful narrow-terminal degrade: stacked unified keeps every char
+    // instead of crushing two panes into unreadable slivers.
+    if (totalW < SBS_NARROW_COLUMNS) {
+        return _jsx(DiffView, { oldText: oldText, newText: newText, lang: lang, maxLines: maxRows });
+    }
+    const sep = ` ${theme.symbol.bar} `;
+    const paneW = Math.max(20, Math.floor((totalW - sep.length) / 2));
+    let maxNo = 0;
+    for (const r of sbs.rows) {
+        if (r.kind === "context")
+            maxNo = Math.max(maxNo, r.oldNo, r.newNo);
+        else {
+            if (r.oldNo !== null)
+                maxNo = Math.max(maxNo, r.oldNo);
+            if (r.newNo !== null)
+                maxNo = Math.max(maxNo, r.newNo);
+        }
+    }
+    const numW = String(Math.max(maxNo, 1)).length;
+    const contentW = Math.max(8, paneW - numW - 1);
+    const view = React.useMemo(() => fitRows(sbs.rows, contentW), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [sbs, contentW]);
+    const shown = view.slice(0, maxRows);
+    const overflow = Math.max(0, view.length - shown.length);
+    const renderCell = (no, body, opts) => {
+        const num = no === null ? " ".repeat(numW) : padEnd(String(no), numW);
+        return (_jsxs(Text, { children: [_jsxs(Text, { color: opts.numColor, dimColor: opts.numColor === undefined || opts.dim, children: [num, " "] }), body] }));
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [sbs.isNewFile ? "new file " : "", "+", sbs.adds, " \u2212", sbs.dels] }), _jsxs(Text, { children: [_jsx(Text, { bold: true, children: padEnd("BEFORE", paneW) }), _jsx(Text, { dimColor: true, children: sep }), _jsx(Text, { bold: true, children: "AFTER" })] }), shown.map((r, k) => {
+                if (r.kind === "context") {
+                    return (_jsxs(Text, { children: [renderCell(r.left.no, _jsx(Text, { dimColor: true, children: r.left.text }), { dim: true }), _jsx(Text, { dimColor: true, children: sep }), renderCell(r.right.no, _jsx(Text, { dimColor: true, children: r.right.text }), { dim: true })] }, k));
+                }
+                const leftNumColor = r.left !== null && r.changed ? theme.color.toolError : undefined;
+                const rightNumColor = r.right !== null && r.changed ? theme.color.success : undefined;
+                return (_jsxs(Text, { children: [r.left !== null
+                            ? renderCell(r.left.no, _jsx(LineBody, { lineText: r.left.text, runs: r.left.runs, base: "del", lang: lang }), { numColor: leftNumColor, dim: !r.changed })
+                            : renderCell(null, _jsx(Text, { children: padEnd("", contentW) }), { dim: true }), _jsx(Text, { dimColor: true, children: sep }), r.right !== null
+                            ? renderCell(r.right.no, _jsx(LineBody, { lineText: r.right.text, runs: r.right.runs, base: "add", lang: lang }), { numColor: rightNumColor, dim: !r.changed })
+                            : renderCell(null, _jsx(Text, { children: padEnd("", contentW) }), { dim: true })] }, k));
+            }), overflow > 0 ? _jsxs(Text, { dimColor: true, children: ["\u2026 ", overflow, " more row", overflow === 1 ? "" : "s"] }) : null, sbs.truncated ? _jsx(Text, { dimColor: true, children: "(diff truncated at 400 changed lines)" }) : null] }));
+}
+export const SideBySideDiffView = React.memo(SideBySideInner);

package/dist/ui/status-bar.js

@@ -1,4 +1,14 @@
 import { Fragment as _Fragment, jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+// Status bar leaf: the sole info bar, state-prioritized and quiet.
+// - idle: provider/model │ token │ cwd[:branch] │ reasoning │ mode.
+//   Labels are positional (no `provider:` prefixes); mode/trust show always
+//   (pinned), cwd shortens, branch only for git repos.
+// - busy: activity │ elapsed │ token │ reasoning │ mode │ esc-hint (+waiting/approval flags).
+//   Provider/model/cwd drop while working — the activity, the
+//   clock, context pressure, effort, and the pinned mode are what matter mid-turn.
+// All paint comes from ui/theme tokens. The token segment formatter lives
+// in context-windows (its only surface).
+import React from "react";
 import { Box, Text } from "ink";
 import { formatTokenSegment } from "../context-windows.js";
 import { theme } from "./theme.js";
@@ -20,7 +30,12 @@ export function shrinkTo(s, n) {
         return "";
     return `…/${s.slice(-(n - 3))}`;
 }
-export function StatusBar({ provider, model, usageTotals, contextLoad, reasoningDisplay, mode, trustAll, busy, activity, phaseLabel, elapsedSecs, stalled, approvalPending, cwd, branch, columns = 100, }) {
+// Render-count probe for the flicker tests: incremented on every StatusBar
+// render (same-props parent churn — token paints, keystrokes, unrelated
+// ticks — must skip it; only changed props repaint).
+export const statusBarRenderProbe = { count: 0 };
+export const StatusBar = React.memo(function StatusBar({ provider, model, usageTotals, contextLoad, reasoningDisplay, mode, trustAll, busy, activity, phaseLabel, elapsedSecs, stalled, approvalPending, cwd, branch, columns = 100, }) {
+    statusBarRenderProbe.count += 1;
     const bar = theme.symbol.bar;
     if (!busy) {
         const token = formatTokenSegment(usageTotals, model, contextLoad);
@@ -49,11 +64,12 @@ export function StatusBar({ provider, model, usageTotals, contextLoad, reasoning
         return (_jsx(Box, { marginTop: theme.spacing.statusMarginTop, children: _jsxs(Text, { dimColor: true, children: [provider, "/", model, " ", bar, " ", token, loc ? (_jsxs(_Fragment, { children: [" ", bar, " ", loc] })) : null, " ", bar, " reasoning: ", reasoningDisplay, " ", bar, " mode: ", mode, trust ? "+trust" : null] }) }));
     }
     // Busy layout prioritizes activity + clock + interrupt hint; the mode
-    // stays pinned (it used to vanish while working). The activity text
+    // stays pinned (it used to vanish while working), and the reasoning
+    // effort stays visible (it used to vanish while working). The activity text
     // shrinks to fit so `esc stops` never wraps away.
     const busyTrust = trustAll && mode !== "plan" ? "+trust" : "";
-    const busyFixed = ` ${bar} ${elapsedSecs}s ${bar} ${formatTokenSegment(usageTotals, model, contextLoad)} ${bar} mode: ${mode}${busyTrust} ${bar} esc stops`;
+    const busyFixed = ` ${bar} ${elapsedSecs}s ${bar} ${formatTokenSegment(usageTotals, model, contextLoad)} ${bar} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust} ${bar} esc stops`;
     const busyAvail = columns - busyFixed.length - 2;
     const activityText = shrinkTo(activity ?? phaseLabel, Math.max(0, busyAvail));
     return (_jsx(Box, { marginTop: theme.spacing.statusMarginTop, children: _jsxs(Text, { dimColor: true, children: [_jsxs(Text, { color: theme.color.activity, children: [theme.symbol.workTool, " ", activityText] }), busyFixed, stalled && !approvalPending ? ` ${bar} waiting${theme.symbol.ellipsis}` : null, approvalPending ? (_jsxs(Text, { color: theme.color.warning, children: [" ", bar, " waiting approval"] })) : null] }) }));
-}
+});

package/dist/ui/theme.js

@@ -54,6 +54,12 @@ export const theme = {
         code: "green",
         link: "cyan",
         heading: undefined, // bold, no hue
+        // Diff-body syntax colors (ui/highlight): Monokai-ish hues that read
+        // on dark and light terminals. Comments stay dim (no hue — same rule
+        // as muted text); plain code inherits the line paint.
+        synKeyword: "magenta",
+        synString: "yellow",
+        synNumber: "cyan",
     },
     border: {
         style: "round",

package/dist/ui/todo-panel.js

@@ -1,4 +1,8 @@
 import { jsxs as _jsxs } from "react/jsx-runtime";
+// Live session checklist panel (TodoWrite mirror). Prop-driven; returns
+// null when empty. Mounted below the transcript, fed by a checklist snapshot.
+// Paint from ui/theme tokens — no literal colors or glyphs here.
+import React from "react";
 import { Box, Text } from "ink";
 import { theme } from "./theme.js";
 // Live session checklist (Claude-Code-style TodoWrite panel). Mounted in
@@ -6,7 +10,11 @@ import { theme } from "./theme.js";
 // by a snapshot the loop refreshes after every todowrite/todo_update call,
 // so the in-progress row — shown with its activeForm when present — always
 // answers "what is the model doing right now". Returns null when empty.
-export function TodoPanel({ items }) {
+// Render-count probe for the flicker tests: same-props parent churn must
+// skip the panel (it only changes when the loop commits todo activity).
+export const todoPanelRenderProbe = { count: 0 };
+export const TodoPanel = React.memo(function TodoPanel({ items }) {
+    todoPanelRenderProbe.count += 1;
     if (items.length === 0)
         return null;
     const done = items.filter((t) => t.status === "completed").length;
@@ -19,4 +27,4 @@ export function TodoPanel({ items }) {
                 const label = t.status === "in_progress" && t.activeForm ? t.activeForm : t.content;
                 return (_jsxs(Text, { dimColor: t.status === "completed", children: [mark, " ", label, t.priority ? ` (${t.priority})` : ""] }, `${i}-${t.content}`));
             })] }));
-}
+});

package/dist/ui/transcript.js

@@ -5,6 +5,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // All paint comes from ui/theme tokens — no literal colors or glyphs here.
 import React from "react";
 import { Box, Text } from "ink";
+import { SideBySideDiffView, TRANSCRIPT_DIFF_MAX_LINES } from "./side-by-side.js";
 import { ErrorCard, classifyToolError } from "./errors.js";
 import { MarkdownText, ToolLine } from "./markdown.js";
 import { theme } from "./theme.js";
@@ -54,6 +55,11 @@ 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.
+    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));
+    }
     // Conversation turns (user/assistant) breathe: one blank line after each,
     // so the eye lands on the next turn. Tool/status lines stay dense — they
     // read as lightweight annotations woven between turns, not blocks.
@@ -65,17 +71,20 @@ export function renderTranscriptItem(item) {
         if (classified) {
             // Paired cards keep the verbatim audit line above the card (pinned
             // `⚙ name target` text for tests/scanning) and name the failure in
-            // the card title. Lone details render the card alone.
-            return (_jsxs(React.Fragment, { children: [item.label ? _jsx(ToolLine, { content: item.label.content, ms: item.label.ms }) : null, _jsx(ErrorCard, { classified: classified })] }, i));
+            // the card title. Lone details render the card alone. A successful
+            // 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 _jsx(ToolLine, { content: t.content, error: t.error, ms: t.ms }, 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(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));
 }
 // Render-count probe for the timer-isolation test: incremented on every
 // TranscriptView render (a 1s timer tick must leave it unchanged).
 export const transcriptRenderProbe = { count: 0 };
-export const TranscriptView = React.memo(function TranscriptView({ turns, clearGen, renderItem, end, windowSize, held, }) {
+export const TranscriptView = React.memo(function TranscriptView({ turns, clearGen, renderItem, end, windowSize, held, showThinking = true, }) {
     transcriptRenderProbe.count += 1;
     const render = renderItem ?? renderTranscriptItem;
     const win = windowSize ?? SCROLLBACK_WINDOW;
@@ -83,9 +92,12 @@ export const TranscriptView = React.memo(function TranscriptView({ turns, clearG
     // Pairing ([audit label, error detail] → one card) runs over the VISIBLE
     // slice only — pairing is positional, and off-window turns never mount.
     // Keys stay global (`turn-${idx}`) so scrolling never remounts rows.
+    // Hidden thinking turns are skipped in place (same index stability).
     const body = [];
     for (let idx = vp.start; idx < vp.end; idx++) {
         const turn = turns[idx];
+        if (turn.thinking === true && !showThinking)
+            continue;
         const next = idx + 1 < vp.end ? turns[idx + 1] : undefined;
         if (isAuditLabel(turn) && next !== undefined && next.role === "tool" && next.error === true) {
             body.push({ id: `turn-${idx}`, turn: next, label: turn });

package/dist/zen.js

@@ -8,7 +8,8 @@ import * as path from "node:path";
 import { MAX_TOOL_STEPS, TOOL_DEFINITIONS, } from "./tools.js";
 import { chatEndpointFor, getProvider, isLocalProviderId, modelsUrlForProvider, providerLabel, } from "./providers.js";
 import { discoverLocalProvider } from "./local-discovery.js";
-import { ANTHROPIC_VERSION, anthropicHeaders, buildAnthropicBody, buildGeminiBody, geminiChatUrl, geminiGenerateUrl, geminiHeaders, parseAnthropicJson, parseAnthropicModelsList, parseGeminiJson, parseGeminiModelsList, parseOpenAIModelsList, readAnthropicSSEMessage, readGeminiSSEMessage, } from "./adapters.js";
+import { ANTHROPIC_VERSION, anthropicHeaders, buildAnthropicBody, buildGeminiBody, geminiChatUrl, geminiGenerateUrl, geminiHeaders, parseAnthropicJson, parseAnthropicModelsList, parseGeminiJson, parseGeminiModelsList, parseOpenAIModelsList, readAnthropicSSEMessage, readGeminiSSEMessage, isStallError, readWithStall, } from "./adapters.js";
+export { isStallError, readWithStall, sseStallTimeoutMs } from "./adapters.js";
 import { KILO_FALLBACK_MODELS, fetchKiloModelsWithStatus, normalizeKiloChatError, } from "./kilo.js";
 import { splitSystemHead } from "./prompt-cache.js";
 import { SYSTEM_PROMPT } from "./system.js";
@@ -336,6 +337,11 @@ export async function fetchModels(endpoint, apiKey) {
 // - Slots with an id but no name at [DONE] are dropped with an onWarning
 //   message and never returned (keeps assistant/tool pairing valid).
 // - A stream that ends without [DONE] throws a truncation error.
+// - A stream silent longer than the stall budget (env ATOM_STALL_TIMEOUT_MS,
+//   default 60s; the clock resets on every received chunk) throws a
+//   Truncated-stream stall error — permanent, never retried, same contract
+//   as a dead connection (verified live: free-tier routers can stall a
+//   200-OK stream mid-generation for minutes).
 // - A stream with zero "data:" lines is treated as a non-SSE JSON payload
 //   (tolerance for bodies that are really single-shot JSON) and parsed as
 //   choices[0].message like the non-streaming fallback.
@@ -513,9 +519,11 @@ export async function readSSEMessage(res, opts) {
                 for (;;) {
                     let chunk;
                     try {
-                        chunk = await reader.read();
+                        chunk = await readWithStall(() => reader.read());
                     }
                     catch (e) {
+                        if (isStallError(e))
+                            throw e;
                         throw new Error(`Truncated stream from model (connection aborted: ${e instanceof Error ? e.message : String(e)}).`);
                     }
                     if (chunk.done)
@@ -550,13 +558,28 @@ export async function readSSEMessage(res, opts) {
             }
         }
         else if (typeof body[Symbol.asyncIterator] === "function") {
-            for await (const v of body) {
-                const text = typeof v === "string" ? v : decoder.decode(v, { stream: true });
-                rawText += text;
-                buffer += text;
-                drainBuffer();
-                if (sawDone)
-                    break;
+            const it = body[Symbol.asyncIterator]();
+            try {
+                for (;;) {
+                    const step = await readWithStall(() => it.next());
+                    if (step.done)
+                        break;
+                    const v = step.value;
+                    const text = typeof v === "string" ? v : decoder.decode(v, { stream: true });
+                    rawText += text;
+                    buffer += text;
+                    drainBuffer();
+                    if (sawDone)
+                        break;
+                }
+            }
+            finally {
+                try {
+                    await it.return?.();
+                }
+                catch {
+                    // ignore — the stream is over either way
+                }
             }
             if (!sawDone && buffer.length > 0) {
                 processLine(buffer);
@@ -1167,6 +1190,7 @@ export function planToolBatches(calls) {
 }
 import { runLoopWithChat } from "./agent/loop.js";
 export { runLoopWithChat } from "./agent/loop.js";
+export { DEFAULT_MAX_TOTAL_TOOL_CALLS, DEFAULT_TOOL_TIMEOUT_MS, executeWithTimeout, resolveMaxTotalToolCalls, resolveToolTimeoutMs, } from "./agent/loop.js";
 export async function runAgenticLoopForProvider(provider, apiKey, model, history, opts) {
     return runLoopWithChat((h, o) => chatCompletionForProvider(provider, apiKey, model, h, {
         onToken: o?.onToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom-agent",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Agentic terminal coding assistant: multi-provider LLM loop with local file/shell/web tools in an Ink (React) TUI.",
   "type": "module",
   "license": "MIT",