@aragon-agent/cli 0.6.4 → 0.6.8

package/dist/ui/frame-observer.js

@@ -0,0 +1,81 @@
+import stripAnsi from 'strip-ansi';
+import stringWidth from 'string-width';
+import { parseInkFrame } from './frame-parser.js';
+import { pickGlyphs } from './glyphs.js';
+function summarizeFrame(chunk, rows, cols) {
+    const lines = typeof chunk === 'string' ? parseInkFrame(chunk) : null;
+    if (!lines || rows < 12 || cols < 40 || lines.length !== rows - 1)
+        return null;
+    const unicode = pickGlyphs({ unicode: true, colorLevel: 0 });
+    const cells = new Set(['|', '#', unicode.scrollTrack, unicode.scrollThumb]);
+    const plain = lines.map((line) => stripAnsi(line));
+    const track = plain.slice(1, rows - 3);
+    if (plain.some((line) => stringWidth(line) > cols) ||
+        !track.every((line) => stringWidth(line) === cols && cells.has(line.slice(-1))))
+        return null;
+    return { columns: cols, rows, trackTop: 2, trackRows: rows - 4 };
+}
+/** Observe before differ transformation, but acknowledge only after downstream write returns. */
+export function createFrameObserver(options) {
+    const { stdout, terminal, scrollbar } = options;
+    let summary = null;
+    let disposed = false;
+    let resizeTimer = null;
+    const invalidate = () => { summary = null; scrollbar.invalidate(); };
+    const onResize = () => {
+        invalidate();
+        if (resizeTimer)
+            clearTimeout(resizeTimer);
+        // Ink suppresses identical frames when a resize burst returns to its starting size.
+        // Wait past the 50 ms React size debounce, then request a normal redraw if needed.
+        resizeTimer = setTimeout(() => {
+            resizeTimer = null;
+            if (!disposed && !scrollbar.frameReady)
+                scrollbar.requestRedraw?.();
+        }, 60);
+        resizeTimer.unref?.();
+    };
+    const match = () => {
+        const g = scrollbar.geometry;
+        scrollbar.frameReady = !!summary && !!g && summary.columns === terminal.columns &&
+            summary.rows === terminal.rows && g.trackCol === summary.columns &&
+            g.trackTop === summary.trackTop && g.trackRows === summary.trackRows;
+    };
+    const observe = (chunk) => {
+        summary = summarizeFrame(chunk, terminal.rows, terminal.columns);
+        if (!summary) {
+            invalidate();
+            return;
+        }
+        match();
+    };
+    scrollbar.onGeometry = match;
+    terminal.on('resize', onResize);
+    const bound = new Map();
+    const proxy = new Proxy(stdout, {
+        get(target, prop) {
+            if (prop === 'write')
+                return (...args) => {
+                    const result = Reflect.apply(target.write, target, args);
+                    if (!disposed)
+                        observe(args[0]);
+                    return result;
+                };
+            const value = Reflect.get(target, prop, target);
+            if (typeof value !== 'function')
+                return value;
+            if (!bound.has(prop))
+                bound.set(prop, value.bind(target));
+            return bound.get(prop);
+        },
+    });
+    return { stdout: proxy, invalidate, dispose: () => {
+            disposed = true;
+            if (resizeTimer)
+                clearTimeout(resizeTimer);
+            resizeTimer = null;
+            terminal.off('resize', onResize);
+            scrollbar.onGeometry = undefined;
+            invalidate();
+        } };
+}

package/dist/ui/frame-parser.d.ts

@@ -0,0 +1,7 @@
+/** Recognize Ink's erase-lines prefix without accepting arbitrary control writes. */
+export declare function matchInkErasePrefix(chunk: string): {
+    prefix: string;
+    erased: number;
+} | null;
+/** Parse complete frames, including Ink's prefixless initial frame. */
+export declare function parseInkFrame(chunk: string): string[] | null;

package/dist/ui/frame-parser.js

@@ -0,0 +1,18 @@
+/** Recognize Ink's erase-lines prefix without accepting arbitrary control writes. */
+export function matchInkErasePrefix(chunk) {
+    const match = /^(?:\x1b\[2K(?:\x1b\[1A)?)+\x1b\[G/.exec(chunk);
+    return match ? { prefix: match[0], erased: match[0].split('\x1b[2K').length - 1 } : null;
+}
+/** Parse complete frames, including Ink's prefixless initial frame. */
+export function parseInkFrame(chunk) {
+    const prefix = matchInkErasePrefix(chunk);
+    const body = chunk.slice(prefix?.prefix.length ?? 0);
+    if (!body.endsWith('\n'))
+        return null;
+    // SGR and OSC-8 may decorate text; cursor movement is never frame content.
+    const controls = body.replace(/\x1b\[[0-9;:]*m/g, '')
+        .replace(/\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)/g, '');
+    if (/[\x00-\x08\x0b-\x1f\x7f]/.test(controls))
+        return null;
+    return body.slice(0, -1).split('\n');
+}

package/dist/ui/layout/AppShell.d.ts

@@ -1,14 +1,4 @@
-/**
- * AppShell (spec §4.3) — the frame that makes R2 true.
- *
- * In `fullscreen` the root box has a FIXED height of `frameHeight(rows)` and the
- * middle viewport is the only `flexGrow` child, so the bottom chrome (toast /
- * composer / status bar) is physically the last thing on the screen from the
- * very first frame — empty session, long session, mid-scroll, overlay open.
- *
- * In `inline` the same children are emitted in the same order with no height
- * constraint, i.e. byte-for-byte the v0.2.0 document-flow behavior.
- */
+/** Stable fullscreen slots preserve the editor during overlays and small resizes. */
 import React from 'react';
 import { type RenderMode } from './frame.js';
 export interface AppShellProps {
@@ -17,51 +7,16 @@ export interface AppShellProps {
     cols: number;
     header: React.ReactNode;
     viewport: React.ReactNode;
-    /**
-     * The live subagent roster (team-subagents §6.1), or nothing.
-     *
-     * IT RENDERS IN THE BOTTOM CHROME OF THE FULL-SCREEN BRANCH, above `toast` and
-     * below the viewport: the roster is transient status about the run in progress,
-     * so it belongs with the other transient rows rather than inside the scrolling
-     * transcript, where it would be interleaved with history and scroll away.
-     */
+    /** Legacy inline footer; fullscreen assembles these slots inside its viewport. */
     team?: React.ReactNode;
-    /**
-     * The right-hand region of the MIDDLE band (todo-plan-execution §3.9), or
-     * nothing.
-     *
-     * NAMED FOR ITS POSITION, NOT ITS CONTENT (D-18): this file is a layout
-     * primitive and has no business knowing what a todo is. `team` above already
-     * leaks content vocabulary in here; there is no reason to repeat it.
-     *
-     * IT MUST BE RENDERED IN THE MIDDLE BAND, BESIDE THE VIEWPORT (C-6 / I-4) —
-     * that is what makes it a rail rather than another row of bottom chrome. Moved
-     * down into the bottom box it would stop being a column beside the transcript
-     * and start eating viewport height, growing and shrinking the transcript every
-     * time the list changed length.
-     *
-     * The INLINE branch does not include it at all — a structural guarantee rather
-     * than a promise that the caller passes `null` (non-goal 4).
-     */
+    /** Kept source-compatible; fullscreen rail is owned by ScrollViewport. */
     rail?: React.ReactNode;
-    /**
-     * The one-row plan strip for INLINE mode (todo-plan-followthrough §3.7), or
-     * nothing.
-     *
-     * THE STRUCTURAL MIRROR OF `rail` ABOVE, in the opposite direction: the
-     * FULL-SCREEN branch does not reference it at all. The reason is the same one
-     * `rail`'s inline omission records — a prop that is merely SUPPOSED to be null
-     * in one mode becomes non-null eventually, and then the rail and the strip are
-     * both on screen showing the same list (I-6). Fullscreen has the rail; that is
-     * the whole design.
-     *
-     * It sits between `viewport` and `team`, mirroring where the rail sits in the
-     * other branch: last thing above the bottom chrome, so the strip and the
-     * roster read top-to-bottom in the same order in both modes.
-     */
+    /** Inline-only plan strip. */
     strip?: React.ReactNode;
     toast: React.ReactNode;
     composer: React.ReactNode;
     status: React.ReactNode;
+    inactive?: boolean;
+    placeholder?: React.ReactNode;
 }
-export declare function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, }: AppShellProps): React.ReactElement;
+export declare function AppShell({ mode, rows, cols, header, viewport, team, strip, toast, composer, status, inactive, placeholder, }: AppShellProps): React.ReactElement;

package/dist/ui/layout/AppShell.js

@@ -1,9 +1,9 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box } from 'ink';
 import { frameHeight } from './frame.js';
-export function AppShell({ mode, rows, cols, header, viewport, team, rail, strip, toast, composer, status, }) {
+export function AppShell({ mode, rows, cols, header, viewport, team, strip, toast, composer, status, inactive = false, placeholder, }) {
     if (mode === 'inline') {
         return (_jsxs(Box, { flexDirection: "column", children: [header, viewport, strip, team, toast, composer, status] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexShrink: 0, children: header }), _jsxs(Box, { flexDirection: "row", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), rail] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [team, toast, composer, status] })] }));
+    return (_jsxs(Box, { flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsxs(Box, { display: inactive ? 'none' : 'flex', flexDirection: "column", height: frameHeight(rows), width: cols, overflow: "hidden", children: [_jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: header }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: viewport }), _jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: toast }), _jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: status })] }), _jsx(Box, { display: inactive ? 'flex' : 'none', height: frameHeight(rows), overflow: "hidden", children: placeholder })] }));
 }

package/dist/ui/layout/ScrollIndicator.d.ts

@@ -18,14 +18,15 @@ import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { ThumbRange } from './scroll-indicator.js';
-/** Below this width a column of content is worth more than the affordance. */
-export declare const MIN_INDICATOR_COLS = 50;
+/** Smallest supported fullscreen width; every usable chat frame reserves the column. */
+export declare const MIN_INDICATOR_COLS = 40;
 export interface ScrollIndicatorProps {
     /** Viewport height in rows, as measured by `ScrollViewport`. */
     rows: number;
     /** `null` when the content fits — the rail is drawn as bare track. */
     thumb: ThumbRange | null;
+    dragging?: boolean;
     theme: Theme;
     caps: TermCapabilities;
 }
-export declare function ScrollIndicator({ rows, thumb, theme, caps, }: ScrollIndicatorProps): React.ReactElement;
+export declare function ScrollIndicator({ rows, thumb, dragging, theme, caps, }: ScrollIndicatorProps): React.ReactElement;

package/dist/ui/layout/ScrollIndicator.js

@@ -1,15 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { pickGlyphs } from '../glyphs.js';
-/** Below this width a column of content is worth more than the affordance. */
-export const MIN_INDICATOR_COLS = 50;
-export function ScrollIndicator({ rows, thumb, theme, caps, }) {
+/** Smallest supported fullscreen width; every usable chat frame reserves the column. */
+export const MIN_INDICATOR_COLS = 40;
+export function ScrollIndicator({ rows, thumb, dragging = false, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
     const count = Math.max(0, Math.floor(rows) || 0);
     const cells = [];
     for (let i = 0; i < count; i += 1) {
         const onThumb = !!thumb && i >= thumb.start && i < thumb.start + thumb.size;
-        cells.push(_jsx(Text, { color: onThumb ? theme.primary : theme.border, children: onThumb ? glyphs.scrollThumb : glyphs.scrollTrack }, i));
+        cells.push(_jsx(Text, { color: onThumb ? theme.primary : theme.muted, bold: onThumb && dragging, children: onThumb ? glyphs.scrollThumb : glyphs.scrollTrack }, i));
     }
     return (_jsx(Box, { flexDirection: "column", flexShrink: 0, width: 1, children: cells }));
 }

package/dist/ui/layout/ScrollViewport.d.ts

@@ -1,88 +1,35 @@
-/**
- * ScrollViewport (spec §4.5) — a self-drawn scrolling window built from Ink's
- * negative `marginTop` + `overflow: hidden` + `measureElement`.
- *
- * Once the frame occupies the whole screen, `<Static>` history is pushed above
- * the frame where only one line is visible, so native scrollback stops being a
- * usable mechanism and the app has to own scrolling. That is why this exists.
- *
- * SINGLE SOURCE OF TRUTH (review P1-7): both the metrics and the scroll offset
- * live here. The parent only pushes an *intent* down and receives one derived
- * *display* number back. Holding the offset in the parent as well would create a
- * measure → setState → re-render → measure loop whose convergence is provable
- * but whose frame count is not — expensive inside a 33 ms streaming window.
- *
- * AS OF tui-selection-and-scroll-follow THIS IS AN ADAPTER, NOT A POLICY OWNER.
- * The two follow rules are pure and live in `follow-state.ts`; what stays here is
- * measure → compute a tail delta → apply → arm a timer. `scroll.ts` is
- * unchanged, so every existing scroll test keeps passing (R-10).
- *
- * The "N new lines · PgDn" hint used to take this viewport's LAST ROW. It now
- * renders as a chip inside the composer's bordered input row (§4.2), which costs
- * zero rows and removes the feedback loop where the hint's own presence shrank
- * the viewport, which changed `overflowLines`, which was the number the hint
- * displayed. The data still leaves through `onScrolledLinesChange`.
- */
 import React from 'react';
+import { type DOMElement } from 'ink';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
+import { type ScrollbarBridge } from '../scrollbar-controller.js';
 import { type ScrollIntent } from './scroll.js';
 import { type TailSink } from './follow-state.js';
 export interface ScrollViewportProps {
-    /**
-     * Scroll intent. `nonce` is monotonic so pressing the same key twice re-fires.
-     * `repeat` folds a coalesced wheel burst into one state update (defaults 1).
-     */
     intent?: {
         kind: ScrollIntent;
         nonce: number;
         repeat?: number;
     };
-    /** Bumped by the parent to force a pin to the newest output (e.g. on submit). */
     pinToBottomNonce?: number;
-    /** Derived display value for the status bar's `↑N`. Must be referentially stable. */
+    resetKey?: unknown;
     onScrolledLinesChange?: (lines: number) => void;
-    /**
-     * Rows hidden ABOVE the window, published on every change (§4.3.3).
-     *
-     * PUBLISHED, NOT LIFTED — the same shape as `onScrolledLinesChange`, so there
-     * is still exactly one owner of the offset. `shiftUp` changes exactly when the
-     * rows on screen move, which is the property the selection's clear-list was
-     * approximating by enumeration (I-9 / P1-4). Must be referentially stable.
-     */
-    onViewportShiftChange?: (shiftUp: number) => void;
-    /**
-     * The transcript's tail row counter (§4.3.1a), written during ITS render and
-     * therefore already current when this component's layout effect runs.
-     *
-     * ABSENT ⇒ NO ANCHORING AT ALL, deliberately: every existing caller and every
-     * existing test that does not supply it behaves exactly as it did before this
-     * feature, because `tailDelta` is then permanently 0.
-     */
+    onViewportShiftChange?: (shift: number) => void;
     tailRowsRef?: TailSink;
-    /**
-     * True while a selection drag is in progress (§4.4). It anchors the content
-     * even from a pinned viewport, and it suspends the resume timer.
-     */
     hold?: boolean;
-    /** Idle delay before returning to the newest line, in ms; `0` disables (AC-9). */
     resumeMs?: number;
-    /** Reserve the right-edge scroll-position rail (mouse-wheel §4.8). */
     showScrollIndicator?: boolean;
-    /**
-     * The viewport's own width, when it is narrower than the terminal
-     * (todo-plan-execution §3.9 / C-7).
-     *
-     * This component is the ONLY one inside the viewport subtree that reads
-     * `stdout.columns` directly, and the place it uses the number — the
-     * `MIN_INDICATOR_COLS` gate — is about how much room THIS BOX has, not how
-     * wide the terminal is. Once the todo rail takes a fifth of the frame those two
-     * stop being the same number. Optional so every existing caller (and every
-     * test) is unchanged.
-     */
     cols?: number;
+    footer?: React.ReactNode;
+    rail?: React.ReactNode;
+    overlay?: React.ReactNode;
+    active?: boolean;
+    scrollbar?: ScrollbarBridge;
+    composerRef?: React.RefObject<DOMElement>;
+    onComposerVisibilityChange?: (visible: boolean) => void;
     theme: Theme;
     caps: TermCapabilities;
     children: React.ReactNode;
 }
-export declare function ScrollViewport({ intent, pinToBottomNonce, onScrolledLinesChange, onViewportShiftChange, tailRowsRef, hold, resumeMs, showScrollIndicator, cols: colsProp, theme, caps, children, }: ScrollViewportProps): React.ReactElement;
+/** One offset for messages, padding and editor; hidden trees keep their local state. */
+export declare function ScrollViewport(props: ScrollViewportProps): React.ReactElement;