ink-prompt 0.2.4 → 0.3.0

package/README.md

@@ -54,13 +54,14 @@ render(<App />);
 | `maxImageSizeBytes` | `number` | `10485760` | Maximum image size in bytes (default 10 MiB) |
 | `maxImageCount` | `number` | `10` | Maximum number of pasted images |
 | `acceptedMimeTypes` | `string[]` | | Restricts accepted image MIME types |
+| `maxHeight` | `number` | `Math.floor(terminalHeight * 0.8)` | Maximum visual rows to render before scrolling (defaults to terminal height minus a 20% buffer) |
 
 ### Keyboard Controls
 
 `MultilineInput` supports typical editing controls:
 
 - **Arrow keys** for navigation
-- `Ctrl+J` or typing `\` before **Enter** to add a newline
+- **Shift+Enter**, `Ctrl+J`, or typing `\` before **Enter** to add a newline (Shift+Enter requires a terminal that distinguishes it — most emit `ESC + CR` or the kitty `CSI 13;2u` sequence)
 - `Ctrl+Z` / `Ctrl+Y` for undo/redo
 - `Ctrl+A` / `Ctrl+E` for jump to line start/end
 - **Home** / **End** keys for line start/end

package/dist/components/MultilineInput/KeyHandler.js

@@ -125,6 +125,15 @@ const BACKSPACE_SEQUENCES = ['\u0008', '\u007f'];
 function isBackspaceSequence(seq) {
     return !!seq && BACKSPACE_SEQUENCES.includes(seq);
 }
+/**
+ * Raw sequences that represent Shift+Enter across terminal emulators.
+ * - `\x1b\r` / `\x1b\n`: ESC + CR/LF emitted by terminals like iTerm2 / WezTerm when configured.
+ * - `\x1b[13;2u`: kitty keyboard protocol encoding for Shift+Enter.
+ */
+const SHIFT_ENTER_SEQUENCES = ['\x1b\r', '\x1b\n', '\x1b[13;2u'];
+function isShiftEnterSequence(seq) {
+    return !!seq && SHIFT_ENTER_SEQUENCES.includes(seq);
+}
 /**
  * Handles keyboard input and maps it to text input actions.
  *
@@ -192,6 +201,15 @@ export function handleKey(key, input, buffer, actions, cursor, rawInput, width)
         actions.moveCursor('lineEnd');
         return;
     }
+    // Alt+\ for buffer start, Alt+/ for buffer end (nano style)
+    if (key.meta && input === '\\') {
+        actions.moveCursor('bufferStart');
+        return;
+    }
+    if (key.meta && input === '/') {
+        actions.moveCursor('bufferEnd');
+        return;
+    }
     // Paste / History
     if (key.ctrl) {
         if (input === 'v' && actions.paste) {
@@ -223,6 +241,15 @@ export function handleKey(key, input, buffer, actions, cursor, rawInput, width)
         actions.deleteForward();
         return;
     }
+    // Shift+Enter inserts a newline regardless of buffer state.
+    // Detected via Ink's shift+return flags or raw escape sequences emitted by
+    // terminals that distinguish Shift+Enter from Enter.
+    if ((key.shift && key.return) ||
+        (key.meta && key.return) ||
+        isShiftEnterSequence(rawInput)) {
+        actions.newLine();
+        return;
+    }
     // Submission / New Line
     if (key.return) {
         log(`[KEYHANDLER] return key, cursor=${JSON.stringify(cursor)}, currentLine="${(cursor ? buffer.lines[cursor.line || 0] : 'no cursor').replace(/[\x00-\x1F\x7F-\uFFFF]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" endsWithBackslash=${cursor ? buffer.lines[cursor.line || 0].endsWith('\\') : false}`);

package/dist/components/MultilineInput/TextBuffer.js

@@ -354,6 +354,12 @@ export function moveCursor(buffer, cursor, direction, width, entries) {
             return { line, column: 0 };
         case 'lineEnd':
             return { line, column: currentLine.length };
+        case 'bufferStart':
+            return { line: 0, column: 0 };
+        case 'bufferEnd': {
+            const lastLineIdx = lineCount - 1;
+            return { line: lastLineIdx, column: buffer.lines[lastLineIdx].length };
+        }
         default:
             return cursor;
     }

package/dist/components/MultilineInput/TextRenderer.d.ts

@@ -8,6 +8,7 @@ export interface TextRendererProps {
     showCursor?: boolean;
     /** Block state for expanding markers into display text */
     blockState?: BlockState;
+    maxHeight?: number;
 }
 interface VisualSegment {
     text: string;
@@ -21,5 +22,5 @@ interface VisualRow {
 export declare function wrapLines(buffer: Buffer, cursor: Cursor, width: number, entries?: Map<string, import('./BlockTypes.js').BlockEntry>): WrapResult & {
     rows: VisualRow[];
 };
-export declare function TextRenderer({ buffer, cursor, width: propWidth, showCursor, blockState, }: TextRendererProps): React.ReactElement;
+export declare function TextRenderer({ buffer, cursor, width: propWidth, showCursor, blockState, maxHeight, }: TextRendererProps): React.ReactElement;
 export {};

package/dist/components/MultilineInput/TextRenderer.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
 import { Box, Text } from 'ink';
 import { useTerminalWidth } from '../../hooks/useTerminalWidth.js';
 import { getVisualRows } from './TextBuffer.js';
@@ -140,12 +141,44 @@ function renderVisualRow(row, isCursorRow, cursorCol, showCursor) {
         : [];
     return (_jsxs(_Fragment, { children: [renderSegments(before, 'b'), _jsx(Text, { inverse: true, dimColor: under.dim, children: under.ch }), renderSegments(after, 'a')] }));
 }
-export function TextRenderer({ buffer, cursor, width: propWidth, showCursor = true, blockState, }) {
+export function TextRenderer({ buffer, cursor, width: propWidth, showCursor = true, blockState, maxHeight, }) {
     const width = useTerminalWidth(propWidth);
     const entries = blockState?.entries;
     const { rows, cursorVisualRow, cursorVisualCol } = wrapLines(buffer, cursor, width, entries);
-    return (_jsx(Box, { flexDirection: "column", children: rows.map((row, index) => {
-            const isCursorRow = index === cursorVisualRow;
-            return (_jsx(Box, { children: renderVisualRow(row, isCursorRow, cursorVisualCol, showCursor) }, index));
+    // Scroll state
+    const [scrollTop, setScrollTop] = React.useState(0);
+    let currentScrollTop = scrollTop;
+    if (maxHeight !== undefined) {
+        if (cursorVisualRow < currentScrollTop) {
+            currentScrollTop = cursorVisualRow;
+        }
+        else if (cursorVisualRow >= currentScrollTop + maxHeight) {
+            currentScrollTop = cursorVisualRow - maxHeight + 1;
+        }
+        const maxScroll = Math.max(0, rows.length - maxHeight);
+        if (currentScrollTop > maxScroll) {
+            currentScrollTop = maxScroll;
+        }
+        if (currentScrollTop < 0) {
+            currentScrollTop = 0;
+        }
+        if (currentScrollTop !== scrollTop) {
+            // In React, setting state during render is a standard pattern for deriving state.
+            setScrollTop(currentScrollTop);
+        }
+    }
+    else {
+        if (scrollTop !== 0) {
+            setScrollTop(0);
+        }
+        currentScrollTop = 0;
+    }
+    const visibleRows = maxHeight !== undefined
+        ? rows.slice(currentScrollTop, currentScrollTop + maxHeight)
+        : rows;
+    return (_jsx(Box, { flexDirection: "column", children: visibleRows.map((row, index) => {
+            const originalIndex = currentScrollTop + index;
+            const isCursorRow = originalIndex === cursorVisualRow;
+            return (_jsx(Box, { children: renderVisualRow(row, isCursorRow, cursorVisualCol, showCursor) }, originalIndex));
         }) }));
 }

package/dist/components/MultilineInput/__tests__/KeyHandler.test.js

@@ -61,6 +61,14 @@ describe('KeyHandler', () => {
             handleKey({ ctrl: true }, 'e', buffer, actions);
             expect(actions.moveCursor).toHaveBeenCalledWith('lineEnd');
         });
+        it('handles Alt+\ as buffer start', () => {
+            handleKey({ meta: true }, '\\', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('bufferStart');
+        });
+        it('handles Alt+/ as buffer end', () => {
+            handleKey({ meta: true }, '/', buffer, actions);
+            expect(actions.moveCursor).toHaveBeenCalledWith('bufferEnd');
+        });
     });
     describe('Boundary Arrow', () => {
         describe('Left boundary', () => {
@@ -289,6 +297,24 @@ describe('KeyHandler', () => {
             expect(actions.newLine).not.toHaveBeenCalled();
             expect(actions.submit).not.toHaveBeenCalled();
         });
+        it('handles Shift+Enter as newline', () => {
+            buffer = { lines: ['hello'] };
+            handleKey({ shift: true, return: true }, '', buffer, actions);
+            expect(actions.newLine).toHaveBeenCalledTimes(1);
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
+        it('handles ESC+CR raw sequence (Shift+Enter) as newline', () => {
+            buffer = { lines: ['hello'] };
+            handleKey({ meta: true, return: true }, '', buffer, actions, undefined, '\x1b\r');
+            expect(actions.newLine).toHaveBeenCalledTimes(1);
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
+        it('handles kitty Shift+Enter CSI u sequence as newline', () => {
+            buffer = { lines: ['hello'] };
+            handleKey({}, '', buffer, actions, undefined, '\x1b[13;2u');
+            expect(actions.newLine).toHaveBeenCalledTimes(1);
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
         it('handles Enter as newline if line ends with backslash (multiple lines)', () => {
             const cursor = { line: 1, column: 7 };
             buffer = { lines: ['first', 'second\\'] };

package/dist/components/MultilineInput/__tests__/MultilineInput.test.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, act } from '@testing-library/react';
+import { MultilineInput } from '../index.js';
+import { EventEmitter } from 'events';
+// Create event emitters for standard streams
+const mockStdout = new EventEmitter();
+mockStdout.columns = 80;
+const mockStdin = new EventEmitter();
+let capturedUseInputHandler = null;
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useStdout: () => ({
+            stdout: mockStdout,
+        }),
+        useStdin: () => ({
+            stdin: mockStdin,
+            isRawModeSupported: true,
+        }),
+        useInput: (handler) => {
+            capturedUseInputHandler = handler;
+        },
+    };
+});
+describe('MultilineInput Meta Key handling', () => {
+    beforeEach(() => {
+        capturedUseInputHandler = null;
+        mockStdin.removeAllListeners();
+        vi.clearAllMocks();
+    });
+    it('correctly maps Alt+\\ (buffer start) even when Ink fails to parse key.meta', () => {
+        const onCursorChange = vi.fn();
+        // Initial value is "hello", cursor is at offset 5 (end)
+        render(_jsx(MultilineInput, { value: "hello", onCursorChange: onCursorChange, isActive: true }));
+        expect(capturedUseInputHandler).not.toBeNull();
+        // 1. Simulate the raw stdin data event and useInput handler in act
+        act(() => {
+            mockStdin.emit('data', Buffer.from('\x1b\\'));
+            capturedUseInputHandler('\\', { meta: false });
+        });
+        // The cursor should have moved to buffer start (offset 0)
+        expect(onCursorChange).toHaveBeenLastCalledWith(0);
+    });
+    it('correctly maps Alt+/ (buffer end) even when Ink fails to parse key.meta', () => {
+        const onCursorChange = vi.fn();
+        // We render and override cursor to start (offset 0)
+        render(_jsx(MultilineInput, { value: "hello", onCursorChange: onCursorChange, cursorOverride: 0, isActive: true }));
+        expect(capturedUseInputHandler).not.toBeNull();
+        // Clear initial cursor change calls to avoid confusion
+        onCursorChange.mockClear();
+        // 1. Simulate the raw stdin data event and useInput handler in act
+        act(() => {
+            mockStdin.emit('data', Buffer.from('\x1b/'));
+            capturedUseInputHandler('/', { meta: false });
+        });
+        // The cursor should have moved to buffer end (offset 5)
+        expect(onCursorChange).toHaveBeenLastCalledWith(5);
+    });
+    it('does not touch key.meta if it is not a 2-char escape sequence', () => {
+        const onChange = vi.fn();
+        render(_jsx(MultilineInput, { value: "", onChange: onChange, isActive: true }));
+        expect(capturedUseInputHandler).not.toBeNull();
+        onChange.mockClear();
+        // Simulate typing a slash character (normal '/')
+        act(() => {
+            mockStdin.emit('data', Buffer.from('/'));
+            capturedUseInputHandler('/', { meta: false });
+        });
+        // It should be treated as a normal character insertion
+        expect(onChange).toHaveBeenLastCalledWith('/');
+    });
+});

package/dist/components/MultilineInput/__tests__/TextBuffer.test.js

@@ -428,6 +428,46 @@ describe('TextBuffer', () => {
                 expect(result).toEqual({ line: 0, column: 5 });
             });
         });
+        describe('bufferStart', () => {
+            it('moves to start of buffer on first line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 3 };
+                const result = moveCursor(buffer, cursor, 'bufferStart');
+                expect(result).toEqual({ line: 0, column: 0 });
+            });
+            it('moves to start of buffer from later line', () => {
+                const buffer = createBuffer('line1\nline2\nline3');
+                const cursor = { line: 2, column: 3 };
+                const result = moveCursor(buffer, cursor, 'bufferStart');
+                expect(result).toEqual({ line: 0, column: 0 });
+            });
+            it('stays at start if already there', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 0 };
+                const result = moveCursor(buffer, cursor, 'bufferStart');
+                expect(result).toEqual({ line: 0, column: 0 });
+            });
+        });
+        describe('bufferEnd', () => {
+            it('moves to end of buffer on last line', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 2 };
+                const result = moveCursor(buffer, cursor, 'bufferEnd');
+                expect(result).toEqual({ line: 0, column: 5 });
+            });
+            it('moves to end of buffer from earlier line', () => {
+                const buffer = createBuffer('line1\nline2\nline3');
+                const cursor = { line: 0, column: 3 };
+                const result = moveCursor(buffer, cursor, 'bufferEnd');
+                expect(result).toEqual({ line: 2, column: 5 });
+            });
+            it('stays at end if already there', () => {
+                const buffer = createBuffer('hello');
+                const cursor = { line: 0, column: 5 };
+                const result = moveCursor(buffer, cursor, 'bufferEnd');
+                expect(result).toEqual({ line: 0, column: 5 });
+            });
+        });
     });
     describe('getTextContent', () => {
         it('returns empty string for empty buffer', () => {

package/dist/components/MultilineInput/__tests__/TextRenderer.test.js

@@ -182,4 +182,47 @@ describe('TextRenderer', () => {
             expect(container.textContent).toContain('fghij');
         });
     });
+    describe('maxHeight and scrolling', () => {
+        it('only renders up to maxHeight lines when text is longer', () => {
+            const buffer = { lines: ['line1', 'line2', 'line3', 'line4', 'line5'] };
+            const cursor = { line: 0, column: 0 };
+            const { container } = render(_jsx(TextRenderer, { buffer: buffer, cursor: cursor, maxHeight: 3 }));
+            expect(container.textContent).toContain('line1');
+            expect(container.textContent).toContain('line2');
+            expect(container.textContent).toContain('line3');
+            expect(container.textContent).not.toContain('line4');
+            expect(container.textContent).not.toContain('line5');
+        });
+        it('scrolls down to show the cursor when it moves past the viewport height', () => {
+            const buffer = { lines: ['line1', 'line2', 'line3', 'line4', 'line5'] };
+            const cursor = { line: 4, column: 0 };
+            const { container } = render(_jsx(TextRenderer, { buffer: buffer, cursor: cursor, maxHeight: 3 }));
+            expect(container.textContent).not.toContain('line1');
+            expect(container.textContent).not.toContain('line2');
+            expect(container.textContent).toContain('line3');
+            expect(container.textContent).toContain('line4');
+            expect(container.textContent).toContain('line5');
+        });
+        it('scrolls up to show the cursor when it moves above the viewport top', () => {
+            const buffer = { lines: ['line1', 'line2', 'line3', 'line4', 'line5'] };
+            // Step 1: Render with cursor at bottom to establish scroll (scrollTop = 2)
+            const { container, rerender } = render(_jsx(TextRenderer, { buffer: buffer, cursor: { line: 4, column: 0 }, maxHeight: 3 }));
+            expect(container.textContent).not.toContain('line1');
+            expect(container.textContent).toContain('line5');
+            // Step 2: Move cursor back to line 1 (scrollTop should become 1)
+            rerender(_jsx(TextRenderer, { buffer: buffer, cursor: { line: 1, column: 0 }, maxHeight: 3 }));
+            expect(container.textContent).not.toContain('line1');
+            expect(container.textContent).toContain('line2');
+            expect(container.textContent).toContain('line3');
+            expect(container.textContent).toContain('line4');
+            expect(container.textContent).not.toContain('line5');
+            // Step 3: Move cursor back to line 0 (scrollTop should become 0)
+            rerender(_jsx(TextRenderer, { buffer: buffer, cursor: { line: 0, column: 0 }, maxHeight: 3 }));
+            expect(container.textContent).toContain('line1');
+            expect(container.textContent).toContain('line2');
+            expect(container.textContent).toContain('line3');
+            expect(container.textContent).not.toContain('line4');
+            expect(container.textContent).not.toContain('line5');
+        });
+    });
 });

package/dist/components/MultilineInput/index.d.ts

@@ -31,6 +31,7 @@ export interface MultilineInputProps {
     maxImageSizeBytes?: number;
     maxImageCount?: number;
     acceptedMimeTypes?: string[];
+    maxHeight?: number;
 }
 export interface MultilineInputCoreProps {
     value?: string;
@@ -57,6 +58,7 @@ export interface MultilineInputCoreProps {
     formatPastePlaceholder?: (displayNumber: number) => string;
     images?: ImageRef[];
     onImagesChange?: (images: ImageRef[]) => void;
+    maxHeight?: number;
 }
 export declare const MultilineInputCore: React.FC<MultilineInputCoreProps>;
 export declare const MultilineInput: React.FC<MultilineInputProps>;

package/dist/components/MultilineInput/index.js

@@ -2,12 +2,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useCallback, useRef } from 'react';
 import { useInput, useStdin, Box, Text } from 'ink';
 import { useTerminalWidth } from '../../hooks/useTerminalWidth.js';
+import { useTerminalHeight } from '../../hooks/useTerminalHeight.js';
 import { useTextInput } from './useTextInput.js';
 import { handleKey } from './KeyHandler.js';
 import { TextRenderer } from './TextRenderer.js';
 import { useClipboardPaste } from './useClipboardPaste.js';
 import { log } from '../../utils/logger.js';
-export const MultilineInputCore = ({ value, onChange, placeholder, showCursor = true, width = 80, onCursorChange, cursorOverride, undoDebounceMs, pasteThreshold, formatPastePlaceholder, images, onImagesChange, }) => {
+export const MultilineInputCore = ({ value, onChange, placeholder, showCursor = true, width = 80, onCursorChange, cursorOverride, undoDebounceMs, pasteThreshold, formatPastePlaceholder, images, onImagesChange, maxHeight, }) => {
     const textInput = useTextInput({ initialValue: value ?? '', undoDebounceMs, pasteThreshold, formatPastePlaceholder });
     const isSyncingFromProps = useRef(false);
     useEffect(() => {
@@ -58,9 +59,12 @@ export const MultilineInputCore = ({ value, onChange, placeholder, showCursor =
     if (showPlaceholder) {
         return _jsx("div", { style: { opacity: 0.5 }, children: placeholder });
     }
-    return (_jsx(TextRenderer, { buffer: textInput.buffer, cursor: textInput.cursor, width: width, showCursor: showCursor, blockState: textInput.blockState }));
+    const terminalHeight = useTerminalHeight();
+    const defaultMaxHeight = Math.max(1, Math.floor(terminalHeight * 0.8));
+    const effectiveMaxHeight = maxHeight ?? defaultMaxHeight;
+    return (_jsx(TextRenderer, { buffer: textInput.buffer, cursor: textInput.cursor, width: width, showCursor: showCursor, blockState: textInput.blockState, maxHeight: effectiveMaxHeight }));
 };
-export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, onCursorChange, cursorOverride, onBoundaryArrow, undoDebounceMs, pasteThreshold, formatPastePlaceholder, images, onImagesChange, onPasteError, enableImagePaste = false, maxImageSizeBytes, maxImageCount, acceptedMimeTypes, }) => {
+export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, onCursorChange, cursorOverride, onBoundaryArrow, undoDebounceMs, pasteThreshold, formatPastePlaceholder, images, onImagesChange, onPasteError, enableImagePaste = false, maxImageSizeBytes, maxImageCount, acceptedMimeTypes, maxHeight, }) => {
     const terminalWidth = useTerminalWidth(width);
     const { stdin } = useStdin();
     const lastRawInput = useRef('');
@@ -211,13 +215,26 @@ export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCur
             suppressNextInput.current = false;
             return;
         }
-        log(`[USEINPUT] input="${input.replace(/[\x00-\x1F\x7F-￿]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" key=${JSON.stringify(key)} rawLen=${lastRawInput.current?.length || 0}`);
-        handleKey(key, input, textInput.buffer, actions, textInput.cursor, lastRawInput.current, terminalWidth);
+        log(`[USEINPUT] input="${input.replace(/[\x00-\x1F\x7F-]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" key=${JSON.stringify(key)} rawLen=${lastRawInput.current?.length || 0}`);
+        // Detect if this is an Alt keypress for symbol keys (like Alt+\ or Alt+/)
+        // Standard Alt keypresses send ESC (\x1b) followed by the character.
+        // We check if it is a 2-character sequence starting with ESC, excluding CSI/SS3 prefixes ('[' or 'O')
+        const raw = lastRawInput.current;
+        const isMeta = key.meta || (raw &&
+            raw.length === 2 &&
+            raw.startsWith('\x1b') &&
+            raw[1] !== '[' &&
+            raw[1] !== 'O');
+        const updatedKey = isMeta ? { ...key, meta: true } : key;
+        handleKey(updatedKey, input, textInput.buffer, actions, textInput.cursor, lastRawInput.current, terminalWidth);
     }, { isActive });
     const isEmpty = textInput.value === '';
     const showPlaceholder = isEmpty && placeholder && !showCursor;
     if (showPlaceholder && !isPasting) {
         return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: placeholder }) }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TextRenderer, { buffer: textInput.buffer, cursor: textInput.cursor, width: terminalWidth, showCursor: showCursor, blockState: textInput.blockState }), isPasting && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Reading clipboard..." }) }))] }));
+    const terminalHeight = useTerminalHeight();
+    const defaultMaxHeight = Math.max(1, Math.floor(terminalHeight * 0.8));
+    const effectiveMaxHeight = maxHeight ?? defaultMaxHeight;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(TextRenderer, { buffer: textInput.buffer, cursor: textInput.cursor, width: terminalWidth, showCursor: showCursor, blockState: textInput.blockState, maxHeight: effectiveMaxHeight }), isPasting && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Reading clipboard..." }) }))] }));
 };

package/dist/components/MultilineInput/types.d.ts

@@ -17,7 +17,7 @@ export interface Buffer {
 /**
  * Cursor movement directions
  */
-export type Direction = 'up' | 'down' | 'left' | 'right' | 'lineStart' | 'lineEnd';
+export type Direction = 'up' | 'down' | 'left' | 'right' | 'lineStart' | 'lineEnd' | 'bufferStart' | 'bufferEnd';
 /**
  * Boundary arrow directions (subset of Direction used for boundary detection)
  */

package/dist/hooks/__tests__/useTerminalHeight.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/__tests__/useTerminalHeight.test.js

@@ -0,0 +1,128 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useTerminalHeight } from '../useTerminalHeight.js';
+import { EventEmitter } from 'events';
+// Mock stdout
+const mockStdout = new EventEmitter();
+mockStdout.rows = 24;
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useStdout: () => ({
+            stdout: mockStdout,
+        }),
+    };
+});
+describe('useTerminalHeight', () => {
+    beforeEach(() => {
+        mockStdout.rows = 24;
+        mockStdout.removeAllListeners();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns default terminal height', () => {
+        const { result } = renderHook(() => useTerminalHeight());
+        expect(result.current).toBe(24);
+    });
+    it('returns prop height when provided', () => {
+        const { result } = renderHook(() => useTerminalHeight(10));
+        expect(result.current).toBe(10);
+    });
+    it('updates height on resize', async () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTerminalHeight());
+        expect(result.current).toBe(24);
+        // Simulate resize
+        mockStdout.rows = 40;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        // Wait for debounce to complete
+        await act(async () => {
+            vi.advanceTimersByTime(100);
+        });
+        expect(result.current).toBe(40);
+        vi.useRealTimers();
+    });
+    it('does not update when prop height is provided', () => {
+        const { result } = renderHook(() => useTerminalHeight(15));
+        expect(result.current).toBe(15);
+        // Simulate resize - should still use prop height
+        mockStdout.rows = 40;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        // Still returns prop height
+        expect(result.current).toBe(15);
+    });
+    it('cleans up resize listener on unmount', () => {
+        const { unmount } = renderHook(() => useTerminalHeight());
+        expect(mockStdout.listenerCount('resize')).toBe(1);
+        unmount();
+        expect(mockStdout.listenerCount('resize')).toBe(0);
+    });
+    it('debounces multiple rapid resize events', async () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTerminalHeight());
+        expect(result.current).toBe(24);
+        // Simulate rapid resize events
+        mockStdout.rows = 30;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        mockStdout.rows = 35;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        mockStdout.rows = 45;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        // Still at initial height because debounce hasn't fired yet
+        expect(result.current).toBe(24);
+        // Wait for debounce to complete
+        await act(async () => {
+            vi.advanceTimersByTime(100);
+        });
+        // Now updated to the last value
+        expect(result.current).toBe(45);
+        vi.useRealTimers();
+    });
+    it('accepts custom debounce delay', async () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTerminalHeight(undefined, 50));
+        expect(result.current).toBe(24);
+        // Simulate resize
+        mockStdout.rows = 30;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        expect(result.current).toBe(24);
+        // Wait for custom debounce to complete
+        await act(async () => {
+            vi.advanceTimersByTime(50);
+        });
+        expect(result.current).toBe(30);
+        vi.useRealTimers();
+    });
+    it('cancels pending debounce on unmount', async () => {
+        vi.useFakeTimers();
+        const { unmount } = renderHook(() => useTerminalHeight());
+        // Simulate resize
+        mockStdout.rows = 30;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        // Unmount before debounce fires
+        unmount();
+        // Advance time past debounce delay
+        await act(async () => {
+            vi.advanceTimersByTime(200);
+        });
+        // No errors should occur
+        expect(true).toBe(true);
+        vi.useRealTimers();
+    });
+});

package/dist/hooks/index.d.ts

@@ -1 +1,2 @@
 export { useTerminalWidth } from './useTerminalWidth.js';
+export { useTerminalHeight } from './useTerminalHeight.js';

package/dist/hooks/index.js

@@ -1 +1,2 @@
 export { useTerminalWidth } from './useTerminalWidth.js';
+export { useTerminalHeight } from './useTerminalHeight.js';

package/dist/hooks/useTerminalHeight.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook to get the current terminal height and listen for resize events.
+ *
+ * @param propHeight - Optional explicit height to use instead of terminal height
+ * @param debounceMs - Optional debounce delay in milliseconds (default: 100)
+ * @returns The effective height (propHeight if provided, otherwise terminal height)
+ */
+export declare function useTerminalHeight(propHeight?: number, debounceMs?: number): number;

package/dist/hooks/useTerminalHeight.js

@@ -0,0 +1,39 @@
+import { useState, useEffect, useRef } from 'react';
+import { useStdout } from 'ink';
+/**
+ * Hook to get the current terminal height and listen for resize events.
+ *
+ * @param propHeight - Optional explicit height to use instead of terminal height
+ * @param debounceMs - Optional debounce delay in milliseconds (default: 100)
+ * @returns The effective height (propHeight if provided, otherwise terminal height)
+ */
+export function useTerminalHeight(propHeight, debounceMs = 100) {
+    const { stdout } = useStdout();
+    const [terminalHeight, setTerminalHeight] = useState(stdout?.rows ?? 24);
+    const debounceTimer = useRef(null);
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => {
+            // Cancel any pending debounce timer
+            if (debounceTimer.current) {
+                clearTimeout(debounceTimer.current);
+            }
+            // Set a new debounce timer
+            debounceTimer.current = setTimeout(() => {
+                setTerminalHeight(stdout.rows);
+                debounceTimer.current = null;
+            }, debounceMs);
+        };
+        stdout.on('resize', onResize);
+        return () => {
+            stdout.off('resize', onResize);
+            // Clean up any pending timer on unmount
+            if (debounceTimer.current) {
+                clearTimeout(debounceTimer.current);
+                debounceTimer.current = null;
+            }
+        };
+    }, [stdout, debounceMs]);
+    return propHeight ?? terminalHeight;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ink-prompt",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "A React Ink component for prompts",
   "type": "module",
   "main": "./dist/index.js",

package/dist/components/MultilineInput/ImageSentinel.d.ts

@@ -1,15 +0,0 @@
-export declare function generateImageId(): string;
-export declare function createSentinel(id: string, displayNumber: number): string;
-export interface SentinelInfo {
-    id: string;
-    displayNumber: number;
-    start: number;
-    end: number;
-}
-export declare function parseSentinels(text: string): SentinelInfo[];
-export declare function findSentinelAt(text: string, offset: number): SentinelInfo | null;
-export declare function isInsideSentinel(text: string, offset: number): boolean;
-export declare function removeSentinel(text: string, offset: number): string;
-export declare function getPlaceholderText(displayNumber: number): string;
-export declare function getPlaceholderVisualWidth(displayNumber: number): number;
-export declare function getSentinelVisualWidthFromText(text: string, offset: number): number | null;

package/dist/components/MultilineInput/ImageSentinel.js

@@ -1,62 +0,0 @@
-import { SENTINEL_OPEN, SENTINEL_CLOSE } from './ImageTypes.js';
-export function generateImageId() {
-    return Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 6);
-}
-export function createSentinel(id, displayNumber) {
-    return `${SENTINEL_OPEN}${id}:${displayNumber}${SENTINEL_CLOSE}`;
-}
-export function parseSentinels(text) {
-    const result = [];
-    let i = 0;
-    while (i < text.length) {
-        const openIdx = text.indexOf(SENTINEL_OPEN, i);
-        if (openIdx === -1)
-            break;
-        const closeIdx = text.indexOf(SENTINEL_CLOSE, openIdx + 1);
-        if (closeIdx === -1)
-            break;
-        const raw = text.substring(openIdx + 1, closeIdx);
-        const colonIdx = raw.lastIndexOf(':');
-        const id = colonIdx >= 0 ? raw.substring(0, colonIdx) : raw;
-        const displayNumber = colonIdx >= 0 ? parseInt(raw.substring(colonIdx + 1), 10) || 1 : 1;
-        result.push({ id, displayNumber, start: openIdx, end: closeIdx + 1 });
-        i = closeIdx + 1;
-    }
-    return result;
-}
-export function findSentinelAt(text, offset) {
-    const sentinels = parseSentinels(text);
-    for (const s of sentinels) {
-        if (offset >= s.start && offset <= s.end) {
-            return s;
-        }
-    }
-    return null;
-}
-export function isInsideSentinel(text, offset) {
-    const sentinels = parseSentinels(text);
-    for (const s of sentinels) {
-        if (offset >= s.start && offset < s.end) {
-            return true;
-        }
-    }
-    return false;
-}
-export function removeSentinel(text, offset) {
-    const sentinel = findSentinelAt(text, offset);
-    if (!sentinel)
-        return text;
-    return text.slice(0, sentinel.start) + text.slice(sentinel.end);
-}
-export function getPlaceholderText(displayNumber) {
-    return `[Pasted Image #${displayNumber}]`;
-}
-export function getPlaceholderVisualWidth(displayNumber) {
-    return getPlaceholderText(displayNumber).length;
-}
-export function getSentinelVisualWidthFromText(text, offset) {
-    const s = findSentinelAt(text, offset);
-    if (!s)
-        return null;
-    return getPlaceholderVisualWidth(s.displayNumber);
-}

package/dist/components/MultilineInput/__tests__/ImageSentinel.test.js

@@ -1,154 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateImageId, createSentinel, parseSentinels, findSentinelAt, isInsideSentinel, removeSentinel, getPlaceholderText, getPlaceholderVisualWidth, } from '../ImageSentinel.js';
-import { SENTINEL_OPEN, SENTINEL_CLOSE } from '../ImageTypes.js';
-describe('ImageSentinel', () => {
-    describe('generateImageId', () => {
-        it('generates a string id', () => {
-            const id = generateImageId();
-            expect(typeof id).toBe('string');
-            expect(id.length).toBeGreaterThan(0);
-        });
-        it('generates unique ids', () => {
-            const ids = new Set(Array.from({ length: 100 }, () => generateImageId()));
-            expect(ids.size).toBe(100);
-        });
-    });
-    describe('createSentinel', () => {
-        it('creates a sentinel block with the given id and display number', () => {
-            const result = createSentinel('abc123', 1);
-            expect(result).toBe(`${SENTINEL_OPEN}abc123:1${SENTINEL_CLOSE}`);
-        });
-        it('creates a sentinel with higher display number', () => {
-            const result = createSentinel('def456', 42);
-            expect(result).toBe(`${SENTINEL_OPEN}def456:42${SENTINEL_CLOSE}`);
-        });
-    });
-    describe('parseSentinels', () => {
-        it('returns empty array for text without sentinels', () => {
-            expect(parseSentinels('hello world')).toEqual([]);
-        });
-        it('finds a single sentinel', () => {
-            const text = `hello ${SENTINEL_OPEN}abc123:1${SENTINEL_CLOSE} world`;
-            const result = parseSentinels(text);
-            expect(result).toEqual([
-                { id: 'abc123', displayNumber: 1, start: 6, end: 16 },
-            ]);
-        });
-        it('finds multiple sentinels', () => {
-            const text = `${SENTINEL_OPEN}id1:1${SENTINEL_CLOSE}hello${SENTINEL_OPEN}id2:2${SENTINEL_CLOSE}`;
-            const result = parseSentinels(text);
-            expect(result).toEqual([
-                { id: 'id1', displayNumber: 1, start: 0, end: 7 },
-                { id: 'id2', displayNumber: 2, start: 12, end: 19 },
-            ]);
-        });
-        it('returns empty for unmatched opener', () => {
-            const text = `hello ${SENTINEL_OPEN}abc:1`;
-            const result = parseSentinels(text);
-            expect(result).toEqual([]);
-        });
-        it('returns empty for unmatched closer', () => {
-            const text = `hello abc:1${SENTINEL_CLOSE} world`;
-            const result = parseSentinels(text);
-            expect(result).toEqual([]);
-        });
-    });
-    describe('findSentinelAt', () => {
-        it('returns null when offset is not near a sentinel', () => {
-            const text = `hello ${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE} world`;
-            expect(findSentinelAt(text, 0)).toBeNull();
-        });
-        it('finds sentinel when offset is at the opener', () => {
-            const text = `hello ${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE} world`;
-            const result = findSentinelAt(text, 6);
-            expect(result).toMatchObject({ id: 'abc', displayNumber: 1, start: 6 });
-        });
-        it('finds sentinel when offset is inside the id', () => {
-            const text = `hello ${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE} world`;
-            const result = findSentinelAt(text, 8);
-            expect(result).toMatchObject({ id: 'abc', displayNumber: 1 });
-        });
-        it('finds sentinel when offset is at the closer', () => {
-            const text = `hello ${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE} world`;
-            const result = findSentinelAt(text, 12);
-            expect(result).toMatchObject({ id: 'abc', displayNumber: 1 });
-        });
-        it('finds sentinel when offset is right after the closer', () => {
-            const text = `${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}`;
-            const result = findSentinelAt(text, 7);
-            expect(result).toMatchObject({ id: 'abc', displayNumber: 1, start: 0, end: 7 });
-        });
-    });
-    describe('isInsideSentinel', () => {
-        it('returns false when offset is before any sentinel', () => {
-            const text = `hi ${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}`;
-            expect(isInsideSentinel(text, 0)).toBe(false);
-        });
-        it('returns false when offset is after sentinel', () => {
-            const text = `${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE} world`;
-            expect(isInsideSentinel(text, 10)).toBe(false);
-        });
-        it('returns true when offset is at the opener', () => {
-            const text = `${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}`;
-            expect(isInsideSentinel(text, 0)).toBe(true);
-        });
-        it('returns true when offset is inside the id', () => {
-            const text = `${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}`;
-            expect(isInsideSentinel(text, 2)).toBe(true);
-        });
-        it('returns true when offset is at the closer', () => {
-            const text = `${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}`;
-            expect(isInsideSentinel(text, 6)).toBe(true);
-        });
-        it('returns false when offset is after the closer', () => {
-            const text = `${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}`;
-            expect(isInsideSentinel(text, 7)).toBe(false);
-        });
-    });
-    describe('removeSentinel', () => {
-        it('removes sentinel block at cursor position', () => {
-            const text = `hello ${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE} world`;
-            const result = removeSentinel(text, 10);
-            expect(result).toBe('hello  world');
-        });
-        it('removes sentinel when cursor is at the opener', () => {
-            const text = `${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}hello`;
-            const result = removeSentinel(text, 0);
-            expect(result).toBe('hello');
-        });
-        it('removes sentinel when cursor is at the closer', () => {
-            const text = `hello${SENTINEL_OPEN}abc:1${SENTINEL_CLOSE}`;
-            const result = removeSentinel(text, 11);
-            expect(result).toBe('hello');
-        });
-        it('removes first sentinel when cursor is between two', () => {
-            const text = `${SENTINEL_OPEN}a:1${SENTINEL_CLOSE}${SENTINEL_OPEN}b:2${SENTINEL_CLOSE}`;
-            const result = removeSentinel(text, 1);
-            expect(result).toBe(`${SENTINEL_OPEN}b:2${SENTINEL_CLOSE}`);
-        });
-        it('returns text unchanged if no sentinel at offset', () => {
-            const text = 'hello world';
-            const result = removeSentinel(text, 3);
-            expect(result).toBe('hello world');
-        });
-    });
-    describe('getPlaceholderText', () => {
-        it('returns correct placeholder for display number 1', () => {
-            expect(getPlaceholderText(1)).toBe('[Pasted Image #1]');
-        });
-        it('returns correct placeholder for display number 42', () => {
-            expect(getPlaceholderText(42)).toBe('[Pasted Image #42]');
-        });
-    });
-    describe('getPlaceholderVisualWidth', () => {
-        it('returns correct width for display number 1', () => {
-            expect(getPlaceholderVisualWidth(1)).toBe(17);
-        });
-        it('returns correct width for display number 100', () => {
-            expect(getPlaceholderVisualWidth(100)).toBe(19);
-        });
-        it('returns correct width for display number 0', () => {
-            expect(getPlaceholderVisualWidth(0)).toBe(17);
-        });
-    });
-});