@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/scrollback/renderer.js

@@ -1,186 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * Offscreen entry renderer (tui-native-terminal-scroll §4.5 / D4).
- *
- * Settled entries are rendered ONCE, to ANSI text, by a resident Ink instance that
- * writes to a fake stdout (`debug: true`: Ink then emits the complete layout in one
- * write per render and never touches log-update). The resulting rows go to the feed
- * and are printed; they are never mounted in the live React tree, so the per-frame
- * render cost stays proportional to what is on screen, not to the session length.
- *
- * Failure isolation (I-S12): one entry that throws while rendering degrades to a
- * single placeholder row. It must never block the queue or take the session down.
- */
-import React from 'react';
-import { EventEmitter } from 'node:events';
-import { Box, render } from 'ink';
-import { EntryView } from '../Transcript.js';
-import { getLogger } from '../../logging/logger.js';
-import { SCROLLBACK_LIMITS } from './limits.js';
-import { elisionRow } from './overflow-print.js';
-/**
- * Catches a throwing entry INSIDE the offscreen tree.
- *
- * Without it Ink's own boundary would print an error overview into the frame (which
- * would then be printed into the user's scrollback, forever) and unmount the
- * instance, so every later entry would fail too. With it the failure is a flag the
- * caller reads synchronously and the instance stays healthy (I-S12).
- */
-class RenderGuard extends React.Component {
-    state = { failed: false };
-    static getDerivedStateFromError() {
-        return { failed: true };
-    }
-    componentDidCatch(error) {
-        this.props.failure.error = error;
-    }
-    render() {
-        return this.state.failed ? null : this.props.children;
-    }
-}
-const NO_FAILURE = Symbol('no-failure');
-function createOffscreen(cols) {
-    const last = { value: null };
-    const stdout = Object.assign(new EventEmitter(), {
-        columns: cols,
-        rows: 1000,
-        isTTY: false,
-        write(chunk) {
-            last.value = chunk;
-            return true;
-        },
-    });
-    const stdin = Object.assign(new EventEmitter(), {
-        isTTY: false,
-        setEncoding() { },
-        resume() { },
-        pause() { },
-        ref() { },
-        unref() { },
-    });
-    const instance = render(null, {
-        stdout, stdin, stderr: stdout, debug: true, exitOnCtrlC: false, patchConsole: false,
-    });
-    // A rejected exit promise nobody awaits is an unhandled rejection.
-    void instance.waitUntilExit().catch(() => undefined);
-    return { cols, stdout, stdin, instance, last, failure: { error: NO_FAILURE } };
-}
-/** A function, so the compiler does not narrow the mutable `last` box to `null`. */
-function readFrame(target) {
-    return target.last.value;
-}
-function trimTrailingBlank(rows) {
-    let end = rows.length;
-    while (end > 0 && rows[end - 1].trim().length === 0)
-        end -= 1;
-    return end === rows.length ? rows : rows.slice(0, end);
-}
-export function createEntryRenderer(initial) {
-    let options = initial;
-    /**
-     * Resident offscreen instances, keyed by width.
-     *
-     * TWO SLOTS, NOT ONE. Ink reads `columns` once, at creation, so a width change needs a new
-     * instance - but a width change happens WITHIN one promotion pass as soon as the plan
-     * measures at the box width (`previewCols`) and prints at `contentCols`, and a single slot
-     * would then dispose and rebuild a complete Ink root on every such frame. Two slots cover
-     * both widths of the current geometry; a third width (an actual resize) evicts the oldest.
-     */
-    const slots = new Map();
-    const MAX_SLOTS = 2;
-    let elidedRows = 0;
-    let failures = 0;
-    let guardKey = 0;
-    const disposeSlot = (cols) => {
-        const target = slots.get(cols);
-        if (!target)
-            return;
-        slots.delete(cols);
-        try {
-            target.instance.unmount();
-            target.instance.cleanup();
-        }
-        catch {
-            // Tearing down a fake stream must never throw into an exit path.
-        }
-    };
-    const dispose = () => {
-        for (const cols of [...slots.keys()])
-            disposeSlot(cols);
-    };
-    /** Ink reads `columns` once, at creation, so a width change rebuilds the instance. */
-    const ensure = (cols) => {
-        const resident = slots.get(cols);
-        if (resident) {
-            // Refresh the recency order so the OTHER width is the eviction candidate.
-            slots.delete(cols);
-            slots.set(cols, resident);
-            return resident;
-        }
-        const evictable = [...slots.keys()][0];
-        if (evictable !== undefined && slots.size >= MAX_SLOTS)
-            disposeSlot(evictable);
-        const created = createOffscreen(cols);
-        slots.set(cols, created);
-        return created;
-    };
-    const capRows = (rows) => {
-        const cap = SCROLLBACK_LIMITS.maxRowsPerEntry;
-        if (rows.length <= cap)
-            return rows;
-        const hidden = rows.length - (cap - 1);
-        elidedRows += hidden;
-        return [...rows.slice(0, cap - 1), elisionRow(hidden)];
-    };
-    const renderFrame = (node, cols) => {
-        const target = ensure(Math.max(1, Math.floor(cols)));
-        target.last.value = null;
-        target.failure.error = NO_FAILURE;
-        guardKey += 1;
-        target.instance.rerender(_jsx(Box, { flexDirection: "column", width: target.cols, children: _jsx(RenderGuard, { failure: target.failure, children: node }, guardKey) }));
-        const frame = readFrame(target);
-        const failure = target.failure.error;
-        target.instance.rerender(null);
-        if (failure !== NO_FAILURE)
-            throw failure;
-        if (frame === null)
-            throw new Error('offscreen Ink instance produced no frame');
-        return trimTrailingBlank(frame.split('\n'));
-    };
-    const failureRow = (label) => {
-        failures += 1;
-        return [`[aragon] ${label} could not be rendered`];
-    };
-    const entryFrame = (entry, prev, cols, expanded) => renderFrame(_jsx(EntryView, { entry: entry, prev: prev, expanded: expanded, thinkingVisible: options.thinkingVisible, reducedMotion: options.reducedMotion, density: options.density, theme: options.theme, caps: options.caps }), cols);
-    const renderEntryRows = (entry, prev, cols, expanded = false) => {
-        try {
-            return entryFrame(entry, prev, cols, expanded);
-        }
-        catch (error) {
-            getLogger().warn('cli', 'entry_render_failed', {
-                id: entry.id, kind: entry.kind, error: String(error),
-            });
-            return failureRow(`entry ${entry.id} (${entry.kind})`);
-        }
-    };
-    return {
-        renderEntry(entry, prev, cols, expanded = false) {
-            return capRows(renderEntryRows(entry, prev, cols, expanded));
-        },
-        renderEntryRows,
-        renderNode(node, cols) {
-            try {
-                return capRows(renderFrame(node, cols));
-            }
-            catch (error) {
-                getLogger().warn('cli', 'node_render_failed', { error: String(error) });
-                return failureRow('startup banner');
-            }
-        },
-        setOptions(partial) {
-            options = { ...options, ...partial };
-        },
-        stats: () => ({ elidedRows, failures }),
-        dispose,
-    };
-}

package/dist/ui/scrollback/scrollback-writer.d.ts

@@ -1,174 +0,0 @@
-/**
- * ScrollbackWriter — the byte contract of native-scroll mode
- * (tui-native-terminal-scroll §4.3, extended by tui-bottom-anchored-live-region
- * and re-based on a CANVAS by tui-canvas-bottom-anchor).
- *
- * It implements `FrameDiffer`, so `stdout-frame-writer.ts::wrapStdoutForFrames`
- * binds it to a real stream exactly as it binds the full-screen differ. What it
- * does differently: the screen is NOT the app's. Settled conversation rows are
- * printed into the host terminal's own scrollback, and Ink's frame is only a small
- * LIVE REGION parked under the last printed row.
- *
- * GEOMETRY IS RELATIVE (D2/D4). A batch is `CUU(canvasRows)` to the top of the
- * previous CANVAS, erase down, skip the gap, print the content rows, print the
- * region, park on the last row. Nothing needs the terminal's absolute row count, so
- * a terminal that scrolls underneath cannot misplace anything.
- *
- * THE CANVAS (tui-canvas-bottom-anchor D1/D3). The `rows - 1` rows above the parked
- * row belong to the writer and are always laid out top-down as
- * `[gap][content][region]`. The previous feature put its blank rows between the
- * content and the region (`[content][pad][region]`), which is why a short
- * conversation left a reply floating far above the composer. The blank space now
- * lives above every visible content row, so the newest printed row always touches
- * the top row of the live region, while the composer stays on the last two rows.
- * The gap is SKIPPED with CUD and never written, so a blank row can never be pushed
- * into the scrollback (I-B3).
- *
- * THE PRICE, and it is the only one: the content rows still on the canvas can be
- * re-drawn when the layout changes (a region collapse, a longer draft), because the
- * rows that the region gives back have to move onto the canvas top. That is why the
- * writer keeps a bounded cache of them (`held`, at most `capacity - H` rows). A row
- * that leaves the canvas — pushed into the scrollback or erased at exit — is never
- * written again, so the history the user scrolls through is exactly what was
- * printed, once (I-B5). `anchor: unknown` (nothing measured: no TTY, no filter, no
- * CPR answer) keeps the pre-feature bytes exactly, which is what keeps the old byte
- * tests meaningful (I-B7).
- *
- * THE INVARIANTS THAT FAIL SILENTLY IF DROPPED:
- *  - I-S4 · every batch parks the cursor one row below the region, column 0, the
- *    same place Ink's `previousLineCount = H + 1` expects.
- *  - I-S8 · geometry in doubt (foreign write, unparseable chunk) => `prev = null`
- *    => next batch is a SEED. Never keep erasing on a stale height.
- *  - I-S14 · after `finalize` EVERY Ink write is swallowed.
- *  - I-S13 · no emitted row is wider than `cols - 1` (clipped, counted).
- *  - I-B1 · a batch ends parked on `rows - 1`, which is what the next `CUU` assumes.
- *  - I-B3 · blank rows only ever exist as SKIPPED rows, and a batch that scrolls has
- *    `gap = 0`, so the scrollback never receives an empty row from this file.
- *  - I-B5 · `held` is a contiguous suffix of the printed content, and `dropped` is
- *    exactly the number of rows this batch pushed off the top. The BYTES carry the
- *    untrimmed content: the terminal can only scroll away rows it was given.
- *  - I-B14 · a re-measurement re-derives `capacity` from `spaceBelow + canvasRows`,
- *    never from `spaceBelow` alone: the canvas itself still owns the rows above the
- *    cursor, and forgetting them makes the next batch read its own screen as an
- *    overflow and print every visible row a second time.
- *  - I-B15 · every batch starts by reconciling `top + capacity` with the live
- *    `rows - 1` (a resize event can arrive one frame late), and a column change
- *    resets before it writes.
- *  - I-B17 · a SHRINK re-pins the canvas, it never drops it. The canvas keeps
- *    `min(canvasRows, screenCapacity(rows))` rows — the screen keeps the rows nearest
- *    the parked cursor, so the survivors are its SUFFIX — and its top moves down to
- *    `capacity - kept`, which preserves LB-3. Dropping the cache instead made the next
- *    batch a SEED, and a seed assumes nothing is below the cursor
- *    (`writer-shapes.ts:60-64`); after a shrink that is false, so the batch overflowed
- *    the screen and the previous frame — status row included — went into the
- *    scrollback: the same row in two places. For the same reason a frame TALLER than
- *    the screen gives way at its TOP instead of being swallowed whole: the composer
- *    and the status line are the two rows a human is interacting with.
- *  - I-A9 · the writer never writes a probe byte; it only asks the host, which owns
- *    deferral, coalescing and the death switch.
- */
-import type { FrameDiffer } from '../frame-differ.js';
-import { type AnchorSource } from './canvas.js';
-import type { ScrollbackDrain } from './drain.js';
-export interface ScrollbackWriterOptions {
-    rows: () => number | undefined;
-    cols: () => number | undefined;
-    /** DEC 2026 envelope around each batch. */
-    sync: boolean;
-    /** `diffRender: false` — every batch rewrites the whole region. */
-    fullEveryFrame: boolean;
-    drain: ScrollbackDrain;
-    /** Raised once on the first foreign / unparseable write. */
-    onFirstFallback?: () => void;
-    /** Raised when out-of-resize tall frames repeat; the App degrades to a placeholder. */
-    onGuardTrip?: () => void;
-    /**
-     * Ask the host to call `repaint()` soon (coalesced here). Used when static rows
-     * arrive without a new Ink frame, and to flush the rest of an oversized feed.
-     */
-    requestRepaint?: () => void;
-    /**
-     * Ask the host for one more cursor measurement (resize settled, geometry lost).
-     *
-     * CONTRACT (P0-3), and the writer does NOT implement any of it: the call can
-     * arrive from inside Ink's `stdout.write` (`invalidate` is called by
-     * `transform`), so the host MUST defer it with `setImmediate`, MUST coalesce
-     * everything inside the window into one `ESC[6n`, and MUST drop it after
-     * `finalize`/`dispose`/`exit` — a probe written at a terminal already handed
-     * back to the shell leaks `^[[12;1R` onto the user's prompt (I-A9).
-     */
-    requestAnchorProbe?: () => void;
-    /** Injected clock for the resize grace window. */
-    now?: () => number;
-}
-export interface ScrollbackWriterStats {
-    framesSeed: number;
-    framesDiff: number;
-    framesFull: number;
-    staticRowsWritten: number;
-    bytesWritten: number;
-    fallbacks: number;
-    /** Tall frames swallowed (the scrollback-erasing `ESC[3J` path), resize or not. */
-    guardHits: number;
-    /** The subset NOT explained by a recent resize: the real defect signal. */
-    guardHitsOutsideResize: number;
-    /** Frames taller than the screen, drawn after giving way at their TOP (I-B17). */
-    tallFramesTrimmed: number;
-    clippedRows: number;
-    elidedEntries: number;
-    resizes: number;
-    repaints: number;
-    /** Where the anchor came from: `probe`, one-off `fill`, or never measured. */
-    anchorSource: AnchorSource;
-    /** Canvas height of the most recent batch — the next erase distance (0 = unknown). */
-    anchorCanvasRows: number;
-    /** Content rows inside that canvas. */
-    anchorHeldRows: number;
-    /** Blank rows above the content in that canvas. */
-    anchorGapRows: number;
-    /** Rows this session pushed into the scrollback (the "is it scrolling" signal). */
-    anchorScrollRows: number;
-    /** Times the geometry was dropped on purpose (column change, nothing left to pin). */
-    anchorResets: number;
-    /** Measurements accepted AFTER the first one — the re-probe count (not resize events). */
-    anchorReprobes: number;
-}
-export interface CanvasStats {
-    /** `'pinned'` = measured, drawing a canvas; `'unknown'` = legacy append path. */
-    state: 'pinned' | 'unknown';
-    /** Probe / fill origin; `'none'` = never measured. */
-    source: AnchorSource;
-    /** Rows of the most recent canvas (0 while unknown). */
-    canvasRows: number;
-    /** Content rows inside it. */
-    heldRows: number;
-    /** Blank rows above the content. */
-    gapRows: number;
-    /** Canvas top row (0 = the canvas starts at the first screen row). */
-    top: number;
-}
-export interface ScrollbackWriter extends FrameDiffer {
-    /** Idempotent. Returns the exit bytes; afterwards every Ink write is swallowed. */
-    finalize(summary: readonly string[]): string;
-    /**
-     * Rows of the LIVE REGION as last parked — the frame height `H`, NOT the canvas
-     * (P1-4). `/perf` prints this as "scrollback region N rows", and it has to keep
-     * meaning the same number; the canvas height is `anchorStats().canvasRows`.
-     */
-    regionRows(): number;
-    scrollbackStats(): ScrollbackWriterStats;
-    /**
-     * The host measured how many blank rows are left below the parked cursor
-     * (`0` = already on the last row). Writes no bytes; the next batch — or the
-     * `repaint()` the host schedules right after — consumes it.
-     *
-     * Idempotent and overwritable: the post-resize re-probe calls it again, and it
-     * must then arrive at the SAME capacity the resize delta did (I-B14). Side
-     * effect: sets `anchorDirty`, which is what lets `repaint()` redraw while the
-     * feed is idle (P0-2).
-     */
-    setAnchorSpaceBelow(spaceBelow: number, source: AnchorSource): void;
-    /** For `/perf` and tests. Produces no bytes. */
-    anchorStats(): CanvasStats;
-}
-export declare function createScrollbackWriter(o: ScrollbackWriterOptions): ScrollbackWriter;