@aragon-agent/cli 0.6.34 → 0.6.36

package/dist/ui/overlays/PromptLibraryOverlay.js

@@ -0,0 +1,191 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The prompt manager: `Ctrl+P` (quick-prompt-library §4.4 / §6.4).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * A LIST PLUS A DETAIL BLOCK, the `KitPicker` idiom (F-17): three columns of prompt
+ * metadata never fit on a 72-column terminal, and the detail block is how this
+ * package already shows everything that does not fit in a row.
+ *
+ * THE OVERLAY OWNS NO DATA. Every mutation goes out through `onMutate`, and the new
+ * snapshot comes back through `library`. An overlay that patched its own copy would
+ * show a prompt the disk does not have (I-6), and the first time that happened the
+ * user would find out at the next launch.
+ */
+import { useEffect, useReducer, useRef } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+import { promptDeletedCopy, promptErrorCopy, promptSavedCopy, PROMPT_EMPTY_BODY_COPY, PROMPT_EMPTY_TITLE_COPY } from '../../prompts/copy.js';
+import { INITIAL_PROMPT_LIBRARY_STATE, deleteDetail, finishPromptEditor, libraryDetail, libraryHint, libraryRows, promptLibraryReducer, } from './prompt-library-state.js';
+import { PromptEditorPage } from './PromptEditorPage.js';
+/** The reducer takes the library as a third argument, so it is bound per dispatch. */
+function reduce(state, dispatched) {
+    return promptLibraryReducer(state, dispatched.action, dispatched.library);
+}
+export function PromptLibraryOverlay(props) {
+    const { library, cols, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const [state, rawDispatch] = useReducer(reduce, INITIAL_PROMPT_LIBRARY_STATE);
+    const dispatch = (action) => rawDispatch({ action, library });
+    const rows = libraryRows(library);
+    const count = rows.length;
+    const cursor = count === 0 ? 0 : Math.min(state.index, count - 1);
+    const focused = rows[cursor];
+    const offset = useProfileScroll(props, cursor);
+    /**
+     * CONSUME THE INTENT EXACTLY ONCE (I-8).
+     *
+     * A `useRef`, not state: the ref is written before the dispatch is processed, so a
+     * StrictMode double-invoke of this effect sees `nonce <= consumed` and does nothing.
+     * State would be one render behind and would open the editor twice.
+     */
+    const consumed = useRef(0);
+    const intent = props.intent;
+    useEffect(() => {
+        if (!intent || intent.nonce <= consumed.current)
+            return;
+        consumed.current = intent.nonce;
+        dispatch({ type: 'init', entry: intent.entry, library, nonce: intent.nonce });
+    }, [intent]);
+    /** One mutation, its refusal routed to the same two channels every time. */
+    const mutate = (action) => {
+        const result = props.onMutate(action);
+        if (!result.ok)
+            props.onNotice?.('warn', promptErrorCopy(result.code));
+        return result;
+    };
+    const save = () => {
+        const verdict = finishPromptEditor(state.draft);
+        if (!verdict.ok) {
+            dispatch({ type: 'failed', code: verdict.code, field: verdict.field });
+            props.onNotice?.('warn', promptErrorCopy(verdict.code));
+            return;
+        }
+        const draft = state.draft;
+        const result = draft.id === null
+            ? mutate({ kind: 'create', draft })
+            : mutate({ kind: 'update', id: draft.id, draft });
+        if (!result.ok) {
+            // THE PAGE DOES NOT CLOSE AND THE DRAFT IS NOT TOUCHED (D-12): the editor is
+            // where the user has invested the most, so a refusal must cost nothing.
+            dispatch({ type: 'failed', code: result.code });
+            return;
+        }
+        dispatch({ type: 'commit', id: result.id ?? draft.id });
+        props.onNotice?.('info', promptSavedCopy(draft.title.trim()));
+    };
+    const confirmDelete = () => {
+        const id = state.pendingDeleteId;
+        if (!id) {
+            dispatch({ type: 'cancelled' });
+            return;
+        }
+        const title = library.prompts.find((prompt) => prompt.id === id)?.title ?? '';
+        const result = mutate({ kind: 'delete', id });
+        dispatch({ type: 'cancelled' });
+        // `promptDeletedCopy`, not `promptSavedCopy`: the two sentences are one word apart
+        // and the wrong one tells the user their prompt still exists.
+        if (result.ok)
+            props.onNotice?.('info', promptDeletedCopy(title));
+    };
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        // THE EDITOR PAGE OWNS EVERY KEY WHILE IT IS OPEN, Esc INCLUDED. Two `useInput`
+        // hooks are live at once (this one and the page's), so handling Esc in both would
+        // dispatch `esc` TWICE for one keypress: the first arms the discard and the second
+        // executes it, which silently throws away a drafted body on a single Esc. The page
+        // already reports Esc through `onEsc`, so this branch must stay silent.
+        if (state.page === 'editor')
+            return;
+        if (state.page === 'delete') {
+            if (key.escape || input === 'n' || input === 'N') {
+                dispatch({ type: 'cancelled' });
+                return;
+            }
+            if (key.return || input === 'y' || input === 'Y')
+                confirmDelete();
+            return;
+        }
+        // --- list page ---------------------------------------------------------
+        if (key.escape) {
+            props.onClose();
+            return;
+        }
+        // THE RAW SEQUENCE **AND** THE PARSED CHORD (D-23, corrected by measurement).
+        // Ink 5's `parse-keypress` recognises `\x1b[1;5A`, reports it as
+        // `ctrl + upArrow`, and hands the component an EMPTY `input` - so the sequence
+        // comparison alone would be a dead branch on this runtime, and the chord
+        // comparison alone would miss a host that passes the raw bytes through. Either
+        // shape reorders; `\x1b[A` (modifier lost) matches neither and only moves focus.
+        const reorderUp = input === '\x1b[1;5A' || (key.ctrl && key.upArrow);
+        const reorderDown = input === '\x1b[1;5B' || (key.ctrl && key.downArrow);
+        if (reorderUp || reorderDown) {
+            if (!focused)
+                return;
+            const result = mutate({ kind: 'move', id: focused.id, delta: reorderUp ? -1 : 1 });
+            if (result.ok)
+                dispatch({ type: 'list', focusId: focused.id });
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            dispatch({ type: 'focus', index: count === 0 ? 0 : (cursor - 1 + count) % count });
+            return;
+        }
+        if (key.downArrow) {
+            dispatch({ type: 'focus', index: count === 0 ? 0 : (cursor + 1) % count });
+            return;
+        }
+        if (key.return) {
+            if (focused)
+                dispatch({ type: 'edit', id: focused.id, library });
+            return;
+        }
+        if (key.ctrl || key.meta)
+            return;
+        if (input === 'a') {
+            dispatch({ type: 'create' });
+            return;
+        }
+        if (input === 'd' && focused) {
+            dispatch({ type: 'delete', id: focused.id });
+            return;
+        }
+        if (input === 'f' && focused) {
+            const prompt = library.prompts.find((entry) => entry.id === focused.id);
+            mutate({ kind: 'favorite', id: focused.id, favorite: prompt?.favorite !== true });
+            dispatch({ type: 'list', focusId: focused.id });
+        }
+    });
+    if (state.page === 'editor') {
+        return (_jsx(PromptEditorPage, { isActive: props.isActive, state: state, cols: cols, maxRows: props.maxRows, theme: theme, caps: caps, ...(props.reducedMotion === undefined ? {} : { reducedMotion: props.reducedMotion }), onDraft: (patch) => dispatch({ type: 'draft', patch }), onSave: save, onEsc: () => dispatch({ type: 'esc' }), onCancel: () => dispatch({ type: 'cancelled' }) }));
+    }
+    const body = [];
+    if (state.page === 'delete') {
+        for (const [at, line] of deleteDetail(library, state.pendingDeleteId).entries()) {
+            body.push(_jsx(Text, { wrap: "truncate", color: at === 0 ? theme.accent : theme.muted, children: clipProfileText(line, cols - 8) }, `del-${at}`));
+        }
+        return (_jsx(OverlayFrame, { title: "Delete prompt", hint: libraryHint(state, count), rows: body, scrollOffset: 0, maxRows: props.maxRows, cols: cols, theme: theme, caps: caps }));
+    }
+    for (const [at, row] of rows.entries()) {
+        const isCursor = at === cursor;
+        body.push(_jsx(Text, { wrap: "truncate", color: isCursor ? theme.accent : theme.muted, children: `${isCursor ? glyphs.caret : ' '} ${clipProfileText(row.label, cols - 8)}` }, row.id));
+    }
+    if (count === 0) {
+        // TWO ROWS, NOT AN EMPTY SCREEN (§9.7): an empty list that says nothing reads as a
+        // broken panel, and the key that fixes it (`a`) is not otherwise discoverable. The
+        // sentences come from `prompts/copy.ts` so this state and the picker's own empty
+        // state cannot drift into two wordings of the same advice.
+        body.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: clipProfileText(PROMPT_EMPTY_TITLE_COPY, cols - 8) }, "empty-title"));
+        body.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: clipProfileText(PROMPT_EMPTY_BODY_COPY, cols - 8) }, "empty-body"));
+    }
+    // THE DETAIL BLOCK DESCRIBES THE FOCUSED ROW ONLY, and it is last so a narrow
+    // terminal clips the description rather than the list.
+    for (const [at, line] of libraryDetail(focused, library, cols).entries()) {
+        body.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: clipProfileText(`  ${line}`, cols - 8) }, `detail-${at}`));
+    }
+    return (_jsx(OverlayFrame, { title: `Prompts${count > 0 ? ` (${count})` : ''}`, hint: libraryHint(state, count), rows: body, scrollOffset: offset, onScrollClamp: props.onScrollClamp, maxRows: props.maxRows, cols: cols, theme: theme, caps: caps }));
+}

package/dist/ui/overlays/PromptPicker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The prompt picker: `/prompts` (quick-prompt-library §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE QUERY BOX IS THE LIST. There is no separate search field and no `/` mode: the
+ * picker exists for one keystroke-to-answer gesture, and an extra mode to enter is an
+ * extra thing that can be wrong about which component owns the next key.
+ *
+ * `Ctrl+Enter` IS RECOGNISED BY ITS BYTES, NOT BY `key.ctrl && key.return`. The stdin
+ * filter normalises every modified Enter (`\x1b[13;5u`, the win32 record, `\x1b[13;2u`)
+ * into `ENTER_NEWLINE_FRAME` before Ink sees it (enter-sequences.ts), so the parsed
+ * chord never occurs - a branch written that way is dead code that LOOKS implemented
+ * (R-11). On a terminal without keyboard enhancement the chord degrades to a plain
+ * `Enter`, which fills without sending; the footer therefore names `Enter fill` first.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { PromptLibrary, PromptLibraryEntry } from '../../prompts/types.js';
+export interface PromptPickerProps {
+    isActive: boolean;
+    library: PromptLibrary;
+    cols: number;
+    maxRows: number;
+    scrollOffset: number;
+    onScrollClamp?: (offset: number) => void;
+    theme: Theme;
+    caps: TermCapabilities;
+    /** `submit` is true only for `Ctrl+Enter` (see `SUBMIT_FRAMES`). */
+    onFill: (id: string, submit: boolean) => void;
+    /** `Tab` / `a`: hand over to the manager without leaving the overlay stack. */
+    onManage: (entry: PromptLibraryEntry) => void;
+    onClose: () => void;
+}
+export declare function PromptPicker(props: PromptPickerProps): React.ReactElement;

package/dist/ui/overlays/PromptPicker.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * The prompt picker: `/prompts` (quick-prompt-library §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THE QUERY BOX IS THE LIST. There is no separate search field and no `/` mode: the
+ * picker exists for one keystroke-to-answer gesture, and an extra mode to enter is an
+ * extra thing that can be wrong about which component owns the next key.
+ *
+ * `Ctrl+Enter` IS RECOGNISED BY ITS BYTES, NOT BY `key.ctrl && key.return`. The stdin
+ * filter normalises every modified Enter (`\x1b[13;5u`, the win32 record, `\x1b[13;2u`)
+ * into `ENTER_NEWLINE_FRAME` before Ink sees it (enter-sequences.ts), so the parsed
+ * chord never occurs - a branch written that way is dead code that LOOKS implemented
+ * (R-11). On a terminal without keyboard enhancement the chord degrades to a plain
+ * `Enter`, which fills without sending; the footer therefore names `Enter fill` first.
+ */
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { ENTER_NEWLINE_FRAME } from '../../input/limits.js';
+import { PROMPT_PICKER_LIMITS } from '../../prompts/limits.js';
+import { nextView } from '../../prompts/search.js';
+import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+import { pickerDetail, pickerDigitTarget, pickerHint, pickerRows, } from './prompt-picker-state.js';
+/** Every modified Enter the stdin filter folds into its frame, plus the raw CSI-u. */
+const SUBMIT_FRAMES = [ENTER_NEWLINE_FRAME, '\x1b[13;5u'];
+export function PromptPicker(props) {
+    const { library, cols, theme, caps } = props;
+    const glyphs = pickGlyphs(caps);
+    const [query, setQuery] = useState('');
+    const [view, setView] = useState('manual');
+    // THE FOCUS IS AN ID, NOT AN INDEX (D-9's cost, paid here): both filtering and
+    // `Ctrl+S` can reorder the list under the cursor, and an index would silently point
+    // at a different prompt after either.
+    const [focusId, setFocusId] = useState(null);
+    const rows = pickerRows({ library, query, view });
+    const found = rows.findIndex((row) => row.id === focusId);
+    const cursor = rows.length === 0 ? 0 : Math.max(0, Math.min(found, rows.length - 1));
+    const focused = rows[cursor];
+    const offset = useProfileScroll(props, cursor);
+    const empty = library.prompts.length === 0;
+    const fill = (id, submit) => {
+        if (!id)
+            return;
+        props.onFill(id, submit);
+    };
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        if (key.escape) {
+            props.onClose();
+            return;
+        }
+        // BEFORE `key.return`: the frame arrives with `return` false, so this branch must
+        // not be reachable only through the plain-Enter path.
+        if (SUBMIT_FRAMES.includes(input)) {
+            fill(focused?.id, true);
+            return;
+        }
+        if (key.return) {
+            fill(focused?.id, false);
+            return;
+        }
+        if (key.ctrl && (input === 's' || input === 'S')) {
+            setView(nextView(view));
+            return;
+        }
+        if (key.upArrow) {
+            if (rows.length === 0)
+                return;
+            setFocusId(rows[(cursor - 1 + rows.length) % rows.length].id);
+            return;
+        }
+        if (key.downArrow) {
+            if (rows.length === 0)
+                return;
+            setFocusId(rows[(cursor + 1) % rows.length].id);
+            return;
+        }
+        if (key.tab) {
+            // ONE OVERLAY STACK, NOT TWO (AC-23): the picker hands the manager an intent and
+            // closes, and an empty library lands straight in the editor because there is
+            // nothing for a list page to show.
+            props.onManage(empty ? { kind: 'create' } : { kind: 'list' });
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setQuery((value) => [...value].slice(0, -1).join(''));
+            return;
+        }
+        if (key.ctrl || key.meta)
+            return;
+        const clean = stripPasteFrames(stripEnterFrames(input));
+        if (clean.length === 0)
+            return;
+        if (query.length === 0) {
+            // `1`-`9` PICK A ROW (AC-21). Only while the query is empty: otherwise the digit
+            // is the first character of what the user is searching for.
+            if (input === 'a' && empty) {
+                props.onManage({ kind: 'create' });
+                return;
+            }
+            const target = pickerDigitTarget(rows, input);
+            if (target !== null) {
+                fill(target, false);
+                return;
+            }
+        }
+        setQuery((value) => (value + clean).slice(0, PROMPT_PICKER_LIMITS.queryMaxChars));
+        setFocusId(null);
+    });
+    const body = [
+        _jsx(Text, { wrap: "truncate", color: theme.primary, children: `${glyphs.caret} ${query.length > 0 ? query : '(type to filter)'}` }, "query"),
+    ];
+    for (const [at, row] of rows.entries()) {
+        const isCursor = at === cursor;
+        const marks = `${row.favorite ? ' [fav]' : ''}${row.tags.length > 0 ? ` #${row.tags[0]}` : ''}`;
+        body.push(_jsx(Text, { wrap: "truncate", color: isCursor ? theme.accent : theme.muted, children: `${isCursor ? glyphs.caret : ' '} ${row.index}. `
+                + clipProfileText(`${row.title}${marks}`, cols - 12) }, row.id));
+    }
+    for (const [at, line] of pickerDetail(focused, library).entries()) {
+        body.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: clipProfileText(`  ${line}`, cols - 8) }, `detail-${at}`));
+    }
+    return (_jsx(OverlayFrame, { title: `Pick a prompt (${rows.length}/${library.prompts.length})`, hint: pickerHint({ count: rows.length, query, view }), rows: body, scrollOffset: offset, onScrollClamp: props.onScrollClamp, maxRows: props.maxRows, cols: cols, theme: theme, caps: caps }));
+}

package/dist/ui/overlays/PromptTextArea.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The one editable multi-line field in this feature (quick-prompt-library D-11).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * RENDER AND CARET COME FROM THE SAME FUNCTION. `layoutComposer` wraps the buffer and
+ * reports the caret's row and column from ONE `buildEditorVisualMap` pass, and the
+ * drawing below splits that same row at that same column. Every second authority
+ * here - a prose wrapper, a second width table, a "count the characters instead" -
+ * puts the caret on a cell that does not hold the character it points at, and the
+ * only symptom is that the user's edits land one column off in Chinese text.
+ *
+ * WHY `layout/wrap-rows.ts::wrapToRows` IS BANNED HERE (it is used one directory
+ * away, for the list's read-only preview): it splits on whitespace and rejoins with
+ * single spaces, so it eats indentation and destroys the character-index-to-cell
+ * mapping. `composer-rows.ts:16-20` says so in as many words, and that is the module
+ * this one borrows from.
+ *
+ * NO PASTE-COLLAPSE TOKENS, deliberately. The token machinery exists so a 218-line
+ * paste does not have to live in a one-line input; this IS a multi-line field, and a
+ * token inside a saved prompt body would be data corruption the user could not undo.
+ */
+import React from 'react';
+import type { Theme } from '../theme.js';
+import type { TermCapabilities } from '../capabilities.js';
+export interface PromptTextAreaState {
+    buffer: string;
+    cursor: number;
+    /** Kept across vertical moves, cleared by any horizontal one (composer parity). */
+    preferredVisualColumn?: number;
+}
+export declare const EMPTY_TEXT_AREA: PromptTextAreaState;
+export type PromptTextAreaAction = {
+    type: 'insert';
+    text: string;
+} | {
+    type: 'newline';
+} | {
+    type: 'backspace';
+} | {
+    type: 'delete';
+} | {
+    type: 'left';
+} | {
+    type: 'right';
+} | {
+    type: 'home';
+} | {
+    type: 'end';
+}
+/** Vertical moves need the wrap width; it is part of the ACTION, not of the state. */
+ | {
+    type: 'up';
+    cols: number;
+} | {
+    type: 'down';
+    cols: number;
+} | {
+    type: 'replace';
+    buffer: string;
+    cursor: number;
+};
+/**
+ * Pure. No React, no Ink, no filesystem - so the twelve editing cases are a table
+ * test rather than a rendered frame assertion.
+ */
+export declare function promptTextAreaReducer(state: PromptTextAreaState, action: PromptTextAreaAction): PromptTextAreaState;
+export interface PromptTextAreaProps {
+    state: PromptTextAreaState;
+    /** Wrap width, in cells, already net of the field's own chrome. */
+    cols: number;
+    /** Rows the field may occupy. `1` is the single-line case for title/description. */
+    rows: number;
+    focused: boolean;
+    theme: Theme;
+    caps: TermCapabilities;
+    reducedMotion?: boolean;
+}
+/**
+ * One field's worth of rows.
+ *
+ * The overflow chip is a plain `+N` on the LAST row rather than a row of its own:
+ * an extra row would make this component draw one more line than the caller budgeted
+ * for, and the frame it lives in has no way to find out.
+ */
+export declare function PromptTextArea(props: PromptTextAreaProps): React.ReactElement;

package/dist/ui/overlays/PromptTextArea.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The one editable multi-line field in this feature (quick-prompt-library D-11).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * RENDER AND CARET COME FROM THE SAME FUNCTION. `layoutComposer` wraps the buffer and
+ * reports the caret's row and column from ONE `buildEditorVisualMap` pass, and the
+ * drawing below splits that same row at that same column. Every second authority
+ * here - a prose wrapper, a second width table, a "count the characters instead" -
+ * puts the caret on a cell that does not hold the character it points at, and the
+ * only symptom is that the user's edits land one column off in Chinese text.
+ *
+ * WHY `layout/wrap-rows.ts::wrapToRows` IS BANNED HERE (it is used one directory
+ * away, for the list's read-only preview): it splits on whitespace and rejoins with
+ * single spaces, so it eats indentation and destroys the character-index-to-cell
+ * mapping. `composer-rows.ts:16-20` says so in as many words, and that is the module
+ * this one borrows from.
+ *
+ * NO PASTE-COLLAPSE TOKENS, deliberately. The token machinery exists so a 218-line
+ * paste does not have to live in a one-line input; this IS a multi-line field, and a
+ * token inside a saved prompt body would be data corruption the user could not undo.
+ */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { layoutComposer, splitRowAtColumn } from '../composer-rows.js';
+import { moveVisualCursor, snapGrapheme, stepGrapheme } from '../editor-navigation.js';
+import { PromptCaret } from '../PromptCaret.js';
+export const EMPTY_TEXT_AREA = { buffer: '', cursor: 0 };
+function withCursor(state, buffer, cursor) {
+    return { buffer, cursor: snapGrapheme(buffer, cursor, true) };
+}
+/**
+ * Pure. No React, no Ink, no filesystem - so the twelve editing cases are a table
+ * test rather than a rendered frame assertion.
+ */
+export function promptTextAreaReducer(state, action) {
+    switch (action.type) {
+        case 'insert': {
+            const cursor = snapGrapheme(state.buffer, state.cursor);
+            const buffer = state.buffer.slice(0, cursor) + action.text + state.buffer.slice(cursor);
+            return {
+                buffer,
+                cursor: snapGrapheme(buffer, cursor + action.text.length, true),
+            };
+        }
+        case 'newline': {
+            const cursor = snapGrapheme(state.buffer, state.cursor);
+            const buffer = `${state.buffer.slice(0, cursor)}\n${state.buffer.slice(cursor)}`;
+            return { buffer, cursor: cursor + 1 };
+        }
+        case 'backspace':
+        case 'delete': {
+            const cursor = snapGrapheme(state.buffer, state.cursor);
+            if (action.type === 'backspace') {
+                if (cursor <= 0)
+                    return state;
+                const from = stepGrapheme(state.buffer, cursor, 'left');
+                return withCursor(state, state.buffer.slice(0, from) + state.buffer.slice(cursor), from);
+            }
+            if (cursor >= state.buffer.length)
+                return state;
+            const to = stepGrapheme(state.buffer, cursor, 'right');
+            return withCursor(state, state.buffer.slice(0, cursor) + state.buffer.slice(to), cursor);
+        }
+        case 'left':
+            return {
+                buffer: state.buffer,
+                cursor: stepGrapheme(state.buffer, state.cursor, 'left'),
+            };
+        case 'right':
+            return {
+                buffer: state.buffer,
+                cursor: stepGrapheme(state.buffer, state.cursor, 'right'),
+            };
+        case 'home':
+            return { buffer: state.buffer, cursor: 0 };
+        case 'end':
+            return { buffer: state.buffer, cursor: snapGrapheme(state.buffer, state.buffer.length) };
+        case 'up':
+        case 'down': {
+            const moved = moveVisualCursor({
+                buffer: state.buffer,
+                cursor: state.cursor,
+                cols: action.cols,
+                direction: action.type,
+                ...(state.preferredVisualColumn === undefined
+                    ? {}
+                    : { preferredVisualColumn: state.preferredVisualColumn }),
+            });
+            // A vertical move at the first or last visual row stays put rather than
+            // jumping to the buffer's edge: the composer behaves the same way, and a jump
+            // here would silently relocate the caret in a field the user is editing.
+            return moved === null
+                ? state
+                : {
+                    buffer: state.buffer,
+                    cursor: moved.cursor,
+                    preferredVisualColumn: moved.preferredVisualColumn,
+                };
+        }
+        case 'replace':
+            return withCursor(state, action.buffer, action.cursor);
+    }
+}
+function renderSegments(segments, keyPrefix) {
+    return segments.map((segment, at) => (_jsx(Text, { children: segment.text }, `${keyPrefix}${at}`)));
+}
+/**
+ * One field's worth of rows.
+ *
+ * The overflow chip is a plain `+N` on the LAST row rather than a row of its own:
+ * an extra row would make this component draw one more line than the caller budgeted
+ * for, and the frame it lives in has no way to find out.
+ */
+export function PromptTextArea(props) {
+    const { state, cols, rows, focused } = props;
+    const glyphs = pickGlyphs(props.caps);
+    const layout = layoutComposer({
+        buffer: state.buffer,
+        cursor: state.cursor,
+        cols: Math.max(4, cols),
+        maxRows: Math.max(1, rows),
+        active: focused,
+    });
+    const hidden = layout.hiddenAbove + layout.hiddenBelow;
+    const resetKey = React.useMemo(() => ({}), [state.buffer, state.cursor, focused, props.cols, rows]);
+    if (state.buffer.length === 0) {
+        return (_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: [_jsx(PromptCaret, { text: " ", active: focused, reducedMotion: props.reducedMotion ?? false, colorLevel: props.caps.colorLevel, color: props.theme.muted, resetKey: resetKey }), glyphs.ellipsis] }));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: layout.rows.map((row, at) => {
+            if (at !== layout.cursorRow) {
+                return _jsx(Text, { wrap: "truncate", children: renderSegments(row.segments, `r${at}.`) }, at);
+            }
+            const split = splitRowAtColumn(row, layout.cursorCol);
+            return (_jsxs(Text, { wrap: "truncate", children: [renderSegments(split.before, `b${at}.`), _jsx(PromptCaret, { text: split.at ? split.at.text : ' ', active: focused, reducedMotion: props.reducedMotion ?? false, colorLevel: props.caps.colorLevel, resetKey: resetKey }), renderSegments(split.after, `a${at}.`), at === layout.rows.length - 1 && hidden > 0
+                        ? _jsx(Text, { color: props.theme.muted, children: ` +${hidden}` })
+                        : null] }, at));
+        }) }));
+}