@elizaos/tui 2.0.0-alpha.10

package/dist/components/editor/layout.js

@@ -0,0 +1,205 @@
+/**
+ * Text layout and word wrapping utilities for the Editor component.
+ */
+import { getSegmenter, isWhitespaceChar, visibleWidth } from "../../utils.js";
+const segmenter = getSegmenter();
+/**
+ * Split a line into word-wrapped chunks.
+ * Wraps at word boundaries when possible, falling back to character-level
+ * wrapping for words longer than the available width.
+ *
+ * @param line - The text line to wrap
+ * @param maxWidth - Maximum visible width per chunk
+ * @returns Array of chunks with text and position information
+ */
+export function wordWrapLine(line, maxWidth) {
+    if (!line || maxWidth <= 0) {
+        return [{ text: "", startIndex: 0, endIndex: 0 }];
+    }
+    const lineWidth = visibleWidth(line);
+    if (lineWidth <= maxWidth) {
+        return [{ text: line, startIndex: 0, endIndex: line.length }];
+    }
+    const chunks = [];
+    const segments = [...segmenter.segment(line)];
+    let currentWidth = 0;
+    let chunkStart = 0;
+    // Wrap opportunity: the position after the last whitespace before a non-whitespace
+    // grapheme, i.e. where a line break is allowed.
+    let wrapOppIndex = -1;
+    let wrapOppWidth = 0;
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const grapheme = seg.segment;
+        const gWidth = visibleWidth(grapheme);
+        const charIndex = seg.index;
+        const isWs = isWhitespaceChar(grapheme);
+        // Overflow check before advancing.
+        if (currentWidth + gWidth > maxWidth) {
+            if (wrapOppIndex >= 0) {
+                // Backtrack to last wrap opportunity.
+                chunks.push({ text: line.slice(chunkStart, wrapOppIndex), startIndex: chunkStart, endIndex: wrapOppIndex });
+                chunkStart = wrapOppIndex;
+                currentWidth -= wrapOppWidth;
+            }
+            else if (chunkStart < charIndex) {
+                // No wrap opportunity: force-break at current position.
+                chunks.push({ text: line.slice(chunkStart, charIndex), startIndex: chunkStart, endIndex: charIndex });
+                chunkStart = charIndex;
+                currentWidth = 0;
+            }
+            wrapOppIndex = -1;
+        }
+        // Advance.
+        currentWidth += gWidth;
+        // Record wrap opportunity: whitespace followed by non-whitespace.
+        // Multiple spaces join (no break between them); the break point is
+        // after the last space before the next word.
+        const next = segments[i + 1];
+        if (isWs && next && !isWhitespaceChar(next.segment)) {
+            wrapOppIndex = next.index;
+            wrapOppWidth = currentWidth;
+        }
+    }
+    // Push final chunk.
+    chunks.push({ text: line.slice(chunkStart), startIndex: chunkStart, endIndex: line.length });
+    return chunks;
+}
+/**
+ * Layout text into visual lines for rendering.
+ *
+ * @param state - Current editor state
+ * @param contentWidth - Maximum width for content
+ * @returns Array of layout lines ready for rendering
+ */
+export function layoutText(state, contentWidth) {
+    const layoutLines = [];
+    if (state.lines.length === 0 || (state.lines.length === 1 && state.lines[0] === "")) {
+        // Empty editor
+        layoutLines.push({
+            text: "",
+            hasCursor: true,
+            cursorPos: 0,
+        });
+        return layoutLines;
+    }
+    // Process each logical line
+    for (let i = 0; i < state.lines.length; i++) {
+        const line = state.lines[i];
+        const isCurrentLine = i === state.cursorLine;
+        const lineVisibleWidth = visibleWidth(line);
+        if (lineVisibleWidth <= contentWidth) {
+            // Line fits in one layout line
+            if (isCurrentLine) {
+                layoutLines.push({
+                    text: line,
+                    hasCursor: true,
+                    cursorPos: state.cursorCol,
+                });
+            }
+            else {
+                layoutLines.push({
+                    text: line,
+                    hasCursor: false,
+                });
+            }
+        }
+        else {
+            // Line needs wrapping - use word-aware wrapping
+            const chunks = wordWrapLine(line, contentWidth);
+            for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+                const chunk = chunks[chunkIndex];
+                if (!chunk)
+                    continue;
+                const cursorPos = state.cursorCol;
+                const isLastChunk = chunkIndex === chunks.length - 1;
+                // Determine if cursor is in this chunk
+                let hasCursorInChunk = false;
+                let adjustedCursorPos = 0;
+                if (isCurrentLine) {
+                    if (isLastChunk) {
+                        // Last chunk: cursor belongs here if >= startIndex
+                        hasCursorInChunk = cursorPos >= chunk.startIndex;
+                        adjustedCursorPos = cursorPos - chunk.startIndex;
+                    }
+                    else {
+                        // Non-last chunk: cursor belongs here if in range [startIndex, endIndex)
+                        hasCursorInChunk = cursorPos >= chunk.startIndex && cursorPos < chunk.endIndex;
+                        if (hasCursorInChunk) {
+                            adjustedCursorPos = cursorPos - chunk.startIndex;
+                            // Clamp to text length (in case cursor was in trimmed whitespace)
+                            if (adjustedCursorPos > chunk.text.length) {
+                                adjustedCursorPos = chunk.text.length;
+                            }
+                        }
+                    }
+                }
+                layoutLines.push({
+                    text: chunk.text,
+                    hasCursor: hasCursorInChunk,
+                    cursorPos: hasCursorInChunk ? adjustedCursorPos : undefined,
+                });
+            }
+        }
+    }
+    return layoutLines;
+}
+/**
+ * Build a mapping from visual lines to logical positions.
+ *
+ * @param state - Current editor state
+ * @param width - Maximum width for content
+ * @returns Array where each element represents a visual line
+ */
+export function buildVisualLineMap(state, width) {
+    const visualLines = [];
+    for (let i = 0; i < state.lines.length; i++) {
+        const line = state.lines[i];
+        const lineVisWidth = visibleWidth(line);
+        if (line.length === 0) {
+            // Empty line still takes one visual line
+            visualLines.push({ logicalLine: i, startCol: 0, length: 0 });
+        }
+        else if (lineVisWidth <= width) {
+            visualLines.push({ logicalLine: i, startCol: 0, length: line.length });
+        }
+        else {
+            // Line needs wrapping - use word-aware wrapping
+            const chunks = wordWrapLine(line, width);
+            for (const chunk of chunks) {
+                visualLines.push({
+                    logicalLine: i,
+                    startCol: chunk.startIndex,
+                    length: chunk.endIndex - chunk.startIndex,
+                });
+            }
+        }
+    }
+    return visualLines;
+}
+/**
+ * Find the visual line index for the current cursor position.
+ *
+ * @param visualLines - Visual line mappings
+ * @param cursorLine - Current logical line
+ * @param cursorCol - Current column position
+ * @returns Visual line index
+ */
+export function findCurrentVisualLine(visualLines, cursorLine, cursorCol) {
+    for (let i = 0; i < visualLines.length; i++) {
+        const vl = visualLines[i];
+        if (!vl)
+            continue;
+        if (vl.logicalLine === cursorLine) {
+            const colInSegment = cursorCol - vl.startCol;
+            // Cursor is in this segment if it's within range
+            // For the last segment of a logical line, cursor can be at length (end position)
+            const isLastSegmentOfLine = i === visualLines.length - 1 || visualLines[i + 1]?.logicalLine !== vl.logicalLine;
+            if (colInSegment >= 0 && (colInSegment < vl.length || (isLastSegmentOfLine && colInSegment <= vl.length))) {
+                return i;
+            }
+        }
+    }
+    // Fallback: return last visual line
+    return visualLines.length - 1;
+}

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

@@ -0,0 +1,68 @@
+/**
+ * Type definitions for the Editor component.
+ */
+import type { SelectListTheme } from "../select-list.js";
+/**
+ * Editor state containing the text content and cursor position.
+ */
+export interface EditorState {
+    /** Lines of text in the editor */
+    lines: string[];
+    /** Current logical line index (0-based) */
+    cursorLine: number;
+    /** Current column position within the line */
+    cursorCol: number;
+}
+/**
+ * A single layout line after word wrapping.
+ */
+export interface LayoutLine {
+    /** The text content of this layout line */
+    text: string;
+    /** Whether this line contains the cursor */
+    hasCursor: boolean;
+    /** Position of cursor within this line (if hasCursor is true) */
+    cursorPos?: number;
+}
+/**
+ * Theme configuration for the Editor component.
+ */
+export interface EditorTheme {
+    /** Function to apply border color styling */
+    borderColor: (str: string) => string;
+    /** Theme for the autocomplete dropdown */
+    selectList: SelectListTheme;
+}
+/**
+ * Options for the Editor component.
+ */
+export interface EditorOptions {
+    /** Horizontal padding (default: 0) */
+    paddingX?: number;
+    /** Maximum visible items in autocomplete dropdown (default: 5) */
+    autocompleteMaxVisible?: number;
+}
+/**
+ * Represents a chunk of text for word-wrap layout.
+ * Tracks both the text content and its position in the original line.
+ */
+export interface TextChunk {
+    /** The text content of this chunk */
+    text: string;
+    /** Starting index in the original line */
+    startIndex: number;
+    /** Ending index in the original line */
+    endIndex: number;
+}
+/**
+ * Visual line mapping for cursor navigation.
+ */
+export interface VisualLineMapping {
+    /** Index into the logical lines array */
+    logicalLine: number;
+    /** Starting column in the logical line */
+    startCol: number;
+    /** Length of this visual line segment */
+    length: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/components/editor/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/editor/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,kCAAkC;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,SAAS,EAAE,OAAO,CAAC;IACnB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,6CAA6C;IAC7C,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,0CAA0C;IAC1C,UAAU,EAAE,eAAe,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,sBAAsB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;CACf"}

package/dist/components/editor/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for the Editor component.
+ */
+export {};

package/dist/components/editor/undo.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Undo/redo support for the Editor component.
+ */
+import type { EditorState } from "./types.js";
+/**
+ * Manages undo stack for the Editor.
+ */
+export declare class UndoManager {
+    private stack;
+    /**
+     * Capture a snapshot of the current state.
+     *
+     * @param state - Current editor state
+     * @returns Deep clone of the state
+     */
+    captureSnapshot(state: EditorState): EditorState;
+    /**
+     * Push a snapshot onto the undo stack.
+     *
+     * @param state - Current editor state to save
+     */
+    push(state: EditorState): void;
+    /**
+     * Pop and return the most recent snapshot.
+     *
+     * @returns The previous state, or undefined if stack is empty
+     */
+    pop(): EditorState | undefined;
+    /**
+     * Check if there are any undo snapshots available.
+     */
+    canUndo(): boolean;
+    /**
+     * Clear the undo stack.
+     */
+    clear(): void;
+    get length(): number;
+}
+/**
+ * Restore an undo snapshot to the target state object.
+ *
+ * @param target - State object to restore to
+ * @param snapshot - Snapshot to restore
+ */
+export declare function restoreSnapshot(target: EditorState, snapshot: EditorState): void;
+//# sourceMappingURL=undo.d.ts.map

package/dist/components/editor/undo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undo.d.ts","sourceRoot":"","sources":["../../../src/components/editor/undo.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,qBAAa,WAAW;IACvB,OAAO,CAAC,KAAK,CAAqB;IAElC;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW;IAIhD;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAI9B;;;;OAIG;IACH,GAAG,IAAI,WAAW,GAAG,SAAS;IAI9B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb,IAAI,MAAM,IAAI,MAAM,CAEnB;CACD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,GAAG,IAAI,CAEhF"}

package/dist/components/editor/undo.js

@@ -0,0 +1,58 @@
+/**
+ * Undo/redo support for the Editor component.
+ */
+/**
+ * Manages undo stack for the Editor.
+ */
+export class UndoManager {
+    stack = [];
+    /**
+     * Capture a snapshot of the current state.
+     *
+     * @param state - Current editor state
+     * @returns Deep clone of the state
+     */
+    captureSnapshot(state) {
+        return structuredClone(state);
+    }
+    /**
+     * Push a snapshot onto the undo stack.
+     *
+     * @param state - Current editor state to save
+     */
+    push(state) {
+        this.stack.push(this.captureSnapshot(state));
+    }
+    /**
+     * Pop and return the most recent snapshot.
+     *
+     * @returns The previous state, or undefined if stack is empty
+     */
+    pop() {
+        return this.stack.pop();
+    }
+    /**
+     * Check if there are any undo snapshots available.
+     */
+    canUndo() {
+        return this.stack.length > 0;
+    }
+    /**
+     * Clear the undo stack.
+     */
+    clear() {
+        this.stack.length = 0;
+    }
+    get length() {
+        return this.stack.length;
+    }
+}
+/**
+ * Restore an undo snapshot to the target state object.
+ *
+ * @param target - State object to restore to
+ * @param snapshot - Snapshot to restore
+ */
+export function restoreSnapshot(target, snapshot) {
+    Object.assign(target, structuredClone(snapshot));
+}

package/dist/components/editor.d.ts

@@ -0,0 +1,196 @@
+import type { AutocompleteProvider } from "../autocomplete.js";
+import { type Component, type Focusable, type TUI } from "../tui.js";
+export { DEFAULT_HISTORY_LIMIT, EditorHistory } from "./editor/history.js";
+export { KillRing } from "./editor/kill-ring.js";
+export { buildVisualLineMap, findCurrentVisualLine, layoutText, wordWrapLine, } from "./editor/layout.js";
+export type { EditorOptions, EditorState, EditorTheme, LayoutLine, TextChunk, VisualLineMapping, } from "./editor/types.js";
+export { restoreSnapshot, UndoManager } from "./editor/undo.js";
+import type { EditorOptions, EditorTheme } from "./editor/types.js";
+export declare class Editor implements Component, Focusable {
+    private state;
+    /** Get line at index, returns empty string for invalid indices */
+    private getLine;
+    /** Get current line at cursor */
+    private get currentLine();
+    /** Focusable interface - set by TUI when focus changes */
+    focused: boolean;
+    protected tui: TUI;
+    private theme;
+    private paddingX;
+    private lastWidth;
+    private scrollOffset;
+    borderColor: (str: string) => string;
+    private autocompleteProvider?;
+    private autocompleteList?;
+    private autocompleteState;
+    private autocompletePrefix;
+    private autocompleteMaxVisible;
+    private pastes;
+    private pasteCounter;
+    private pasteBuffer;
+    private isInPaste;
+    private history;
+    private historyIndex;
+    private killRing;
+    private lastAction;
+    private jumpMode;
+    private preferredVisualCol;
+    private undoStack;
+    onSubmit?: (text: string) => void;
+    onChange?: (text: string) => void;
+    disableSubmit: boolean;
+    constructor(tui: TUI, theme: EditorTheme, options?: EditorOptions);
+    getPaddingX(): number;
+    setPaddingX(padding: number): void;
+    getAutocompleteMaxVisible(): number;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    setAutocompleteProvider(provider: AutocompleteProvider): void;
+    /**
+     * Add a prompt to history for up/down arrow navigation.
+     * Called after successful submission.
+     */
+    addToHistory(text: string): void;
+    private isEditorEmpty;
+    private isOnFirstVisualLine;
+    private isOnLastVisualLine;
+    private navigateHistory;
+    /** Internal setText that doesn't reset history state - used by navigateHistory */
+    private setTextInternal;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    private layoutText;
+    getText(): string;
+    /**
+     * Get text with paste markers expanded to their actual content.
+     * Use this when you need the full content (e.g., for external editor).
+     */
+    getExpandedText(): string;
+    getLines(): string[];
+    getCursor(): {
+        line: number;
+        col: number;
+    };
+    setText(text: string): void;
+    /**
+     * Insert text at the current cursor position.
+     * Used for programmatic insertion (e.g., clipboard image markers).
+     * This is atomic for undo - single undo restores entire pre-insert state.
+     */
+    insertTextAtCursor(text: string): void;
+    /**
+     * Internal text insertion at cursor. Handles single and multi-line text.
+     * Does not push undo snapshots or trigger autocomplete - caller is responsible.
+     * Normalizes line endings and calls onChange once at the end.
+     */
+    private insertTextAtCursorInternal;
+    private insertCharacter;
+    private handlePaste;
+    private addNewLine;
+    private shouldSubmitOnBackslashEnter;
+    private submitValue;
+    private handleBackspace;
+    /**
+     * Set cursor column and clear preferredVisualCol.
+     * Use this for all non-vertical cursor movements to reset sticky column behavior.
+     */
+    private setCursorCol;
+    /**
+     * Move cursor to a target visual line, applying sticky column logic.
+     * Shared by moveCursor() and pageScroll().
+     */
+    private moveToVisualLine;
+    /**
+     * Compute the target visual column for vertical cursor movement.
+     * Implements the sticky column decision table:
+     *
+     * | P | S | T | U | Scenario                                             | Set Preferred | Move To     |
+     * |---|---|---|---| ---------------------------------------------------- |---------------|-------------|
+     * | 0 | * | 0 | - | Start nav, target fits                               | null          | current     |
+     * | 0 | * | 1 | - | Start nav, target shorter                            | current       | target end  |
+     * | 1 | 0 | 0 | 0 | Clamped, target fits preferred                       | null          | preferred   |
+     * | 1 | 0 | 0 | 1 | Clamped, target longer but still can't fit preferred | keep          | target end  |
+     * | 1 | 0 | 1 | - | Clamped, target even shorter                         | keep          | target end  |
+     * | 1 | 1 | 0 | - | Rewrapped, target fits current                       | null          | current     |
+     * | 1 | 1 | 1 | - | Rewrapped, target shorter than current               | current       | target end  |
+     *
+     * Where:
+     * - P = preferred col is set
+     * - S = cursor in middle of source line (not clamped to end)
+     * - T = target line shorter than current visual col
+     * - U = target line shorter than preferred col
+     */
+    private computeVerticalMoveColumn;
+    private moveToLineStart;
+    private moveToLineEnd;
+    private deleteToStartOfLine;
+    private deleteToEndOfLine;
+    private deleteWordBackwards;
+    private deleteWordForward;
+    private handleForwardDelete;
+    /**
+     * Build a mapping from visual lines to logical positions.
+     * Returns an array where each element represents a visual line with:
+     * - logicalLine: index into this.state.lines
+     * - startCol: starting column in the logical line
+     * - length: length of this visual line segment
+     */
+    private buildVisualLineMap;
+    /**
+     * Find the visual line index for the current cursor position.
+     */
+    private findCurrentVisualLine;
+    private moveCursor;
+    /**
+     * Scroll by a page (direction: -1 for up, 1 for down).
+     * Moves cursor by the page size while keeping it in bounds.
+     */
+    private pageScroll;
+    private moveWordBackwards;
+    /**
+     * Yank (paste) the most recent kill ring entry at cursor position.
+     */
+    private yank;
+    /**
+     * Cycle through kill ring (only works immediately after yank or yank-pop).
+     * Replaces the last yanked text with the previous entry in the ring.
+     */
+    private yankPop;
+    /**
+     * Insert text at cursor position (used by yank operations).
+     */
+    private insertYankedText;
+    /**
+     * Delete the previously yanked text (used by yank-pop).
+     * The yanked text is derived from killRing[end] since it hasn't been rotated yet.
+     */
+    private deleteYankedText;
+    /**
+     * Add text to the kill ring.
+     * If lastAction is "kill", accumulates with the previous entry.
+     * @param text - The text to add
+     * @param prepend - If accumulating, prepend (true) or append (false) to existing entry
+     */
+    private addToKillRing;
+    private captureUndoSnapshot;
+    private restoreUndoSnapshot;
+    private pushUndoSnapshot;
+    private undo;
+    /**
+     * Jump to the first occurrence of a character in the specified direction.
+     * Multi-line search. Case-sensitive. Skips the current cursor position.
+     */
+    private jumpToChar;
+    private moveWordForwards;
+    private isSlashMenuAllowed;
+    private isAtStartOfMessage;
+    private isInSlashCommandContext;
+    private tryTriggerAutocomplete;
+    private handleTabCompletion;
+    private handleSlashCommandCompletion;
+    private forceFileAutocomplete;
+    private cancelAutocomplete;
+    isShowingAutocomplete(): boolean;
+    private updateAutocomplete;
+}
+//# sourceMappingURL=editor.d.ts.map

package/dist/components/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../src/components/editor.ts"],"names":[],"mappings":"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"}