recoder-code 2.3.4 → 2.3.6

package/cli/approval-dialog.js

@@ -0,0 +1,230 @@
+const readline = require('readline');
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+/**
+ * Approval Dialog System - Claude Code Style
+ * Multi-choice numbered options with preferences
+ */
+class ApprovalDialog {
+  constructor(rl) {
+    this.rl = rl;
+    this.preferences = new Map(); // Store "don't ask again" preferences
+  }
+
+  /**
+   * Show bash command approval with multi-choice options
+   */
+  async showBashApproval(command, description = '') {
+    const width = 90;
+
+    // Build dialog
+    console.log('');
+    console.log(chalk.cyan('╭' + '─'.repeat(width - 2) + '╮'));
+    console.log(chalk.cyan('│') + chalk.bold(' Bash command') + ' '.repeat(width - 15) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ' '.repeat(width - 2) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '  ' + chalk.white(this.truncate(command, width - 6)) + ' '.repeat(Math.max(0, width - 6 - command.length)) + chalk.cyan('│'));
+
+    if (description) {
+      console.log(chalk.cyan('│') + '  ' + chalk.dim(this.truncate(description, width - 6)) + ' '.repeat(Math.max(0, width - 6 - description.length)) + chalk.cyan('│'));
+    }
+
+    console.log(chalk.cyan('│') + ' '.repeat(width - 2) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + chalk.white(' Do you want to proceed?') + ' '.repeat(width - 28) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + chalk.green(' ❯ 1. ') + chalk.white('Yes') + ' '.repeat(width - 13) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '   ' + chalk.dim('2. ') + chalk.white('Yes, and don\'t ask again for bash commands') + ' '.repeat(Math.max(0, width - 51)) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '   ' + chalk.dim('3. ') + chalk.white('No, and tell Claude what to do differently ') + chalk.dim('(esc)') + ' '.repeat(Math.max(0, width - 58)) + chalk.cyan('│'));
+    console.log(chalk.cyan('╰' + '─'.repeat(width - 2) + '╯'));
+    console.log('');
+
+    return this.waitForChoice(3);
+  }
+
+  /**
+   * Show file operation approval with multi-choice options
+   */
+  async showFileApproval(operation, filePath, diff, stats = {}) {
+    const width = 90;
+    const { additions = 0, deletions = 0 } = stats;
+
+    // Determine operation type
+    let title = 'File Operation';
+    let descText = '';
+
+    if (operation === 'create') {
+      title = 'File Creation';
+      descText = `Create ${filePath}`;
+    } else if (operation === 'str_replace') {
+      title = 'File Edit';
+      descText = `Modify ${filePath} (${additions > 0 ? '+' + additions : ''}${deletions > 0 ? ' -' + deletions : ''})`;
+    }
+
+    // Build dialog
+    console.log('');
+    console.log(chalk.cyan('╭' + '─'.repeat(width - 2) + '╮'));
+    console.log(chalk.cyan('│') + chalk.bold(` ${title}`) + ' '.repeat(width - title.length - 3) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ' '.repeat(width - 2) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '  ' + chalk.white(this.truncate(descText, width - 6)) + ' '.repeat(Math.max(0, width - 6 - descText.length)) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ' '.repeat(width - 2) + chalk.cyan('│'));
+
+    // Show truncated diff
+    const diffLines = diff.split('\n').slice(0, 8);
+    diffLines.forEach(line => {
+      const displayLine = this.truncate(line, width - 6);
+      console.log(chalk.cyan('│') + '  ' + displayLine + ' '.repeat(Math.max(0, width - 4 - displayLine.length)) + chalk.cyan('│'));
+    });
+
+    if (diff.split('\n').length > 8) {
+      const remaining = diff.split('\n').length - 8;
+      console.log(chalk.cyan('│') + '  ' + chalk.yellow(`… +${remaining} lines `) + chalk.dim('(ctrl+o to expand)') + ' '.repeat(Math.max(0, width - 30 - remaining.toString().length)) + chalk.cyan('│'));
+    }
+
+    console.log(chalk.cyan('│') + ' '.repeat(width - 2) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + chalk.white(' Do you want to proceed?') + ' '.repeat(width - 28) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + chalk.green(' ❯ 1. ') + chalk.white('Yes') + ' '.repeat(width - 13) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '   ' + chalk.dim('2. ') + chalk.white('Yes, and auto-accept all remaining changes') + ' '.repeat(Math.max(0, width - 50)) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '   ' + chalk.dim('3. ') + chalk.white('No, skip this change') + ' '.repeat(width - 28) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '   ' + chalk.dim('4. ') + chalk.white('No, and tell Claude what to change ') + chalk.dim('(esc)') + ' '.repeat(Math.max(0, width - 50)) + chalk.cyan('│'));
+    console.log(chalk.cyan('╰' + '─'.repeat(width - 2) + '╯'));
+    console.log('');
+
+    return this.waitForChoice(4);
+  }
+
+  /**
+   * Wait for user to select a numbered choice
+   */
+  async waitForChoice(maxChoice) {
+    return new Promise((resolve) => {
+      const handleInput = (input) => {
+        const choice = input.trim();
+
+        // Handle escape key
+        if (input === '\x1b') {
+          cleanup();
+          resolve({ choice: maxChoice, alternative: true }); // Last option is always "tell me what to do"
+          return;
+        }
+
+        // Handle numbered choices
+        const num = parseInt(choice);
+        if (num >= 1 && num <= maxChoice) {
+          cleanup();
+          resolve({ choice: num, alternative: false });
+          return;
+        }
+
+        // Invalid input - show again
+        process.stdout.write(chalk.red('Invalid choice. ') + chalk.dim(`Enter 1-${maxChoice}: `));
+      };
+
+      const cleanup = () => {
+        process.stdin.removeListener('data', handleInput);
+      };
+
+      // Listen for keypress
+      process.stdout.write(chalk.dim(`Enter choice (1-${maxChoice}): `));
+      process.stdin.once('data', handleInput);
+    });
+  }
+
+  /**
+   * Show simple yes/no confirmation
+   */
+  async showConfirmation(message) {
+    const width = 90;
+
+    console.log('');
+    console.log(chalk.cyan('╭' + '─'.repeat(width - 2) + '╮'));
+    console.log(chalk.cyan('│') + '  ' + chalk.white(this.truncate(message, width - 6)) + ' '.repeat(Math.max(0, width - 6 - message.length)) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ' '.repeat(width - 2) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + chalk.green(' ❯ 1. ') + chalk.white('Yes') + ' '.repeat(width - 13) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + '   ' + chalk.dim('2. ') + chalk.white('No') + ' '.repeat(width - 12) + chalk.cyan('│'));
+    console.log(chalk.cyan('╰' + '─'.repeat(width - 2) + '╯'));
+    console.log('');
+
+    const result = await this.waitForChoice(2);
+    return result.choice === 1;
+  }
+
+  /**
+   * Store preference to not ask again
+   */
+  setPreference(key, value) {
+    this.preferences.set(key, value);
+  }
+
+  /**
+   * Check if we should ask based on preferences
+   */
+  shouldAsk(key) {
+    return !this.preferences.has(key);
+  }
+
+  /**
+   * Clear all preferences
+   */
+  clearPreferences() {
+    this.preferences.clear();
+  }
+
+  /**
+   * Truncate text to fit width
+   */
+  truncate(text, maxLength) {
+    // Remove ANSI codes for length calculation
+    const plainText = text.replace(/\x1b\[[0-9;]*m/g, '');
+    if (plainText.length <= maxLength) return text;
+
+    // Find position in original text that corresponds to maxLength in plain text
+    let plainPos = 0;
+    let textPos = 0;
+    while (plainPos < maxLength - 3 && textPos < text.length) {
+      if (text.substr(textPos, 2) === '\x1b[') {
+        // Skip ANSI code
+        const endPos = text.indexOf('m', textPos);
+        if (endPos > -1) {
+          textPos = endPos + 1;
+        } else {
+          textPos++;
+        }
+      } else {
+        plainPos++;
+        textPos++;
+      }
+    }
+
+    return text.substring(0, textPos) + '...';
+  }
+
+  /**
+   * Format diff for display in dialog
+   */
+  formatDiffForDialog(oldContent, newContent) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const maxLines = Math.max(oldLines.length, newLines.length);
+
+    let formatted = [];
+    for (let i = 0; i < Math.min(maxLines, 8); i++) {
+      const oldLine = oldLines[i];
+      const newLine = newLines[i];
+      const lineNum = String(i + 1).padStart(3, ' ');
+
+      if (oldLine !== newLine) {
+        if (oldLine !== undefined) {
+          formatted.push(chalk.red(`-${lineNum}  ${oldLine}`));
+        }
+        if (newLine !== undefined) {
+          formatted.push(chalk.green(`+${lineNum}  ${newLine}`));
+        }
+      } else {
+        formatted.push(chalk.dim(` ${lineNum}  ${oldLine || ''}`));
+      }
+    }
+
+    return formatted.join('\n');
+  }
+}
+
+module.exports = ApprovalDialog;

package/cli/collaboration-manager.js

@@ -32,9 +32,9 @@ class CollaborationManager {
     try {
       // Load existing team workspaces
       await this.loadTeamWorkspaces();
-      console.log(chalk.blue('🤝 Collaboration manager initialized'));
+      // Silent initialization - no console output
     } catch (error) {
-      console.log(chalk.yellow(`⚠️  Collaboration init warning: ${error.message}`));
+      // Silent error handling
     }
   }
 

package/cli/diff-generator.js

@@ -0,0 +1,272 @@
+const fs = require('fs');
+const path = require('path');
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+/**
+ * Diff Generator for Recoder Code
+ * Generates visual diffs for file operations
+ * Similar to Claude Code and OpenCode diff displays
+ */
+class DiffGenerator {
+  constructor() {
+    this.maxDiffLines = 200; // Recommended by Claude Code
+
+    // File type icons mapping
+    this.fileIcons = {
+      '.js': '📜',
+      '.ts': '📘',
+      '.jsx': '⚛️',
+      '.tsx': '⚛️',
+      '.py': '🐍',
+      '.rb': '💎',
+      '.go': '🔷',
+      '.rs': '🦀',
+      '.java': '☕',
+      '.cpp': '⚙️',
+      '.c': '⚙️',
+      '.php': '🐘',
+      '.html': '🌐',
+      '.css': '🎨',
+      '.scss': '🎨',
+      '.json': '📋',
+      '.md': '📝',
+      '.yaml': '⚙️',
+      '.yml': '⚙️',
+      '.xml': '📄',
+      '.sh': '🔧',
+      '.sql': '🗃️',
+      '.txt': '📄',
+      '.log': '📊'
+    };
+  }
+
+  /**
+   * Get icon for file type
+   */
+  getFileIcon(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return this.fileIcons[ext] || '📄';
+  }
+
+  /**
+   * Generate diff for any file operation
+   * @param {string} operation - 'create', 'str_replace', 'view'
+   * @param {string} filePath
+   * @param {string} oldContent
+   * @param {string} newContent
+   * @returns {string} - Formatted diff
+   */
+  generateDiff(operation, filePath, oldContent = '', newContent = '') {
+    if (operation === 'create') {
+      return this.generateCreateDiff(filePath, newContent);
+    } else if (operation === 'str_replace') {
+      return this.generateEditDiff(filePath, oldContent, newContent);
+    } else if (operation === 'view') {
+      return this.generateViewDiff(filePath, oldContent);
+    }
+    return '';
+  }
+
+  /**
+   * Generate diff for file creation
+   */
+  generateCreateDiff(filePath, content) {
+    const lines = content.split('\n');
+    const size = Buffer.byteLength(content, 'utf8');
+    const fileName = path.basename(filePath);
+    const ext = path.extname(filePath);
+    const icon = this.getFileIcon(filePath);
+
+    // Build header
+    let diff = '\n';
+    diff += chalk.cyan('┌' + '─'.repeat(58) + '┐\n');
+    diff += chalk.cyan('│ ') + chalk.bold.green(`${icon} Create: `) + chalk.bold(fileName);
+    diff += ' '.repeat(Math.max(0, 58 - 14 - fileName.length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('│ ') + chalk.dim(`Size: ${this.formatBytes(size)} | Lines: ${lines.length} | Type: ${ext || 'txt'}`);
+    diff += ' '.repeat(Math.max(0, 58 - 35 - ext.length - size.toString().length - lines.length.toString().length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('├' + '─'.repeat(58) + '┤\n');
+
+    // Show content with line numbers (limit to max lines)
+    const displayLines = lines.slice(0, this.maxDiffLines);
+    const lineNumWidth = displayLines.length.toString().length;
+
+    displayLines.forEach((line, i) => {
+      const lineNum = (i + 1).toString().padStart(lineNumWidth, ' ');
+      const displayLine = this.truncateLine(line, 52);
+      diff += chalk.cyan('│ ') + chalk.green(`+ ${lineNum} │ ${displayLine}`);
+      diff += ' '.repeat(Math.max(0, 58 - 6 - lineNumWidth - displayLine.length)) + chalk.cyan('│\n');
+    });
+
+    if (lines.length > this.maxDiffLines) {
+      diff += chalk.cyan('│ ') + chalk.dim(`... ${lines.length - this.maxDiffLines} more lines`);
+      diff += ' '.repeat(Math.max(0, 58 - 15 - (lines.length - this.maxDiffLines).toString().length)) + chalk.cyan('│\n');
+    }
+
+    // Footer
+    diff += chalk.cyan('├' + '─'.repeat(58) + '┤\n');
+    diff += chalk.cyan('│ ') + chalk.green(`+${lines.length} lines to add`);
+    diff += ' '.repeat(Math.max(0, 58 - 17 - lines.length.toString().length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('└' + '─'.repeat(58) + '┘\n');
+
+    return diff;
+  }
+
+  /**
+   * Generate diff for file editing
+   */
+  generateEditDiff(filePath, oldContent, newContent) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const fileName = path.basename(filePath);
+    const icon = this.getFileIcon(filePath);
+
+    // Calculate stats
+    const oldSize = Buffer.byteLength(oldContent, 'utf8');
+    const newSize = Buffer.byteLength(newContent, 'utf8');
+    const sizeDiff = newSize - oldSize;
+    const lineDiff = newLines.length - oldLines.length;
+
+    // Build header
+    let diff = '\n';
+    diff += chalk.cyan('┌' + '─'.repeat(58) + '┐\n');
+    diff += chalk.cyan('│ ') + chalk.bold.yellow(`${icon} Edit: `) + chalk.bold(fileName);
+    diff += ' '.repeat(Math.max(0, 58 - 13 - fileName.length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('│ ') + chalk.dim(`Lines: ${oldLines.length} → ${newLines.length} (${lineDiff >= 0 ? '+' : ''}${lineDiff})`);
+    diff += ' '.repeat(Math.max(0, 58 - 20 - oldLines.length.toString().length - newLines.length.toString().length - lineDiff.toString().length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('├' + '─'.repeat(58) + '┤\n');
+
+    // Generate unified diff
+    const diffLines = this.generateUnifiedDiff(oldLines, newLines);
+    const displayLines = diffLines.slice(0, this.maxDiffLines);
+
+    displayLines.forEach(({ type, lineNum, content }) => {
+      const displayLine = this.truncateLine(content, 48);
+      const num = lineNum.toString().padStart(3, ' ');
+
+      if (type === 'add') {
+        diff += chalk.cyan('│ ') + chalk.green(`+ ${num} │ ${displayLine}`);
+        diff += ' '.repeat(Math.max(0, 58 - 8 - displayLine.length)) + chalk.cyan('│\n');
+      } else if (type === 'remove') {
+        diff += chalk.cyan('│ ') + chalk.red(`- ${num} │ ${displayLine}`);
+        diff += ' '.repeat(Math.max(0, 58 - 8 - displayLine.length)) + chalk.cyan('│\n');
+      } else {
+        diff += chalk.cyan('│ ') + chalk.dim(`  ${num} │ ${displayLine}`);
+        diff += ' '.repeat(Math.max(0, 58 - 8 - displayLine.length)) + chalk.cyan('│\n');
+      }
+    });
+
+    if (diffLines.length > this.maxDiffLines) {
+      diff += chalk.cyan('│ ') + chalk.dim(`... ${diffLines.length - this.maxDiffLines} more lines`);
+      diff += ' '.repeat(Math.max(0, 58 - 15 - (diffLines.length - this.maxDiffLines).toString().length)) + chalk.cyan('│\n');
+    }
+
+    // Footer with stats
+    diff += chalk.cyan('├' + '─'.repeat(58) + '┤\n');
+    const added = diffLines.filter(l => l.type === 'add').length;
+    const removed = diffLines.filter(l => l.type === 'remove').length;
+    diff += chalk.cyan('│ ') + chalk.dim(`Changes: `) + chalk.green(`+${added}`) + chalk.dim(' ') + chalk.red(`-${removed}`);
+    diff += ' '.repeat(Math.max(0, 58 - 14 - added.toString().length - removed.toString().length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('└' + '─'.repeat(58) + '┘\n');
+
+    return diff;
+  }
+
+  /**
+   * Generate view-only diff (for file preview)
+   */
+  generateViewDiff(filePath, content) {
+    const lines = content.split('\n');
+    const size = Buffer.byteLength(content, 'utf8');
+    const fileName = path.basename(filePath);
+    const icon = this.getFileIcon(filePath);
+
+    let diff = '\n';
+    diff += chalk.cyan('┌' + '─'.repeat(58) + '┐\n');
+    diff += chalk.cyan('│ ') + chalk.bold.blue(`${icon} View: `) + chalk.bold(fileName);
+    diff += ' '.repeat(Math.max(0, 58 - 13 - fileName.length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('│ ') + chalk.dim(`Size: ${this.formatBytes(size)} | Lines: ${lines.length}`);
+    diff += ' '.repeat(Math.max(0, 58 - 25 - size.toString().length - lines.length.toString().length)) + chalk.cyan('│\n');
+    diff += chalk.cyan('├' + '─'.repeat(58) + '┤\n');
+
+    const displayLines = lines.slice(0, this.maxDiffLines);
+    const lineNumWidth = displayLines.length.toString().length;
+
+    displayLines.forEach((line, i) => {
+      const lineNum = (i + 1).toString().padStart(lineNumWidth, ' ');
+      const displayLine = this.truncateLine(line, 52 - lineNumWidth);
+      diff += chalk.cyan('│ ') + chalk.dim(`${lineNum} │ ${displayLine}`);
+      diff += ' '.repeat(Math.max(0, 58 - 4 - lineNumWidth - displayLine.length)) + chalk.cyan('│\n');
+    });
+
+    if (lines.length > this.maxDiffLines) {
+      diff += chalk.cyan('│ ') + chalk.dim(`... ${lines.length - this.maxDiffLines} more lines`);
+      diff += ' '.repeat(Math.max(0, 58 - 15 - (lines.length - this.maxDiffLines).toString().length)) + chalk.cyan('│\n');
+    }
+
+    diff += chalk.cyan('└' + '─'.repeat(58) + '┘\n');
+
+    return diff;
+  }
+
+  /**
+   * Generate unified diff from two arrays of lines
+   * Returns array of { type, lineNum, content }
+   */
+  generateUnifiedDiff(oldLines, newLines) {
+    const diff = [];
+    const maxLines = Math.max(oldLines.length, newLines.length);
+
+    // Simple line-by-line diff (can be enhanced with better algorithm)
+    let oldIdx = 0;
+    let newIdx = 0;
+
+    while (oldIdx < oldLines.length || newIdx < newLines.length) {
+      const oldLine = oldLines[oldIdx];
+      const newLine = newLines[newIdx];
+
+      if (oldLine === newLine) {
+        // Unchanged line
+        diff.push({ type: 'context', lineNum: newIdx + 1, content: newLine });
+        oldIdx++;
+        newIdx++;
+      } else if (oldIdx >= oldLines.length) {
+        // Only new lines left
+        diff.push({ type: 'add', lineNum: newIdx + 1, content: newLine });
+        newIdx++;
+      } else if (newIdx >= newLines.length) {
+        // Only old lines left
+        diff.push({ type: 'remove', lineNum: oldIdx + 1, content: oldLine });
+        oldIdx++;
+      } else {
+        // Lines differ - simple approach: mark as remove + add
+        diff.push({ type: 'remove', lineNum: oldIdx + 1, content: oldLine });
+        diff.push({ type: 'add', lineNum: newIdx + 1, content: newLine });
+        oldIdx++;
+        newIdx++;
+      }
+    }
+
+    return diff;
+  }
+
+  /**
+   * Format bytes to human-readable size
+   */
+  formatBytes(bytes) {
+    if (bytes < 1024) return bytes + 'B';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + 'KB';
+    return (bytes / (1024 * 1024)).toFixed(1) + 'MB';
+  }
+
+  /**
+   * Truncate line to max width
+   */
+  truncateLine(line, maxWidth) {
+    if (line.length <= maxWidth) return line;
+    return line.substring(0, maxWidth - 3) + '...';
+  }
+}
+
+module.exports = DiffGenerator;

package/cli/output-formatter.js

@@ -0,0 +1,265 @@
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+/**
+ * Output Formatter for Claude Code-style display
+ * Provides collapsible sections, progress indicators, and clean formatting
+ */
+class OutputFormatter {
+  constructor() {
+    this.collapsedSections = new Map();
+    this.truncateLength = 10; // Show first N lines by default
+  }
+
+  /**
+   * Format tool execution header (like Claude Code's ⏺ Bash(...))
+   */
+  formatToolHeader(toolName, args) {
+    let header = chalk.dim('⏺ ');
+
+    switch (toolName) {
+      case 'bash':
+        header += chalk.cyan(`Bash(${this.truncateArg(args.command)})`);
+        break;
+      case 'str_replace_editor':
+        header += chalk.cyan(`Edit(${args.command} ${this.truncateArg(args.path)})`);
+        break;
+      case 'codebase_search':
+        header += chalk.cyan(`Search(${this.truncateArg(args.query)})`);
+        break;
+      case 'web_fetch':
+        header += chalk.cyan(`WebFetch(${this.truncateArg(args.url)})`);
+        break;
+      default:
+        header += chalk.cyan(`${toolName}(...)`);
+    }
+
+    return header;
+  }
+
+  /**
+   * Format tool execution body with collapsible output
+   */
+  formatToolBody(output, sectionId, truncate = true) {
+    if (!output) return '';
+
+    const lines = output.split('\n');
+    const totalLines = lines.length;
+
+    if (!truncate || totalLines <= this.truncateLength) {
+      // Show all lines with indent
+      return lines.map(line => chalk.dim('  ⎿  ') + line).join('\n');
+    }
+
+    // Show truncated with expand option
+    const visibleLines = lines.slice(0, this.truncateLength);
+    const hiddenCount = totalLines - this.truncateLength;
+
+    let formatted = visibleLines.map(line => chalk.dim('  ⎿  ') + line).join('\n');
+    formatted += '\n' + chalk.dim('  ⎿  ') + chalk.yellow(`… +${hiddenCount} lines `) + chalk.dim('(ctrl+o to expand)');
+
+    // Store full output for expansion
+    this.collapsedSections.set(sectionId, lines);
+
+    return formatted;
+  }
+
+  /**
+   * Format thinking/processing indicator
+   */
+  formatThinking(message = 'Thinking') {
+    return chalk.dim('✳ ') + chalk.cyan(message) + chalk.dim('…');
+  }
+
+  /**
+   * Format status line (bottom bar like Claude Code)
+   */
+  formatStatusBar(mode, sessionInfo = {}) {
+    const modeIcons = {
+      ask: '⏸',
+      auto: '⏵⏵',
+      plan: '📖',
+      build: '🔨'
+    };
+
+    const modeIcon = modeIcons[mode] || '⏸';
+    const modeText = mode === 'auto' ? 'accept edits on' : mode + ' mode';
+
+    let status = chalk.dim('  ') + modeIcon + chalk.dim(` ${modeText} `);
+    status += chalk.dim('(shift+tab to cycle)');
+
+    // Add background tasks if any
+    if (sessionInfo.backgroundTasks > 0) {
+      status += chalk.dim(` · ${sessionInfo.backgroundTasks} background task${sessionInfo.backgroundTasks > 1 ? 's' : ''}`);
+    }
+
+    // Add shortcuts hint
+    status += chalk.dim(' · ? for shortcuts');
+
+    // Add context info
+    if (sessionInfo.contextUsage) {
+      status += chalk.dim(`     Context left: ${sessionInfo.contextUsage}%`);
+    }
+
+    return status;
+  }
+
+  /**
+   * Format separator line
+   */
+  formatSeparator(width = 90) {
+    return chalk.dim('─'.repeat(width));
+  }
+
+  /**
+   * Format success message (like Claude Code's ⏺ Perfect! ...)
+   */
+  formatSuccess(message) {
+    return chalk.dim('⏺ ') + chalk.green(message);
+  }
+
+  /**
+   * Format error message
+   */
+  formatError(message) {
+    return chalk.dim('⏺ ') + chalk.red('Error: ') + message;
+  }
+
+  /**
+   * Format info message
+   */
+  formatInfo(message) {
+    return chalk.dim('⏺ ') + chalk.cyan(message);
+  }
+
+  /**
+   * Truncate argument for display
+   */
+  truncateArg(arg, maxLength = 50) {
+    if (!arg) return '';
+    const str = String(arg);
+    if (str.length <= maxLength) return str;
+    return str.substring(0, maxLength - 3) + '...';
+  }
+
+  /**
+   * Format multi-line output with proper indentation
+   */
+  formatIndented(text, indent = '  ') {
+    const lines = text.split('\n');
+    return lines.map(line => chalk.dim(indent + '⎿  ') + line).join('\n');
+  }
+
+  /**
+   * Format code block
+   */
+  formatCodeBlock(code, language = '') {
+    const lines = code.split('\n');
+    return lines.map((line, i) => {
+      const lineNum = String(i + 1).padStart(3, ' ');
+      return chalk.dim(`  ${lineNum} `) + chalk.gray('│ ') + line;
+    }).join('\n');
+  }
+
+  /**
+   * Expand collapsed section
+   */
+  expandSection(sectionId) {
+    const lines = this.collapsedSections.get(sectionId);
+    if (!lines) return null;
+
+    return lines.map(line => chalk.dim('  ⎿  ') + line).join('\n');
+  }
+
+  /**
+   * Format progress with spinner
+   */
+  formatProgress(message, step = 0, total = 0) {
+    const spinners = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    const spinner = spinners[step % spinners.length];
+
+    let progress = chalk.cyan(spinner) + ' ' + message;
+
+    if (total > 0) {
+      progress += chalk.dim(` (${step}/${total})`);
+    }
+
+    return progress;
+  }
+
+  /**
+   * Format file tree structure
+   */
+  formatFileTree(files, depth = 0) {
+    const indent = '  '.repeat(depth);
+    return files.map(file => {
+      const icon = file.isDirectory ? '📁' : this.getFileIcon(file.name);
+      return chalk.dim(indent) + icon + ' ' + chalk.white(file.name);
+    }).join('\n');
+  }
+
+  /**
+   * Get file icon by extension
+   */
+  getFileIcon(filename) {
+    const ext = filename.split('.').pop();
+    const icons = {
+      'js': '📜', 'ts': '📘', 'jsx': '⚛️', 'tsx': '⚛️',
+      'py': '🐍', 'rb': '💎', 'go': '🔷', 'rs': '🦀',
+      'java': '☕', 'cpp': '⚙️', 'c': '⚙️', 'php': '🐘',
+      'html': '🌐', 'css': '🎨', 'json': '📋', 'md': '📝',
+      'yaml': '⚙️', 'yml': '⚙️', 'xml': '📄', 'sh': '🔧',
+      'sql': '🗃️', 'txt': '📄', 'log': '📊'
+    };
+    return icons[ext] || '📄';
+  }
+
+  /**
+   * Format list with bullets
+   */
+  formatList(items, bullet = '•') {
+    return items.map(item => chalk.dim('  ' + bullet + ' ') + item).join('\n');
+  }
+
+  /**
+   * Format numbered list
+   */
+  formatNumberedList(items) {
+    return items.map((item, i) => {
+      const num = String(i + 1).padStart(2, ' ');
+      return chalk.dim(`  ${num}. `) + item;
+    }).join('\n');
+  }
+
+  /**
+   * Clear current line
+   */
+  clearLine() {
+    process.stdout.write('\r\x1b[K');
+  }
+
+  /**
+   * Move cursor up N lines
+   */
+  moveCursorUp(lines = 1) {
+    process.stdout.write(`\x1b[${lines}A`);
+  }
+
+  /**
+   * Format elapsed time
+   */
+  formatElapsedTime(startTime) {
+    const elapsed = Date.now() - startTime;
+    const seconds = Math.floor(elapsed / 1000);
+
+    if (seconds < 60) {
+      return `${seconds}s`;
+    }
+
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+  }
+}
+
+module.exports = OutputFormatter;

package/cli/permission-manager.js

@@ -0,0 +1,223 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Permission Manager for Recoder Code
+ * Manages approval workflows for file operations and commands
+ * Similar to Claude Code and OpenCode permission systems
+ */
+class PermissionManager {
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.recoder-code', 'config.json');
+    this.config = this.loadConfig();
+    this.sessionAutoAccept = false;
+    this.sessionMode = null; // Override config mode for current session
+  }
+
+  /**
+   * Load configuration from ~/.recoder-code/config.json
+   */
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const configData = fs.readFileSync(this.configPath, 'utf8');
+        const config = JSON.parse(configData);
+
+        // Ensure permission object exists
+        if (!config.permission) {
+          config.permission = this.getDefaultPermissions();
+        }
+
+        return config;
+      }
+    } catch (error) {
+      // Silent error - use defaults
+    }
+
+    // Default configuration
+    return {
+      permission: this.getDefaultPermissions()
+    };
+  }
+
+  /**
+   * Get default permission settings
+   */
+  getDefaultPermissions() {
+    return {
+      mode: 'ask',        // 'ask', 'auto', 'deny'
+      edit: 'ask',        // File editing permission
+      bash: 'ask',        // Bash command permission
+      autoAcceptAll: false
+    };
+  }
+
+  /**
+   * Save configuration to ~/.recoder-code/config.json
+   */
+  saveConfig() {
+    try {
+      const configDir = path.dirname(this.configPath);
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+      }
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check if we should ask for permission for a specific operation
+   * @param {string} operation - 'edit', 'bash', 'web_fetch', etc.
+   * @returns {boolean} - true if should ask, false if auto-approve
+   */
+  shouldAskPermission(operation) {
+    // Ensure config and permission object exist
+    if (!this.config || !this.config.permission) {
+      this.config = { permission: this.getDefaultPermissions() };
+    }
+
+    // Session auto-accept overrides everything
+    if (this.sessionAutoAccept) {
+      return false;
+    }
+
+    // Session mode overrides config
+    const mode = this.sessionMode || this.config.permission.mode || 'ask';
+
+    // Check global mode first
+    if (mode === 'auto') {
+      return false;
+    }
+
+    if (mode === 'deny') {
+      return true; // Will be denied, but still "ask"
+    }
+
+    // Check operation-specific permission
+    const operationPerm = this.config.permission[operation] || 'ask';
+    if (operationPerm === 'allow') {
+      return false;
+    }
+
+    if (operationPerm === 'deny') {
+      return true;
+    }
+
+    // Default to ask
+    return true;
+  }
+
+  /**
+   * Check if an operation is denied
+   * @param {string} operation
+   * @returns {boolean}
+   */
+  isDenied(operation) {
+    // Ensure config and permission object exist
+    if (!this.config || !this.config.permission) {
+      this.config = { permission: this.getDefaultPermissions() };
+    }
+
+    const mode = this.sessionMode || this.config.permission.mode || 'ask';
+
+    if (mode === 'deny') {
+      return true;
+    }
+
+    const operationPerm = this.config.permission[operation] || 'ask';
+    return operationPerm === 'deny';
+  }
+
+  /**
+   * Enable auto-accept for the current session
+   * Similar to Claude Code's "⏵⏵ accept edits on"
+   */
+  setAutoAcceptSession(enabled) {
+    this.sessionAutoAccept = enabled;
+  }
+
+  /**
+   * Get current auto-accept status
+   */
+  isAutoAcceptEnabled() {
+    return this.sessionAutoAccept;
+  }
+
+  /**
+   * Set session mode (overrides config)
+   * @param {string} mode - 'ask', 'auto', 'plan', 'deny'
+   */
+  setSessionMode(mode) {
+    this.sessionMode = mode;
+  }
+
+  /**
+   * Get current mode (session override or config)
+   */
+  getCurrentMode() {
+    // Ensure config and permission object exist
+    if (!this.config || !this.config.permission) {
+      this.config = { permission: this.getDefaultPermissions() };
+    }
+    return this.sessionMode || this.config.permission.mode || 'ask';
+  }
+
+  /**
+   * Update config permission for an operation
+   * @param {string} operation
+   * @param {string} value - 'ask', 'allow', 'deny'
+   */
+  setPermission(operation, value) {
+    // Ensure config and permission object exist
+    if (!this.config || !this.config.permission) {
+      this.config = { permission: this.getDefaultPermissions() };
+    }
+    this.config.permission[operation] = value;
+    this.saveConfig();
+  }
+
+  /**
+   * Update global mode
+   * @param {string} mode - 'ask', 'auto', 'deny'
+   */
+  setMode(mode) {
+    // Ensure config and permission object exist
+    if (!this.config || !this.config.permission) {
+      this.config = { permission: this.getDefaultPermissions() };
+    }
+    this.config.permission.mode = mode;
+    this.saveConfig();
+  }
+
+  /**
+   * Reset to defaults
+   */
+  resetToDefaults() {
+    this.config = {
+      permission: this.getDefaultPermissions()
+    };
+    this.sessionAutoAccept = false;
+    this.sessionMode = null;
+    this.saveConfig();
+  }
+
+  /**
+   * Get human-readable mode description
+   */
+  getModeDescription() {
+    const mode = this.getCurrentMode();
+    const descriptions = {
+      ask: '⏸ Manual approval mode - will ask for each change',
+      auto: '⏵⏵ Auto-accept mode - all changes approved automatically',
+      plan: '📖 Plan mode - read-only, no changes allowed',
+      deny: '⊘ Deny mode - all changes blocked'
+    };
+    return descriptions[mode] || descriptions.ask;
+  }
+}
+
+module.exports = PermissionManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recoder-code",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "description": "🚀 AI-powered development platform - Chat with 32+ models, build projects, automate workflows. Free models included!",
   "main": "index.js",
   "scripts": {