atom-agent 0.3.0 → 1.1.0

package/dist/ui/errors.js

@@ -0,0 +1,129 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { theme } from "./theme.js";
+// The audit label grammar (`⚙ name target`) carries the tool identity the
+// error detail alone lacks. Paired in TranscriptView (adjacent turns).
+export function parseToolLabel(label) {
+    const mark = `${theme.symbol.toolMark} `;
+    const stripped = (label.startsWith(mark) ? label.slice(mark.length) : label).trim();
+    const space = stripped.indexOf(" ");
+    if (space === -1)
+        return { name: stripped, target: "" };
+    return { name: stripped.slice(0, space), target: stripped.slice(space + 1).trim() };
+}
+export function titleCase(name) {
+    return name.length > 0 ? name[0].toUpperCase() + name.slice(1) : name;
+}
+const NETWORK_RE = /HTTP (429|500|502|503|504)|connection reset|fetch failed|network|timed? ?out|ENOTFOUND|ECONN|EAI_AGAIN|socket hang up/i;
+const MODEL_RE = /Empty reply|Truncated stream|malformed|unexpected payload|no .* usage|invalid response/i;
+const CONFIG_RE = /Missing API key|no API key|not configured|invalid baseURL|auth/i;
+// Classify a tool-role turn. Returns null when the turn is not an error
+// presentation (normal audit lines, warnings, retries, boundaries, todo
+// output, and the pinned `(cancelled)` line, which keeps its legacy look).
+export function classifyToolError(turn, label) {
+    const content = turn.content;
+    if (content.startsWith("(cancelled)"))
+        return null;
+    if (!turn.error) {
+        if (/^Missing API key/i.test(content.trim())) {
+            return {
+                kind: "config",
+                title: "Setup needed",
+                detail: content.trim(),
+                hint: "Run /provider to paste a key, then resend.",
+                inspectable: false,
+            };
+        }
+        return null;
+    }
+    const detail = content.replace(/^[↳\s]+/, "");
+    if (/denied by user/i.test(detail)) {
+        const tool = detail.split(":").pop()?.trim() ?? "";
+        return {
+            kind: "denial",
+            title: tool ? `Denied — ${titleCase(tool)}` : "Denied",
+            detail,
+            hint: "Approve next time, or pre-approve with /allow.",
+            inspectable: false,
+        };
+    }
+    if (NETWORK_RE.test(detail)) {
+        return {
+            kind: "network",
+            title: "Network failed",
+            detail,
+            hint: "Auto-retried — check the connection, then resend.",
+            inspectable: false,
+        };
+    }
+    if (MODEL_RE.test(detail)) {
+        return {
+            kind: "model",
+            title: "Model failed",
+            detail,
+            hint: "Resend to retry the request.",
+            inspectable: false,
+        };
+    }
+    if (CONFIG_RE.test(detail)) {
+        return {
+            kind: "config",
+            title: "Setup needed",
+            detail,
+            hint: "Run /provider to paste a key, then resend.",
+            inspectable: false,
+        };
+    }
+    if (/panic|invariant|unexpected|internal/i.test(detail)) {
+        return {
+            kind: "internal",
+            title: "Internal error",
+            detail,
+            hint: "Please report this with the transcript.",
+            inspectable: false,
+        };
+    }
+    // Default: a failed tool call. The audit line above already names the
+    // tool + target (paired by TranscriptView), so the card title stays
+    // short; the full result waits in the inspector store.
+    if (label) {
+        const { name } = parseToolLabel(label.content);
+        return {
+            kind: "tool",
+            title: `${titleCase(name) || "Tool"} failed`,
+            detail,
+            hint: "Ctrl+O opens the full output in the inspector.",
+            inspectable: true,
+        };
+    }
+    return {
+        kind: "tool",
+        title: "Tool failed",
+        detail,
+        hint: "Ctrl+O opens the full output in the inspector.",
+        inspectable: true,
+    };
+}
+const KIND_GLYPH = {
+    tool: "✕",
+    denial: "⊘",
+    network: "⚠",
+    model: "✕",
+    cancelled: "",
+    config: "→",
+    internal: "‼",
+};
+const KIND_COLOR = {
+    tool: theme.color.toolError,
+    denial: theme.color.warning,
+    network: theme.color.warning,
+    model: theme.color.toolError,
+    cancelled: undefined,
+    config: theme.color.user,
+    internal: theme.color.toolError,
+};
+// Compact card: bold titled first line, one detail line, one dim hint line.
+// No boxes, no walls — three lines max per error.
+export function ErrorCard({ classified }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, color: KIND_COLOR[classified.kind], children: [KIND_GLYPH[classified.kind], " ", classified.title] }), _jsxs(Text, { children: ["  ", classified.detail] }), classified.hint ? _jsxs(Text, { dimColor: true, children: ["  ", classified.hint] }) : null] }));
+}

package/dist/ui/highlight.js

@@ -0,0 +1,120 @@
+const C_KEYWORDS = new Set("break case catch class const continue debugger default delete do else enum export extends finally for function if implements import interface let new return static super switch this throw try typeof var void while with yield async await".split(" "));
+const PY_KEYWORDS = new Set("def class return if elif else for while in is not and or import from as try except finally with lambda pass break continue raise True False None async await".split(" "));
+const SH_KEYWORDS = new Set("if then else elif fi for while do done case esac function return exit echo local export readonly".split(" "));
+function keywordsFor(lang) {
+    if (lang === "c")
+        return C_KEYWORDS;
+    if (lang === "py")
+        return PY_KEYWORDS;
+    if (lang === "sh")
+        return SH_KEYWORDS;
+    return null; // "data": no keywords
+}
+function commentStyle(lang) {
+    if (lang === "c")
+        return "slash";
+    if (lang === "data")
+        return "hash";
+    return "hash"; // py + sh
+}
+// Master token pattern over the code part of a line: strings (with
+// escapes, incl. unterminated tails so streaming/odd lines still paint),
+// numbers, words, and single fallback chars.
+const TOKEN_RE = /'(?:[^'\\\n]|\\.)*(?:'|$)|"(?:[^"\\\n]|\\.)*(?:"|$)|`(?:[^`\\]|\\.)*(?:`|$)|[0-9][0-9_]*(?:\.[0-9_]+)?\b|[A-Za-z_$][A-Za-z0-9_$]*|\s+|./g;
+const NUMBER_RE = /^[0-9][0-9_]*(?:\.[0-9_]+)?\b$/;
+const WORD_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+// Split off a trailing line comment, honoring string spans: `//` inside
+// a string is code, and (for hash style) `#` inside a string is code.
+// Single-line `/* … */` pairs are treated as comments when both halves
+// sit on this line; an unterminated opener is left as code (multi-line
+// state is the documented non-goal).
+function splitComment(line, lang) {
+    const style = commentStyle(lang);
+    let inStr = null;
+    let escaped = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (inStr !== null) {
+            if (escaped)
+                escaped = false;
+            else if (c === "\\")
+                escaped = true;
+            else if (c === inStr)
+                inStr = null;
+            continue;
+        }
+        if (c === "'" || c === '"' || c === "`") {
+            inStr = c;
+            continue;
+        }
+        if (style === "slash" && c === "/" && line[i + 1] === "/") {
+            return { code: line.slice(0, i), comment: line.slice(i) };
+        }
+        if (style === "hash" && c === "#") {
+            // Shebang or comment to end of line.
+            return { code: line.slice(0, i), comment: line.slice(i) };
+        }
+    }
+    if (style === "slash") {
+        const open = line.indexOf("/*");
+        const close = open >= 0 ? line.indexOf("*/", open + 2) : -1;
+        if (open >= 0 && close > open) {
+            // Keep it simple: trailing block comment paints as comment; an
+            // embedded one splits code around it via the token pass below
+            // (rare — paint the whole tail as comment only when the opener
+            // starts after code we already keep plain).
+            return { code: line.slice(0, open), comment: line.slice(open) };
+        }
+    }
+    return { code: line, comment: "" };
+}
+function highlightCode(code, lang, base) {
+    const runs = [];
+    const keywords = keywordsFor(lang);
+    TOKEN_RE.lastIndex = 0;
+    let m;
+    while ((m = TOKEN_RE.exec(code)) !== null) {
+        const text = m[0];
+        const start = base + (m.index ?? 0);
+        let kind = "plain";
+        const first = text[0];
+        if (first === "'" || first === '"' || first === "`")
+            kind = "string";
+        else if (NUMBER_RE.test(text))
+            kind = "number";
+        else if (keywords !== null && WORD_RE.test(text) && keywords.has(text))
+            kind = "keyword";
+        runs.push({ text, kind, start, end: start + text.length });
+    }
+    return runs;
+}
+// Bounded highlight cache: diff hunks re-render on busy ticks and the
+// same lines repeat across hunks/turns — tokenize once per unique line.
+const HIGHLIGHT_CACHE_CAP = 2000;
+const highlightCache = new Map();
+export function highlightLine(line, lang) {
+    if (lang !== "c" && lang !== "py" && lang !== "sh" && lang !== "data") {
+        return line === "" ? [] : [{ text: line, kind: "plain", start: 0, end: line.length }];
+    }
+    const key = `${lang} ${line}`;
+    const hit = highlightCache.get(key);
+    if (hit)
+        return hit;
+    const { code, comment } = splitComment(line, lang);
+    const runs = highlightCode(code, lang, 0);
+    if (comment) {
+        runs.push({ text: comment, kind: "comment", start: code.length, end: line.length });
+    }
+    const out = runs.length > 0 ? runs : [];
+    highlightCache.set(key, out);
+    if (highlightCache.size > HIGHLIGHT_CACHE_CAP) {
+        const oldest = highlightCache.keys().next();
+        if (!oldest.done)
+            highlightCache.delete(oldest.value);
+    }
+    return out;
+}
+// Test seam: current cache size (eviction behavior).
+export function highlightCacheSize() {
+    return highlightCache.size;
+}

package/dist/ui/input-model.js

@@ -0,0 +1,115 @@
+// Pure input-editing model: multiline cursor math, line/word kills, paste
+// normalization, and history-browse index ops. No React, no Ink — the App
+// wires these to state, and the unit tests pin them here.
+export const INPUT_HISTORY_CAP = 100;
+export function splitInputLines(text) {
+    return text.split("\n");
+}
+export function lineColOf(text, offset) {
+    const safe = Math.max(0, Math.min(offset, text.length));
+    const lines = splitInputLines(text);
+    let acc = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const len = lines[i].length;
+        if (safe <= acc + len || i === lines.length - 1) {
+            return { line: i, col: safe - acc };
+        }
+        acc += len + 1;
+    }
+    return { line: 0, col: 0 };
+}
+export function offsetOfLines(lines, line, col) {
+    const l = Math.max(0, Math.min(line, lines.length - 1));
+    const c = Math.max(0, Math.min(col, lines[l].length));
+    let acc = 0;
+    for (let i = 0; i < l; i++)
+        acc += lines[i].length + 1;
+    return acc + c;
+}
+// Vertical cursor motion. `edge` is true when already on the first/last
+// line — the caller falls through to history browse instead of moving.
+export function moveVertically(text, offset, dir) {
+    const lines = splitInputLines(text);
+    const { line, col } = lineColOf(text, offset);
+    const next = line + dir;
+    if (next < 0 || next >= lines.length)
+        return { offset, edge: true };
+    return { offset: offsetOfLines(lines, next, col), edge: false };
+}
+// Ctrl+K: delete to end of the current line; at line end (with more lines)
+// delete the newline itself (join). Ctrl+U: delete to line start.
+export function killToLineEnd(text, offset) {
+    const safe = Math.max(0, Math.min(offset, text.length));
+    const nl = text.indexOf("\n", safe);
+    if (nl === -1) {
+        if (safe >= text.length)
+            return { text, offset: safe };
+        return { text: text.slice(0, safe), offset: safe };
+    }
+    if (nl === safe)
+        return { text: text.slice(0, safe) + text.slice(safe + 1), offset: safe };
+    return { text: text.slice(0, safe) + text.slice(nl), offset: safe };
+}
+export function killToLineStart(text, offset) {
+    const safe = Math.max(0, Math.min(offset, text.length));
+    const { line, col } = lineColOf(text, safe);
+    if (col === 0)
+        return { text, offset: safe };
+    const lines = splitInputLines(text);
+    const start = offsetOfLines(lines, line, 0);
+    return { text: text.slice(0, start) + text.slice(safe), offset: start };
+}
+// Ctrl+W: delete the word before the cursor (word chars + the gap before
+// it). Words are [A-Za-z0-9_]+ runs; anything else is a single-char step
+// when no word precedes (punctuation never eats a whole run).
+export function killWordBefore(text, offset) {
+    let at = Math.max(0, Math.min(offset, text.length));
+    if (at <= 0)
+        return { text, offset: 0 };
+    let start = at;
+    while (start > 0 && /\s/.test(text[start - 1]))
+        start -= 1;
+    // A skipped gap is the whole kill unit ("foo   " → "foo", not "").
+    if (start < at)
+        return { text: text.slice(0, start) + text.slice(at), offset: start };
+    if (/[\w]/.test(text[start - 1])) {
+        while (start > 0 && /[\w]/.test(text[start - 1]))
+            start -= 1;
+    }
+    else {
+        start -= 1;
+    }
+    return { text: text.slice(0, start) + text.slice(at), offset: start };
+}
+// Bracketed-paste content arrives verbatim (including newlines) — only line
+// endings normalize. Pasted text never submits, even when multiline.
+export function normalizePaste(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+// History is in-memory only (never persisted: prompts may carry pasted
+// secrets, and the session file warns as much). Blank + consecutive-duplicate
+// submits are skipped; oldest drops past the cap.
+export function pushInputHistory(hist, text) {
+    if (!text.trim())
+        return hist;
+    if (hist.length > 0 && hist[hist.length - 1] === text)
+        return hist;
+    const next = [...hist, text];
+    if (next.length > INPUT_HISTORY_CAP)
+        next.splice(0, next.length - INPUT_HISTORY_CAP);
+    return next;
+}
+export function historyOlderIndex(hist, index) {
+    if (hist.length === 0)
+        return null;
+    if (index === null)
+        return hist.length - 1;
+    return Math.max(0, index - 1);
+}
+// Past the newest entry → null (the caller restores the stashed draft).
+export function historyNewerIndex(hist, index) {
+    if (index === null)
+        return null;
+    const next = index + 1;
+    return next >= hist.length ? null : next;
+}

package/dist/ui/input.js

@@ -0,0 +1,40 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+// Input leaf: the boxed prompt surface. Prop-driven + memoized on
+// (input, cursor) so timer ticks never repaint it. Multiline aware: the
+// cursor rides line/col and long lines wrap via Ink. Deliberately bare —
+// no placeholder text, no hints; the box + cursor is the affordance.
+// 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";
+import { lineColOf, splitInputLines } from "./input-model.js";
+// Render-count probe for the input-smoothness test: incremented on every
+// InputBox render (one keystroke must paint the input exactly once; the 1s
+// busy-tick must leave it unchanged while idle input sits still).
+export const inputRenderProbe = { count: 0 };
+// The input is the one boxed, prominent surface: a quiet gray frame sets it
+// apart from the transcript above and the status line below. Memoized on
+// (input, cursor) so elapsed-timer ticks, token paints, and unrelated App
+// state churn never repaint it — keystrokes stay at exactly one paint each,
+// which is what makes navigation feel instant instead of choppy.
+export const InputBox = React.memo(function InputBox({ input, cursor }) {
+    inputRenderProbe.count += 1;
+    // Defensive clamp: the ref is the source of truth mid-tick and always
+    // stays in range, but state may lag it by one render.
+    const safeCursor = Math.max(0, Math.min(cursor, input.length));
+    const lines = splitInputLines(input);
+    const { line: cline, col: ccol } = lineColOf(input, safeCursor);
+    return (_jsxs(Box, { borderStyle: theme.border.style, borderColor: theme.border.input, paddingX: theme.spacing.pickerPadX, children: [_jsxs(Text, { color: theme.color.inputPrompt, bold: true, children: [theme.symbol.inputPrompt, " "] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: lines.map((ln, i) => {
+                    if (i !== cline)
+                        return _jsx(Text, { children: ln.length > 0 ? ln : " " }, i);
+                    // See-through cursor: the character under the cursor renders in
+                    // inverse video instead of inserting a block glyph beside it, so
+                    // letters never shift aside as the cursor moves (the old block
+                    // made the line wobble on every arrow-key step). At end of line
+                    // (or on an empty line) an inverse space holds the cell.
+                    const before = ln.slice(0, ccol);
+                    const at = ln.slice(ccol, ccol + 1);
+                    const after = ln.slice(ccol + 1);
+                    return (_jsxs(Text, { children: [before, _jsx(Text, { inverse: true, children: at.length > 0 ? at : " " }), after] }, i));
+                }) })] }));
+});

package/dist/ui/live-tail.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { activityText } from "./activity.js";
+import { MarkdownStream } from "./markdown.js";
+import { theme } from "./theme.js";
+export function LiveTail({ isEmpty, sessionHint, draft, thinking, busy, held, toolHint, toolElapsedSecs, elapsedSecs, showThinking = true }) {
+    // Held view (user scrolled up mid-turn): the growing draft/thinking blocks
+    // are replaced by one static line so the frame stops gaining terminal
+    // lines — the terminal stops yanking and scrollback stays readable. The
+    // turn keeps running underneath; End resumes the live view. One-line
+    // status (tool hint, thinking tick) keeps updating in place: same line,
+    // no growth, no yank.
+    const freezeLive = held === true && busy;
+    return (_jsxs(Box, { flexDirection: "column", marginY: theme.spacing.liveTailMarginY, children: [isEmpty ? (_jsx(Text, { dimColor: true, children: "Say hi to Atom \u2014 or type / for commands, /provider to pick a provider + key, /model to switch models." })) : null, sessionHint && isEmpty ? (_jsx(Text, { dimColor: true, children: "(last session available \u2014 /resume to restore)" })) : null, freezeLive ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.moreAbove, " held \u2014 turn running \u00B7 End to follow"] })) : null, !freezeLive && draft ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: _jsxs(Text, { color: theme.color.assistant, bold: true, children: [theme.symbol.speakerAssistant, " "] }) }), _jsx(MarkdownStream, { text: draft })] })) : null, !freezeLive && thinking && showThinking ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.thinking, " ", thinking, _jsx(Text, { color: theme.color.mutedPaint, children: theme.symbol.cursorBar })] })) : null, busy && toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workTool, " ", activityText(toolHint), toolElapsedSecs !== null && toolElapsedSecs >= 2 ? (_jsxs(_Fragment, { children: [" ", theme.symbol.separator, " ", toolElapsedSecs, "s"] })) : (theme.symbol.ellipsis)] })) : null, !freezeLive && busy && !draft && !thinking && !toolHint ? (_jsxs(Text, { dimColor: true, children: [theme.symbol.workThinking, " Thinking", theme.symbol.ellipsis, " ", theme.symbol.separator, " ", elapsedSecs, "s"] })) : null] }));
+}