atom-agent 1.2.0 → 1.4.0

package/dist/ui/diff.js

@@ -4,6 +4,10 @@
 export const CHANGE_THRESHOLD = 0.4;
 // Mirrors Claude's DiffDetailView guards.
 export const MAX_FILE_BYTES = 1_000_000;
+// Retained for compatibility (no longer applied — the engine returns the
+// full hunk list; views render it whole). Safety caps that remain enforced:
+// MAX_FILE_BYTES, binary detect, MAX_MYERS_LINES fallback, MAX_WORD_TOKENS
+// fallback.
 export const MAX_CHANGED_LINES = 400;
 export const DIFF_CONTEXT = 3;
 // Worst-case guards for the O(ND) Myers pass + O(w1*w2) word pass.
@@ -183,7 +187,7 @@ export function computeDiff(oldText, newText) {
     const hunks = [];
     let adds = 0;
     let dels = 0;
-    let truncated = false;
+    const truncated = false;
     let hunkStart = Math.max(0, changeIdx[0] - DIFF_CONTEXT);
     let hunkEnd = Math.min(raw.length, changeIdx[0] + DIFF_CONTEXT + 1);
     const flush = (s, e) => {
@@ -242,7 +246,6 @@ export function computeDiff(oldText, newText) {
         }
         hunks.push({ oldStart, oldLines: oCount, newStart, newLines: nCount, lines });
     };
-    let changed = 0;
     for (let c = 1; c < changeIdx.length; c++) {
         const prev = changeIdx[c - 1];
         const cur = changeIdx[c];
@@ -251,32 +254,11 @@ export function computeDiff(oldText, newText) {
         }
         else {
             flush(hunkStart, hunkEnd);
-            changed = hunks.reduce((t, h) => t + h.lines.filter((l) => l.kind !== "context").length, 0);
-            if (changed >= MAX_CHANGED_LINES) {
-                truncated = true;
-                return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
-            }
             hunkStart = Math.max(0, cur - DIFF_CONTEXT);
             hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
         }
     }
     flush(hunkStart, hunkEnd);
-    changed = hunks.reduce((t, h) => t + h.lines.filter((l) => l.kind !== "context").length, 0);
-    if (changed > MAX_CHANGED_LINES) {
-        // Trim trailing hunks past the budget (keep the head — the user
-        // reviews top-down; the notice names the remainder).
-        let kept = 0;
-        const out = [];
-        for (const h of hunks) {
-            const n = h.lines.filter((l) => l.kind !== "context").length;
-            if (kept + n > MAX_CHANGED_LINES)
-                break;
-            out.push(h);
-            kept += n;
-        }
-        truncated = true;
-        return { hunks: out, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
-    }
     return { hunks, adds, dels, truncated, skipped: null, isNewFile: oldText === null };
 }
 export function computeSideBySide(oldText, newText) {
@@ -316,9 +298,7 @@ export function computeSideBySide(oldText, newText) {
     const rows = [];
     let adds = 0;
     let dels = 0;
-    let truncated = false;
-    const changedSoFar = () => dels + adds;
-    // Returns false when the change budget is exhausted (stop windowing).
+    const truncated = false;
     const flushSlice = (s, e) => {
         const slice = raw.slice(s, e);
         let k = 0;
@@ -376,12 +356,7 @@ export function computeSideBySide(oldText, newText) {
             }
             dels += delRun.length;
             adds += addRun.length;
-            if (changedSoFar() >= MAX_CHANGED_LINES) {
-                truncated = true;
-                return false;
-            }
         }
-        return true;
     };
     let hunkStart = Math.max(0, changeIdx[0] - DIFF_CONTEXT);
     let hunkEnd = Math.min(raw.length, changeIdx[0] + DIFF_CONTEXT + 1);
@@ -392,31 +367,11 @@ export function computeSideBySide(oldText, newText) {
             hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
         }
         else {
-            if (!flushSlice(hunkStart, hunkEnd)) {
-                return { kind: "diff", rows, adds, dels, truncated, isNewFile: oldText === null };
-            }
+            flushSlice(hunkStart, hunkEnd);
             hunkStart = Math.max(0, cur - DIFF_CONTEXT);
             hunkEnd = Math.min(raw.length, cur + DIFF_CONTEXT + 1);
         }
     }
     flushSlice(hunkStart, hunkEnd);
-    if (dels + adds > MAX_CHANGED_LINES) {
-        // Single-hunk overflow: the slice already pushed past the budget —
-        // trim trailing rows past 400 changes (keep the head; the notice
-        // names the remainder). Mirrors computeDiff's trailing-hunk trim.
-        let kept = 0;
-        let cut = rows.length;
-        for (let i = 0; i < rows.length; i++) {
-            if (rows[i].kind === "change") {
-                kept += 1;
-                if (kept > MAX_CHANGED_LINES) {
-                    cut = i;
-                    break;
-                }
-            }
-        }
-        rows.length = cut;
-        truncated = true;
-    }
     return { kind: "diff", rows, adds, dels, truncated, isNewFile: oldText === null };
 }

package/dist/ui/modals.js

@@ -7,10 +7,10 @@ import React from "react";
 import { Box, Text } from "ink";
 import { SideBySideDiffView } from "./side-by-side.js";
 import { theme } from "./theme.js";
-// Max diff body lines inside the approval modal (hunk headers excluded;
-// the trailer names the remainder). Keeps the modal scannable while the
-// 1s busy tick repaints around it.
-export const APPROVAL_DIFF_MAX_LINES = 40;
+// Retained for compatibility (no longer applied — the approval preview
+// renders the full diff; smoothness comes from the per-mount memo + word
+// fallbacks, not from a row cap).
+export const APPROVAL_DIFF_MAX_LINES = Infinity;
 export const APPROVAL_OPTIONS = ["once", "always", "trustAll", "no"];
 // Command/file preview: the audit description minus its `⚙ name` prefix
 // (the tool name already headlines above). Falls back to the full text
@@ -39,7 +39,7 @@ export const ApprovalBox = React.memo(function ApprovalBox({ toolName, descripti
         { label: "[t]rust all write/edit/bash this session", option: "trustAll" },
         { label: "[n]o — deny this call", option: "no" },
     ];
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.approval, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { bold: true, color: theme.color.warning, children: [theme.symbol.warningMark, " Atom permission \u2014 allow this tool?"] }), _jsx(Text, { bold: true, children: approvalTitle(toolName) }), _jsx(Text, { color: theme.color.code, children: approvalPreview(toolName, description) }), diff ? _jsx(SideBySideDiffView, { oldText: diff.oldText, newText: diff.newText, lang: diff.lang, maxRows: APPROVAL_DIFF_MAX_LINES }) : null, rows.map((r, i) => (_jsxs(Text, { color: i === selected ? theme.color.selection : undefined, children: [i === selected ? `${theme.symbol.select} ` : theme.spacing.rowIndent, r.label] }, r.option))), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 + Enter selects \u00B7 y/a/t/n shortcuts \u00B7 Esc denies" })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: theme.border.style, borderColor: theme.border.approval, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { bold: true, color: theme.color.warning, children: [theme.symbol.warningMark, " Atom permission \u2014 allow this tool?"] }), _jsx(Text, { bold: true, children: approvalTitle(toolName) }), _jsx(Text, { color: theme.color.code, children: approvalPreview(toolName, description) }), diff ? _jsx(SideBySideDiffView, { oldText: diff.oldText, newText: diff.newText, lang: diff.lang }) : null, rows.map((r, i) => (_jsxs(Text, { color: i === selected ? theme.color.selection : undefined, children: [i === selected ? `${theme.symbol.select} ` : theme.spacing.rowIndent, r.label] }, r.option))), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 + Enter selects \u00B7 y/a/t/n shortcuts \u00B7 Esc denies" })] }));
 });
 export const QuestionBox = React.memo(function QuestionBox({ question, options, allowCustom, askCustom, askSelIndex }) {
     questionRenderProbe.count += 1;

package/dist/ui/palette.js

@@ -9,7 +9,7 @@ import { Box, Text } from "ink";
 import { PickerMoreAbove, PickerMoreBelow, pickerWindow } from "./pickers.js";
 import { theme } from "./theme.js";
 export const PALETTE_WINDOW = 12;
-export const PALETTE_CATEGORY_ORDER = ["Model", "Session", "Tools", "Skills", "Flow", "Help"];
+export const PALETTE_CATEGORY_ORDER = ["Model", "Session", "Tools", "Skills", "Flow", "Extensions", "Help"];
 const PALETTE_CATEGORIES = {
     "/model": "Model",
     "/provider": "Model",

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

@@ -14,7 +14,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 //   (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.
+//   rendered whole (an explicit maxRows windows it when a caller passes one)
+//   — never recomputed per tick, never floods via re-computation.
 // All paint comes from ui/theme tokens.
 import React from "react";
 import { Box, Text } from "ink";
@@ -24,10 +25,11 @@ 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;
+// Uncapped: views render the full row list (smooth via per-mount useMemo +
+// append-once Static + word-token/Myers fallbacks in the engine). maxRows
+// remains as an opt-in window for callers/tests that want a collapsed tail.
+// Retained for compatibility.
+export const TRANSCRIPT_DIFF_MAX_LINES = Infinity;
 function truncateTo(s, width) {
     const chars = [...s];
     if (chars.length <= width)

package/dist/ui/status-bar.js

@@ -12,6 +12,47 @@ import React from "react";
 import { Box, Text } from "ink";
 import { formatTokenSegment } from "../context-windows.js";
 import { theme } from "./theme.js";
+// Default objective budget for the goal segment: compact enough to share the
+// line with the pinned model/token/mode segments at 100 columns.
+export const GOAL_STATUS_OBJECTIVE_CHARS = 32;
+// Truncate an objective to n chars max (`…` tail keeps the start, which
+// carries the verb). n < 4 yields "" (the caller drops the segment instead).
+export function truncateGoalObjective(objective, max = GOAL_STATUS_OBJECTIVE_CHARS) {
+    const text = typeof objective === "string" ? objective : "";
+    if (text.length <= max)
+        return text;
+    if (max < 4)
+        return "";
+    return `${text.slice(0, max - 1)}…`;
+}
+// Full goal segment at the default budget, or null when no goal is live.
+// Paused reads distinct from active (`[paused]` vs `[active]`).
+export function formatGoalSegment(goal, max = GOAL_STATUS_OBJECTIVE_CHARS) {
+    if (!goal || typeof goal.objective !== "string" || goal.objective.length === 0)
+        return null;
+    const state = goal.active === true ? "active" : "paused";
+    return `goal: ${truncateGoalObjective(goal.objective, max)} [${state}]`;
+}
+// Fit the goal segment into `room` chars (the width left after every other
+// segment): full text when it fits, a shorter truncation when it almost
+// fits, null (drop the segment) when even a stub would displace the line.
+// Never throws; never returns "".
+export function fitGoalSegment(goal, room) {
+    if (!goal || typeof goal.objective !== "string" || goal.objective.length === 0)
+        return null;
+    if (typeof room !== "number" || !Number.isFinite(room) || room <= 0)
+        return null;
+    const state = goal.active === true ? "active" : "paused";
+    const full = `goal: ${goal.objective} [${state}]`;
+    if (full.length <= room)
+        return full;
+    // Room for at least 4 objective chars plus the fixed framing, else drop.
+    const overhead = `goal:  [${state}]`.length + 1;
+    const allow = Math.floor(room - overhead);
+    if (allow < 4)
+        return null;
+    return `goal: ${truncateGoalObjective(goal.objective, allow)} [${state}]`;
+}
 // ~/… collapse + tail-cut: informative, never a full scroll of nesting.
 // Further shrinking for tight widths goes through shrinkTo below (the bar
 // measures first and only renders what fits).
@@ -34,9 +75,13 @@ export function shrinkTo(s, n) {
 // 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, }) {
+export const StatusBar = React.memo(function StatusBar({ provider, model, usageTotals, contextLoad, reasoningDisplay, mode, trustAll, busy, activity, phaseLabel, elapsedSecs, stalled, approvalPending, cwd, branch, columns = 100, extensionStatus, goal, }) {
     statusBarRenderProbe.count += 1;
     const bar = theme.symbol.bar;
+    // Extension guest slot (ticket 10): pre-budgeted text renders only when
+    // the full line still fits — the fixed-width contract above. The `+ 3`
+    // is the ` ${bar} ` separator the segment carries with it.
+    const hasExt = typeof extensionStatus === "string" && extensionStatus.length > 0;
     if (!busy) {
         const token = formatTokenSegment(usageTotals, model, contextLoad);
         const trust = trustAll && mode !== "plan" ? "+trust" : "";
@@ -46,7 +91,8 @@ export const StatusBar = React.memo(function StatusBar({ provider, model, usageT
         // order: branch → cwd tail → the whole segment.
         const tail = `reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${trust}`;
         const baseLen = `${provider}/${model} ${bar} ${token} ${bar}  ${bar} ${tail}`.length;
-        const avail = columns - baseLen;
+        const showExt = hasExt && baseLen + extensionStatus.length + 3 + 2 <= columns;
+        const avail = columns - baseLen - (showExt ? extensionStatus.length + 3 : 0);
         let loc = null;
         if (cwd) {
             const branchPart = branch ? ` : ${branch}` : "";
@@ -61,15 +107,44 @@ export const StatusBar = React.memo(function StatusBar({ provider, model, usageT
                 loc = shrunk ? shrunk : null;
             }
         }
-        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] }) }));
+        // Goal segment (ticket 09): lowest-priority builtin — it takes only the
+        // width left after every other segment and drops whole rather than push
+        // the line past `columns`. Hidden entirely with no goal.
+        const lineSoFar = baseLen + (showExt ? extensionStatus.length + 3 : 0) + (loc ? loc.length + 3 : 0);
+        const goalSeg = fitGoalSegment(goal ?? null, columns - lineSoFar - 2);
+        return (_jsx(Box, { marginTop: theme.spacing.statusMarginTop, children: _jsxs(Text, { dimColor: true, children: [provider, "/", model, " ", bar, " ", token, showExt ? (_jsxs(_Fragment, { children: [" ", bar, " ", extensionStatus] })) : null, loc ? (_jsxs(_Fragment, { children: [" ", bar, " ", loc] })) : null, " ", bar, " reasoning: ", reasoningDisplay, " ", bar, " mode: ", mode, trust ? "+trust" : null, goalSeg ? (_jsxs(_Fragment, { children: [" ", bar, " ", goalSeg] })) : null] }) }));
     }
     // Busy layout prioritizes activity + clock + interrupt hint; the mode
     // 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} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust} ${bar} esc stops`;
+    const busyToken = formatTokenSegment(usageTotals, model, contextLoad);
+    // Goal segment (ticket 09): a guest in the fixed part — capped at 48
+    // chars and rendered only when the FULL activity text still fits beside
+    // it. Otherwise the goal drops whole and every existing segment renders
+    // exactly as with no goal (the goal never displaces, same precedent as
+    // the extension guest above). The clock, token, mode, and esc-hint
+    // segments never move for it either way.
+    const busyGoalSeg = fitGoalSegment(goal ?? null, 48);
+    const busyGoalCandidate = busyGoalSeg ? ` ${bar} ${busyGoalSeg}` : "";
+    const activityFull = activity ?? phaseLabel;
+    const busyCore = ` ${bar} ${elapsedSecs}s ${bar} ${busyToken} ${bar} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust}`;
+    const busyTail = ` ${bar} esc stops`;
+    const busyExtCandidate = hasExt && `${busyCore}${busyGoalCandidate}${busyTail}`.length + extensionStatus.length + 3 + 2 <= columns
+        ? ` ${bar} ${extensionStatus}`
+        : "";
+    const withGoalFixed = `${busyCore}${busyExtCandidate}${busyGoalCandidate}${busyTail}`;
+    // Room check against the unfitted activity text: when it no longer fits
+    // whole with the goal aboard, the goal yields (drop whole, recompute).
+    const busyGoalPart = busyGoalCandidate !== "" &&
+        withGoalFixed.length + activityFull.length + 2 <= columns
+        ? busyGoalCandidate
+        : "";
+    const busyNoExt = `${busyCore}${busyGoalPart}${busyTail}`;
+    const showBusyExt = hasExt && busyNoExt.length + extensionStatus.length + 3 + 2 <= columns;
+    const busyFixed = ` ${bar} ${elapsedSecs}s${showBusyExt ? ` ${bar} ${extensionStatus}` : ""} ${bar} ${busyToken} ${bar} reasoning: ${reasoningDisplay} ${bar} mode: ${mode}${busyTrust}${busyGoalPart} ${bar} esc stops`;
     const busyAvail = columns - busyFixed.length - 2;
-    const activityText = shrinkTo(activity ?? phaseLabel, Math.max(0, busyAvail));
+    const activityText = shrinkTo(activityFull, 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/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";
@@ -73,9 +73,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 }) : null, labelDiff && !item.label?.error ? (_jsx(SideBySideDiffView, { oldText: labelDiff.oldText, newText: labelDiff.newText, lang: labelDiff.lang })) : 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 }), t.diff && !t.error ? (_jsx(SideBySideDiffView, { oldText: t.diff.oldText, newText: t.diff.newText, lang: t.diff.lang })) : 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));
 }