ink-prompt 0.1.5 → 0.1.6

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

@@ -2,6 +2,7 @@ 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;
+    onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
 }
 /**
  * Handles keyboard input and maps it to text input actions.
@@ -12,5 +13,6 @@ export interface KeyHandlerActions extends Omit<UseTextInputResult, 'value' | 'c
  * @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)
+ * @param width - Terminal width for visual-aware boundary detection (optional)
  */
-export declare function handleKey(key: Partial<Key>, input: string, buffer: Buffer, actions: KeyHandlerActions, cursor?: Cursor, rawInput?: string): void;
+export declare function handleKey(key: Partial<Key>, input: string, buffer: Buffer, actions: KeyHandlerActions, cursor?: Cursor, rawInput?: string, width?: number): void;

package/dist/components/MultilineInput/KeyHandler.js

@@ -1,4 +1,105 @@
+import { getVisualRows } from './TextBuffer.js';
 import { log } from '../../utils/logger.js';
+/**
+ * Check if cursor is at the left boundary (start of text).
+ */
+function isAtLeftBoundary(cursor) {
+    return cursor.line === 0 && cursor.column === 0;
+}
+/**
+ * Check if cursor is at the right boundary (end of text).
+ */
+function isAtRightBoundary(buffer, cursor) {
+    const lastLineIndex = buffer.lines.length - 1;
+    const lastLine = buffer.lines[lastLineIndex];
+    return cursor.line === lastLineIndex && cursor.column >= lastLine.length;
+}
+/**
+ * Check if cursor is at the top boundary (cannot move up).
+ * When width is provided, this considers visual line wrapping.
+ */
+function isAtTopBoundary(buffer, cursor, width) {
+    if (cursor.line > 0) {
+        // Not on first buffer line, check visual wrapping
+        if (width !== undefined) {
+            const currentLine = buffer.lines[cursor.line];
+            const rows = getVisualRows(currentLine, width);
+            // Find which visual row the cursor is on
+            let visualRow = 0;
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const rowEnd = row.start + row.length;
+                if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                    visualRow = i;
+                    break;
+                }
+            }
+            // If cursor is not on the first visual row of this line, it can move up
+            return false;
+        }
+        return false;
+    }
+    // Cursor is on first buffer line
+    if (width !== undefined) {
+        const currentLine = buffer.lines[0];
+        const rows = getVisualRows(currentLine, width);
+        // Find which visual row the cursor is on
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const rowEnd = row.start + row.length;
+            if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                // At top boundary only if on first visual row
+                return i === 0;
+            }
+        }
+    }
+    // No width - buffer line-based: first line means at top
+    return true;
+}
+/**
+ * Check if cursor is at the bottom boundary (cannot move down).
+ * When width is provided, this considers visual line wrapping.
+ */
+function isAtBottomBoundary(buffer, cursor, width) {
+    const lastLineIndex = buffer.lines.length - 1;
+    if (cursor.line < lastLineIndex) {
+        // Not on last buffer line, check visual wrapping
+        if (width !== undefined) {
+            const currentLine = buffer.lines[cursor.line];
+            const rows = getVisualRows(currentLine, width);
+            // Find which visual row the cursor is on
+            let visualRow = 0;
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const rowEnd = row.start + row.length;
+                if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                    visualRow = i;
+                    break;
+                }
+            }
+            // If cursor is not on the last visual row of this line, it can move down
+            return false;
+        }
+        return false;
+    }
+    // Cursor is on last buffer line
+    if (width !== undefined) {
+        const currentLine = buffer.lines[lastLineIndex];
+        const rows = getVisualRows(currentLine, width);
+        const lastVisualRow = rows.length - 1;
+        // Find which visual row the cursor is on
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const rowEnd = row.start + row.length;
+            if (cursor.column >= row.start && cursor.column <= rowEnd) {
+                // At bottom boundary only if on last visual row
+                return i === lastVisualRow;
+            }
+        }
+    }
+    // No width - buffer line-based: last line means at bottom
+    return true;
+}
 /**
  * Escape sequences for Home key (various terminal emulators)
  */
@@ -33,22 +134,39 @@ function isBackspaceSequence(seq) {
  * @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)
+ * @param width - Terminal width for visual-aware boundary detection (optional)
  */
-export function handleKey(key, input, buffer, actions, cursor, rawInput) {
-    // Navigation
+export function handleKey(key, input, buffer, actions, cursor, rawInput, width) {
+    // Navigation with boundary detection
     if (key.upArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtTopBoundary(buffer, cursor, width)) {
+            actions.onBoundaryArrow('up');
+            return;
+        }
         actions.moveCursor('up');
         return;
     }
     if (key.downArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtBottomBoundary(buffer, cursor, width)) {
+            actions.onBoundaryArrow('down');
+            return;
+        }
         actions.moveCursor('down');
         return;
     }
     if (key.leftArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtLeftBoundary(cursor)) {
+            actions.onBoundaryArrow('left');
+            return;
+        }
         actions.moveCursor('left');
         return;
     }
     if (key.rightArrow) {
+        if (cursor && actions.onBoundaryArrow && isAtRightBoundary(buffer, cursor)) {
+            actions.onBoundaryArrow('right');
+            return;
+        }
         actions.moveCursor('right');
         return;
     }

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

@@ -62,6 +62,179 @@ describe('KeyHandler', () => {
             expect(actions.moveCursor).toHaveBeenCalledWith('lineEnd');
         });
     });
+    describe('Boundary Arrow', () => {
+        describe('Left boundary', () => {
+            it('calls onBoundaryArrow("left") when cursor is at position 0', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 0 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('left');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when cursor can move left', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 3 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('left');
+            });
+            it('does not call onBoundaryArrow when at start of line but previous line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 1, column: 0 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('left');
+            });
+        });
+        describe('Right boundary', () => {
+            it('calls onBoundaryArrow("right") when cursor is at end of text', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 5 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('right');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when cursor can move right', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('right');
+            });
+            it('does not call onBoundaryArrow when at end of line but next line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 0, column: 5 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('right');
+            });
+        });
+        describe('Up boundary', () => {
+            it('calls onBoundaryArrow("up") when cursor is on first line', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('up');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when previous line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 1, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('up');
+            });
+            it('considers visual rows when width is provided - cursor on first visual row', () => {
+                // "hello world" with width 5 wraps to:
+                // "hello" (visual row 0)
+                // " worl" (visual row 1)
+                // "d" (visual row 2)
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 2 }; // On first visual row
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('up');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('considers visual rows when width is provided - cursor on second visual row', () => {
+                // "hello world" with width 5 wraps to visual rows
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 7 }; // On second visual row (after first wrap)
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                // Can move up within the same buffer line (to previous visual row)
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('up');
+            });
+        });
+        describe('Down boundary', () => {
+            it('calls onBoundaryArrow("down") when cursor is on last line', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('down');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('does not call onBoundaryArrow when next line exists', () => {
+                buffer = { lines: ['first', 'second'] };
+                const cursor = { line: 0, column: 2 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('down');
+            });
+            it('considers visual rows when width is provided - cursor on last visual row', () => {
+                // "hello world" with width 5 wraps to visual rows
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 10 }; // On last visual row (at 'd')
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('down');
+                expect(actions.moveCursor).not.toHaveBeenCalled();
+            });
+            it('considers visual rows when width is provided - cursor on first visual row', () => {
+                // "hello world" with width 5 wraps to visual rows
+                buffer = { lines: ['hello world'] };
+                const cursor = { line: 0, column: 2 }; // On first visual row
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ downArrow: true }, '', buffer, actions, cursor, undefined, 5);
+                // Can move down within the same buffer line (to next visual row)
+                expect(onBoundaryArrow).not.toHaveBeenCalled();
+                expect(actions.moveCursor).toHaveBeenCalledWith('down');
+            });
+        });
+        describe('No callback provided', () => {
+            it('moves cursor normally when onBoundaryArrow is not set', () => {
+                buffer = { lines: ['hello'] };
+                const cursor = { line: 0, column: 0 };
+                // actions.onBoundaryArrow is not set
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(actions.moveCursor).toHaveBeenCalledWith('left');
+            });
+        });
+        describe('Empty buffer', () => {
+            it('calls onBoundaryArrow for all directions in empty buffer', () => {
+                buffer = { lines: [''] };
+                const cursor = { line: 0, column: 0 };
+                const onBoundaryArrow = vi.fn();
+                actions.onBoundaryArrow = onBoundaryArrow;
+                handleKey({ upArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('up');
+                onBoundaryArrow.mockClear();
+                handleKey({ downArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('down');
+                onBoundaryArrow.mockClear();
+                handleKey({ leftArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('left');
+                onBoundaryArrow.mockClear();
+                handleKey({ rightArrow: true }, '', buffer, actions, cursor);
+                expect(onBoundaryArrow).toHaveBeenCalledWith('right');
+            });
+        });
+    });
     describe('Editing', () => {
         it('handles Backspace', () => {
             handleKey({ backspace: true }, 'backspace', buffer, actions);

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

@@ -18,6 +18,10 @@ export interface Buffer {
  * Cursor movement directions
  */
 export type Direction = 'up' | 'down' | 'left' | 'right' | 'lineStart' | 'lineEnd';
+/**
+ * Boundary arrow directions (subset of Direction used for boundary detection)
+ */
+export type BoundaryDirection = 'up' | 'down' | 'left' | 'right';
 /**
  * Result of wrapping buffer lines for visual display
  */

package/dist/index.d.ts

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

package/package.json

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

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

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

package/dist/examples/examples/basic.js

@@ -1,9 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,97 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-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;

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

@@ -1,127 +0,0 @@
-/**
- * Create a new buffer from optional initial text
- */
-export function createBuffer(text) {
-    if (!text) {
-        return { lines: [''] };
-    }
-    return { lines: text.split('\n') };
-}
-/**
- * Insert a character at the cursor position
- */
-export function insertChar(buffer, cursor, char) {
-    const { line, column } = cursor;
-    const currentLine = buffer.lines[line];
-    const newLine = currentLine.slice(0, column) + char + currentLine.slice(column);
-    const newLines = [...buffer.lines];
-    newLines[line] = newLine;
-    return {
-        buffer: { lines: newLines },
-        cursor: { line, column: column + 1 },
-    };
-}
-/**
- * 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 },
-    };
-}
-/**
- * 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 },
-    };
-}
-/**
- * Move cursor in specified direction with bounds checking
- */
-export function moveCursor(buffer, cursor, direction) {
-    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 (line > 0) {
-                const targetLine = buffer.lines[line - 1];
-                return { line: line - 1, column: Math.min(column, targetLine.length) };
-            }
-            return cursor;
-        case 'down':
-            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');
-}