ink-prompt 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Duc Nguyen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# ink-prompt
+
+A React Ink component library focused on terminal-friendly prompts. The first
+export is `MultilineInput`, an Ink component for collecting multi-line text in
+CLIs.
+
+## Installation
+
+```bash
+npm install ink-prompt
+```
+
+## Usage
+
+```tsx
+import React from 'react';
+import { render, Box, Text } from 'ink';
+import { MultilineInput } from 'ink-prompt';
+
+const App = () => {
+  return (
+    <Box flexDirection="column">
+      <Text>Describe your change (press Enter to submit):</Text>
+      <MultilineInput
+        onSubmit={(value) => console.log(value)}
+        width={80}
+      />
+    </Box>
+  );
+};
+
+render(<App />);
+```
+
+`MultilineInput` supports typical editing controls:
+
+- Arrow keys for navigation
+- `Ctrl+J` or typing `\` before Enter to add a newline
+- `Ctrl+Z`/`Ctrl+Y` for undo/redo
+- Enter submits the current buffer
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Watch for changes
+npm run dev
+
+# Type check
+npm run type-check
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,16 @@
+import { type Key, type Buffer, type Cursor } from './types.js';
+import { type UseTextInputResult } from './useTextInput.js';
+export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'cursor' | 'cursorOffset' | 'setCursorOffset'> {
+    submit: () => void;
+}
+/**
+ * Handles keyboard input and maps it to text input actions.
+ *
+ * @param key - The Ink key object
+ * @param input - The input string (if any)
+ * @param buffer - The current text buffer
+ * @param actions - The actions available to modify the state
+ * @param cursor - The current cursor position (optional, but required for some logic like backslash check)
+ * @param rawInput - The raw input sequence (optional, used for detecting Home/End keys)
+ */
+export declare function handleKey(key: Partial<Key>, input: string, buffer: Buffer, actions: KeyHandlerActions, cursor?: Cursor, rawInput?: string): void;

package/dist/components/MultilineInput/KeyHandler.js

@@ -0,0 +1,124 @@
+import { log } from '../../utils/logger.js';
+/**
+ * Escape sequences for Home key (various terminal emulators)
+ */
+const HOME_SEQUENCES = [
+    '\x1b[H', // CSI H (xterm)
+    '\x1b[1~', // CSI 1~ (linux console)
+    '\x1bOH', // SS3 H (xterm application mode)
+    '\x1b[7~', // CSI 7~ (rxvt)
+];
+/**
+ * Escape sequences for End key (various terminal emulators)
+ */
+const END_SEQUENCES = [
+    '\x1b[F', // CSI F (xterm)
+    '\x1b[4~', // CSI 4~ (linux console)
+    '\x1bOF', // SS3 F (xterm application mode)
+    '\x1b[8~', // CSI 8~ (rxvt)
+];
+/**
+ * Handles keyboard input and maps it to text input actions.
+ *
+ * @param key - The Ink key object
+ * @param input - The input string (if any)
+ * @param buffer - The current text buffer
+ * @param actions - The actions available to modify the state
+ * @param cursor - The current cursor position (optional, but required for some logic like backslash check)
+ * @param rawInput - The raw input sequence (optional, used for detecting Home/End keys)
+ */
+export function handleKey(key, input, buffer, actions, cursor, rawInput) {
+    // Navigation
+    if (key.upArrow) {
+        actions.moveCursor('up');
+        return;
+    }
+    if (key.downArrow) {
+        actions.moveCursor('down');
+        return;
+    }
+    if (key.leftArrow) {
+        actions.moveCursor('left');
+        return;
+    }
+    if (key.rightArrow) {
+        actions.moveCursor('right');
+        return;
+    }
+    // Home/End key detection
+    // Ink doesn't expose key.home/key.end, so we check:
+    // 1. Raw escape sequences if available
+    // 2. Ctrl+A (home) and Ctrl+E (end) - common terminal shortcuts
+    if (rawInput && HOME_SEQUENCES.includes(rawInput)) {
+        actions.moveCursor('lineStart');
+        return;
+    }
+    if (rawInput && END_SEQUENCES.includes(rawInput)) {
+        actions.moveCursor('lineEnd');
+        return;
+    }
+    // Ctrl+A for line start (common in bash/readline)
+    if (key.ctrl && input === 'a') {
+        actions.moveCursor('lineStart');
+        return;
+    }
+    // Ctrl+E for line end (common in bash/readline)
+    if (key.ctrl && input === 'e') {
+        actions.moveCursor('lineEnd');
+        return;
+    }
+    // History
+    if (key.ctrl) {
+        if (input === 'z') {
+            actions.undo();
+            return;
+        }
+        if (input === 'y') {
+            actions.redo();
+            return;
+        }
+        if (input === 'j') {
+            actions.newLine();
+            return;
+        }
+    }
+    // Editing
+    if (key.backspace) {
+        actions.delete();
+        return;
+    }
+    if (key.delete) {
+        // Delete key - forward delete (delete character after cursor)
+        actions.deleteForward();
+        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}`);
+        if (cursor) {
+            const currentLine = buffer.lines[cursor.line]; // Check if line ends with backslash AND cursor is at the end (or we just check the line content?)
+            // Requirement: "Line ending with \ + Enter continues to next line"
+            // Usually this implies the user typed '\' then Enter.
+            // We should probably check if the character *before* the cursor is '\' if we want to be precise,
+            // or just if the line ends with '\'.
+            // Let's assume "line ends with \" means the last char of the line is '\'.
+            if (currentLine.endsWith('\\')) {
+                // Use combined action to ensure both operations happen with correct state
+                actions.deleteAndNewLine();
+                return;
+            }
+        }
+        log(`[KEYHANDLER] submit value lines=${buffer.lines.length} lastLine="${buffer.lines[buffer.lines.length - 1]?.replace(/[\x00-\x1F\x7F-\uFFFF]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}"`);
+        actions.submit();
+        return;
+    }
+    // Text Insertion
+    // Ignore control keys if they don't have a specific handler above
+    if (key.ctrl || key.meta) {
+        return;
+    }
+    if (input) {
+        log(`[KEYHANDLER] insert input="${input.replace(/[\x00-\x1F\x7F-\uFFFF]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" len=${input.length} cursor=${JSON.stringify(cursor || {})} bufferLines=${buffer.lines.length}`);
+        actions.insert(input);
+    }
+}

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

@@ -0,0 +1,52 @@
+import type { Buffer, Cursor, Direction } from './types.js';
+/**
+ * Create a new buffer from optional initial text
+ */
+export declare function createBuffer(text?: string): Buffer;
+/**
+ * Insert text at the cursor position.
+ * Handles both single-line and multi-line text (containing \n).
+ */
+export declare function insertText(buffer: Buffer, cursor: Cursor, text: string): {
+    buffer: Buffer;
+    cursor: Cursor;
+};
+/**
+ * Delete character before cursor (backspace)
+ */
+export declare function deleteChar(buffer: Buffer, cursor: Cursor): {
+    buffer: Buffer;
+    cursor: Cursor;
+};
+/**
+ * Delete character after cursor (forward delete / Delete key)
+ */
+export declare function deleteCharForward(buffer: Buffer, cursor: Cursor): {
+    buffer: Buffer;
+    cursor: Cursor;
+};
+/**
+ * Insert a new line at cursor position (splits current line)
+ */
+export declare function insertNewLine(buffer: Buffer, cursor: Cursor): {
+    buffer: Buffer;
+    cursor: Cursor;
+};
+/**
+ * Move cursor in specified direction with bounds checking.
+ * When width is provided, up/down movement is based on visual lines (accounting for wrapping).
+ * When width is not provided, up/down movement is based on buffer lines.
+ */
+export declare function moveCursor(buffer: Buffer, cursor: Cursor, direction: Direction, width?: number): Cursor;
+/**
+ * Get the full text content from buffer (lines joined with newlines)
+ */
+export declare function getTextContent(buffer: Buffer): string;
+/**
+ * Get the flat offset (index) from a cursor position.
+ */
+export declare function getOffset(buffer: Buffer, cursor: Cursor): number;
+/**
+ * Get the cursor position from a flat offset.
+ */
+export declare function getCursor(buffer: Buffer, offset: number): Cursor;

package/dist/components/MultilineInput/TextBuffer.js

@@ -0,0 +1,312 @@
+/**
+ * Create a new buffer from optional initial text
+ */
+export function createBuffer(text) {
+    if (!text) {
+        return { lines: [''] };
+    }
+    return { lines: text.split('\n') };
+}
+/**
+ * Insert text at the cursor position.
+ * Handles both single-line and multi-line text (containing \n).
+ */
+export function insertText(buffer, cursor, text) {
+    if (!text)
+        return { buffer, cursor };
+    const { line, column } = cursor;
+    const currentLine = buffer.lines[line];
+    // Insert text and handle newlines
+    const beforeCursor = currentLine.slice(0, column);
+    const afterCursor = currentLine.slice(column);
+    const fullText = beforeCursor + text + afterCursor;
+    // Split into lines
+    const newLines = fullText.split('\n');
+    // Calculate new cursor position
+    const textLines = text.split('\n');
+    const cursorLine = line + (textLines.length - 1);
+    const cursorColumn = textLines.length === 1
+        ? column + text.length
+        : textLines[textLines.length - 1].length;
+    // Rebuild buffer
+    const resultLines = [
+        ...buffer.lines.slice(0, line),
+        ...newLines,
+        ...buffer.lines.slice(line + 1),
+    ];
+    return {
+        buffer: { lines: resultLines },
+        cursor: { line: cursorLine, column: cursorColumn },
+    };
+}
+/**
+ * Delete character before cursor (backspace)
+ */
+export function deleteChar(buffer, cursor) {
+    const { line, column } = cursor;
+    // At the very start of the buffer - nothing to delete
+    if (line === 0 && column === 0) {
+        return { buffer, cursor };
+    }
+    // At the start of a line - merge with previous line
+    if (column === 0) {
+        const previousLine = buffer.lines[line - 1];
+        const currentLine = buffer.lines[line];
+        const mergedLine = previousLine + currentLine;
+        const newLines = [...buffer.lines];
+        newLines[line - 1] = mergedLine;
+        newLines.splice(line, 1);
+        return {
+            buffer: { lines: newLines },
+            cursor: { line: line - 1, column: previousLine.length },
+        };
+    }
+    // Delete character within the line
+    const currentLine = buffer.lines[line];
+    const newLine = currentLine.slice(0, column - 1) + currentLine.slice(column);
+    const newLines = [...buffer.lines];
+    newLines[line] = newLine;
+    return {
+        buffer: { lines: newLines },
+        cursor: { line, column: column - 1 },
+    };
+}
+/**
+ * Delete character after cursor (forward delete / Delete key)
+ */
+export function deleteCharForward(buffer, cursor) {
+    const { line, column } = cursor;
+    const currentLine = buffer.lines[line];
+    const lineCount = buffer.lines.length;
+    // At the very end of the buffer - nothing to delete
+    if (line === lineCount - 1 && column >= currentLine.length) {
+        return { buffer, cursor };
+    }
+    // At the end of a line - merge with next line
+    if (column >= currentLine.length) {
+        const nextLine = buffer.lines[line + 1];
+        const mergedLine = currentLine + nextLine;
+        const newLines = [...buffer.lines];
+        newLines[line] = mergedLine;
+        newLines.splice(line + 1, 1);
+        return {
+            buffer: { lines: newLines },
+            cursor, // Cursor stays in place
+        };
+    }
+    // Delete character after cursor within the line
+    const newLine = currentLine.slice(0, column) + currentLine.slice(column + 1);
+    const newLines = [...buffer.lines];
+    newLines[line] = newLine;
+    return {
+        buffer: { lines: newLines },
+        cursor, // Cursor stays in place
+    };
+}
+/**
+ * Insert a new line at cursor position (splits current line)
+ */
+export function insertNewLine(buffer, cursor) {
+    const { line, column } = cursor;
+    const currentLine = buffer.lines[line];
+    const beforeCursor = currentLine.slice(0, column);
+    const afterCursor = currentLine.slice(column);
+    const newLines = [...buffer.lines];
+    newLines[line] = beforeCursor;
+    newLines.splice(line + 1, 0, afterCursor);
+    return {
+        buffer: { lines: newLines },
+        cursor: { line: line + 1, column: 0 },
+    };
+}
+/**
+ * Calculate which visual row (within a buffer line) the cursor is on,
+ * and the column within that visual row.
+ */
+function getVisualPosition(bufferColumn, lineLength, width) {
+    if (lineLength <= width) {
+        return { visualRow: 0, visualCol: bufferColumn };
+    }
+    const visualRow = Math.floor(bufferColumn / width);
+    const visualCol = bufferColumn % width;
+    return { visualRow, visualCol };
+}
+/**
+ * Calculate how many visual rows a buffer line takes.
+ */
+function getVisualRowCount(lineLength, width) {
+    if (lineLength === 0)
+        return 1;
+    return Math.ceil(lineLength / width);
+}
+/**
+ * Convert visual position back to buffer column.
+ */
+function visualToBufferColumn(visualRow, visualCol, lineLength, width) {
+    const bufferColumn = visualRow * width + visualCol;
+    return Math.min(bufferColumn, lineLength);
+}
+/**
+ * Get the length of a specific visual row within a buffer line.
+ */
+function getVisualRowLength(lineLength, visualRow, width) {
+    const totalVisualRows = getVisualRowCount(lineLength, width);
+    if (visualRow >= totalVisualRows)
+        return 0;
+    if (visualRow === totalVisualRows - 1) {
+        // Last visual row - might be shorter
+        const remaining = lineLength - visualRow * width;
+        return remaining;
+    }
+    return width;
+}
+/**
+ * Move cursor in specified direction with bounds checking.
+ * When width is provided, up/down movement is based on visual lines (accounting for wrapping).
+ * When width is not provided, up/down movement is based on buffer lines.
+ */
+export function moveCursor(buffer, cursor, direction, width) {
+    const { line, column } = cursor;
+    const currentLine = buffer.lines[line];
+    const lineCount = buffer.lines.length;
+    switch (direction) {
+        case 'left':
+            if (column > 0) {
+                return { line, column: column - 1 };
+            }
+            // Wrap to end of previous line
+            if (line > 0) {
+                return { line: line - 1, column: buffer.lines[line - 1].length };
+            }
+            return cursor;
+        case 'right':
+            if (column < currentLine.length) {
+                return { line, column: column + 1 };
+            }
+            // Wrap to start of next line
+            if (line < lineCount - 1) {
+                return { line: line + 1, column: 0 };
+            }
+            return cursor;
+        case 'up':
+            if (width !== undefined) {
+                // Visual-aware movement
+                const { visualRow, visualCol } = getVisualPosition(column, currentLine.length, width);
+                if (visualRow > 0) {
+                    // Move to previous visual row within the same buffer line
+                    const targetVisualRow = visualRow - 1;
+                    const targetVisualRowLength = getVisualRowLength(currentLine.length, targetVisualRow, width);
+                    const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
+                    return { line, column: visualToBufferColumn(targetVisualRow, targetVisualCol, currentLine.length, width) };
+                }
+                // At first visual row of current line - move to last visual row of previous buffer line
+                if (line > 0) {
+                    const prevLine = buffer.lines[line - 1];
+                    const prevLineVisualRows = getVisualRowCount(prevLine.length, width);
+                    const targetVisualRow = prevLineVisualRows - 1;
+                    const targetVisualRowLength = getVisualRowLength(prevLine.length, targetVisualRow, width);
+                    const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
+                    return { line: line - 1, column: visualToBufferColumn(targetVisualRow, targetVisualCol, prevLine.length, width) };
+                }
+                return cursor;
+            }
+            // Buffer-line movement (no width provided)
+            if (line > 0) {
+                const targetLine = buffer.lines[line - 1];
+                return { line: line - 1, column: Math.min(column, targetLine.length) };
+            }
+            return cursor;
+        case 'down':
+            if (width !== undefined) {
+                // Visual-aware movement
+                const { visualRow, visualCol } = getVisualPosition(column, currentLine.length, width);
+                const currentLineVisualRows = getVisualRowCount(currentLine.length, width);
+                if (visualRow < currentLineVisualRows - 1) {
+                    // Move to next visual row within the same buffer line
+                    const targetVisualRow = visualRow + 1;
+                    const targetVisualRowLength = getVisualRowLength(currentLine.length, targetVisualRow, width);
+                    const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
+                    return { line, column: visualToBufferColumn(targetVisualRow, targetVisualCol, currentLine.length, width) };
+                }
+                // At last visual row of current line - move to first visual row of next buffer line
+                if (line < lineCount - 1) {
+                    const nextLine = buffer.lines[line + 1];
+                    const targetVisualRowLength = getVisualRowLength(nextLine.length, 0, width);
+                    const targetVisualCol = Math.min(visualCol, targetVisualRowLength);
+                    return { line: line + 1, column: Math.min(targetVisualCol, nextLine.length) };
+                }
+                return cursor;
+            }
+            // Buffer-line movement (no width provided)
+            if (line < lineCount - 1) {
+                const targetLine = buffer.lines[line + 1];
+                return { line: line + 1, column: Math.min(column, targetLine.length) };
+            }
+            return cursor;
+        case 'lineStart':
+            return { line, column: 0 };
+        case 'lineEnd':
+            return { line, column: currentLine.length };
+        default:
+            return cursor;
+    }
+}
+/**
+ * Get the full text content from buffer (lines joined with newlines)
+ */
+export function getTextContent(buffer) {
+    // Single empty line is considered empty buffer
+    if (buffer.lines.length === 1 && buffer.lines[0] === '') {
+        return '';
+    }
+    return buffer.lines.join('\n');
+}
+/**
+ * Get the flat offset (index) from a cursor position.
+ */
+export function getOffset(buffer, cursor) {
+    let offset = 0;
+    for (let i = 0; i < cursor.line; i++) {
+        offset += buffer.lines[i].length + 1; // +1 for the newline
+    }
+    offset += cursor.column;
+    return offset;
+}
+/**
+ * Get the cursor position from a flat offset.
+ */
+export function getCursor(buffer, offset) {
+    let currentOffset = 0;
+    for (let i = 0; i < buffer.lines.length; i++) {
+        const lineLength = buffer.lines[i].length;
+        // Check if the offset falls within this line (including the newline character unless it's the last line)
+        // We treat the position *after* the newline as the start of the next line.
+        // Position *at* the end of line (before newline) is valid cursor column.
+        // If we are on the last line, we accept up to lineLength
+        if (i === buffer.lines.length - 1) {
+            if (offset <= currentOffset + lineLength) {
+                return { line: i, column: Math.max(0, offset - currentOffset) };
+            }
+            // If offset is beyond the content, clamp to end
+            return { line: i, column: lineLength };
+        }
+        // For non-last lines, we account for newline character (+1)
+        if (offset <= currentOffset + lineLength) {
+            return { line: i, column: Math.max(0, offset - currentOffset) };
+        }
+        // If offset is exactly at the newline character, it depends on interpretation.
+        // Usually, cursor at the newline means it's at the end of the line.
+        // But if we are "past" the newline, we are on the start of next line.
+        // Logic:
+        // Line 0: "abc" (len 3). Newline at index 3.
+        // Index 0='a', 1='b', 2='c', 3='\n'.
+        // If target offset is 3: That's end of line 0.
+        // If target offset is 4: That's start of line 1.
+        // currentOffset + lineLength is index of newline.
+        // If offset == currentOffset + lineLength + 1, we move to next loop
+        currentOffset += lineLength + 1;
+    }
+    // Fallback (should have returned in loop)
+    const lastLineIdx = buffer.lines.length - 1;
+    return { line: lastLineIdx, column: buffer.lines[lastLineIdx].length };
+}

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

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { Buffer, Cursor, WrapResult } from './types.js';
+/**
+ * Props for the TextRenderer component
+ */
+export interface TextRendererProps {
+    /** Text buffer to render */
+    buffer: Buffer;
+    /** Current cursor position */
+    cursor: Cursor;
+    /** Terminal width for word wrapping (defaults to 80) */
+    width?: number;
+    /** Whether to show the cursor (defaults to true) */
+    showCursor?: boolean;
+}
+/**
+ * Wrap buffer lines to fit within a given width.
+ * Returns visual lines and maps cursor position to visual coordinates.
+ */
+export declare function wrapLines(buffer: Buffer, cursor: Cursor, width: number): WrapResult;
+/**
+ * TextRenderer component for displaying buffer content with cursor
+ */
+export declare function TextRenderer({ buffer, cursor, width, showCursor, }: TextRendererProps): React.ReactElement;