centaurus-cli 3.0.1 → 3.1.0

package/dist/utils/syntax-checker.js.map

@@ -1 +1 @@
-{"version":3,"file":"syntax-checker.js","sourceRoot":"","sources":["../../src/utils/syntax-checker.ts"],"names":[],"mappings":"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"}
+{"version":3,"sources":["../../src/utils/syntax-checker.ts"],"sourcesContent":["import * as vm from 'vm';\r\nimport * as path from 'path';\r\nimport * as fs from 'fs';\r\nimport { spawn } from 'child_process';\r\nimport * as ts from 'typescript';\r\n\r\n/**\r\n * Result of a syntax check operation\r\n */\r\nexport interface SyntaxCheckResult {\r\n    success: boolean;\r\n    language: string;\r\n    error?: string;\r\n    skipped?: boolean;\r\n    skipReason?: string;\r\n}\r\n\r\n/**\r\n * File extension to language mapping\r\n */\r\nconst LANGUAGE_MAP: Record<string, string> = {\r\n    // JavaScript\r\n    '.js': 'javascript',\r\n    '.mjs': 'javascript',\r\n    '.cjs': 'javascript',\r\n    '.jsx': 'javascript',\r\n\r\n    // TypeScript\r\n    '.ts': 'typescript',\r\n    '.tsx': 'typescript',\r\n    '.mts': 'typescript',\r\n    '.cts': 'typescript',\r\n\r\n    // Python\r\n    '.py': 'python',\r\n    '.pyw': 'python',\r\n\r\n    // JSON\r\n    '.json': 'json',\r\n    '.jsonc': 'json',\r\n\r\n    // Skip syntax checking for these (text/markup/config)\r\n    '.txt': 'text',\r\n    '.md': 'markdown',\r\n    '.markdown': 'markdown',\r\n    '.log': 'log',\r\n    '.csv': 'csv',\r\n    '.html': 'html',\r\n    '.htm': 'html',\r\n    '.css': 'css',\r\n    '.scss': 'scss',\r\n    '.sass': 'sass',\r\n    '.less': 'less',\r\n    '.xml': 'xml',\r\n    '.yaml': 'yaml',\r\n    '.yml': 'yaml',\r\n    '.toml': 'toml',\r\n    '.ini': 'ini',\r\n    '.cfg': 'config',\r\n    '.conf': 'config',\r\n    '.env': 'env',\r\n    '.gitignore': 'gitignore',\r\n    '.dockerignore': 'dockerignore',\r\n    '.editorconfig': 'config',\r\n    '.prettierrc': 'config',\r\n    '.eslintrc': 'config',\r\n    '.babelrc': 'config',\r\n};\r\n\r\n/**\r\n * Languages that should skip syntax checking\r\n */\r\nconst SKIP_SYNTAX_CHECK = new Set([\r\n    'text',\r\n    'markdown',\r\n    'log',\r\n    'csv',\r\n    'html',\r\n    'css',\r\n    'scss',\r\n    'sass',\r\n    'less',\r\n    'xml',\r\n    'yaml',\r\n    'toml',\r\n    'ini',\r\n    'config',\r\n    'env',\r\n    'gitignore',\r\n    'dockerignore',\r\n]);\r\n\r\n/**\r\n * Detect language from file path\r\n */\r\nexport function detectLanguage(filePath: string): string {\r\n    const ext = path.extname(filePath).toLowerCase();\r\n    const basename = path.basename(filePath).toLowerCase();\r\n\r\n    // Check for special filenames without extensions\r\n    if (!ext) {\r\n        // Common config files without extensions\r\n        if (basename === 'dockerfile') return 'dockerfile';\r\n        if (basename === 'makefile') return 'makefile';\r\n        if (basename === '.gitignore') return 'gitignore';\r\n        if (basename === '.dockerignore') return 'dockerignore';\r\n        if (basename === '.env') return 'env';\r\n        return 'unknown';\r\n    }\r\n\r\n    return LANGUAGE_MAP[ext] || 'unknown';\r\n}\r\n\r\n/**\r\n * Check JavaScript syntax using vm.Script\r\n */\r\nfunction checkJavaScriptSyntax(content: string): SyntaxCheckResult {\r\n    try {\r\n        // Use vm.Script to parse and check syntax without execution\r\n        new vm.Script(content, { filename: 'syntax-check.js' });\r\n        return {\r\n            success: true,\r\n            language: 'JavaScript',\r\n        };\r\n    } catch (error) {\r\n        const err = error as Error;\r\n        return {\r\n            success: false,\r\n            language: 'JavaScript',\r\n            error: err.message,\r\n        };\r\n    }\r\n}\r\n\r\n/**\r\n * Check TypeScript syntax using the TypeScript compiler API\r\n */\r\nfunction checkTypeScriptSyntax(content: string, filePath: string): SyntaxCheckResult {\r\n    try {\r\n        const isTsx = filePath.endsWith('.tsx');\r\n        const compilerOptions: ts.CompilerOptions = {\r\n            noEmit: true,\r\n            target: ts.ScriptTarget.ESNext,\r\n            module: ts.ModuleKind.ESNext,\r\n            jsx: isTsx ? ts.JsxEmit.React : undefined,\r\n            strict: false, // Don't enforce strict mode for syntax checking\r\n            skipLibCheck: true,\r\n            allowJs: true,\r\n        };\r\n\r\n        // Create a simple in-memory source file\r\n        const sourceFile = ts.createSourceFile(\r\n            filePath,\r\n            content,\r\n            ts.ScriptTarget.ESNext,\r\n            true,\r\n            isTsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS\r\n        );\r\n\r\n        // Check for parse errors (syntax errors)\r\n        const parseErrors: string[] = [];\r\n\r\n        // Walk through the source file to find syntax errors\r\n        // TypeScript's createSourceFile doesn't throw on syntax errors,\r\n        // but we can check for diagnostic messages\r\n        const parseDiagnostics = (sourceFile as any).parseDiagnostics;\r\n        if (parseDiagnostics && parseDiagnostics.length > 0) {\r\n            for (const diag of parseDiagnostics) {\r\n                const message = ts.flattenDiagnosticMessageText(diag.messageText, '\\n');\r\n                const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diag.start || 0);\r\n                parseErrors.push(`Line ${lineAndChar.line + 1}: ${message}`);\r\n            }\r\n        }\r\n\r\n        if (parseErrors.length > 0) {\r\n            return {\r\n                success: false,\r\n                language: 'TypeScript',\r\n                error: parseErrors.join('\\n'),\r\n            };\r\n        }\r\n\r\n        return {\r\n            success: true,\r\n            language: 'TypeScript',\r\n        };\r\n    } catch (error) {\r\n        const err = error as Error;\r\n        return {\r\n            success: false,\r\n            language: 'TypeScript',\r\n            error: err.message,\r\n        };\r\n    }\r\n}\r\n\r\n/**\r\n * Check Python syntax using the py_compile module\r\n */\r\nasync function checkPythonSyntax(filePath: string): Promise<SyntaxCheckResult> {\r\n    return new Promise((resolve) => {\r\n        // Use python -m py_compile to check syntax\r\n        const pythonCommands = process.platform === 'win32'\r\n            ? ['python', 'python3', 'py']\r\n            : ['python3', 'python'];\r\n\r\n        let attemptIndex = 0;\r\n\r\n        const tryNextCommand = () => {\r\n            if (attemptIndex >= pythonCommands.length) {\r\n                // No Python found\r\n                resolve({\r\n                    success: true,\r\n                    language: 'Python',\r\n                    skipped: true,\r\n                    skipReason: 'Python interpreter not found. Syntax check skipped.',\r\n                });\r\n                return;\r\n            }\r\n\r\n            const pythonCmd = pythonCommands[attemptIndex];\r\n            attemptIndex++;\r\n\r\n            const proc = spawn(pythonCmd, ['-m', 'py_compile', filePath], {\r\n                stdio: ['pipe', 'pipe', 'pipe'],\r\n                timeout: 5000, // 5 second timeout\r\n            });\r\n\r\n            // Close stdin to prevent hanging if python expects input\r\n            proc.stdin.end();\r\n\r\n            let stderr = '';\r\n            let timeoutTriggered = false;\r\n\r\n            // Enforce hard timeout and SIGKILL if it hangs\r\n            const timeoutTimer = setTimeout(() => {\r\n                timeoutTriggered = true;\r\n                proc.kill('SIGKILL');\r\n            }, 5000);\r\n\r\n            proc.stderr.on('data', (data) => {\r\n                stderr += data.toString();\r\n            });\r\n\r\n            proc.on('error', () => {\r\n                clearTimeout(timeoutTimer);\r\n                if (timeoutTriggered) {\r\n                    resolve({\r\n                        success: false,\r\n                        language: 'Python',\r\n                        error: 'Syntax check timed out after 5 seconds',\r\n                    });\r\n                    return;\r\n                }\r\n                // This python command failed, try next\r\n                tryNextCommand();\r\n            });\r\n\r\n            proc.on('close', (code) => {\r\n                clearTimeout(timeoutTimer);\r\n\r\n                if (timeoutTriggered) {\r\n                    resolve({\r\n                        success: false,\r\n                        language: 'Python',\r\n                        error: 'Syntax check timed out after 5 seconds',\r\n                    });\r\n                    return;\r\n                }\r\n\r\n                if (code === 0) {\r\n                    resolve({\r\n                        success: true,\r\n                        language: 'Python',\r\n                    });\r\n                } else {\r\n                    // Parse the error message\r\n                    const errorLines = stderr.trim().split('\\n');\r\n                    const relevantError = errorLines.length > 0\r\n                        ? errorLines[errorLines.length - 1]\r\n                        : 'Syntax error detected';\r\n\r\n                    resolve({\r\n                        success: false,\r\n                        language: 'Python',\r\n                        error: relevantError,\r\n                    });\r\n                }\r\n            });\r\n        };\r\n\r\n        tryNextCommand();\r\n    });\r\n}\r\n\r\n/**\r\n * Check JSON syntax using JSON.parse\r\n */\r\nfunction checkJsonSyntax(content: string): SyntaxCheckResult {\r\n    try {\r\n        JSON.parse(content);\r\n        return {\r\n            success: true,\r\n            language: 'JSON',\r\n        };\r\n    } catch (error) {\r\n        const err = error as SyntaxError;\r\n        return {\r\n            success: false,\r\n            language: 'JSON',\r\n            error: err.message,\r\n        };\r\n    }\r\n}\r\n\r\n/**\r\n * Main syntax check function\r\n * Checks the syntax of a file based on its extension\r\n */\r\nexport async function checkSyntax(filePath: string, content?: string): Promise<SyntaxCheckResult> {\r\n    const language = detectLanguage(filePath);\r\n\r\n    // Skip syntax checking for text/config files\r\n    if (SKIP_SYNTAX_CHECK.has(language)) {\r\n        return {\r\n            success: true,\r\n            language: language.charAt(0).toUpperCase() + language.slice(1),\r\n            skipped: true,\r\n            skipReason: `Syntax check skipped for ${language} files`,\r\n        };\r\n    }\r\n\r\n    // Skip unknown file types\r\n    if (language === 'unknown') {\r\n        return {\r\n            success: true,\r\n            language: 'Unknown',\r\n            skipped: true,\r\n            skipReason: 'Syntax check skipped for unknown file type',\r\n        };\r\n    }\r\n\r\n    // Read content from file if not provided\r\n    let fileContent = content;\r\n    if (!fileContent) {\r\n        try {\r\n            fileContent = fs.readFileSync(filePath, 'utf-8');\r\n        } catch (error) {\r\n            return {\r\n                success: true,\r\n                language: language.charAt(0).toUpperCase() + language.slice(1),\r\n                skipped: true,\r\n                skipReason: 'Could not read file for syntax check',\r\n            };\r\n        }\r\n    }\r\n\r\n    // Perform language-specific syntax check\r\n    switch (language) {\r\n        case 'javascript':\r\n            return checkJavaScriptSyntax(fileContent);\r\n\r\n        case 'typescript':\r\n            return checkTypeScriptSyntax(fileContent, filePath);\r\n\r\n        case 'python':\r\n            // Python requires the file to be on disk for py_compile\r\n            return await checkPythonSyntax(filePath);\r\n\r\n        case 'json':\r\n            return checkJsonSyntax(fileContent);\r\n\r\n        default:\r\n            return {\r\n                success: true,\r\n                language: language.charAt(0).toUpperCase() + language.slice(1),\r\n                skipped: true,\r\n                skipReason: `Syntax check not implemented for ${language}`,\r\n            };\r\n    }\r\n}\r\n\r\n/**\r\n * Format syntax check result as a human-readable string\r\n */\r\nexport function formatSyntaxCheckResult(result: SyntaxCheckResult): string {\r\n    if (result.skipped) {\r\n        return `(${result.skipReason})`;\r\n    }\r\n\r\n    if (result.success) {\r\n        return `✓ Syntax check passed (${result.language})`;\r\n    }\r\n\r\n    return `✗ Syntax error (${result.language}): ${result.error}`;\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/utils/terminal-output.js

@@ -1,313 +1,210 @@
-/**
- * Utility for processing terminal output with proper carriage return handling.
- *
- * When commands output text with \r (carriage return), it means "go back to the start
- * of the line" - used for spinners, progress bars, and other dynamic output.
- *
- * This module provides functions to correctly process such output so that only the
- * final rendered state is preserved (not intermediate states that should be overwritten).
- */
-/**
- * Process terminal output to properly handle carriage returns and ANSI sequences.
- *
- * This function simulates how a terminal would render the output:
- * - \r (carriage return) moves cursor to the start of the line
- * - \x1b[H (cursor home) also moves cursor to start - PTY uses this instead of \r
- * - Subsequent text overwrites from the beginning
- * - ANSI cursor sequences are handled appropriately
- *
- * @param raw - Raw terminal output with potential \r and ANSI sequences
- * @returns Processed output with only the final rendered state
- */
-export function processTerminalOutput(raw, options) {
-    if (!raw)
-        return '';
-    const SCREEN_ROWS = 500;
-    const MAX_CURSOR_ROW = 10000;
-    const MAX_CURSOR_COL = 1000;
-    // const SCREEN_COLS = 200; // Dynamic columns not needed for array-based storage
-    // Initialize screen buffer - array of arrays of Cells
-    // We use a sparse approach: rows are created as needed
-    const screen = [];
-    // Ensure initial rows exist
-    for (let i = 0; i < SCREEN_ROWS; i++) {
-        screen[i] = [];
-    }
-    let cursorRow = 0;
-    let cursorCol = 0;
-    let maxRowUsed = 0;
-    let currentStyle = ''; // Current accumulated ANSI style sequence
-    // Pre-processing: Strip only non-SGR sequences that we don't handle
-    // We keep \x1b[...m (SGR) for colors
-    let input = raw
-        // OSC sequences (\x1b] ... \x07 or \x1b\) - Robustly consume until terminator
-        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
-        // Character set designations (e.g. \x1b(0)
-        .replace(/\x1b[()#][0-9A-Za-z]/g, '')
-        // BEL and Form Feed (ignore for layout)
-        .replace(/\x07/g, '')
-        .replace(/\x0C/g, '')
-        // DEL
-        .replace(/\x7F/g, '');
-    let i = 0;
-    while (i < input.length) {
-        // Check for escape sequences
-        if (input[i] === '\x1b') {
-            // Check for CSI sequence: ESC [
-            if (i + 1 < input.length && input[i + 1] === '[') {
-                let j = i + 2;
-                // 1. Parameter Bytes (0x30-0x3F): 0-9:;<=>?
-                // These includes digits, semicolons, and private mode markers like ? and >
-                let params = '';
-                while (j < input.length && input.charCodeAt(j) >= 0x30 && input.charCodeAt(j) <= 0x3F) {
-                    params += input[j];
-                    j++;
-                }
-                // 2. Intermediate Bytes (0x20-0x2F):  !"#$%&'()*+,-./
-                while (j < input.length && input.charCodeAt(j) >= 0x20 && input.charCodeAt(j) <= 0x2F) {
-                    // We consume but ignore intermediates for now as we don't support them
-                    j++;
+function processTerminalOutput(raw, options) {
+  if (!raw) return "";
+  const SCREEN_ROWS = 500;
+  const MAX_CURSOR_ROW = 1e4;
+  const MAX_CURSOR_COL = 1e3;
+  const screen = [];
+  for (let i2 = 0; i2 < SCREEN_ROWS; i2++) {
+    screen[i2] = [];
+  }
+  let cursorRow = 0;
+  let cursorCol = 0;
+  let maxRowUsed = 0;
+  let currentStyle = "";
+  let input = raw.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b[()#][0-9A-Za-z]/g, "").replace(/\x07/g, "").replace(/\x0C/g, "").replace(/\x7F/g, "");
+  let i = 0;
+  while (i < input.length) {
+    if (input[i] === "\x1B") {
+      if (i + 1 < input.length && input[i + 1] === "[") {
+        let j = i + 2;
+        let params = "";
+        while (j < input.length && input.charCodeAt(j) >= 48 && input.charCodeAt(j) <= 63) {
+          params += input[j];
+          j++;
+        }
+        while (j < input.length && input.charCodeAt(j) >= 32 && input.charCodeAt(j) <= 47) {
+          j++;
+        }
+        if (j < input.length && input.charCodeAt(j) >= 64 && input.charCodeAt(j) <= 126) {
+          const cmd = input[j];
+          const cleanParams = params.replace(/[<>=?]/g, "");
+          const numbers = cleanParams.split(";").map((s) => parseInt(s) || 0);
+          const n = numbers[0] || 1;
+          const m = numbers[1] || 1;
+          switch (cmd) {
+            case "m":
+              if (params === "" || params === "0" || cleanParams === "0" && numbers.length === 1) {
+                currentStyle = "";
+              } else {
+                if (numbers.includes(0)) {
+                  currentStyle = `\x1B[${cleanParams}m`;
+                } else {
+                  currentStyle += `\x1B[${cleanParams}m`;
                 }
-                // 3. Final Byte (0x40-0x7E): @A-Z[\]^_`a-z{|}~
-                if (j < input.length && input.charCodeAt(j) >= 0x40 && input.charCodeAt(j) <= 0x7E) {
-                    const cmd = input[j];
-                    // Parse parameters only if they exist and aren't just private markers
-                    // We filter out ?, > etc for the numeric splitting to avoid NaN
-                    // but keep them in 'params' string for detection if needed.
-                    const cleanParams = params.replace(/[<>=?]/g, '');
-                    const numbers = cleanParams.split(';').map(s => parseInt(s) || 0);
-                    // Default to 1 if missing, for most commands (1-based)
-                    const n = numbers[0] || 1;
-                    const m = numbers[1] || 1;
-                    // Handle supported commands
-                    switch (cmd) {
-                        case 'm': // SGR - Select Graphic Rendition (Colors)
-                            if (params === '' || params === '0' || (cleanParams === '0' && numbers.length === 1)) {
-                                currentStyle = ''; // Reset
-                            }
-                            else {
-                                // Add to current style. 
-                                // Ideally we should be smarter about merging, but appending works.
-                                if (numbers.includes(0)) {
-                                    // If sequence contains reset (e.g. 0;1;31), we treat it as reset + others.
-                                    // For simplicity, we just take the whole sequence as the new style 
-                                    // since it usually starts with 0 if 0 is present.
-                                    currentStyle = `\x1b[${cleanParams}m`;
-                                }
-                                else {
-                                    currentStyle += `\x1b[${cleanParams}m`;
-                                }
-                            }
-                            break;
-                        case 'H': // CUP - Cursor Position
-                        case 'f': // HVP - Horizontal and Vertical Position
-                            // Defaults are 1,1
-                            cursorRow = Math.min(MAX_CURSOR_ROW, Math.max(0, (numbers[0] || 1) - 1));
-                            cursorCol = Math.min(MAX_CURSOR_COL, Math.max(0, (numbers[1] || 1) - 1));
-                            break;
-                        case 'A': // CUU - Cursor Up
-                            cursorRow = Math.max(0, cursorRow - n);
-                            break;
-                        case 'B': // CUD - Cursor Down
-                        case 'e': // VPR - Vertical Position Relative
-                            cursorRow = Math.min(MAX_CURSOR_ROW, cursorRow + n);
-                            break;
-                        case 'C': // CUF - Cursor Forward
-                        case 'a': // HPR - Horizontal Position Relative
-                            cursorCol = Math.min(MAX_CURSOR_COL, cursorCol + n);
-                            break;
-                        case 'D': // CUB - Cursor Back
-                            cursorCol = Math.max(0, cursorCol - n);
-                            break;
-                        case 'E': // CNL - Cursor Next Line
-                            cursorRow = Math.min(MAX_CURSOR_ROW, cursorRow + n);
-                            cursorCol = 0;
-                            break;
-                        case 'F': // CPL - Cursor Preceding Line
-                            cursorRow = Math.max(0, cursorRow - n);
-                            cursorCol = 0;
-                            break;
-                        case 'G': // CHA - Cursor Horizontal Absolute
-                            cursorCol = Math.min(MAX_CURSOR_COL, Math.max(0, n - 1));
-                            break;
-                        case 'd': // VPA - Vertical Position Absolute
-                            cursorRow = Math.min(MAX_CURSOR_ROW, Math.max(0, n - 1));
-                            break;
-                        case 'K': // EL - Erase in Line
-                            {
-                                const mode = numbers[0] || 0;
-                                if (!screen[cursorRow])
-                                    screen[cursorRow] = [];
-                                if (mode === 0) { // Cursor to end
-                                    screen[cursorRow].splice(cursorCol);
-                                }
-                                else if (mode === 1) { // Start to cursor
-                                    for (let k = 0; k <= cursorCol; k++) {
-                                        if (k < screen[cursorRow].length) {
-                                            screen[cursorRow][k] = { char: ' ', style: '' };
-                                        }
-                                    }
-                                }
-                                else if (mode === 2) { // Entire line
-                                    screen[cursorRow] = [];
-                                }
-                            }
-                            break;
-                        case 'J': // ED - Erase in Display
-                            {
-                                const mode = numbers[0] || 0;
-                                if (mode === 0) {
-                                    // Erase from cursor to end of display
-                                    if (screen[cursorRow])
-                                        screen[cursorRow].splice(cursorCol);
-                                    for (let r = cursorRow + 1; r <= maxRowUsed; r++) {
-                                        screen[r] = [];
-                                    }
-                                    maxRowUsed = cursorRow;
-                                }
-                                else if (mode === 1) {
-                                    // Erase from start of display to cursor
-                                    for (let r = 0; r < cursorRow; r++) {
-                                        screen[r] = [];
-                                    }
-                                    if (screen[cursorRow]) {
-                                        for (let c = 0; c <= cursorCol; c++) {
-                                            if (c < screen[cursorRow].length) {
-                                                screen[cursorRow][c] = { char: ' ', style: '' };
-                                            }
-                                        }
-                                    }
-                                }
-                                else if (mode === 2 || mode === 3) {
-                                    // Erase entire display (2) or erase display + scrollback (3)
-                                    for (let r = 0; r <= maxRowUsed; r++) {
-                                        screen[r] = [];
-                                    }
-                                    maxRowUsed = cursorRow;
-                                }
-                            }
-                            break;
-                        // P (DCH), @ (ICH), L (IL), M (DL) - Delete/Insert characters/lines
-                        // These are complex to implement fully for a buffer-based approach without strict bounds.
-                        // For now we ignore them to avoid corruption, or we could implement simple versions.
-                        default:
-                            // Unknown command, we just consume it (which is the fix for the bug!)
-                            break;
+              }
+              break;
+            case "H":
+            // CUP - Cursor Position
+            case "f":
+              cursorRow = Math.min(MAX_CURSOR_ROW, Math.max(0, (numbers[0] || 1) - 1));
+              cursorCol = Math.min(MAX_CURSOR_COL, Math.max(0, (numbers[1] || 1) - 1));
+              break;
+            case "A":
+              cursorRow = Math.max(0, cursorRow - n);
+              break;
+            case "B":
+            // CUD - Cursor Down
+            case "e":
+              cursorRow = Math.min(MAX_CURSOR_ROW, cursorRow + n);
+              break;
+            case "C":
+            // CUF - Cursor Forward
+            case "a":
+              cursorCol = Math.min(MAX_CURSOR_COL, cursorCol + n);
+              break;
+            case "D":
+              cursorCol = Math.max(0, cursorCol - n);
+              break;
+            case "E":
+              cursorRow = Math.min(MAX_CURSOR_ROW, cursorRow + n);
+              cursorCol = 0;
+              break;
+            case "F":
+              cursorRow = Math.max(0, cursorRow - n);
+              cursorCol = 0;
+              break;
+            case "G":
+              cursorCol = Math.min(MAX_CURSOR_COL, Math.max(0, n - 1));
+              break;
+            case "d":
+              cursorRow = Math.min(MAX_CURSOR_ROW, Math.max(0, n - 1));
+              break;
+            case "K":
+              {
+                const mode = numbers[0] || 0;
+                if (!screen[cursorRow]) screen[cursorRow] = [];
+                if (mode === 0) {
+                  screen[cursorRow].splice(cursorCol);
+                } else if (mode === 1) {
+                  for (let k = 0; k <= cursorCol; k++) {
+                    if (k < screen[cursorRow].length) {
+                      screen[cursorRow][k] = { char: " ", style: "" };
                     }
-                    // Move past the final byte
-                    i = j + 1;
-                    continue;
+                  }
+                } else if (mode === 2) {
+                  screen[cursorRow] = [];
                 }
-                else {
-                    // Malformed CSI, treat as plain text if no final byte found? 
-                    // Or just consume what we found? 
-                    // ECMA-48 says if it doesn't end with 0x40-0x7E it's not a valid CSI?
-                    // But in practice we should probably just treat ESC as a char if not valid.
+              }
+              break;
+            case "J":
+              {
+                const mode = numbers[0] || 0;
+                if (mode === 0) {
+                  if (screen[cursorRow]) screen[cursorRow].splice(cursorCol);
+                  for (let r = cursorRow + 1; r <= maxRowUsed; r++) {
+                    screen[r] = [];
+                  }
+                  maxRowUsed = cursorRow;
+                } else if (mode === 1) {
+                  for (let r = 0; r < cursorRow; r++) {
+                    screen[r] = [];
+                  }
+                  if (screen[cursorRow]) {
+                    for (let c = 0; c <= cursorCol; c++) {
+                      if (c < screen[cursorRow].length) {
+                        screen[cursorRow][c] = { char: " ", style: "" };
+                      }
+                    }
+                  }
+                } else if (mode === 2 || mode === 3) {
+                  for (let r = 0; r <= maxRowUsed; r++) {
+                    screen[r] = [];
+                  }
+                  maxRowUsed = cursorRow;
                 }
-            }
-            // Check for simple ESC sequences (ESC X)
-            // e.g. ESC 7 (Save Cursor), ESC 8 (Restore Cursor), ESC M (Reverse Index)
-            else if (i + 1 < input.length) {
-                // Simple 2-char escape
-                const next = input[i + 1];
-                // If it is [ it is CSI (handled above)
-                // If not, we might want to handle some.
-                // However, the main bug is CSI parsing.
-                // Let's not be too aggressive with consuming other escapes unless we distinguish them.
-                // Valid simple escapes are usually 0x30-0x7E.
-            }
-        }
-        const char = input[i];
-        if (char === '\r') {
-            cursorCol = 0;
-        }
-        else if (char === '\n') {
-            cursorRow++;
-            cursorCol = 0;
-        }
-        else if (char === '\x08') { // Backspace
-            if (cursorCol > 0)
-                cursorCol--;
-        }
-        else if (char === '\t') {
-            cursorCol = Math.min(MAX_CURSOR_COL, Math.floor(cursorCol / 8 + 1) * 8);
-        }
-        else if (char >= ' ' || char === '\x00') {
-            if (char === '\x00') {
-                i++;
-                continue;
-            }
-            // Ensure row exists
-            while (cursorRow >= screen.length) {
-                screen.push([]);
-            }
-            if (!screen[cursorRow])
-                screen[cursorRow] = [];
-            // Pad with spaces if needed
-            while (screen[cursorRow].length < cursorCol) {
-                screen[cursorRow].push({ char: ' ', style: '' });
-            }
-            // Write cell with current style
-            screen[cursorRow][cursorCol] = { char: char, style: currentStyle };
-            cursorCol++;
-            if (cursorRow > maxRowUsed)
-                maxRowUsed = cursorRow;
+              }
+              break;
+            // P (DCH), @ (ICH), L (IL), M (DL) - Delete/Insert characters/lines
+            // These are complex to implement fully for a buffer-based approach without strict bounds.
+            // For now we ignore them to avoid corruption, or we could implement simple versions.
+            default:
+              break;
+          }
+          i = j + 1;
+          continue;
+        } else {
         }
+      } else if (i + 1 < input.length) {
+        const next = input[i + 1];
+      }
+    }
+    const char = input[i];
+    if (char === "\r") {
+      cursorCol = 0;
+    } else if (char === "\n") {
+      cursorRow++;
+      cursorCol = 0;
+    } else if (char === "\b") {
+      if (cursorCol > 0) cursorCol--;
+    } else if (char === "	") {
+      cursorCol = Math.min(MAX_CURSOR_COL, Math.floor(cursorCol / 8 + 1) * 8);
+    } else if (char >= " " || char === "\0") {
+      if (char === "\0") {
         i++;
+        continue;
+      }
+      while (cursorRow >= screen.length) {
+        screen.push([]);
+      }
+      if (!screen[cursorRow]) screen[cursorRow] = [];
+      while (screen[cursorRow].length < cursorCol) {
+        screen[cursorRow].push({ char: " ", style: "" });
+      }
+      screen[cursorRow][cursorCol] = { char, style: currentStyle };
+      cursorCol++;
+      if (cursorRow > maxRowUsed) maxRowUsed = cursorRow;
     }
-    // ... (previous code)
-    // Render to string with optimization
-    const outputLines = [];
-    let lastRenderedStyle = '';
-    for (let row = 0; row <= maxRowUsed; row++) {
-        let lineStr = '';
-        const rowCells = screen[row] || [];
-        // Ensure we process up to cursor column if this is the cursor row
-        // This ensures the cursor is drawn even if it's past the end of text
-        const effectiveLength = (options?.highlightCursor && row === cursorRow)
-            ? Math.max(rowCells.length, cursorCol + 1)
-            : rowCells.length;
-        for (let col = 0; col < effectiveLength; col++) {
-            let cell = rowCells[col] || { char: ' ', style: '' };
-            // Apply cursor highlighting
-            if (options?.highlightCursor && row === cursorRow && col === cursorCol) {
-                // Invert colors for cursor
-                // Standard ANSI invert is 7
-                // We append it to the current style
-                // If style is empty, it becomes \x1b[7m
-                // If style is \x1b[31m, it becomes \x1b[31m\x1b[7m
-                // We create a temporary cell for rendering
-                cell = {
-                    char: cell.char || ' ', // Ensure visible char for cursor block
-                    style: cell.style + '\x1b[7m'
-                };
-            }
-            // If style changed, emit ANSI code
-            if (cell.style !== lastRenderedStyle) {
-                if (cell.style === '') {
-                    lineStr += '\x1b[0m';
-                }
-                else {
-                    lineStr += '\x1b[0m' + cell.style;
-                }
-                lastRenderedStyle = cell.style;
-            }
-            lineStr += cell.char;
-        }
-        // Reset at end of line
-        if (lastRenderedStyle !== '') {
-            lineStr += '\x1b[0m';
-            lastRenderedStyle = '';
+    i++;
+  }
+  const outputLines = [];
+  let lastRenderedStyle = "";
+  for (let row = 0; row <= maxRowUsed; row++) {
+    let lineStr = "";
+    const rowCells = screen[row] || [];
+    const effectiveLength = options?.highlightCursor && row === cursorRow ? Math.max(rowCells.length, cursorCol + 1) : rowCells.length;
+    for (let col = 0; col < effectiveLength; col++) {
+      let cell = rowCells[col] || { char: " ", style: "" };
+      if (options?.highlightCursor && row === cursorRow && col === cursorCol) {
+        cell = {
+          char: cell.char || " ",
+          // Ensure visible char for cursor block
+          style: cell.style + "\x1B[7m"
+        };
+      }
+      if (cell.style !== lastRenderedStyle) {
+        if (cell.style === "") {
+          lineStr += "\x1B[0m";
+        } else {
+          lineStr += "\x1B[0m" + cell.style;
         }
-        outputLines.push(lineStr);
+        lastRenderedStyle = cell.style;
+      }
+      lineStr += cell.char;
+    }
+    if (lastRenderedStyle !== "") {
+      lineStr += "\x1B[0m";
+      lastRenderedStyle = "";
     }
-    let result = outputLines.join('\n');
-    // Cleanup
-    result = result.replace(/\n{3,}/g, '\n\n');
-    result = result.replace(/^\n+/, '');
-    result = result.trimEnd();
-    // Ensure final reset
-    result += '\x1b[0m';
-    return result;
+    outputLines.push(lineStr);
+  }
+  let result = outputLines.join("\n");
+  result = result.replace(/\n{3,}/g, "\n\n");
+  result = result.replace(/^\n+/, "");
+  result = result.trimEnd();
+  result += "\x1B[0m";
+  return result;
 }
+export {
+  processTerminalOutput
+};
 //# sourceMappingURL=terminal-output.js.map