banana-code 1.2.0

package/lib/borderRenderer.js

@@ -0,0 +1,41 @@
+/**
+ * borderRenderer.js - Colored left-border prefix strings for message types
+ */
+
+const RESET = '\x1b[0m';
+
+const BORDERS = {
+  user:     { char: '│', color: '\x1b[38;5;220m' },  // banana yellow
+  ai:       { char: '│', color: '\x1b[38;5;75m'  },  // blue/cyan
+  thinking: { char: '│', color: '\x1b[38;5;240m' },  // dim gray
+  tool:     { char: '│', color: '\x1b[38;5;245m' },  // gray
+};
+
+const PAD = '   ';
+
+/**
+ * Returns a colored border prefix string for the given speaker type.
+ * e.g. "  \x1b[38;5;220m│\x1b[0m "
+ */
+function prefix(speaker) {
+  const b = BORDERS[speaker];
+  if (!b) return PAD;
+  return `${PAD}${b.color}${b.char}${RESET} `;
+}
+
+/**
+ * Strip ANSI escape codes from a string for visual width calculation.
+ */
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+/**
+ * Get the visual (display) width of the prefix for a speaker type.
+ */
+function prefixWidth(speaker) {
+  return stripAnsi(prefix(speaker)).length;
+}
+
+module.exports = { prefix, stripAnsi, prefixWidth, BORDERS, PAD };

package/lib/commandRunner.js

@@ -0,0 +1,205 @@
+/**
+ * Command Runner - Execute shell commands safely
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Commands that are always blocked
+const BLOCKED_COMMANDS = [
+  'rm -rf /', 'rm -rf /*', 'del /s /q c:',
+  'format c:', 'mkfs', ':(){:|:&};:'
+];
+
+// Commands that require confirmation
+const DANGEROUS_PATTERNS = [
+  /^rm\s+-rf/i,
+  /^del\s+\/s/i,
+  /^rmdir\s+\/s/i,
+  /drop\s+database/i,
+  /drop\s+table/i,
+  /truncate\s+table/i
+];
+
+class CommandRunner {
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.isWindows = process.platform === 'win32';
+  }
+
+  /**
+   * Check if a command is blocked
+   */
+  isBlocked(command) {
+    const lowerCmd = command.toLowerCase().trim();
+
+    // Check absolute blocks
+    for (const blocked of BLOCKED_COMMANDS) {
+      if (lowerCmd.includes(blocked)) {
+        return { blocked: true, reason: 'This command is blocked for safety' };
+      }
+    }
+
+    return { blocked: false };
+  }
+
+  /**
+   * Check if a command needs extra confirmation
+   */
+  isDangerous(command) {
+    for (const pattern of DANGEROUS_PATTERNS) {
+      if (pattern.test(command)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Run a command and return a promise with the result
+   */
+  run(command, options = {}) {
+    return new Promise((resolve, reject) => {
+      const blockCheck = this.isBlocked(command);
+      if (blockCheck.blocked) {
+        reject(new Error(blockCheck.reason));
+        return;
+      }
+
+      const shell = this.isWindows ? 'cmd.exe' : '/bin/sh';
+      const shellArg = this.isWindows ? '/c' : '-c';
+
+      const child = spawn(shell, [shellArg, command], {
+        cwd: options.cwd || this.projectDir,
+        env: { ...process.env, ...options.env },
+        stdio: options.stream ? 'inherit' : 'pipe'
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      if (!options.stream) {
+        child.stdout.on('data', (data) => {
+          stdout += data.toString();
+          if (options.onStdout) options.onStdout(data.toString());
+        });
+
+        child.stderr.on('data', (data) => {
+          stderr += data.toString();
+          if (options.onStderr) options.onStderr(data.toString());
+        });
+      }
+
+      child.on('close', (code) => {
+        resolve({
+          code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          success: code === 0
+        });
+      });
+
+      child.on('error', (error) => {
+        reject(error);
+      });
+
+      // Handle timeout
+      if (options.timeout) {
+        setTimeout(() => {
+          child.kill('SIGTERM');
+          reject(new Error(`Command timed out after ${options.timeout}ms`));
+        }, options.timeout);
+      }
+    });
+  }
+
+  /**
+   * Run a command with streaming output
+   */
+  runWithStream(command, options = {}) {
+    return this.run(command, { ...options, stream: true });
+  }
+
+  /**
+   * Run npm/pnpm/yarn command
+   */
+  async runPackageManager(args, options = {}) {
+    // Detect package manager
+    const fs = require('fs');
+
+    let pm = 'npm';
+    if (fs.existsSync(path.join(this.projectDir, 'pnpm-lock.yaml'))) {
+      pm = 'pnpm';
+    } else if (fs.existsSync(path.join(this.projectDir, 'yarn.lock'))) {
+      pm = 'yarn';
+    } else if (fs.existsSync(path.join(this.projectDir, 'bun.lockb'))) {
+      pm = 'bun';
+    }
+
+    return this.run(`${pm} ${args}`, options);
+  }
+
+  /**
+   * Install dependencies
+   */
+  async install(packages = [], options = {}) {
+    if (packages.length === 0) {
+      return this.runPackageManager('install', options);
+    }
+    return this.runPackageManager(`install ${packages.join(' ')}`, options);
+  }
+
+  /**
+   * Run a dev server
+   */
+  async runDev(options = {}) {
+    return this.runPackageManager('run dev', { ...options, stream: true });
+  }
+
+  /**
+   * Run build
+   */
+  async build(options = {}) {
+    return this.runPackageManager('run build', options);
+  }
+
+  /**
+   * Run tests
+   */
+  async test(options = {}) {
+    return this.runPackageManager('test', options);
+  }
+
+  /**
+   * Git operations
+   */
+  async git(args, options = {}) {
+    return this.run(`git ${args}`, options);
+  }
+
+  /**
+   * Get current git status
+   */
+  async gitStatus() {
+    try {
+      const result = await this.git('status --porcelain');
+      if (!result.success) {
+        return { isRepo: false, changes: [] };
+      }
+
+      const changes = result.stdout
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => ({
+          status: line.substring(0, 2).trim(),
+          file: line.substring(3)
+        }));
+
+      return { isRepo: true, changes };
+    } catch {
+      return { isRepo: false, changes: [] };
+    }
+  }
+}
+
+module.exports = CommandRunner;

package/lib/completer.js

@@ -0,0 +1,286 @@
+/**
+ * Tab completion for Banana Code
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class Completer {
+  constructor(projectDir, contextBuilder) {
+    this.projectDir = projectDir;
+    this.contextBuilder = contextBuilder;
+
+    // All built-in slash commands from handleCommand() switch
+    this.builtinCommands = [
+      '/help', '/?', '/update', '/version', '/v',
+      '/files', '/ls', '/read', '/add', '/unread', '/remove',
+      '/tree', '/find', '/grep', '/search',
+      '/image',
+      '/git', '/status', '/diff', '/log',
+      '/clear', '/clearhistory',
+      '/save', '/load', '/sessions',
+      '/context', '/tokens',
+      '/think', '/steer', '/steering',
+      '/ctx', '/compact', '/stream',
+      '/watch', '/yolo', '/agent',
+      '/hooks',
+      '/work', '/code', '/plan', '/implement', '/ask', '/mode',
+      '/prompt', '/model', '/models', '/connect', '/mcp',
+      '/config', '/set', '/instructions',
+      '/run', '/exec', '/$',
+      '/undo', '/backups', '/restore',
+      '/exit', '/quit', '/q',
+      '/commands'
+    ];
+
+    // Load custom commands from all locations, deduplicated
+    this.commands = [...new Set([
+      ...this.builtinCommands,
+      ...this._loadGlobalCommandNames(),
+      ...this._loadProjectCommandNames()
+    ])];
+
+    this.configKeys = [
+      'compactMode', 'streamingEnabled', 'maxTokens',
+      'tokenWarningThreshold', 'autoSaveHistory', 'geminiApiKey', 'steeringEnabled'
+    ];
+  }
+
+  complete(line) {
+    const trimmed = line.trim();
+
+    // Command completion
+    if (trimmed.startsWith('/')) {
+      return this.completeCommand(trimmed);
+    }
+
+    // @ file mention completion
+    if (trimmed.includes('@')) {
+      return this.completeFileMention(trimmed);
+    }
+
+    // Default: no completions
+    return [[], line];
+  }
+
+  completeCommand(line) {
+    const parts = line.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+
+    // If just "/" show all commands
+    if (cmd === '/') {
+      return [this.commands, '/'];
+    }
+
+    // If just the command, complete command names
+    if (parts.length === 1) {
+      const matches = this.commands.filter(c => c.startsWith(cmd));
+      return [matches, cmd];
+    }
+
+    // Command-specific completions
+    const arg = parts.slice(1).join(' ');
+
+    switch (cmd) {
+      case '/read':
+      case '/unread':
+      case '/restore':
+        return this.completeFilePath(arg, cmd + ' ');
+
+      case '/set':
+        if (parts.length === 2) {
+          const matches = this.configKeys.filter(k =>
+            k.toLowerCase().startsWith(arg.toLowerCase())
+          );
+          return [matches.map(m => `${cmd} ${m}`), line];
+        }
+        break;
+
+      case '/connect':
+        if (parts.length === 2) {
+          const options = ['anthropic', 'openai', 'openrouter', 'status', 'list', 'disconnect', 'use'];
+          const matches = options.filter(o => o.startsWith(arg.toLowerCase()));
+          return [matches.map(m => `${cmd} ${m}`), line];
+        }
+        if (parts.length === 3 && ['disconnect', 'use'].includes(parts[1].toLowerCase())) {
+          const providers = ['local', 'anthropic', 'openai', 'openrouter'];
+          const providerArg = parts[2].toLowerCase();
+          const matches = providers.filter(p => p.startsWith(providerArg));
+          return [matches.map(m => `${cmd} ${parts[1]} ${m}`), line];
+        }
+        break;
+
+      case '/model':
+      case '/models':
+        if (parts.length === 2) {
+          const options = ['search'];
+          const matches = options.filter(o => o.startsWith(arg.toLowerCase()));
+          return [matches.map(m => `${cmd} ${m}`), line];
+        }
+        break;
+
+      case '/think':
+        if (parts.length === 2) {
+          const options = ['off', 'low', 'medium', 'high'];
+          const matches = options.filter(o => o.startsWith(arg.toLowerCase()));
+          return [matches.map(m => `${cmd} ${m}`), line];
+        }
+        break;
+
+      case '/steer':
+      case '/steering':
+        if (parts.length === 2) {
+          const options = ['status', 'show', 'clear', 'on', 'off'];
+          const matches = options.filter(o => o.startsWith(arg.toLowerCase()));
+          return [matches.map(m => `${cmd} ${m}`), line];
+        }
+        break;
+
+      case '/hooks':
+        if (parts.length === 2) {
+          const options = ['list', 'add', 'remove', 'toggle', 'test'];
+          const matches = options.filter(o => o.startsWith(arg.toLowerCase()));
+          return [matches.map(m => `${cmd} ${m}`), line];
+        }
+        break;
+
+      case '/load':
+        return this.completeSessionName(arg, cmd + ' ');
+
+      case '/find':
+      case '/grep':
+        // No completion for search patterns
+        break;
+
+      case '/run':
+        return this.completeShellCommand(arg, cmd + ' ');
+    }
+
+    return [[], line];
+  }
+
+  completeFilePath(partial, prefix = '') {
+    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 [[], prefix + partial];
+      }
+
+      const entries = fs.readdirSync(fullSearchDir, { withFileTypes: true });
+
+      const matches = entries
+        .filter(e => {
+          // Skip hidden and common ignores
+          if (e.name.startsWith('.')) return false;
+          if (e.name === 'node_modules') return false;
+          return e.name.toLowerCase().startsWith(searchBase.toLowerCase());
+        })
+        .map(e => {
+          const relativePath = searchDir === '.'
+            ? e.name
+            : path.join(searchDir, e.name).replace(/\\/g, '/');
+          return prefix + relativePath + (e.isDirectory() ? '/' : '');
+        })
+        .slice(0, 20); // Limit suggestions
+
+      return [matches, prefix + partial];
+    } catch {
+      return [[], prefix + partial];
+    }
+  }
+
+  completeFileMention(line) {
+    // Find the @ mention being typed
+    const atIndex = line.lastIndexOf('@');
+    if (atIndex === -1) return [[], line];
+
+    const beforeAt = line.slice(0, atIndex);
+    const afterAt = line.slice(atIndex + 1);
+
+    // Get file completions
+    const [completions] = this.completeFilePath(afterAt);
+
+    // Format as @ mentions
+    const matches = completions.map(c => beforeAt + '@' + c);
+
+    return [matches, line];
+  }
+
+  completeSessionName(partial, prefix = '') {
+    try {
+      const historyDir = path.join(this.projectDir, '.banana', 'history');
+      if (!fs.existsSync(historyDir)) return [[], prefix + partial];
+
+      const files = fs.readdirSync(historyDir)
+        .filter(f => f.endsWith('.json'))
+        .filter(f => f.toLowerCase().includes(partial.toLowerCase()))
+        .slice(0, 10);
+
+      return [files.map(f => prefix + f), prefix + partial];
+    } catch {
+      return [[], prefix + partial];
+    }
+  }
+
+  _loadGlobalCommandNames() {
+    const names = [];
+    const dirs = [
+      path.join(require('os').homedir(), '.banana', 'commands'),
+      path.join(require('os').homedir(), '.ripley', 'commands') // legacy
+    ];
+    for (const dir of dirs) {
+      try {
+        if (!fs.existsSync(dir)) continue;
+        for (const f of fs.readdirSync(dir)) {
+          if (f.endsWith('.md')) {
+            const cmd = '/' + f.replace('.md', '').toLowerCase();
+            if (!names.includes(cmd)) names.push(cmd);
+          }
+        }
+      } catch {}
+    }
+    return names;
+  }
+
+  _loadProjectCommandNames() {
+    try {
+      const commandsDir = path.join(this.projectDir, '.banana', 'commands');
+      if (!fs.existsSync(commandsDir)) return [];
+      return fs.readdirSync(commandsDir)
+        .filter(f => f.endsWith('.md'))
+        .map(f => '/' + f.replace('.md', '').toLowerCase())
+        .filter(cmd => !this.builtinCommands.includes(cmd)); // avoid duplicates
+    } catch {
+      return [];
+    }
+  }
+
+  completeShellCommand(partial, prefix = '') {
+    // Common commands
+    const commonCommands = [
+      'npm install', 'npm run', 'npm test', 'npm start', 'npm run dev', 'npm run build',
+      'pnpm install', 'pnpm run', 'pnpm test', 'pnpm dev', 'pnpm build',
+      'yarn install', 'yarn', 'yarn test', 'yarn dev', 'yarn build',
+      'git status', 'git add', 'git commit', 'git push', 'git pull', 'git log',
+      'ls', 'dir', 'cd', 'mkdir', 'rm', 'cat', 'echo',
+      'node', 'npx', 'tsx', 'ts-node'
+    ];
+
+    const matches = commonCommands
+      .filter(c => c.toLowerCase().startsWith(partial.toLowerCase()))
+      .map(c => prefix + c);
+
+    return [matches, prefix + partial];
+  }
+}
+
+module.exports = Completer;