codeep 1.1.12 → 1.1.13

package/dist/renderer/Input.js

@@ -0,0 +1,371 @@
+/**
+ * Raw input handling for terminal
+ * Handles keypresses, special keys, and line editing
+ */
+export class Input {
+    handlers = [];
+    rl = null;
+    /**
+     * Start listening for input
+     */
+    start() {
+        // Enable raw mode for character-by-character input
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        // Enable mouse tracking (SGR mode for better compatibility)
+        // \x1b[?1000h - enable basic mouse tracking
+        // \x1b[?1006h - enable SGR extended mouse mode
+        process.stdout.write('\x1b[?1000h\x1b[?1006h');
+        process.stdin.on('data', (data) => {
+            const event = this.parseKey(data);
+            this.emit(event);
+        });
+    }
+    /**
+     * Stop listening
+     */
+    stop() {
+        // Disable mouse tracking
+        process.stdout.write('\x1b[?1006l\x1b[?1000l');
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+    }
+    /**
+     * Add key handler
+     */
+    onKey(handler) {
+        this.handlers.push(handler);
+        return () => {
+            const index = this.handlers.indexOf(handler);
+            if (index !== -1) {
+                this.handlers.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Emit key event to all handlers
+     */
+    emit(event) {
+        for (const handler of this.handlers) {
+            handler(event);
+        }
+    }
+    /**
+     * Parse raw input into KeyEvent
+     */
+    parseKey(data) {
+        const event = {
+            key: '',
+            ctrl: false,
+            alt: false,
+            shift: false,
+            raw: data,
+            isPaste: false,
+        };
+        // Check for mouse scroll events (SGR format: \x1b[<button;x;yM or \x1b[<button;x;ym)
+        // Button 64 = scroll up, Button 65 = scroll down
+        const mouseMatch = data.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+        if (mouseMatch) {
+            const button = parseInt(mouseMatch[1], 10);
+            // const x = parseInt(mouseMatch[2], 10);
+            // const y = parseInt(mouseMatch[3], 10);
+            // const release = mouseMatch[4] === 'm';
+            if (button === 64) {
+                // Scroll up
+                event.key = 'scrollup';
+                return event;
+            }
+            else if (button === 65) {
+                // Scroll down
+                event.key = 'scrolldown';
+                return event;
+            }
+            // Ignore other mouse events (clicks, etc.)
+            event.key = 'mouse';
+            return event;
+        }
+        // Detect paste: multiple printable characters at once (not escape sequences)
+        if (data.length > 1 && !data.startsWith('\x1b')) {
+            // Check if it's all printable characters (paste event)
+            const isPrintable = /^[\x20-\x7E\n\r\t]+$/.test(data) ||
+                data.split('').every(c => c.charCodeAt(0) >= 32 || c === '\n' || c === '\r' || c === '\t');
+            if (isPrintable) {
+                event.key = data;
+                event.isPaste = true;
+                return event;
+            }
+        }
+        // Ctrl+C
+        if (data === '\x03') {
+            event.key = 'c';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+D
+        if (data === '\x04') {
+            event.key = 'd';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+L
+        if (data === '\x0c') {
+            event.key = 'l';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+V (paste)
+        if (data === '\x16') {
+            event.key = 'v';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+A (go to beginning)
+        if (data === '\x01') {
+            event.key = 'a';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+E (go to end)
+        if (data === '\x05') {
+            event.key = 'e';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+U (clear line)
+        if (data === '\x15') {
+            event.key = 'u';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+W (delete word)
+        if (data === '\x17') {
+            event.key = 'w';
+            event.ctrl = true;
+            return event;
+        }
+        // Ctrl+K (delete to end of line)
+        if (data === '\x0b') {
+            event.key = 'k';
+            event.ctrl = true;
+            return event;
+        }
+        // Enter
+        if (data === '\r' || data === '\n') {
+            event.key = 'enter';
+            return event;
+        }
+        // Backspace
+        if (data === '\x7f' || data === '\b') {
+            event.key = 'backspace';
+            return event;
+        }
+        // Escape
+        if (data === '\x1b') {
+            event.key = 'escape';
+            return event;
+        }
+        // Tab
+        if (data === '\t') {
+            event.key = 'tab';
+            return event;
+        }
+        // Arrow keys and other escape sequences
+        if (data.startsWith('\x1b[')) {
+            const seq = data.slice(2);
+            switch (seq) {
+                case 'A':
+                    event.key = 'up';
+                    break;
+                case 'B':
+                    event.key = 'down';
+                    break;
+                case 'C':
+                    event.key = 'right';
+                    break;
+                case 'D':
+                    event.key = 'left';
+                    break;
+                case 'H':
+                    event.key = 'home';
+                    break;
+                case 'F':
+                    event.key = 'end';
+                    break;
+                case '3~':
+                    event.key = 'delete';
+                    break;
+                case '5~':
+                    event.key = 'pageup';
+                    break;
+                case '6~':
+                    event.key = 'pagedown';
+                    break;
+                default:
+                    event.key = 'unknown';
+            }
+            return event;
+        }
+        // Alt+key (ESC followed by character)
+        if (data.startsWith('\x1b') && data.length === 2) {
+            event.key = data[1];
+            event.alt = true;
+            return event;
+        }
+        // Ctrl+letter (0x01-0x1a maps to a-z)
+        const code = data.charCodeAt(0);
+        if (code >= 1 && code <= 26) {
+            event.key = String.fromCharCode(code + 96); // 1 -> 'a', etc.
+            event.ctrl = true;
+            return event;
+        }
+        // Regular character
+        event.key = data;
+        return event;
+    }
+}
+/**
+ * Simple line editor with cursor support
+ */
+export class LineEditor {
+    value = '';
+    cursorPos = 0;
+    history = [];
+    historyIndex = -1;
+    tempValue = '';
+    getValue() {
+        return this.value;
+    }
+    getCursorPos() {
+        return this.cursorPos;
+    }
+    setValue(value) {
+        this.value = value;
+        this.cursorPos = value.length;
+    }
+    clear() {
+        this.value = '';
+        this.cursorPos = 0;
+        this.historyIndex = -1;
+    }
+    /**
+     * Insert text at cursor position
+     */
+    insert(text) {
+        this.value = this.value.slice(0, this.cursorPos) + text + this.value.slice(this.cursorPos);
+        this.cursorPos += text.length;
+    }
+    /**
+     * Set cursor position
+     */
+    setCursorPos(pos) {
+        this.cursorPos = Math.max(0, Math.min(pos, this.value.length));
+    }
+    /**
+     * Delete word backward (Ctrl+W)
+     */
+    deleteWordBackward() {
+        if (this.cursorPos === 0)
+            return;
+        const beforeCursor = this.value.slice(0, this.cursorPos);
+        const afterCursor = this.value.slice(this.cursorPos);
+        // Find last word boundary (skip trailing spaces, then find space)
+        let i = beforeCursor.length - 1;
+        while (i >= 0 && beforeCursor[i] === ' ')
+            i--;
+        while (i >= 0 && beforeCursor[i] !== ' ')
+            i--;
+        const newBefore = beforeCursor.slice(0, i + 1);
+        this.value = newBefore + afterCursor;
+        this.cursorPos = newBefore.length;
+    }
+    /**
+     * Delete to end of line (Ctrl+K)
+     */
+    deleteToEnd() {
+        this.value = this.value.slice(0, this.cursorPos);
+    }
+    addToHistory(value) {
+        if (value.trim()) {
+            this.history.push(value);
+            // Keep last 100 entries
+            if (this.history.length > 100) {
+                this.history.shift();
+            }
+        }
+        this.historyIndex = -1;
+    }
+    /**
+     * Handle key event, returns true if value changed
+     */
+    handleKey(event) {
+        const oldValue = this.value;
+        const oldCursor = this.cursorPos;
+        switch (event.key) {
+            case 'backspace':
+                if (this.cursorPos > 0) {
+                    this.value = this.value.slice(0, this.cursorPos - 1) + this.value.slice(this.cursorPos);
+                    this.cursorPos--;
+                }
+                break;
+            case 'delete':
+                if (this.cursorPos < this.value.length) {
+                    this.value = this.value.slice(0, this.cursorPos) + this.value.slice(this.cursorPos + 1);
+                }
+                break;
+            case 'left':
+                if (this.cursorPos > 0) {
+                    this.cursorPos--;
+                }
+                break;
+            case 'right':
+                if (this.cursorPos < this.value.length) {
+                    this.cursorPos++;
+                }
+                break;
+            case 'home':
+                this.cursorPos = 0;
+                break;
+            case 'end':
+                this.cursorPos = this.value.length;
+                break;
+            case 'up':
+                if (this.history.length > 0) {
+                    if (this.historyIndex === -1) {
+                        this.tempValue = this.value;
+                        this.historyIndex = this.history.length - 1;
+                    }
+                    else if (this.historyIndex > 0) {
+                        this.historyIndex--;
+                    }
+                    this.value = this.history[this.historyIndex];
+                    this.cursorPos = this.value.length;
+                }
+                break;
+            case 'down':
+                if (this.historyIndex !== -1) {
+                    if (this.historyIndex < this.history.length - 1) {
+                        this.historyIndex++;
+                        this.value = this.history[this.historyIndex];
+                    }
+                    else {
+                        this.historyIndex = -1;
+                        this.value = this.tempValue;
+                    }
+                    this.cursorPos = this.value.length;
+                }
+                break;
+            default:
+                // Regular character (single char, not control)
+                if (event.key.length === 1 && !event.ctrl && !event.alt) {
+                    this.value = this.value.slice(0, this.cursorPos) + event.key + this.value.slice(this.cursorPos);
+                    this.cursorPos++;
+                }
+        }
+        return this.value !== oldValue || this.cursorPos !== oldCursor;
+    }
+}

package/dist/renderer/Screen.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Screen buffer with diff-based rendering
+ * Only writes changes to terminal - minimizes flickering
+ */
+export interface Cell {
+    char: string;
+    style: string;
+}
+export declare class Screen {
+    private width;
+    private height;
+    private buffer;
+    private rendered;
+    private cursorX;
+    private cursorY;
+    private cursorVisible;
+    constructor();
+    private createEmptyBuffer;
+    /**
+     * Get terminal dimensions
+     */
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Clear the buffer
+     */
+    clear(): void;
+    /**
+     * Write text at position
+     */
+    write(x: number, y: number, text: string, textStyle?: string): void;
+    /**
+     * Write a line, clearing rest of line
+     */
+    writeLine(y: number, text: string, textStyle?: string): void;
+    /**
+     * Write raw line with pre-formatted ANSI codes (for syntax highlighted content)
+     * This writes directly without parsing for styles since the text already contains ANSI escapes
+     */
+    writeRaw(y: number, text: string, prefixStyle?: string): void;
+    /**
+     * Write multiple lines starting at y
+     */
+    writeLines(startY: number, lines: string[], textStyle?: string): number;
+    /**
+     * Write text with word wrapping
+     */
+    writeWrapped(x: number, y: number, text: string, maxWidth: number, textStyle?: string): number;
+    /**
+     * Draw a horizontal line
+     */
+    horizontalLine(y: number, char?: string, textStyle?: string): void;
+    /**
+     * Set cursor position for input
+     */
+    setCursor(x: number, y: number): void;
+    /**
+     * Show/hide cursor
+     */
+    showCursor(visible: boolean): void;
+    /**
+     * Render only changed cells (diff render)
+     */
+    render(): void;
+    /**
+     * Full render (no diff, redraw everything)
+     */
+    fullRender(): void;
+    /**
+     * Initialize screen (hide cursor, clear)
+     */
+    init(): void;
+    /**
+     * Cleanup (show cursor, clear)
+     */
+    cleanup(): void;
+}