banana-code 1.2.0

package/lib/diffViewer.js

@@ -0,0 +1,295 @@
+/**
+ * Diff Viewer - Show colorful diffs for file changes
+ */
+
+const { diffLines, createPatch } = require('diff');
+
+// ANSI colors (fallback if chalk not available)
+const colors = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  green: '\x1b[38;5;120m',
+  red: '\x1b[38;5;210m',
+  cyan: '\x1b[38;5;51m',
+  yellow: '\x1b[38;5;226m',
+  banana: '\x1b[38;5;220m',
+  bananaGlow: '\x1b[38;5;228m',
+  orange: '\x1b[38;5;220m',
+  gray: '\x1b[38;5;245m',
+  white: '\x1b[38;5;255m',
+  magenta: '\x1b[38;5;183m',
+  bgGreen: '\x1b[48;5;22m',
+  bgRed: '\x1b[48;5;52m'
+};
+
+/**
+ * Format a line number with padding
+ */
+function formatLineNum(num, width = 4) {
+  return String(num).padStart(width, ' ');
+}
+
+/**
+ * Generate a unified diff view
+ */
+function generateDiff(oldContent, newContent, filePath) {
+  const patch = createPatch(filePath, oldContent || '', newContent, 'old', 'new');
+  return patch;
+}
+
+/**
+ * Create a pretty diff display for terminal
+ */
+function prettyDiff(oldContent, newContent, filePath, maxLines = 50) {
+  const differences = diffLines(oldContent || '', newContent);
+  const lines = [];
+  let lineCount = 0;
+  let hasChanges = false;
+
+  // Header
+  lines.push(`${colors.cyan}${'─'.repeat(60)}${colors.reset}`);
+  lines.push(`${colors.cyan}│${colors.reset} ${colors.white}${filePath}${colors.reset}`);
+  lines.push(`${colors.cyan}${'─'.repeat(60)}${colors.reset}`);
+
+  let oldLineNum = 1;
+  let newLineNum = 1;
+
+  for (const part of differences) {
+    const partLines = part.value.split('\n');
+    // Remove empty last line from split
+    if (partLines[partLines.length - 1] === '') {
+      partLines.pop();
+    }
+
+    for (const line of partLines) {
+      if (lineCount >= maxLines) {
+        lines.push(`${colors.gray}  ... ${differences.length - lineCount} more changes ...${colors.reset}`);
+        break;
+      }
+
+      if (part.added) {
+        hasChanges = true;
+        lines.push(`${colors.green}+ ${formatLineNum(newLineNum)}${colors.reset} ${colors.bgGreen}${line}${colors.reset}`);
+        newLineNum++;
+      } else if (part.removed) {
+        hasChanges = true;
+        lines.push(`${colors.red}- ${formatLineNum(oldLineNum)}${colors.reset} ${colors.bgRed}${line}${colors.reset}`);
+        oldLineNum++;
+      } else {
+        // Context line (unchanged) - show less of these
+        if (lineCount < 5 || lineCount > differences.length - 5) {
+          lines.push(`${colors.gray}  ${formatLineNum(oldLineNum)}${colors.reset} ${line}`);
+        } else if (lines[lines.length - 1] !== '...') {
+          lines.push(`${colors.gray}  ...${colors.reset}`);
+        }
+        oldLineNum++;
+        newLineNum++;
+      }
+
+      lineCount++;
+    }
+
+    if (lineCount >= maxLines) break;
+  }
+
+  if (!hasChanges) {
+    lines.push(`${colors.gray}  (no changes)${colors.reset}`);
+  }
+
+  lines.push(`${colors.cyan}${'─'.repeat(60)}${colors.reset}`);
+
+  return lines.join('\n');
+}
+
+/**
+ * Show a new file creation preview
+ */
+function showNewFile(content, filePath, maxLines = 30) {
+  const lines = content.split('\n');
+  const output = [];
+
+  output.push(`${colors.green}CREATE${colors.reset} ${colors.white}${filePath}${colors.reset}`);
+  output.push(`${colors.cyan}${'─'.repeat(60)}${colors.reset}`);
+
+  for (let i = 0; i < Math.min(lines.length, maxLines); i++) {
+    output.push(`${colors.green}+ ${formatLineNum(i + 1)}${colors.reset} ${lines[i]}`);
+  }
+
+  if (lines.length > maxLines) {
+    output.push(`${colors.gray}  ... ${lines.length - maxLines} more lines ...${colors.reset}`);
+  }
+
+  output.push(`${colors.cyan}${'─'.repeat(60)}${colors.reset}`);
+  output.push(`${colors.dim}${lines.length} lines${colors.reset}`);
+
+  return output.join('\n');
+}
+
+/**
+ * Show a file deletion preview
+ */
+function showDeleteFile(content, filePath, maxLines = 15) {
+  const lines = content ? content.split('\n') : [];
+  const output = [];
+
+  output.push(`${colors.red}DELETE${colors.reset} ${colors.white}${filePath}${colors.reset}`);
+  output.push(`${colors.cyan}${'─'.repeat(60)}${colors.reset}`);
+
+  for (let i = 0; i < Math.min(lines.length, maxLines); i++) {
+    output.push(`${colors.red}- ${formatLineNum(i + 1)}${colors.reset} ${colors.dim}${lines[i]}${colors.reset}`);
+  }
+
+  if (lines.length > maxLines) {
+    output.push(`${colors.gray}  ... ${lines.length - maxLines} more lines ...${colors.reset}`);
+  }
+
+  output.push(`${colors.cyan}${'─'.repeat(60)}${colors.reset}`);
+
+  return output.join('\n');
+}
+
+/**
+ * Show an edit preview
+ */
+function showEdit(oldContent, newContent, filePath) {
+  return prettyDiff(oldContent, newContent, filePath);
+}
+
+/**
+ * Get change summary (for compact display)
+ */
+function getChangeSummary(oldContent, newContent) {
+  const differences = diffLines(oldContent || '', newContent);
+  let added = 0;
+  let removed = 0;
+
+  for (const part of differences) {
+    const lineCount = part.value.split('\n').length - 1;
+    if (part.added) added += lineCount;
+    if (part.removed) removed += lineCount;
+  }
+
+  return { added, removed };
+}
+
+/**
+ * Format operation for display
+ */
+function formatOperation(operation, existingContent = null) {
+  const { action, path, content } = operation;
+
+  switch (action) {
+    case 'create':
+      return showNewFile(content, path);
+
+    case 'delete':
+      return showDeleteFile(existingContent, path);
+
+    case 'edit':
+      if (existingContent === null) {
+        // No existing content, treat as create
+        return showNewFile(content, path);
+      }
+      return showEdit(existingContent, content, path);
+
+    default:
+      return `Unknown action: ${action}`;
+  }
+}
+
+/**
+ * Format multiple operations in a batched view with summary
+ */
+function formatOperationsBatch(operations, fileManager) {
+  const output = [];
+  const summary = { created: 0, modified: 0, deleted: 0, additions: 0, deletions: 0 };
+
+  // Header
+  output.push(`\n${colors.banana}${'═'.repeat(60)}${colors.reset}`);
+  output.push(`${colors.banana}  PROPOSED CHANGES (${operations.length} files)${colors.reset}`);
+  output.push(`${colors.banana}${'═'.repeat(60)}${colors.reset}\n`);
+
+  // Process each operation
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    const existingContent = fileManager.exists(op.path)
+      ? fileManager.readFile(op.path).content
+      : null;
+
+    // Get change stats
+    if (op.action === 'create') {
+      summary.created++;
+      const lines = op.content.split('\n').length;
+      summary.additions += lines;
+    } else if (op.action === 'delete') {
+      summary.deleted++;
+      if (existingContent) {
+        summary.deletions += existingContent.split('\n').length;
+      }
+    } else if (op.action === 'edit') {
+      summary.modified++;
+      const changes = getChangeSummary(existingContent, op.content);
+      summary.additions += changes.added;
+      summary.deletions += changes.removed;
+    }
+
+    // File number indicator
+    output.push(`${colors.dim}[${i + 1}/${operations.length}]${colors.reset}`);
+    output.push(formatOperation(op, existingContent));
+    output.push('');
+  }
+
+  // Summary footer
+  output.push(`${colors.banana}${'═'.repeat(60)}${colors.reset}`);
+
+  const parts = [];
+  if (summary.created > 0) parts.push(`${colors.green}+${summary.created} new${colors.reset}`);
+  if (summary.modified > 0) parts.push(`${colors.yellow}~${summary.modified} modified${colors.reset}`);
+  if (summary.deleted > 0) parts.push(`${colors.red}-${summary.deleted} deleted${colors.reset}`);
+
+  output.push(`${colors.white}  Summary:${colors.reset} ${parts.join(' | ')}`);
+  output.push(`${colors.dim}  Lines: ${colors.green}+${summary.additions}${colors.reset} ${colors.red}-${summary.deletions}${colors.reset}`);
+  output.push(`${colors.banana}${'═'.repeat(60)}${colors.reset}\n`);
+
+  return output.join('\n');
+}
+
+/**
+ * Show a compact summary of changes (for confirmation prompts)
+ */
+function formatCompactSummary(operations, fileManager) {
+  const lines = [`\n${colors.cyan}Changes:${colors.reset}`];
+
+  for (const op of operations) {
+    const icon = op.action === 'create' ? '✚' : op.action === 'delete' ? '✖' : '✎';
+    const iconColor = op.action === 'create' ? colors.green : op.action === 'delete' ? colors.red : colors.yellow;
+
+    let detail = '';
+    if (op.action === 'edit' && fileManager.exists(op.path)) {
+      const existing = fileManager.readFile(op.path).content;
+      const { added, removed } = getChangeSummary(existing, op.content);
+      detail = ` ${colors.dim}(${colors.green}+${added}${colors.dim}/${colors.red}-${removed}${colors.dim})${colors.reset}`;
+    } else if (op.action === 'create') {
+      const lineCount = op.content.split('\n').length;
+      detail = ` ${colors.dim}(${lineCount} lines)${colors.reset}`;
+    }
+
+    lines.push(`  ${iconColor}${icon}${colors.reset} ${op.path}${detail}`);
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+module.exports = {
+  generateDiff,
+  prettyDiff,
+  showNewFile,
+  showDeleteFile,
+  showEdit,
+  getChangeSummary,
+  formatOperation,
+  formatOperationsBatch,
+  formatCompactSummary,
+  colors
+};

package/lib/fileManager.js

@@ -0,0 +1,224 @@
+/**
+ * File Manager - Read/write files with backup support
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// File extensions to always skip
+const BINARY_EXTENSIONS = [
+  '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
+  '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv',
+  '.zip', '.tar', '.gz', '.rar', '.7z',
+  '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+  '.exe', '.dll', '.so', '.dylib',
+  '.woff', '.woff2', '.ttf', '.eot', '.otf',
+  '.lock', '.bin', '.dat'
+];
+
+// Max file size to read (100KB)
+const MAX_FILE_SIZE = 100 * 1024;
+
+class FileManager {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.backupDir = path.join(projectDir, '.banana', 'backups');
+  }
+
+  /**
+   * Ensure backup directory exists
+   */
+  ensureBackupDir() {
+    if (!fs.existsSync(this.backupDir)) {
+      fs.mkdirSync(this.backupDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Check if file should be skipped (binary, too large, etc.)
+   */
+  shouldSkipFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (BINARY_EXTENSIONS.includes(ext)) {
+      return { skip: true, reason: 'binary file' };
+    }
+
+    try {
+      const stats = fs.statSync(filePath);
+      if (stats.size > MAX_FILE_SIZE) {
+        return { skip: true, reason: `file too large (${Math.round(stats.size / 1024)}KB)` };
+      }
+    } catch {
+      return { skip: true, reason: 'cannot read file stats' };
+    }
+
+    return { skip: false };
+  }
+
+  /**
+   * Read a file's contents
+   */
+  readFile(filePath) {
+    const fullPath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.projectDir, filePath);
+
+    const skipCheck = this.shouldSkipFile(fullPath);
+    if (skipCheck.skip) {
+      return { success: false, error: skipCheck.reason };
+    }
+
+    try {
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      return { success: true, content, path: fullPath };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Write content to a file (with backup)
+   */
+  writeFile(filePath, content) {
+    const fullPath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.projectDir, filePath);
+
+    try {
+      // Create backup if file exists
+      if (fs.existsSync(fullPath)) {
+        this.ensureBackupDir();
+        const timestamp = Date.now();
+        const relativePath = path.relative(this.projectDir, fullPath);
+        const backupName = `${relativePath.replace(/[/\\]/g, '_')}.${timestamp}.bak`;
+        const backupPath = path.join(this.backupDir, backupName);
+
+        fs.copyFileSync(fullPath, backupPath);
+      }
+
+      // Ensure directory exists
+      const dir = path.dirname(fullPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      // Write the file
+      fs.writeFileSync(fullPath, content, 'utf-8');
+
+      return { success: true, path: fullPath, isNew: !fs.existsSync(fullPath) };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Delete a file (with backup)
+   */
+  deleteFile(filePath) {
+    const fullPath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.projectDir, filePath);
+
+    try {
+      if (!fs.existsSync(fullPath)) {
+        return { success: false, error: 'File does not exist' };
+      }
+
+      // Create backup before deleting
+      this.ensureBackupDir();
+      const timestamp = Date.now();
+      const relativePath = path.relative(this.projectDir, fullPath);
+      const backupName = `${relativePath.replace(/[/\\]/g, '_')}.${timestamp}.deleted.bak`;
+      const backupPath = path.join(this.backupDir, backupName);
+
+      fs.copyFileSync(fullPath, backupPath);
+      fs.unlinkSync(fullPath);
+
+      return { success: true, path: fullPath };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Get list of backups
+   */
+  getBackups() {
+    if (!fs.existsSync(this.backupDir)) {
+      return [];
+    }
+
+    try {
+      const files = fs.readdirSync(this.backupDir);
+      return files
+        .map(file => {
+          const stats = fs.statSync(path.join(this.backupDir, file));
+          return {
+            name: file,
+            path: path.join(this.backupDir, file),
+            timestamp: stats.mtime
+          };
+        })
+        .sort((a, b) => b.timestamp - a.timestamp);
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Restore most recent backup for a file
+   */
+  restoreLatest(filePath) {
+    const relativePath = path.relative(this.projectDir,
+      path.isAbsolute(filePath) ? filePath : path.join(this.projectDir, filePath)
+    );
+    const searchPrefix = relativePath.replace(/[/\\]/g, '_') + '.';
+
+    const backups = this.getBackups().filter(b => b.name.startsWith(searchPrefix));
+
+    if (backups.length === 0) {
+      return { success: false, error: 'No backups found for this file' };
+    }
+
+    const latestBackup = backups[0];
+
+    try {
+      const content = fs.readFileSync(latestBackup.path, 'utf-8');
+      const targetPath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(this.projectDir, filePath);
+
+      fs.writeFileSync(targetPath, content, 'utf-8');
+
+      return { success: true, restored: latestBackup.name };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Check if a path exists
+   */
+  exists(filePath) {
+    const fullPath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.projectDir, filePath);
+    return fs.existsSync(fullPath);
+  }
+
+  /**
+   * Check if path is a directory
+   */
+  isDirectory(filePath) {
+    const fullPath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(this.projectDir, filePath);
+    try {
+      return fs.statSync(fullPath).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = FileManager;

package/lib/historyManager.js

@@ -0,0 +1,124 @@
+/**
+ * Command history manager with readline integration
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class HistoryManager {
+  constructor(bananaDir, maxHistory = 100) {
+    this.historyFile = path.join(bananaDir, 'command_history.txt');
+    this.maxHistory = maxHistory;
+    this.history = [];
+    this.historyIndex = -1;
+    this.currentInput = '';
+    this.load();
+  }
+
+  load() {
+    try {
+      let filePath = this.historyFile;
+      // Migrate from .ripley/ history if .banana/ history doesn't exist
+      if (!fs.existsSync(filePath)) {
+        const legacyPath = filePath.replace(/\.banana/, '.ripley');
+        if (legacyPath !== filePath && fs.existsSync(legacyPath)) {
+          filePath = legacyPath;
+        }
+      }
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        this.history = content.split('\n').filter(line => line.trim());
+        // Keep only recent history
+        if (this.history.length > this.maxHistory) {
+          this.history = this.history.slice(-this.maxHistory);
+        }
+        // If we read from legacy path, save to new path
+        if (filePath !== this.historyFile) {
+          this.save();
+        }
+      }
+    } catch {
+      this.history = [];
+    }
+  }
+
+  save() {
+    try {
+      const dir = path.dirname(this.historyFile);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.historyFile, this.history.join('\n'));
+    } catch {
+      // Ignore save errors
+    }
+  }
+
+  add(command) {
+    if (!command.trim()) return;
+
+    // Don't add duplicates of the last command
+    if (this.history.length > 0 && this.history[this.history.length - 1] === command) {
+      return;
+    }
+
+    this.history.push(command);
+
+    // Trim history if too long
+    if (this.history.length > this.maxHistory) {
+      this.history = this.history.slice(-this.maxHistory);
+    }
+
+    this.resetIndex();
+    this.save();
+  }
+
+  resetIndex() {
+    this.historyIndex = this.history.length;
+    this.currentInput = '';
+  }
+
+  up(currentLine) {
+    if (this.historyIndex === this.history.length) {
+      this.currentInput = currentLine;
+    }
+
+    if (this.historyIndex > 0) {
+      this.historyIndex--;
+      return this.history[this.historyIndex];
+    }
+
+    return this.history[0] || currentLine;
+  }
+
+  down(currentLine) {
+    if (this.historyIndex < this.history.length - 1) {
+      this.historyIndex++;
+      return this.history[this.historyIndex];
+    } else if (this.historyIndex === this.history.length - 1) {
+      this.historyIndex = this.history.length;
+      return this.currentInput;
+    }
+
+    return currentLine;
+  }
+
+  search(prefix) {
+    const matches = this.history.filter(cmd =>
+      cmd.toLowerCase().startsWith(prefix.toLowerCase())
+    );
+    return matches;
+  }
+
+  getRecent(count = 10) {
+    return this.history.slice(-count);
+  }
+
+  clear() {
+    this.history = [];
+    this.resetIndex();
+    this.save();
+  }
+}
+
+module.exports = HistoryManager;