banana-code 1.2.0

package/lib/imageHandler.js

@@ -0,0 +1,268 @@
+/**
+ * Image/Screenshot handler for Banana Code
+ * Supports base64 encoding for vision models
+ * Includes clipboard paste support for screenshots
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+const os = require('os');
+
+class ImageHandler {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.pendingImages = [];
+
+    this.supportedFormats = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp'];
+    this.maxSizeBytes = 20 * 1024 * 1024; // 20MB limit
+
+    // Temp directory for clipboard images
+    this.tempDir = path.join(os.tmpdir(), 'banana-screenshots');
+    if (!fs.existsSync(this.tempDir)) {
+      fs.mkdirSync(this.tempDir, { recursive: true });
+    }
+  }
+
+  // Load an image and convert to base64
+  loadImage(imagePath) {
+    const fullPath = path.isAbsolute(imagePath)
+      ? imagePath
+      : path.join(this.projectDir, imagePath);
+
+    if (!fs.existsSync(fullPath)) {
+      return { success: false, error: `File not found: ${imagePath}` };
+    }
+
+    const ext = path.extname(fullPath).toLowerCase();
+    if (!this.supportedFormats.includes(ext)) {
+      return {
+        success: false,
+        error: `Unsupported format: ${ext}. Supported: ${this.supportedFormats.join(', ')}`
+      };
+    }
+
+    const stats = fs.statSync(fullPath);
+    if (stats.size > this.maxSizeBytes) {
+      return {
+        success: false,
+        error: `Image too large: ${(stats.size / 1024 / 1024).toFixed(1)}MB (max: 20MB)`
+      };
+    }
+
+    try {
+      const buffer = fs.readFileSync(fullPath);
+      const base64 = buffer.toString('base64');
+      const mimeType = this.getMimeType(ext);
+
+      return {
+        success: true,
+        data: {
+          path: imagePath,
+          base64,
+          mimeType,
+          size: stats.size,
+          dataUrl: `data:${mimeType};base64,${base64}`
+        }
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  getMimeType(ext) {
+    const mimeTypes = {
+      '.png': 'image/png',
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.gif': 'image/gif',
+      '.webp': 'image/webp',
+      '.bmp': 'image/bmp'
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+  }
+
+  // Add image to pending list (to be included in next message)
+  addImage(imagePath) {
+    const result = this.loadImage(imagePath);
+    if (result.success) {
+      this.pendingImages.push(result.data);
+    }
+    return result;
+  }
+
+  // Get pending images and clear the list
+  consumePendingImages() {
+    const images = [...this.pendingImages];
+    this.pendingImages = [];
+    return images;
+  }
+
+  // Check if there are pending images
+  hasPendingImages() {
+    return this.pendingImages.length > 0;
+  }
+
+  // Get count of pending images
+  getPendingCount() {
+    return this.pendingImages.length;
+  }
+
+  // Clear pending images
+  clearPending() {
+    this.pendingImages = [];
+  }
+
+  /**
+   * Paste image from clipboard (Windows only for now)
+   * Returns the image data if successful
+   */
+  async pasteFromClipboard() {
+    const platform = process.platform;
+
+    if (platform === 'win32') {
+      return this.pasteFromClipboardWindows();
+    } else if (platform === 'darwin') {
+      return this.pasteFromClipboardMac();
+    } else {
+      return { success: false, error: 'Clipboard paste only supported on Windows and macOS' };
+    }
+  }
+
+  /**
+   * Windows clipboard paste using PowerShell
+   */
+  async pasteFromClipboardWindows() {
+    const timestamp = Date.now();
+    const tempFile = path.join(this.tempDir, `clipboard-${timestamp}.png`);
+    const scriptFile = path.join(this.tempDir, `paste-${timestamp}.ps1`);
+
+    // Write PowerShell script to temp file to avoid escaping issues
+    const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+$img = [System.Windows.Forms.Clipboard]::GetImage()
+if ($img -ne $null) {
+    $img.Save("${tempFile.replace(/\\/g, '\\\\')}", [System.Drawing.Imaging.ImageFormat]::Png)
+    Write-Host "SUCCESS"
+} else {
+    Write-Host "NO_IMAGE"
+}
+`;
+
+    try {
+      // Write script to temp file
+      fs.writeFileSync(scriptFile, psScript, 'utf-8');
+
+      // Execute the script file
+      const result = execSync(`powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptFile}"`, {
+        encoding: 'utf-8',
+        windowsHide: true
+      }).trim();
+
+      // Clean up script file
+      try { fs.unlinkSync(scriptFile); } catch {}
+
+      if (result === 'NO_IMAGE') {
+        return { success: false, error: 'No image in clipboard. Copy a screenshot first (Win+Shift+S)' };
+      }
+
+      if (result === 'SUCCESS' && fs.existsSync(tempFile)) {
+        const loadResult = this.loadImage(tempFile);
+        if (loadResult.success) {
+          loadResult.data.path = `clipboard-${timestamp}.png`;
+          loadResult.data.isClipboard = true;
+          this.pendingImages.push(loadResult.data);
+          return { success: true, data: loadResult.data };
+        }
+        return loadResult;
+      }
+
+      return { success: false, error: 'Failed to save clipboard image' };
+    } catch (error) {
+      // Clean up script file on error
+      try { fs.unlinkSync(scriptFile); } catch {}
+      return { success: false, error: `Clipboard error: ${error.message}` };
+    }
+  }
+
+  /**
+   * macOS clipboard paste using pngpaste or screencapture
+   */
+  async pasteFromClipboardMac() {
+    const timestamp = Date.now();
+    const tempFile = path.join(this.tempDir, `clipboard-${timestamp}.png`);
+
+    try {
+      // Try pngpaste first (brew install pngpaste)
+      try {
+        execSync(`pngpaste "${tempFile}"`, { encoding: 'utf-8' });
+      } catch {
+        // Fallback to osascript + screencapture
+        execSync(`osascript -e 'tell application "System Events" to ¬
+          write (the clipboard as «class PNGf») to ¬
+          (make new file at folder "${this.tempDir}" with properties {name:"clipboard-${timestamp}.png"})'`);
+      }
+
+      if (fs.existsSync(tempFile)) {
+        const loadResult = this.loadImage(tempFile);
+        if (loadResult.success) {
+          loadResult.data.path = `clipboard-${timestamp}.png`;
+          loadResult.data.isClipboard = true;
+          this.pendingImages.push(loadResult.data);
+          return { success: true, data: loadResult.data };
+        }
+        return loadResult;
+      }
+
+      return { success: false, error: 'No image in clipboard' };
+    } catch (error) {
+      return { success: false, error: `Clipboard error: ${error.message}` };
+    }
+  }
+
+  // Format images for API request (OpenAI vision format)
+  formatForAPI(images) {
+    return images.map(img => ({
+      type: 'image_url',
+      image_url: {
+        url: img.dataUrl
+      }
+    }));
+  }
+
+  // Format message with images for vision API
+  formatMessageWithImages(textContent, images) {
+    if (!images || images.length === 0) {
+      return textContent;
+    }
+
+    // Return array format for vision models
+    return [
+      { type: 'text', text: textContent },
+      ...this.formatForAPI(images)
+    ];
+  }
+
+  // Find images in project
+  async findImages(pattern = '**/*.{png,jpg,jpeg,gif,webp}') {
+    const { glob } = require('glob');
+
+    try {
+      const files = await glob(pattern, {
+        cwd: this.projectDir,
+        nodir: true,
+        ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**']
+      });
+
+      return files.map(file => ({
+        path: file,
+        name: path.basename(file),
+        ext: path.extname(file)
+      }));
+    } catch {
+      return [];
+    }
+  }
+}
+
+module.exports = ImageHandler;

package/lib/inlineComplete.js

@@ -0,0 +1,192 @@
+/**
+ * Inline ghost-text autocomplete for Banana Code
+ *
+ * Fish-shell style: as you type, a dim suggestion appears after the cursor.
+ * Tab or Right arrow accepts it.
+ *
+ * This class manages suggestion logic and ghost state.
+ * Visual rendering is handled in banana.js via the keypress event loop:
+ * - prependListener: \x1b[K clears ghost BEFORE readline processes keystroke
+ * - setImmediate: renders new ghost in dim AFTER readline updates cursor
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class InlineComplete {
+  constructor() {
+    this.currentGhost = '';  // The ghost text currently displayed
+    this.commands = [];      // All known commands (sorted)
+    this.projectDir = null;  // For @ file path completion
+    this.justAccepted = false; // Flag: next completer call should skip once
+  }
+
+  /**
+   * Update the list of known commands.
+   * @param {string[]} commands - Array of command strings like ['/help', '/push', ...]
+   */
+  setCommands(commands) {
+    this.commands = [...(commands || [])].sort();
+  }
+
+  /**
+   * Find the best single suggestion for the current line.
+   * Returns the REMAINING text to complete (not the full command).
+   * Returns null if no match or ambiguous.
+   *
+   * @param {string} line - Current input line
+   * @returns {string|null} - Ghost text to display, or null
+   */
+  suggest(line) {
+    if (!line) return null;
+
+    // @ file path completion - find the last @ in the line
+    const atIndex = line.lastIndexOf('@');
+    if (atIndex >= 0) {
+      const partial = line.slice(atIndex + 1);
+      // Only suggest if there's something after @ (user started typing a path)
+      if (partial.length > 0) {
+        return this._suggestFilePath(partial);
+      }
+      return null;
+    }
+
+    // / command completion
+    if (!line.startsWith('/')) return null;
+
+    const lower = line.toLowerCase();
+    const matches = this.commands.filter(c => c.toLowerCase().startsWith(lower));
+
+    if (matches.length === 0) return null;
+
+    // Exact match - nothing to suggest
+    if (matches.some(c => c.toLowerCase() === lower)) return null;
+
+    // Single match - return the remaining portion
+    if (matches.length === 1) {
+      return matches[0].slice(line.length);
+    }
+
+    // Multiple matches - find common prefix beyond what's typed
+    const prefix = commonPrefix(matches.map(c => c.slice(line.length)));
+    if (prefix.length > 0) return prefix;
+
+    // Ambiguous with no common prefix - show nothing rather than guess
+    return null;
+  }
+
+  /**
+   * Suggest a file path completion for @ mentions.
+   * Returns the remaining text to append, or null.
+   */
+  _suggestFilePath(partial) {
+    if (!this.projectDir) return null;
+
+    try {
+      const searchDir = partial.includes('/')
+        ? path.dirname(partial)
+        : '.';
+      const searchBase = partial.includes('/')
+        ? path.basename(partial)
+        : partial;
+      const fullSearchDir = path.join(this.projectDir, searchDir);
+
+      if (!fs.existsSync(fullSearchDir)) return null;
+
+      const entries = fs.readdirSync(fullSearchDir, { withFileTypes: true });
+      const matches = entries
+        .filter(e => {
+          if (e.name.startsWith('.')) return false;
+          if (e.name === 'node_modules') return false;
+          return e.name.toLowerCase().startsWith(searchBase.toLowerCase());
+        })
+        .map(e => {
+          const rel = searchDir === '.'
+            ? e.name
+            : path.join(searchDir, e.name).replace(/\\/g, '/');
+          return rel + (e.isDirectory() ? '/' : '');
+        });
+
+      if (matches.length === 0) return null;
+
+      // Single match
+      if (matches.length === 1) {
+        return matches[0].slice(partial.length);
+      }
+
+      // Multiple matches - find common prefix
+      const prefix = commonPrefix(matches.map(m => m.slice(partial.length)));
+      if (prefix.length > 0) return prefix;
+
+      // Ambiguous with no common prefix - show nothing rather than guess
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Store ghost text suggestion. Visual rendering is done by banana.js.
+   * @param {string} ghost - The ghost text to store
+   */
+  renderGhost(ghost) {
+    if (!ghost) return;
+    this.currentGhost = ghost;
+  }
+
+  /**
+   * Clear the ghost text state. Terminal cleanup is done by banana.js prependListener.
+   */
+  clearGhost() {
+    this.currentGhost = '';
+  }
+
+  /**
+   * Accept the current ghost text.
+   * Clears the visual ghost and optionally marks the next completer call to skip.
+   * Returns the text to be inserted via rl.write().
+   */
+  accept(markForCompleter = false) {
+    const ghost = this.currentGhost;
+    if (!ghost) return null;
+    this.justAccepted = Boolean(markForCompleter);
+    this.clearGhost();
+    return ghost;
+  }
+
+  /**
+   * Check if ghost text is currently showing.
+   */
+  hasGhost() {
+    return this.currentGhost.length > 0;
+  }
+
+  /**
+   * Check and reset the justAccepted flag.
+   * Called by the readline completer to know if it should skip completion.
+   */
+  consumeAccepted() {
+    if (this.justAccepted) {
+      this.justAccepted = false;
+      return true;
+    }
+    return false;
+  }
+}
+
+/**
+ * Find the longest common prefix of an array of strings.
+ */
+function commonPrefix(strings) {
+  if (strings.length === 0) return '';
+  let prefix = strings[0];
+  for (let i = 1; i < strings.length; i++) {
+    while (!strings[i].startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+      if (prefix.length === 0) return '';
+    }
+  }
+  return prefix;
+}
+
+module.exports = InlineComplete;

package/lib/interactivePicker.js

@@ -0,0 +1,254 @@
+/**
+ * Interactive arrow-key picker for Banana Code
+ *
+ * Renders a navigable list in the terminal. Arrow keys move highlight,
+ * Enter selects, Escape cancels. Temporarily takes over stdin.
+ */
+
+const readline = require('readline');
+
+const ESC = '\x1b';
+const HIDE_CURSOR = `${ESC}[?25l`;
+const SHOW_CURSOR = `${ESC}[?25h`;
+const CLEAR_LINE = `${ESC}[2K`;
+const MOVE_UP = (n) => n > 0 ? `${ESC}[${n}A` : '';
+const MOVE_COL0 = `${ESC}[0G`;
+
+// 256-color codes matching diffViewer.js palette
+const DIM = `${ESC}[2m`;
+const RESET = `${ESC}[0m`;
+const GREEN = `${ESC}[38;5;120m`;
+const YELLOW = `${ESC}[38;5;226m`;
+const CYAN = `${ESC}[38;5;51m`;
+const GRAY = `${ESC}[38;5;245m`;
+const INVERSE = `${ESC}[7m`;
+
+// Flag indicating a picker UI is active. When true, the global keypress
+// handler in banana.js should not process keys (arrow keys, escape, etc.)
+// because the picker owns stdin during its lifetime.
+let _pickerActive = false;
+function isPickerActive() { return _pickerActive; }
+
+/**
+ * Show an interactive picker menu.
+ *
+ * @param {Array} items - Array of { key, label, description, active, tags }\r\n * @param {Object} options\r\n * @param {string} options.title - Header text\r\n * @param {number} options.selected - Initial selected index (default: active item or 0)\r\n * @returns {Promise<<ObjectObject|null>} - Selected item, or null if cancelled\r\n */
+function pick(items, options = {}) {
+  return new Promise((resolve) => {
+    if (!items || items.length === 0) {
+      resolve(null);
+      return;
+    }
+
+    let selected = options.selected ?? items.findIndex(i => i.active);
+    if (selected <<  0) selected = 0;
+
+    const out = process.stdout;
+    const title = options.title || 'Select:';
+    const showVisionIndicator = options.showVisionIndicator === true;
+    const footerText = showVisionIndicator
+      ? `${DIM}  ↑↓ navigate  Enter select  Esc cancel  V=vision${RESET}`
+      : `${DIM}  ↑↓ navigate  Enter select  Esc cancel${RESET}`;
+
+    // Pad key names to align descriptions
+    const maxKeyLen = Math.max(...items.map(i => (i.key || '').length));
+
+    function formatItem(item, index) {
+      const isSel = index === selected;
+      const isActive = item.active;
+      const marker = isActive ? `${GREEN}●${RESET}` : `${GRAY}○${RESET}`;
+      const pointer = isSel ? `${CYAN}▸${RESET} ` : '  ';
+      const hasVision = Array.isArray(item.tags) && item.tags.includes('vision');
+      const vision = showVisionIndicator
+        ? (hasVision ? `${CYAN}V${RESET}` : `${DIM}.${RESET}`)
+        : '';
+      const key = (item.key || '').padEnd(maxKeyLen);
+      const tags = item.tags?.length ? ` ${DIM}[${item.tags.join(', ')}]${RESET}` : '';
+      const desc = item.description ? ` ${DIM}- ${item.description}${RESET}` : '';
+      const label = item.label || item.name || item.key;
+
+      if (isSel) {
+        const lead = showVisionIndicator ? `${pointer}${marker} ${vision} ` : `${pointer}${marker} `;
+        return `${lead}${INVERSE} ${YELLOW}${key}${RESET}${INVERSE}  ${label} ${RESET}${tags}`;
+      }
+      const lead = showVisionIndicator ? `${pointer}${marker} ${vision} ` : `${pointer}${marker} `;
+      return `${lead}${YELLOW}${key}${RESET}  ${DIM}${label}${RESET}${tags}`;
+    }
+
+    // Total lines we render (title + items + footer)
+    const totalLines = 1 + items.length + 1;
+
+    function render() {
+      _pickerActive = true;
+      let buf = HIDE_CURSOR;
+      buf += `\n${CYAN}  ${title}${RESET}\n`;
+      for (let i = 0; i << items items.length; i++) {
+        buf += `  ${formatItem(items[i], i)}\n`;
+      }
+      buf += `${footerText}\n`;
+      out.write(buf);
+    }
+
+    function redraw() {
+      // Move up to the start of the picker area
+      let buf = MOVE_UP(totalLines) + MOVE_COL0;
+      // Clear all lines in the area
+      for (let i = 0; i << total totalLines; i++) {
+        buf += CLEAR_LINE + '\n';
+      }
+      // Move back up to the start to re-render
+      buf += MOVE_UP(totalLines) + MOVE_COL0;
+      buf += `${CYAN}  ${title}${RESET}\n`;
+      for (let i = 0; i << items items.length; i++) {
+        buf += `  ${formatItem(items[i], i)}\n`;
+      }
+      buf += `${footerText}\n`;
+      out.write(buf);
+    }
+
+    function cleanup() {
+      _pickerActive = false;
+      process.stdin.removeListener('keypress', onKey);
+      out.write(SHOW_CURSOR);
+    }
+
+    function onKey(str, key) {
+      if (!key) return;
+      try {
+        if (key.name === 'up') {
+          selected = (selected - 1 + items.length) % items.length;
+          redraw();
+        } else if (key.name === 'down') {
+          selected = (selected + 1) % items.length;
+          redraw();
+        } else if (key.name === 'return') {
+          cleanup();
+          resolve(items[selected]);
+        } else if (key.name === 'escape') {
+          cleanup();
+          resolve(null);
+        }
+      } catch (err) {
+        cleanup();
+        resolve(null);
+      }
+    }
+
+    // Ensure keypress events are flowing
+    if (!process.stdin.listenerCount('keypress')) {
+      readline.emitKeypressEvents(process.stdin);
+    }
+
+    render();
+    process.stdin.on('keypress', onKey);
+  });
+}
+
+/**
+ * Interactive toggle list. Items can be toggled on/off with Space.
+ * Arrow keys navigate, Space toggles, Escape exits.
+ *
+ * @param {Array} items - Array of { key, label, description, enabled, meta }\r\n * @param {Object} options\r\n * @param {string} options.title - Header text\r\n * @param {Function} options.onToggle - Called with (item, newEnabled) when toggled. Should return true if toggle succeeded.\r\n * @returns {Promise<<voidvoid>} - Resolves when user presses Escape\r\n */
+function pickToggle(items, options = {}) {
+  return new Promise((resolve) => {
+    if (!items || items.length === 0) {
+      resolve();
+      return;
+    }
+
+    let selected = 0;
+    const out = process.stdout;
+    const title = options.title || 'Toggle:';
+    const onToggle = options.onToggle || (() => true);
+    const RED = `${ESC}[38;5;203m`;
+    const footerText = `${DIM}  ↑↓ navigate  Space toggle  Enter/Esc done${RESET}`;
+
+    const maxKeyLen = Math.max(...items.map(i => (i.key || '').length));
+
+    function formatItem(item, index) {
+      const isSel = index === selected;
+      const pointer = isSel ? `${CYAN}▸${RESET} ` : '  ';
+      const toggle = item.enabled ? `${GREEN}on ${RESET}` : `${RED}off${RESET}`;
+      const key = (item.key || '').padEnd(maxKeyLen);
+      const desc = item.description ? ` ${DIM}${item.description}${RESET}` : '';
+      const meta = item.meta ? ` ${DIM}[${item.meta}]${RESET}` : '';
+
+      if (isSel) {
+        return `${pointer}[${toggle}] ${INVERSE} ${YELLOW}${key}${RESET}${INVERSE} ${RESET}${desc}${meta}`;
+      }
+      return `${pointer}[${toggle}] ${YELLOW}${key}${RESET}${desc}${meta}`;
+    }
+
+    const totalLines = 1 + items.length + 1;
+
+    function render() {
+      _pickerActive = true;
+      let buf = HIDE_CURSOR;
+      buf += `\n${CYAN}  ${title}${RESET}\n`;
+      for (let i = 0; i << items items.length; i++) {
+        buf += `  ${formatItem(items[i], i)}\n`;
+      }
+      buf += `${footerText}\n`;
+      out.write(buf);
+    }
+
+    function redraw() {
+      // Move up to the start of the toggle area
+      let buf = MOVE_UP(totalLines) + MOVE_COL0;
+      // Clear all lines in the area
+      for (let i = 0; i << total totalLines; i++) {
+        buf += CLEAR_LINE + '\n';
+      }
+      // Move back up to the start to re-render
+      buf += MOVE_UP(totalLines) + MOVE_COL0;
+      buf += `${CYAN}  ${title}${RESET}\n`;
+      for (let i = 0; i << items items.length; i++) {
+        buf += `  ${formatItem(items[i], i)}\n`;
+      }
+      buf += `${footerText}\n`;
+      out.write(buf);
+    }
+
+    function cleanup() {
+      _pickerActive = false;
+      process.stdin.removeListener('keypress', onKey);
+      out.write(SHOW_CURSOR);
+    }
+
+    function onKey(str, key) {
+      if (!key) return;
+      try {
+        if (key.name === 'up') {
+          selected = (selected - 1 + items.length) % items.length;
+          redraw();
+        } else if (key.name === 'down') {
+          selected = (selected + 1) % items.length;
+          redraw();
+        } else if (key.name === 'space') {
+          const item = items[selected];
+          const newState = !item.enabled;
+          const success = onToggle(item, newState);
+          if (success !== false) {
+            item.enabled = newState;
+          }
+          redraw();
+        } else if (key.name === 'escape' || key.name === 'return') {
+          cleanup();
+          resolve();
+        }
+      } catch (err) {
+        cleanup();
+        resolve();
+      }
+    }
+
+    if (!process.stdin.listenerCount('keypress')) {
+      readline.emitKeypressEvents(process.stdin);
+    }
+
+    render();
+    process.stdin.on('keypress', onKey);
+  });
+}
+
+module.exports = { pick, pickToggle, isPickerActive };