ink-prompt 0.2.5 → 0.3.0

package/README.md

@@ -54,6 +54,7 @@ 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
 

package/dist/components/MultilineInput/KeyHandler.js

@@ -201,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) {

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', () => {

package/dist/components/MultilineInput/__tests__/MultilineInput.test.d.ts

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

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.5",
+  "version": "0.3.0",
   "description": "A React Ink component for prompts",
   "type": "module",
   "main": "./dist/index.js",