ink-prompt 0.1.7 → 0.1.9

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

@@ -1,5 +1,5 @@
 import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { useTextInput } from '../useTextInput.js';
 describe('useTextInput', () => {
     it('should initialize with empty buffer', () => {
@@ -62,6 +62,74 @@ describe('useTextInput', () => {
         });
         expect(result.current.value).toBe('a');
     });
+    it('should batch consecutive inserts into one undo step when undoDebounceMs is set', () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTextInput({ undoDebounceMs: 200 }));
+        act(() => {
+            result.current.insert('a');
+        });
+        act(() => {
+            result.current.insert('b');
+        });
+        act(() => {
+            result.current.insert('c');
+        });
+        expect(result.current.value).toBe('abc');
+        act(() => {
+            vi.advanceTimersByTime(200);
+        });
+        act(() => {
+            result.current.undo();
+        });
+        expect(result.current.value).toBe('');
+        act(() => {
+            result.current.redo();
+        });
+        expect(result.current.value).toBe('abc');
+        vi.useRealTimers();
+    });
+    it('should undo a pending debounced batch without waiting for commit', () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTextInput({ undoDebounceMs: 200 }));
+        act(() => {
+            result.current.insert('a');
+        });
+        act(() => {
+            result.current.insert('b');
+        });
+        expect(result.current.value).toBe('ab');
+        act(() => {
+            result.current.undo();
+        });
+        expect(result.current.value).toBe('');
+        vi.useRealTimers();
+    });
+    it('should create separate undo steps when there is an idle gap', () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTextInput({ undoDebounceMs: 200 }));
+        act(() => {
+            result.current.insert('a');
+        });
+        act(() => {
+            vi.advanceTimersByTime(200);
+        });
+        act(() => {
+            result.current.insert('b');
+        });
+        act(() => {
+            vi.advanceTimersByTime(200);
+        });
+        expect(result.current.value).toBe('ab');
+        act(() => {
+            result.current.undo();
+        });
+        expect(result.current.value).toBe('a');
+        act(() => {
+            result.current.undo();
+        });
+        expect(result.current.value).toBe('');
+        vi.useRealTimers();
+    });
     it('should remove backslash when deleted at end of line', () => {
         const { result } = renderHook(() => useTextInput({ initialValue: 'hello\\' }));
         // Cursor should be at end: { line: 0, column: 6 } (after the backslash)
@@ -169,4 +237,141 @@ describe('useTextInput', () => {
             expect(result.current.cursor).toEqual({ line: 0, column: 5 });
         });
     });
+    describe('history limit', () => {
+        it('should use default history limit of 100', () => {
+            const { result } = renderHook(() => useTextInput({ undoDebounceMs: 0 }));
+            // Insert 5 characters separately
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.insert('a');
+                });
+            }
+            expect(result.current.value).toBe('aaaaa');
+            // Undo 5 times
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be back to empty
+            expect(result.current.value).toBe('');
+            // Try to undo again - should have no effect
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should respect custom history limit', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 3, undoDebounceMs: 0 }));
+            // Insert 5 characters
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.insert('a');
+                });
+            }
+            expect(result.current.value).toBe('aaaaa');
+            // Undo 4 times - only 3 should work due to limit
+            for (let i = 0; i < 4; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be back to 2 characters (5 - 3 undos, since only 3 history entries)
+            expect(result.current.value).toBe('aa');
+            // Try to undo again - should have no effect
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should trim oldest history when limit exceeded', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 3, undoDebounceMs: 0 }));
+            // Insert 5 characters
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.insert('a');
+                });
+            }
+            expect(result.current.value).toBe('aaaaa');
+            // Can undo 3 times (limited by history)
+            for (let i = 0; i < 3; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be at 2 characters
+            expect(result.current.value).toBe('aa');
+            // Try to undo one more time - should have no effect (no more history)
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should clear redo stack when new edit happens', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 5, undoDebounceMs: 0 }));
+            act(() => {
+                result.current.insert('a');
+            });
+            act(() => {
+                result.current.insert('b');
+            });
+            act(() => {
+                result.current.insert('c');
+            });
+            expect(result.current.value).toBe('abc');
+            // Undo once
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe('ab');
+            // Redo should work
+            act(() => {
+                result.current.redo();
+            });
+            expect(result.current.value).toBe('abc');
+            // Undo again
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe('ab');
+            // Insert new character - redo stack should be cleared
+            act(() => {
+                result.current.insert('d');
+            });
+            expect(result.current.value).toBe('abd');
+            // Redo should not work now (redo stack was cleared on insert)
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.redo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should prevent excessive memory use with bounded history', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 10, undoDebounceMs: 0 }));
+            // Insert 30 characters
+            for (let i = 0; i < 30; i++) {
+                act(() => {
+                    result.current.insert('x');
+                });
+            }
+            expect(result.current.value).toBe('x'.repeat(30));
+            // We should only be able to undo 10 times due to history limit
+            for (let i = 0; i < 10; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be back to 20 characters (30 - 10 undos)
+            expect(result.current.value).toBe('x'.repeat(20));
+            // No more undos available
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+    });
 });

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

@@ -52,6 +52,12 @@ export interface MultilineInputProps {
      * - 'right': cursor is at end of text (after last character)
      */
     onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
+    /**
+     * Batches consecutive single-character inserts into a single undo step.
+     * The batch is committed after this many milliseconds of inactivity (default: 200).
+     * Set to 0 to disable batching (undo will be per edit again).
+     */
+    undoDebounceMs?: number;
 }
 /**
  * Props for the core component (without Ink-specific hooks)
@@ -105,6 +111,12 @@ export interface MultilineInputCoreProps {
      * - 'right': cursor is at end of text (after last character)
      */
     onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
+    /**
+     * Batches consecutive single-character inserts into a single undo step.
+     * The batch is committed after this many milliseconds of inactivity (default: 200).
+     * Set to 0 to disable batching (undo will be per edit again).
+     */
+    undoDebounceMs?: number;
 }
 /**
  * Core rendering component that can be tested without Ink runtime.

package/dist/components/MultilineInput/index.js

@@ -11,8 +11,8 @@ import { log } from '../../utils/logger.js';
  * Core rendering component that can be tested without Ink runtime.
  * Does not include useInput/useStdout hooks.
  */
-export const MultilineInputCore = ({ value, onChange, placeholder, showCursor = true, width = 80, onCursorChange, cursorOverride, }) => {
-    const textInput = useTextInput({ initialValue: value ?? '' });
+export const MultilineInputCore = ({ value, onChange, placeholder, showCursor = true, width = 80, onCursorChange, cursorOverride, undoDebounceMs, }) => {
+    const textInput = useTextInput({ initialValue: value ?? '', undoDebounceMs });
     // Track whether a value change is from syncing props (not user input)
     const isSyncingFromProps = useRef(false);
     // Handle cursor override
@@ -66,7 +66,7 @@ export const MultilineInputCore = ({ value, onChange, placeholder, showCursor =
  * Full MultilineInput with Ink keyboard handling.
  * This component uses Ink-specific hooks and must be rendered in an Ink context.
  */
-export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, onCursorChange, cursorOverride, onBoundaryArrow, }) => {
+export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, onCursorChange, cursorOverride, onBoundaryArrow, undoDebounceMs, }) => {
     // Get terminal width from Ink (with resize support) if not provided
     const terminalWidth = useTerminalWidth(width);
     // Track raw input for detecting Home/End keys
@@ -84,7 +84,7 @@ export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCur
             stdin.off('data', handleData);
         };
     }, [stdin, isActive]);
-    const textInput = useTextInput({ initialValue: value ?? '', width: terminalWidth });
+    const textInput = useTextInput({ initialValue: value ?? '', width: terminalWidth, undoDebounceMs });
     // Handle cursor override
     useEffect(() => {
         if (cursorOverride !== undefined) {

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

@@ -3,6 +3,13 @@ export interface UseTextInputProps {
     initialValue?: string;
     /** Terminal width for visual-aware cursor navigation (up/down arrows respect line wrapping) */
     width?: number;
+    /** Maximum number of history entries to keep (default: 100) */
+    historyLimit?: number;
+    /**
+     * When > 0, consecutive single-character inserts are batched into a single undo step.
+     * A batch is committed after this many milliseconds of inactivity (default: 200).
+     */
+    undoDebounceMs?: number;
 }
 export interface UseTextInputResult {
     value: string;
@@ -19,4 +26,4 @@ export interface UseTextInputResult {
     cursorOffset: number;
     setCursorOffset: (offset: number) => void;
 }
-export declare function useTextInput({ initialValue, width }?: UseTextInputProps): UseTextInputResult;
+export declare function useTextInput({ initialValue, width, historyLimit, undoDebounceMs, }?: UseTextInputProps): UseTextInputResult;

package/dist/components/MultilineInput/useTextInput.js

@@ -1,7 +1,7 @@
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useEffect, useRef } 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 } = {}) {
+export function useTextInput({ initialValue = '', width, historyLimit = 100, undoDebounceMs = 200, } = {}) {
     const [buffer, setBuffer] = useState(() => createBuffer(initialValue));
     const [cursor, setCursor] = useState(() => {
         const lines = initialValue.split('\n');
@@ -12,39 +12,100 @@ export function useTextInput({ initialValue = '', width } = {}) {
     });
     const [undoStack, setUndoStack] = useState([]);
     const [redoStack, setRedoStack] = useState([]);
+    const pendingInsertBatchRef = useRef({});
+    const clearPendingInsertTimer = useCallback(() => {
+        if (pendingInsertBatchRef.current.timerId) {
+            clearTimeout(pendingInsertBatchRef.current.timerId);
+            pendingInsertBatchRef.current.timerId = undefined;
+        }
+    }, []);
+    const appendUndoState = useCallback((state) => {
+        setUndoStack((prev) => {
+            const newStack = [...prev, state];
+            if (newStack.length > historyLimit) {
+                return newStack.slice(-historyLimit);
+            }
+            return newStack;
+        });
+    }, [historyLimit]);
+    const commitPendingInsertBatch = useCallback(() => {
+        const startState = pendingInsertBatchRef.current.startState;
+        if (!startState)
+            return;
+        clearPendingInsertTimer();
+        pendingInsertBatchRef.current.startState = undefined;
+        appendUndoState(startState);
+    }, [appendUndoState, clearPendingInsertTimer]);
+    const schedulePendingInsertCommit = useCallback(() => {
+        if (undoDebounceMs <= 0)
+            return;
+        clearPendingInsertTimer();
+        pendingInsertBatchRef.current.timerId = setTimeout(() => {
+            commitPendingInsertBatch();
+        }, undoDebounceMs);
+    }, [clearPendingInsertTimer, commitPendingInsertBatch, undoDebounceMs]);
+    const beginOrRefreshInsertBatch = useCallback((currentBuffer, currentCursor) => {
+        if (!pendingInsertBatchRef.current.startState) {
+            pendingInsertBatchRef.current.startState = { buffer: currentBuffer, cursor: currentCursor };
+            setRedoStack([]);
+        }
+        schedulePendingInsertCommit();
+    }, [schedulePendingInsertCommit]);
+    const flushPendingInsertBatch = useCallback(() => {
+        commitPendingInsertBatch();
+    }, [commitPendingInsertBatch]);
     const pushToHistory = useCallback((currentBuffer, currentCursor) => {
-        setUndoStack((prev) => [...prev, { buffer: currentBuffer, cursor: currentCursor }]);
+        appendUndoState({ buffer: currentBuffer, cursor: currentCursor });
         setRedoStack([]);
-    }, []);
+    }, [appendUndoState]);
+    useEffect(() => {
+        return () => {
+            clearPendingInsertTimer();
+            pendingInsertBatchRef.current.startState = undefined;
+        };
+    }, [clearPendingInsertTimer]);
     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);
+        const canBatchInsert = undoDebounceMs > 0 &&
+            normalized.length === 1 &&
+            normalized !== '\n';
+        if (canBatchInsert) {
+            beginOrRefreshInsertBatch(buffer, cursor);
+        }
+        else {
+            flushPendingInsertBatch();
+            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]);
+    }, [beginOrRefreshInsertBatch, buffer, cursor, flushPendingInsertBatch, pushToHistory, undoDebounceMs]);
     const deleteChar = useCallback(() => {
+        flushPendingInsertBatch();
         pushToHistory(buffer, cursor);
         const result = bufferDeleteChar(buffer, cursor);
         setBuffer(result.buffer);
         setCursor(result.cursor);
-    }, [buffer, cursor, pushToHistory]);
+    }, [buffer, cursor, flushPendingInsertBatch, pushToHistory]);
     const deleteCharForward = useCallback(() => {
+        flushPendingInsertBatch();
         pushToHistory(buffer, cursor);
         const result = bufferDeleteCharForward(buffer, cursor);
         setBuffer(result.buffer);
         setCursor(result.cursor);
-    }, [buffer, cursor, pushToHistory]);
+    }, [buffer, cursor, flushPendingInsertBatch, pushToHistory]);
     const newLine = useCallback(() => {
+        flushPendingInsertBatch();
         pushToHistory(buffer, cursor);
         const result = bufferInsertNewLine(buffer, cursor);
         setBuffer(result.buffer);
         setCursor(result.cursor);
-    }, [buffer, cursor, pushToHistory]);
+    }, [buffer, cursor, flushPendingInsertBatch, pushToHistory]);
     const deleteAndNewLine = useCallback(() => {
+        flushPendingInsertBatch();
         pushToHistory(buffer, cursor);
         // First delete the character before cursor (the backslash)
         const afterDelete = bufferDeleteChar(buffer, cursor);
@@ -52,12 +113,22 @@ export function useTextInput({ initialValue = '', width } = {}) {
         const afterNewLine = bufferInsertNewLine(afterDelete.buffer, afterDelete.cursor);
         setBuffer(afterNewLine.buffer);
         setCursor(afterNewLine.cursor);
-    }, [buffer, cursor, pushToHistory]);
+    }, [buffer, cursor, flushPendingInsertBatch, pushToHistory]);
     const moveCursor = useCallback((direction) => {
+        flushPendingInsertBatch();
         const newCursor = bufferMoveCursor(buffer, cursor, direction, width);
         setCursor(newCursor);
-    }, [buffer, cursor, width]);
+    }, [buffer, cursor, flushPendingInsertBatch, width]);
     const undo = useCallback(() => {
+        const pendingStartState = pendingInsertBatchRef.current.startState;
+        if (pendingStartState) {
+            clearPendingInsertTimer();
+            pendingInsertBatchRef.current.startState = undefined;
+            setRedoStack((prev) => [...prev, { buffer, cursor }]);
+            setBuffer(pendingStartState.buffer);
+            setCursor(pendingStartState.cursor);
+            return;
+        }
         if (undoStack.length === 0)
             return;
         const previousState = undoStack[undoStack.length - 1];
@@ -66,8 +137,11 @@ export function useTextInput({ initialValue = '', width } = {}) {
         setBuffer(previousState.buffer);
         setCursor(previousState.cursor);
         setUndoStack(newUndoStack);
-    }, [buffer, cursor, undoStack]);
+    }, [buffer, clearPendingInsertTimer, cursor, undoStack]);
     const redo = useCallback(() => {
+        if (pendingInsertBatchRef.current.startState) {
+            return;
+        }
         if (redoStack.length === 0)
             return;
         const nextState = redoStack[redoStack.length - 1];
@@ -78,6 +152,7 @@ export function useTextInput({ initialValue = '', width } = {}) {
         setRedoStack(newRedoStack);
     }, [buffer, cursor, redoStack]);
     const setText = useCallback((text) => {
+        flushPendingInsertBatch();
         pushToHistory(buffer, cursor);
         const newBuffer = createBuffer(text);
         setBuffer(newBuffer);
@@ -87,7 +162,7 @@ export function useTextInput({ initialValue = '', width } = {}) {
             line: lines.length - 1,
             column: lines[lines.length - 1].length,
         });
-    }, [buffer, cursor, pushToHistory]);
+    }, [buffer, cursor, flushPendingInsertBatch, pushToHistory]);
     return {
         value: getTextContent(buffer),
         cursor,
@@ -102,7 +177,8 @@ export function useTextInput({ initialValue = '', width } = {}) {
         setText,
         cursorOffset: getOffset(buffer, cursor),
         setCursorOffset: useCallback((offset) => {
+            flushPendingInsertBatch();
             setCursor(getCursor(buffer, offset));
-        }, [buffer]),
+        }, [buffer, flushPendingInsertBatch]),
     };
 }

package/dist/examples/examples/basic.d.ts

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

package/dist/examples/examples/basic.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { render } from 'ink';
+import { MultilineInput } from '../src/index.js';
+const App = () => {
+    return (React.createElement(MultilineInput
+    // Add props here
+    , null));
+};
+render(React.createElement(App, null));

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

@@ -0,0 +1,15 @@
+import { type Key, type Buffer, type Cursor } from './types';
+import { type UseTextInputResult } from './useTextInput';
+export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'cursor'> {
+    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)
+ */
+export declare function handleKey(key: Partial<Key>, input: string, buffer: Buffer, actions: KeyHandlerActions, cursor?: Cursor): void;

package/dist/examples/src/components/MultilineInput/KeyHandler.js

@@ -0,0 +1,97 @@
+/**
+ * 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)
+ */
+export function handleKey(key, input, buffer, actions, cursor) {
+    // 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 (Ink might not provide these directly in all environments, but if it does)
+    // We check for 'home' and 'end' properties if they exist on the key object,
+    // or specific sequences if we were parsing raw input, but here we assume Ink's Key object.
+    // Note: Ink's Key interface might not have home/end in all versions, but we'll assume it does or we extend it.
+    // If not, we might need to check specific input sequences, but for now let's trust the test/types.
+    if (key.home) {
+        actions.moveCursor('lineStart');
+        return;
+    }
+    if (key.end) {
+        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) {
+        // Currently mapped to delete (backspace behavior) as per requirements/tests,
+        // but usually delete is forward.
+        // The plan said "Delete (delete at cursor)", which usually means forward.
+        // But our useTextInput only has `delete` (which is backspace).
+        // For now, we map it to `delete` as per the test "handles Delete".
+        actions.delete();
+        return;
+    }
+    // Submission / New Line
+    if (key.return) {
+        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('\\')) {
+                actions.delete(); // Remove the backslash
+                actions.newLine(); // Insert newline
+                return;
+            }
+        }
+        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) {
+        actions.insert(input);
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { Buffer, Cursor, Direction } from './types';
+/**
+ * Create a new buffer from optional initial text
+ */
+export declare function createBuffer(text?: string): Buffer;
+/**
+ * Insert a character at the cursor position
+ */
+export declare function insertChar(buffer: Buffer, cursor: Cursor, char: string): {
+    buffer: Buffer;
+    cursor: Cursor;
+};
+/**
+ * Delete character before cursor (backspace)
+ */
+export declare function deleteChar(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
+ */
+export declare function moveCursor(buffer: Buffer, cursor: Cursor, direction: Direction): Cursor;
+/**
+ * Get the full text content from buffer (lines joined with newlines)
+ */
+export declare function getTextContent(buffer: Buffer): string;