codeep 1.1.12 → 1.1.13

package/dist/renderer/Screen.js

@@ -0,0 +1,278 @@
+/**
+ * Screen buffer with diff-based rendering
+ * Only writes changes to terminal - minimizes flickering
+ */
+import { cursor, screen, style, visibleLength } from './ansi.js';
+export class Screen {
+    width;
+    height;
+    buffer;
+    rendered;
+    cursorX = 0;
+    cursorY = 0;
+    cursorVisible = true;
+    constructor() {
+        this.width = process.stdout.columns || 80;
+        this.height = process.stdout.rows || 24;
+        this.buffer = this.createEmptyBuffer();
+        this.rendered = this.createEmptyBuffer();
+        // Handle resize
+        process.stdout.on('resize', () => {
+            this.width = process.stdout.columns || 80;
+            this.height = process.stdout.rows || 24;
+            this.buffer = this.createEmptyBuffer();
+            this.rendered = this.createEmptyBuffer();
+            this.fullRender();
+        });
+    }
+    createEmptyBuffer() {
+        const buffer = [];
+        for (let y = 0; y < this.height; y++) {
+            const row = [];
+            for (let x = 0; x < this.width; x++) {
+                row.push({ char: ' ', style: '' });
+            }
+            buffer.push(row);
+        }
+        return buffer;
+    }
+    /**
+     * Get terminal dimensions
+     */
+    getSize() {
+        return { width: this.width, height: this.height };
+    }
+    /**
+     * Clear the buffer
+     */
+    clear() {
+        this.buffer = this.createEmptyBuffer();
+    }
+    /**
+     * Write text at position
+     */
+    write(x, y, text, textStyle = '') {
+        if (y < 0 || y >= this.height)
+            return;
+        let col = x;
+        let inEscape = false;
+        let currentStyle = textStyle;
+        for (const char of text) {
+            if (char === '\x1b') {
+                inEscape = true;
+                currentStyle += char;
+            }
+            else if (inEscape) {
+                currentStyle += char;
+                if (char.match(/[a-zA-Z]/)) {
+                    inEscape = false;
+                }
+            }
+            else if (char === '\n') {
+                // Newline - would need to handle multi-line writes
+                break;
+            }
+            else {
+                if (col >= 0 && col < this.width) {
+                    this.buffer[y][col] = { char, style: currentStyle };
+                }
+                col++;
+            }
+        }
+    }
+    /**
+     * Write a line, clearing rest of line
+     */
+    writeLine(y, text, textStyle = '') {
+        if (y < 0 || y >= this.height)
+            return;
+        // Clear the line first
+        for (let x = 0; x < this.width; x++) {
+            this.buffer[y][x] = { char: ' ', style: '' };
+        }
+        this.write(0, y, text, textStyle);
+    }
+    /**
+     * 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, text, prefixStyle = '') {
+        if (y < 0 || y >= this.height)
+            return;
+        // Clear the line first
+        for (let x = 0; x < this.width; x++) {
+            this.buffer[y][x] = { char: ' ', style: '' };
+        }
+        // Parse text character by character, tracking ANSI escape sequences
+        let col = 0;
+        let i = 0;
+        let currentStyle = prefixStyle;
+        while (i < text.length && col < this.width) {
+            // Check for ANSI escape sequence
+            if (text[i] === '\x1b' && text[i + 1] === '[') {
+                // Find end of escape sequence (ends with letter)
+                let escEnd = i + 2;
+                while (escEnd < text.length && !text[escEnd].match(/[a-zA-Z]/)) {
+                    escEnd++;
+                }
+                if (escEnd < text.length) {
+                    const escSeq = text.slice(i, escEnd + 1);
+                    // Reset code clears style, otherwise accumulate
+                    if (escSeq === '\x1b[0m') {
+                        currentStyle = prefixStyle;
+                    }
+                    else {
+                        currentStyle += escSeq;
+                    }
+                    i = escEnd + 1;
+                }
+                else {
+                    i++;
+                }
+            }
+            else {
+                // Regular character
+                if (col < this.width) {
+                    this.buffer[y][col] = { char: text[i], style: currentStyle };
+                    col++;
+                }
+                i++;
+            }
+        }
+    }
+    /**
+     * Write multiple lines starting at y
+     */
+    writeLines(startY, lines, textStyle = '') {
+        let y = startY;
+        for (const line of lines) {
+            if (y >= this.height)
+                break;
+            this.writeLine(y, line, textStyle);
+            y++;
+        }
+        return y; // Return next available line
+    }
+    /**
+     * Write text with word wrapping
+     */
+    writeWrapped(x, y, text, maxWidth, textStyle = '') {
+        const words = text.split(' ');
+        let line = '';
+        let lineLength = 0;
+        let currentY = y;
+        for (const word of words) {
+            const wordLength = visibleLength(word);
+            if (lineLength + wordLength + 1 > maxWidth && line) {
+                this.write(x, currentY, line, textStyle);
+                currentY++;
+                if (currentY >= this.height)
+                    break;
+                line = word;
+                lineLength = wordLength;
+            }
+            else {
+                line += (line ? ' ' : '') + word;
+                lineLength += wordLength + (line.length > wordLength ? 1 : 0);
+            }
+        }
+        if (line && currentY < this.height) {
+            this.write(x, currentY, line, textStyle);
+            currentY++;
+        }
+        return currentY; // Return next available line
+    }
+    /**
+     * Draw a horizontal line
+     */
+    horizontalLine(y, char = '─', textStyle = '') {
+        const line = char.repeat(this.width);
+        this.writeLine(y, line, textStyle);
+    }
+    /**
+     * Set cursor position for input
+     */
+    setCursor(x, y) {
+        this.cursorX = Math.max(0, Math.min(x, this.width - 1));
+        this.cursorY = Math.max(0, Math.min(y, this.height - 1));
+    }
+    /**
+     * Show/hide cursor
+     */
+    showCursor(visible) {
+        this.cursorVisible = visible;
+    }
+    /**
+     * Render only changed cells (diff render)
+     */
+    render() {
+        let output = '';
+        let lastStyle = '';
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                const cell = this.buffer[y][x];
+                const renderedCell = this.rendered[y][x];
+                // Skip if unchanged
+                if (cell.char === renderedCell.char && cell.style === renderedCell.style) {
+                    continue;
+                }
+                // Move cursor and write
+                output += cursor.to(y + 1, x + 1);
+                if (cell.style !== lastStyle) {
+                    output += style.reset + cell.style;
+                    lastStyle = cell.style;
+                }
+                output += cell.char;
+                // Update rendered buffer
+                this.rendered[y][x] = { ...cell };
+            }
+        }
+        // Reset style and position cursor
+        output += style.reset;
+        output += cursor.to(this.cursorY + 1, this.cursorX + 1);
+        output += this.cursorVisible ? cursor.show : cursor.hide;
+        if (output) {
+            process.stdout.write(output);
+        }
+    }
+    /**
+     * Full render (no diff, redraw everything)
+     */
+    fullRender() {
+        let output = cursor.hide + cursor.home;
+        let lastStyle = '';
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                const cell = this.buffer[y][x];
+                if (cell.style !== lastStyle) {
+                    output += style.reset + cell.style;
+                    lastStyle = cell.style;
+                }
+                output += cell.char;
+                // Update rendered buffer
+                this.rendered[y][x] = { ...cell };
+            }
+            // Don't add newline after last row
+            if (y < this.height - 1) {
+                output += '\r\n';
+            }
+        }
+        // Reset style and position cursor
+        output += style.reset;
+        output += cursor.to(this.cursorY + 1, this.cursorX + 1);
+        output += this.cursorVisible ? cursor.show : cursor.hide;
+        process.stdout.write(output);
+    }
+    /**
+     * Initialize screen (hide cursor, clear)
+     */
+    init() {
+        process.stdout.write(cursor.hide + screen.clear + cursor.home);
+    }
+    /**
+     * Cleanup (show cursor, clear)
+     */
+    cleanup() {
+        process.stdout.write(style.reset + screen.clear + cursor.home + cursor.show);
+    }
+}

package/dist/renderer/ansi.d.ts

@@ -0,0 +1,99 @@
+/**
+ * ANSI escape codes for terminal control
+ * Low-level building blocks for custom renderer
+ */
+export declare const cursor: {
+    hide: string;
+    show: string;
+    home: string;
+    to: (row: number, col: number) => string;
+    up: (n?: number) => string;
+    down: (n?: number) => string;
+    right: (n?: number) => string;
+    left: (n?: number) => string;
+    save: string;
+    restore: string;
+    getPosition: string;
+};
+export declare const screen: {
+    clear: string;
+    clearLine: string;
+    clearToEnd: string;
+    clearToLineEnd: string;
+    setScrollRegion: (top: number, bottom: number) => string;
+    resetScrollRegion: string;
+    enterAltBuffer: string;
+    exitAltBuffer: string;
+};
+export declare const fg: {
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+    color256: (n: number) => string;
+    rgb: (r: number, g: number, b: number) => string;
+};
+export declare const bg: {
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    color256: (n: number) => string;
+    rgb: (r: number, g: number, b: number) => string;
+};
+export declare const style: {
+    reset: string;
+    bold: string;
+    dim: string;
+    italic: string;
+    underline: string;
+    blink: string;
+    inverse: string;
+    hidden: string;
+    strikethrough: string;
+    resetBold: string;
+    resetDim: string;
+    resetItalic: string;
+    resetUnderline: string;
+    resetBlink: string;
+    resetInverse: string;
+    resetHidden: string;
+    resetStrikethrough: string;
+};
+/**
+ * Helper to create styled text
+ */
+export declare function styled(text: string, ...styles: string[]): string;
+/**
+ * Strip ANSI codes from string (for length calculation)
+ */
+export declare function stripAnsi(str: string): string;
+/**
+ * Get visible length of string (excluding ANSI codes)
+ */
+export declare function visibleLength(str: string): number;
+/**
+ * Truncate string to visible length, preserving ANSI codes
+ */
+export declare function truncate(str: string, maxLength: number, suffix?: string): string;
+/**
+ * Wrap text to fit width, respecting ANSI codes
+ */
+export declare function wordWrap(str: string, width: number): string[];

package/dist/renderer/ansi.js

@@ -0,0 +1,176 @@
+/**
+ * ANSI escape codes for terminal control
+ * Low-level building blocks for custom renderer
+ */
+// Cursor control
+export const cursor = {
+    hide: '\x1b[?25l',
+    show: '\x1b[?25h',
+    home: '\x1b[H',
+    // Move cursor to position (1-indexed)
+    to: (row, col) => `\x1b[${row};${col}H`,
+    // Move cursor relative
+    up: (n = 1) => `\x1b[${n}A`,
+    down: (n = 1) => `\x1b[${n}B`,
+    right: (n = 1) => `\x1b[${n}C`,
+    left: (n = 1) => `\x1b[${n}D`,
+    // Save/restore position
+    save: '\x1b[s',
+    restore: '\x1b[u',
+    // Get position (requires reading response)
+    getPosition: '\x1b[6n',
+};
+// Screen control
+export const screen = {
+    clear: '\x1b[2J',
+    clearLine: '\x1b[2K',
+    clearToEnd: '\x1b[J',
+    clearToLineEnd: '\x1b[K',
+    // Scroll region
+    setScrollRegion: (top, bottom) => `\x1b[${top};${bottom}r`,
+    resetScrollRegion: '\x1b[r',
+    // Alternative screen buffer (like vim uses)
+    enterAltBuffer: '\x1b[?1049h',
+    exitAltBuffer: '\x1b[?1049l',
+};
+// Colors - basic 16 colors
+export const fg = {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+    // Bright variants
+    brightRed: '\x1b[91m',
+    brightGreen: '\x1b[92m',
+    brightYellow: '\x1b[93m',
+    brightBlue: '\x1b[94m',
+    brightMagenta: '\x1b[95m',
+    brightCyan: '\x1b[96m',
+    brightWhite: '\x1b[97m',
+    // 256 color
+    color256: (n) => `\x1b[38;5;${n}m`,
+    // RGB
+    rgb: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
+};
+export const bg = {
+    black: '\x1b[40m',
+    red: '\x1b[41m',
+    green: '\x1b[42m',
+    yellow: '\x1b[43m',
+    blue: '\x1b[44m',
+    magenta: '\x1b[45m',
+    cyan: '\x1b[46m',
+    white: '\x1b[47m',
+    gray: '\x1b[100m',
+    // 256 color
+    color256: (n) => `\x1b[48;5;${n}m`,
+    // RGB
+    rgb: (r, g, b) => `\x1b[48;2;${r};${g};${b}m`,
+};
+// Text styles
+export const style = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    underline: '\x1b[4m',
+    blink: '\x1b[5m',
+    inverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+    strikethrough: '\x1b[9m',
+    // Reset specific
+    resetBold: '\x1b[22m',
+    resetDim: '\x1b[22m',
+    resetItalic: '\x1b[23m',
+    resetUnderline: '\x1b[24m',
+    resetBlink: '\x1b[25m',
+    resetInverse: '\x1b[27m',
+    resetHidden: '\x1b[28m',
+    resetStrikethrough: '\x1b[29m',
+};
+/**
+ * Helper to create styled text
+ */
+export function styled(text, ...styles) {
+    if (styles.length === 0)
+        return text;
+    return styles.join('') + text + style.reset;
+}
+/**
+ * Strip ANSI codes from string (for length calculation)
+ */
+export function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+/**
+ * Get visible length of string (excluding ANSI codes)
+ */
+export function visibleLength(str) {
+    return stripAnsi(str).length;
+}
+/**
+ * Truncate string to visible length, preserving ANSI codes
+ */
+export function truncate(str, maxLength, suffix = '...') {
+    const visible = stripAnsi(str);
+    if (visible.length <= maxLength)
+        return str;
+    // Simple truncation - may cut ANSI codes
+    // For proper handling, we'd need to parse ANSI sequences
+    let visibleCount = 0;
+    let result = '';
+    let inEscape = false;
+    for (const char of str) {
+        if (char === '\x1b') {
+            inEscape = true;
+            result += char;
+        }
+        else if (inEscape) {
+            result += char;
+            if (char.match(/[a-zA-Z]/)) {
+                inEscape = false;
+            }
+        }
+        else {
+            if (visibleCount < maxLength - suffix.length) {
+                result += char;
+                visibleCount++;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    return result + style.reset + suffix;
+}
+/**
+ * Wrap text to fit width, respecting ANSI codes
+ */
+export function wordWrap(str, width) {
+    const lines = [];
+    const words = str.split(' ');
+    let currentLine = '';
+    let currentLength = 0;
+    for (const word of words) {
+        const wordLength = visibleLength(word);
+        if (currentLength + wordLength + 1 > width && currentLine) {
+            lines.push(currentLine);
+            currentLine = word;
+            currentLength = wordLength;
+        }
+        else {
+            currentLine += (currentLine ? ' ' : '') + word;
+            currentLength += wordLength + (currentLine ? 1 : 0);
+        }
+    }
+    if (currentLine) {
+        lines.push(currentLine);
+    }
+    return lines;
+}

package/dist/renderer/components/Box.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Box drawing utilities for borders, frames, modals
+ */
+export declare const boxChars: {
+    single: {
+        topLeft: string;
+        topRight: string;
+        bottomLeft: string;
+        bottomRight: string;
+        horizontal: string;
+        vertical: string;
+    };
+    double: {
+        topLeft: string;
+        topRight: string;
+        bottomLeft: string;
+        bottomRight: string;
+        horizontal: string;
+        vertical: string;
+    };
+    rounded: {
+        topLeft: string;
+        topRight: string;
+        bottomLeft: string;
+        bottomRight: string;
+        horizontal: string;
+        vertical: string;
+    };
+    heavy: {
+        topLeft: string;
+        topRight: string;
+        bottomLeft: string;
+        bottomRight: string;
+        horizontal: string;
+        vertical: string;
+    };
+};
+export type BoxStyle = keyof typeof boxChars;
+export interface BoxOptions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    style?: BoxStyle;
+    title?: string;
+    titleAlign?: 'left' | 'center' | 'right';
+    borderColor?: string;
+    titleColor?: string;
+}
+/**
+ * Generate box lines for rendering
+ */
+export declare function createBox(options: BoxOptions): Array<{
+    y: number;
+    text: string;
+    style: string;
+}>;
+/**
+ * Center a box on screen
+ */
+export declare function centerBox(screenWidth: number, screenHeight: number, boxWidth: number, boxHeight: number): {
+    x: number;
+    y: number;
+};

package/dist/renderer/components/Box.js

@@ -0,0 +1,90 @@
+/**
+ * Box drawing utilities for borders, frames, modals
+ */
+// Box drawing characters (Unicode)
+export const boxChars = {
+    // Single line
+    single: {
+        topLeft: '┌',
+        topRight: '┐',
+        bottomLeft: '└',
+        bottomRight: '┘',
+        horizontal: '─',
+        vertical: '│',
+    },
+    // Double line
+    double: {
+        topLeft: '╔',
+        topRight: '╗',
+        bottomLeft: '╚',
+        bottomRight: '╝',
+        horizontal: '═',
+        vertical: '║',
+    },
+    // Rounded
+    rounded: {
+        topLeft: '╭',
+        topRight: '╮',
+        bottomLeft: '╰',
+        bottomRight: '╯',
+        horizontal: '─',
+        vertical: '│',
+    },
+    // Heavy
+    heavy: {
+        topLeft: '┏',
+        topRight: '┓',
+        bottomLeft: '┗',
+        bottomRight: '┛',
+        horizontal: '━',
+        vertical: '┃',
+    },
+};
+/**
+ * Generate box lines for rendering
+ */
+export function createBox(options) {
+    const { x, y, width, height, style: boxStyle = 'single', title, titleAlign = 'center', borderColor = '', titleColor = '', } = options;
+    const chars = boxChars[boxStyle];
+    const lines = [];
+    // Top border with optional title
+    let topLine = chars.topLeft + chars.horizontal.repeat(width - 2) + chars.topRight;
+    if (title && width > 4) {
+        const maxTitleLen = width - 4;
+        const displayTitle = title.length > maxTitleLen ? title.slice(0, maxTitleLen - 1) + '…' : title;
+        const titleWithPadding = ` ${displayTitle} `;
+        let titlePos;
+        if (titleAlign === 'left') {
+            titlePos = 2;
+        }
+        else if (titleAlign === 'right') {
+            titlePos = width - titleWithPadding.length - 2;
+        }
+        else {
+            titlePos = Math.floor((width - titleWithPadding.length) / 2);
+        }
+        // Insert title into top line
+        const before = chars.topLeft + chars.horizontal.repeat(titlePos - 1);
+        const after = chars.horizontal.repeat(width - titlePos - titleWithPadding.length - 1) + chars.topRight;
+        topLine = before + (titleColor || borderColor) + titleWithPadding + borderColor + after;
+    }
+    lines.push({ y, text: ' '.repeat(x) + topLine, style: borderColor });
+    // Middle lines (empty content area)
+    const emptyLine = chars.vertical + ' '.repeat(width - 2) + chars.vertical;
+    for (let row = 1; row < height - 1; row++) {
+        lines.push({ y: y + row, text: ' '.repeat(x) + emptyLine, style: borderColor });
+    }
+    // Bottom border
+    const bottomLine = chars.bottomLeft + chars.horizontal.repeat(width - 2) + chars.bottomRight;
+    lines.push({ y: y + height - 1, text: ' '.repeat(x) + bottomLine, style: borderColor });
+    return lines;
+}
+/**
+ * Center a box on screen
+ */
+export function centerBox(screenWidth, screenHeight, boxWidth, boxHeight) {
+    return {
+        x: Math.floor((screenWidth - boxWidth) / 2),
+        y: Math.floor((screenHeight - boxHeight) / 2),
+    };
+}