ink-prompt 0.1.2

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

@@ -0,0 +1,55 @@
+/**
+ * Cursor position in the text buffer
+ */
+export interface Cursor {
+    /** 0-indexed line number */
+    line: number;
+    /** 0-indexed column position */
+    column: number;
+}
+/**
+ * Text buffer containing multiple lines
+ */
+export interface Buffer {
+    /** Array of text lines (without newline characters) */
+    lines: string[];
+}
+/**
+ * Cursor movement directions
+ */
+export type Direction = 'up' | 'down' | 'left' | 'right' | 'lineStart' | 'lineEnd';
+/**
+ * Result of wrapping buffer lines for visual display
+ */
+export interface WrapResult {
+    /** Visual lines after wrapping */
+    visualLines: string[];
+    /** Row in visual lines where cursor appears */
+    cursorVisualRow: number;
+    /** Column in that visual row where cursor appears */
+    cursorVisualCol: number;
+}
+/**
+ * Keyboard key state (mirrors Ink's Key interface)
+ * Defined locally to avoid ESM/CJS import issues with Ink
+ */
+export interface Key {
+    upArrow?: boolean;
+    downArrow?: boolean;
+    leftArrow?: boolean;
+    rightArrow?: boolean;
+    pageDown?: boolean;
+    pageUp?: boolean;
+    return?: boolean;
+    escape?: boolean;
+    ctrl?: boolean;
+    shift?: boolean;
+    tab?: boolean;
+    backspace?: boolean;
+    delete?: boolean;
+    meta?: boolean;
+    /** Home key (may not be available in all terminals) */
+    home?: boolean;
+    /** End key (may not be available in all terminals) */
+    end?: boolean;
+}

package/dist/components/MultilineInput/types.js

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

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

@@ -0,0 +1,22 @@
+import type { Cursor, Direction } from './types.js';
+export interface UseTextInputProps {
+    initialValue?: string;
+    /** Terminal width for visual-aware cursor navigation (up/down arrows respect line wrapping) */
+    width?: number;
+}
+export interface UseTextInputResult {
+    value: string;
+    cursor: Cursor;
+    insert: (char: string) => void;
+    delete: () => void;
+    deleteForward: () => void;
+    newLine: () => void;
+    deleteAndNewLine: () => void;
+    moveCursor: (direction: Direction) => void;
+    undo: () => void;
+    redo: () => void;
+    setText: (text: string) => void;
+    cursorOffset: number;
+    setCursorOffset: (offset: number) => void;
+}
+export declare function useTextInput({ initialValue, width }?: UseTextInputProps): UseTextInputResult;

package/dist/components/MultilineInput/useTextInput.js

@@ -0,0 +1,108 @@
+import { useState, useCallback } from 'react';
+import { createBuffer, insertText as bufferInsertText, deleteChar as bufferDeleteChar, deleteCharForward as bufferDeleteCharForward, insertNewLine as bufferInsertNewLine, moveCursor as bufferMoveCursor, getTextContent, getOffset, getCursor, } from './TextBuffer.js';
+import { log } from '../../utils/logger.js';
+export function useTextInput({ initialValue = '', width } = {}) {
+    const [buffer, setBuffer] = useState(() => createBuffer(initialValue));
+    const [cursor, setCursor] = useState(() => {
+        const lines = initialValue.split('\n');
+        return {
+            line: lines.length - 1,
+            column: lines[lines.length - 1].length,
+        };
+    });
+    const [undoStack, setUndoStack] = useState([]);
+    const [redoStack, setRedoStack] = useState([]);
+    const pushToHistory = useCallback((currentBuffer, currentCursor) => {
+        setUndoStack((prev) => [...prev, { buffer: currentBuffer, cursor: currentCursor }]);
+        setRedoStack([]);
+    }, []);
+    const insert = useCallback((char) => {
+        log(`[INSERT] char="${char.replace(/[\x00-\x1F\x7F-\uFFFF]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" len=${char.length} cursor={line:${cursor.line},col:${cursor.column}} linesBefore=${buffer.lines.length}`);
+        // Normalize line endings: \r\n → \n, \r → \n (handles Windows, Unix, and old Mac)
+        const normalized = char.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        pushToHistory(buffer, cursor);
+        // TextBuffer now handles multi-line insertion internally
+        const result = bufferInsertText(buffer, cursor, normalized);
+        setBuffer(result.buffer);
+        setCursor(result.cursor);
+    }, [buffer, cursor, pushToHistory]);
+    const deleteChar = useCallback(() => {
+        pushToHistory(buffer, cursor);
+        const result = bufferDeleteChar(buffer, cursor);
+        setBuffer(result.buffer);
+        setCursor(result.cursor);
+    }, [buffer, cursor, pushToHistory]);
+    const deleteCharForward = useCallback(() => {
+        pushToHistory(buffer, cursor);
+        const result = bufferDeleteCharForward(buffer, cursor);
+        setBuffer(result.buffer);
+        setCursor(result.cursor);
+    }, [buffer, cursor, pushToHistory]);
+    const newLine = useCallback(() => {
+        pushToHistory(buffer, cursor);
+        const result = bufferInsertNewLine(buffer, cursor);
+        setBuffer(result.buffer);
+        setCursor(result.cursor);
+    }, [buffer, cursor, pushToHistory]);
+    const deleteAndNewLine = useCallback(() => {
+        pushToHistory(buffer, cursor);
+        // First delete the character before cursor (the backslash)
+        const afterDelete = bufferDeleteChar(buffer, cursor);
+        // Then insert newline using the updated buffer and cursor
+        const afterNewLine = bufferInsertNewLine(afterDelete.buffer, afterDelete.cursor);
+        setBuffer(afterNewLine.buffer);
+        setCursor(afterNewLine.cursor);
+    }, [buffer, cursor, pushToHistory]);
+    const moveCursor = useCallback((direction) => {
+        const newCursor = bufferMoveCursor(buffer, cursor, direction, width);
+        setCursor(newCursor);
+    }, [buffer, cursor, width]);
+    const undo = useCallback(() => {
+        if (undoStack.length === 0)
+            return;
+        const previousState = undoStack[undoStack.length - 1];
+        const newUndoStack = undoStack.slice(0, -1);
+        setRedoStack((prev) => [...prev, { buffer, cursor }]);
+        setBuffer(previousState.buffer);
+        setCursor(previousState.cursor);
+        setUndoStack(newUndoStack);
+    }, [buffer, cursor, undoStack]);
+    const redo = useCallback(() => {
+        if (redoStack.length === 0)
+            return;
+        const nextState = redoStack[redoStack.length - 1];
+        const newRedoStack = redoStack.slice(0, -1);
+        setUndoStack((prev) => [...prev, { buffer, cursor }]);
+        setBuffer(nextState.buffer);
+        setCursor(nextState.cursor);
+        setRedoStack(newRedoStack);
+    }, [buffer, cursor, redoStack]);
+    const setText = useCallback((text) => {
+        pushToHistory(buffer, cursor);
+        const newBuffer = createBuffer(text);
+        setBuffer(newBuffer);
+        // Move cursor to end of new text
+        const lines = text.split('\n');
+        setCursor({
+            line: lines.length - 1,
+            column: lines[lines.length - 1].length,
+        });
+    }, [buffer, cursor, pushToHistory]);
+    return {
+        value: getTextContent(buffer),
+        cursor,
+        insert,
+        delete: deleteChar,
+        deleteForward: deleteCharForward,
+        newLine,
+        deleteAndNewLine,
+        moveCursor,
+        undo,
+        redo,
+        setText,
+        cursorOffset: getOffset(buffer, cursor),
+        setCursorOffset: useCallback((offset) => {
+            setCursor(getCursor(buffer, offset));
+        }, [buffer]),
+    };
+}

package/dist/hello.test.d.ts

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

package/dist/hello.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+describe('Hello World Test', () => {
+    it('should pass a simple test', () => {
+        expect(true).toBe(true);
+    });
+    it('should perform basic arithmetic', () => {
+        expect(2 + 2).toBe(4);
+    });
+    it('should handle string concatenation', () => {
+        const greeting = 'Hello' + ' ' + 'World';
+        expect(greeting).toBe('Hello World');
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { MultilineInput } from './components/MultilineInput/index.js';
+export type { MultilineInputProps } from './components/MultilineInput/index.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+// Re-export all components and utilities
+export { MultilineInput } from './components/MultilineInput/index.js';

package/dist/utils/logger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Initialize the logger by clearing any existing log file.
+ */
+export declare function initLogger(): void;
+/**
+ * Log a message to the log file if it meets the minimum log level.
+ * @param message - The message to log
+ * @param level - The severity level of the message (default: INFO)
+ */
+export declare function log(message: string, level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR'): void;
+declare const _default: {
+    log: typeof log;
+    initLogger: typeof initLogger;
+};
+export default _default;

package/dist/utils/logger.js

@@ -0,0 +1,42 @@
+import { appendFileSync, existsSync, unlinkSync } from 'fs';
+import { join } from 'path';
+const LOG_FILE = process.env.INK_PROMPT_LOG_FILE || join(process.cwd(), 'ink-prompt.debug.log');
+// Define log levels with numeric priority
+const LOG_LEVELS = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+};
+// Get current log level from env, default to ERROR (or DEBUG if you prefer)
+const CURRENT_LOG_LEVEL = process.env.LOG_LEVEL?.toUpperCase() || 'ERROR';
+const CURRENT_LOG_LEVEL_PRIORITY = LOG_LEVELS[CURRENT_LOG_LEVEL] ?? LOG_LEVELS.INFO;
+/**
+ * Initialize the logger by clearing any existing log file.
+ */
+export function initLogger() {
+    if (existsSync(LOG_FILE)) {
+        unlinkSync(LOG_FILE);
+    }
+}
+/**
+ * Log a message to the log file if it meets the minimum log level.
+ * @param message - The message to log
+ * @param level - The severity level of the message (default: INFO)
+ */
+export function log(message, level = 'INFO') {
+    // Check if we should log based on level priority
+    if ((LOG_LEVELS[level] ?? 1) < CURRENT_LOG_LEVEL_PRIORITY) {
+        return;
+    }
+    try {
+        appendFileSync(LOG_FILE, `${new Date().toISOString()} [${level}] ${message}\n`);
+    }
+    catch (error) {
+        // Silently fail to avoid crashing the application
+        if (process.env.DEBUG) {
+            console.error('Failed to write to log file:', error);
+        }
+    }
+}
+export default { log, initLogger };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "ink-prompt",
+  "version": "0.1.2",
+  "description": "A React Ink component for prompts",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:ui": "vitest --ui",
+    "test:watch": "vitest",
+    "release": "bash scripts/release.sh"
+  },
+  "keywords": [
+    "ink",
+    "react",
+    "prompt",
+    "cli"
+  ],
+  "author": "Duc Nguyen",
+  "license": "MIT",
+  "repository": "github:qduc/ink-prompt",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "ink": "^4.0.0 || ^5.0.0 || ^6.0.0",
+    "react": "^18.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^20.0.0",
+    "@types/react": "^19.0.0",
+    "@vitest/ui": "^4.0.15",
+    "happy-dom": "^20.0.11",
+    "ink": "^6.5.1",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.15"
+  }
+}