beth-copilot 1.0.10 → 1.0.11

package/bin/cli.js

@@ -5,6 +5,7 @@ import { dirname, join, relative } from 'path';
 import { existsSync, mkdirSync, readdirSync, statSync, copyFileSync, readFileSync, writeFileSync } from 'fs';
 import { createRequire } from 'module';
 import { execSync, spawn } from 'child_process';
+import { validateBeadsPath, validateBacklogPath, validateBinaryPath } from './lib/pathValidation.js';
 
 const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
@@ -18,12 +19,367 @@ const CURRENT_VERSION = packageJson.version;
 const COLORS = {
   reset: '\x1b[0m',
   bright: '\x1b[1m',
+  dim: '\x1b[2m',
   red: '\x1b[31m',
   green: '\x1b[32m',
   yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
   cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  bgRed: '\x1b[41m',
+  bgYellow: '\x1b[43m',
 };
 
+// Beth's dramatic ASCII banner
+const BETH_ASCII = [
+  '██████╗ ███████╗████████╗██╗  ██╗',
+  '██╔══██╗██╔════╝╚══██╔══╝██║  ██║',
+  '██████╔╝█████╗     ██║   ███████║',
+  '██╔══██╗██╔══╝     ██║   ██╔══██║',
+  '██████╔╝███████╗   ██║   ██║  ██║',
+  '╚═════╝ ╚══════╝   ╚═╝   ╚═╝  ╚═╝',
+];
+
+// Fire characters for animation (from light to intense)
+const FIRE_CHARS = [' ', '.', ':', '*', 's', 'S', '#', '$', '&', '@'];
+const FIRE_CHARS_SIMPLE = [' ', '.', '*', '^', ')', '(', '%', '#'];
+
+// Generate a fire line with flickering effect
+function generateFireLine(width, intensity, frame) {
+  let line = '';
+  for (let i = 0; i < width; i++) {
+    // Create wave pattern for fire
+    const wave = Math.sin((i + frame) * 0.3) * 0.5 + 0.5;
+    const noise = Math.random();
+    const heat = (intensity * wave * 0.7 + noise * 0.3);
+    
+    if (heat > 0.85) {
+      line += FIRE_CHARS_SIMPLE[7]; // #
+    } else if (heat > 0.7) {
+      line += FIRE_CHARS_SIMPLE[6]; // %
+    } else if (heat > 0.55) {
+      line += FIRE_CHARS_SIMPLE[Math.random() > 0.5 ? 4 : 5]; // ) or (
+    } else if (heat > 0.4) {
+      line += FIRE_CHARS_SIMPLE[3]; // ^
+    } else if (heat > 0.25) {
+      line += FIRE_CHARS_SIMPLE[2]; // *
+    } else if (heat > 0.1) {
+      line += FIRE_CHARS_SIMPLE[1]; // .
+    } else {
+      line += ' ';
+    }
+  }
+  return line;
+}
+
+const BETH_TAGLINES = [
+  "I don't speak dipshit. I speak in consequences.",
+  "They broke my wings and forgot I had claws.",
+  "I'm the trailer park AND the tornado.",
+  "I don't do excuses. I do results.",
+  "You want my opinion? You're getting it either way.",
+  "I believe in lovin' with your whole soul and destroyin' anything that wants to kill what you love.",
+  "The sting never fades. That's the point.",
+];
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function animateBethBanner() {
+  // Simple, clean fire animation
+  const RESET = '\x1b[0m';
+  const BRIGHT = '\x1b[1m';
+  
+  // Fire color palette
+  const FIRE_COLORS = [
+    '\x1b[97m',         // white (hottest)
+    '\x1b[93m',         // bright yellow
+    '\x1b[33m',         // yellow
+    '\x1b[38;5;214m',   // gold
+    '\x1b[38;5;208m',   // orange
+    '\x1b[91m',         // red
+    '\x1b[31m',         // dark red
+    '\x1b[38;5;52m',    // ember
+  ];
+  
+  // BETH gradient (red to yellow)
+  const BETH_COLORS = [
+    '\x1b[38;5;196m', '\x1b[38;5;202m', '\x1b[38;5;208m',
+    '\x1b[38;5;214m', '\x1b[38;5;220m', '\x1b[38;5;226m',
+  ];
+  
+  // Convert to character arrays
+  const bethLines = BETH_ASCII.map(s => [...s]);
+  const W = bethLines[0].length;
+  const H = bethLines.length;
+  const FIRE_H = 4;
+  const TOTAL_H = H + FIRE_H;
+  
+  // Helpers
+  const pick = arr => arr[Math.floor(Math.random() * arr.length)];
+  const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+  
+  // Hide cursor and make space
+  process.stdout.write('\x1b[?25l\n');
+  for (let i = 0; i < TOTAL_H; i++) console.log('');
+  
+  for (let frame = 0; frame < 70; frame++) {
+    process.stdout.write(`\x1b[${TOTAL_H}A`);
+    
+    // BETH visibility (fades in from frame 15-45)
+    const vis = clamp((frame - 15) / 30, 0, 1);
+    // Fire dies down at end
+    const fireStrength = frame > 55 ? 1 - (frame - 55) / 15 : 1;
+    
+    // Render BETH rows
+    for (let r = 0; r < H; r++) {
+      let line = '';
+      for (let c = 0; c < W; c++) {
+        const ch = bethLines[r][c];
+        if (ch === ' ') {
+          // Gap - show fire through it sometimes
+          if (Math.random() < 0.15 * fireStrength) {
+            const h = 0.3 + Math.random() * 0.3;
+            const ci = clamp(Math.floor((1 - h) * 5), 0, FIRE_COLORS.length - 1);
+            line += FIRE_COLORS[ci] + pick(['^', '*', '.']);
+          } else {
+            line += ' ';
+          }
+        } else {
+          // BETH character
+          if (Math.random() < vis) {
+            const ci = Math.floor((c / W) * BETH_COLORS.length);
+            const col = BETH_COLORS[clamp(ci, 0, BETH_COLORS.length - 1)];
+            line += (Math.random() > 0.95 ? '\x1b[97m' : col) + BRIGHT + ch;
+          } else {
+            // Not visible yet - show fire
+            const h = 0.5 + Math.random() * 0.5;
+            const ci = clamp(Math.floor((1 - h) * 4), 0, FIRE_COLORS.length - 1);
+            line += FIRE_COLORS[ci] + pick(['#', '@', '%', '&']);
+          }
+        }
+      }
+      console.log(line + RESET);
+    }
+    
+    // Fire rows below
+    for (let fr = 0; fr < FIRE_H; fr++) {
+      let line = '';
+      const baseHeat = (1 - fr / FIRE_H) * fireStrength;
+      for (let c = 0; c < W; c++) {
+        const wave = Math.sin((c + frame * 2) * 0.15) * 0.15;
+        const heat = clamp(baseHeat + wave + (Math.random() - 0.5) * 0.3, 0, 1);
+        
+        let ch;
+        if (heat > 0.6) ch = pick(['#', '@', '%']);
+        else if (heat > 0.35) ch = pick(['^', '*', '(', ')']);
+        else if (heat > 0.15) ch = pick(['.', ':', '*']);
+        else ch = ' ';
+        
+        const ci = clamp(Math.floor((1 - heat) * 6), 0, FIRE_COLORS.length - 1);
+        line += FIRE_COLORS[ci] + ch;
+      }
+      console.log(line + RESET);
+    }
+    
+    await sleep(frame < 15 ? 80 : frame < 45 ? 50 : 60);
+  }
+  
+  // Final clean frame
+  process.stdout.write(`\x1b[${TOTAL_H}A`);
+  for (let r = 0; r < H; r++) {
+    let line = '';
+    for (let c = 0; c < W; c++) {
+      const ci = Math.floor((c / W) * BETH_COLORS.length);
+      line += BETH_COLORS[clamp(ci, 0, BETH_COLORS.length - 1)] + BRIGHT + bethLines[r][c];
+    }
+    console.log(line + RESET);
+  }
+  // Clear fire area with spaces
+  for (let fr = 0; fr < FIRE_H; fr++) {
+    console.log(' '.repeat(W));
+  }
+  
+  process.stdout.write('\x1b[?25h');
+  
+  const tagline = BETH_TAGLINES[Math.floor(Math.random() * BETH_TAGLINES.length)];
+  console.log('');
+  process.stdout.write(COLORS.cyan + COLORS.bright + '"');
+  for (const ch of tagline) {
+    process.stdout.write(ch);
+    await sleep(18);
+  }
+  console.log('"' + COLORS.reset);
+  console.log('');
+  
+  // Show version and quick help
+  console.log(`${COLORS.dim}v${CURRENT_VERSION}${COLORS.reset}                          ${COLORS.dim}AI Orchestrator for GitHub Copilot${COLORS.reset}`);
+  console.log('');
+  console.log(`${COLORS.bright}Commands:${COLORS.reset}`);
+  console.log(`  ${COLORS.cyan}npx beth-copilot init${COLORS.reset}      Install Beth in your project`);
+  console.log(`  ${COLORS.cyan}npx beth-copilot help${COLORS.reset}      Show full documentation`);
+  console.log('');
+  console.log(`${COLORS.bright}After install:${COLORS.reset} Open VS Code → Copilot Chat → ${COLORS.cyan}@Beth${COLORS.reset}`);
+  console.log('');
+}
+
+function showBethBannerStatic({ showQuickHelp = true } = {}) {
+  const bethColors = [
+    '\x1b[38;5;196m',
+    '\x1b[38;5;202m',
+    '\x1b[38;5;208m',
+    '\x1b[38;5;214m',
+    '\x1b[38;5;220m',
+    '\x1b[38;5;226m',
+  ];
+  
+  const fireColors = [
+    '\x1b[93m',        // bright yellow
+    '\x1b[38;5;208m',  // orange
+    '\x1b[91m',        // red
+    '\x1b[38;5;52m',   // dark red
+  ];
+  
+  console.log('\n');
+  const bethChars = BETH_ASCII.map(line => [...line]);
+  const bethWidth = bethChars[0].length;
+  
+  // BETH with gradient
+  for (let row = 0; row < BETH_ASCII.length; row++) {
+    let line = '';
+    for (let c = 0; c < bethWidth; c++) {
+      const char = bethChars[row][c];
+      const colorIndex = Math.floor((c / bethWidth) * bethColors.length);
+      line += bethColors[Math.min(colorIndex, bethColors.length - 1)] + COLORS.bright + char;
+    }
+    console.log(line + COLORS.reset);
+  }
+  
+
+  
+  const tagline = BETH_TAGLINES[Math.floor(Math.random() * BETH_TAGLINES.length)];
+  console.log('');
+  console.log(COLORS.cyan + COLORS.bright + '"' + tagline + '"' + COLORS.reset);
+  console.log('');
+  
+  // Show version and quick help (optional)
+  if (showQuickHelp) {
+    console.log(`${COLORS.dim}v${CURRENT_VERSION}${COLORS.reset}                          ${COLORS.dim}AI Orchestrator for GitHub Copilot${COLORS.reset}`);
+    console.log('');
+    console.log(`${COLORS.bright}Commands:${COLORS.reset}`);
+    console.log(`  ${COLORS.cyan}npx beth-copilot init${COLORS.reset}      Install Beth in your project`);
+    console.log(`  ${COLORS.cyan}npx beth-copilot help${COLORS.reset}      Show full documentation`);
+    console.log('');
+    console.log(`${COLORS.bright}After install:${COLORS.reset} Open VS Code → Copilot Chat → ${COLORS.cyan}@Beth${COLORS.reset}`);
+    console.log('');
+  }
+}
+
+// Compact Beth portrait with colors
+const BETH_PORTRAIT = [
+  '       .╭━━━━━━━╮.',
+  '    ╭──╯ ▒▓▓▓▓▒ ╰──╮',
+  '   ╱  ▓██████████▓  ╲',
+  '  ╱  ████▓▓██▓▓████  ╲',
+  '  │  ███ ◉ ██ ◉ ███  │',
+  '  │   ███▄▄▄▄▄▄███   │',
+  '  │    ▀██▄══▄██▀    │',
+  '  │      ╰────╯      │',
+  '  │   ▓██████████▓   │',
+  '  ╲   ████████████   ╱',
+  '   ╲  ▀██████████▀  ╱',
+  '    ╰───╮      ╭───╯',
+  '        ╰──────╯',
+];
+
+// Portrait animation for init command
+async function animatePortrait() {
+  const AMBER = '\x1b[38;2;218;165;32m';
+  const GOLD = '\x1b[38;2;255;215;0m';
+  const SKIN = '\x1b[38;2;235;210;160m';
+  const DARK = '\x1b[38;2;139;90;43m';
+  const EYE = '\x1b[38;2;70;130;180m';
+  const LIP = '\x1b[38;2;180;80;80m';
+  const WHITE = '\x1b[38;2;255;255;255m';
+  const RESET = '\x1b[0m';
+  const BOLD = '\x1b[1m';
+  const DIM = '\x1b[2m';
+  
+  // Hide cursor
+  process.stdout.write('\x1b[?25l');
+  
+  try {
+    // Clear screen
+    process.stdout.write('\x1b[2J\x1b[H');
+    await sleep(200);
+    
+    // Quick glitch effect
+    const glitchChars = '░▒▓█';
+    for (let frame = 0; frame < 3; frame++) {
+      process.stdout.write('\x1b[H');
+      for (let j = 0; j < 5; j++) {
+        const col = Math.floor(Math.random() * 20) + 5;
+        const row = Math.floor(Math.random() * 10) + 2;
+        const r = Math.floor(Math.random() * 150 + 100);
+        const g = Math.floor(Math.random() * 100 + 50);
+        const b = Math.floor(Math.random() * 50);
+        const char = glitchChars[Math.floor(Math.random() * glitchChars.length)];
+        process.stdout.write(`\x1b[${row};${col}H\x1b[38;2;${r};${g};${b}m${char.repeat(3)}`);
+      }
+      await sleep(50);
+    }
+    
+    // Display portrait with colors
+    process.stdout.write('\x1b[2J\x1b[H');
+    console.log();
+    
+    for (let i = 0; i < BETH_PORTRAIT.length; i++) {
+      let line = BETH_PORTRAIT[i];
+      // Colorize: frame in amber, face content in skin tones
+      line = line
+        .replace(/[╭╮╯╰│╱╲━.─]/g, `${AMBER}$&${RESET}`)
+        .replace(/[▓█▒░▀▄▐▌]/g, `${SKIN}$&${RESET}`)
+        .replace(/◉/g, `${EYE}◉${RESET}`)
+        .replace(/══/g, `${LIP}══${RESET}`);
+      console.log('  ' + line);
+      await sleep(40);
+    }
+    
+    await sleep(300);
+    
+    // Banner below portrait
+    console.log();
+    console.log(`  ${GOLD}${BOLD}━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+    console.log(`  ${AMBER}${BOLD}        B E T H${RESET}`);
+    console.log(`  ${DIM}${WHITE}   AI Agent Orchestrator${RESET}`);
+    console.log(`  ${GOLD}${BOLD}━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+    
+    await sleep(300);
+    
+    // Typewriter quote
+    const quote = BETH_TAGLINES[Math.floor(Math.random() * BETH_TAGLINES.length)];
+    console.log();
+    process.stdout.write(`  ${AMBER}"`);
+    for (const ch of quote) {
+      process.stdout.write(ch);
+      await sleep(20);
+    }
+    console.log(`"${RESET}`);
+    console.log();
+    
+  } finally {
+    // Show cursor
+    process.stdout.write('\x1b[?25h');
+  }
+}
+
+// Detect if we can do animations (TTY and not piped)
+function canAnimate() {
+  return process.stdout.isTTY && !process.env.CI && !process.env.NO_COLOR;
+}
+
 function log(message, color = '') {
   console.log(`${color}${message}${COLORS.reset}`);
 }
@@ -226,6 +582,19 @@ async function promptForInput(question) {
   });
 }
 
+/**
+ * Installs the backlog.md CLI globally via npm.
+ * 
+ * SECURITY NOTE - shell:true usage:
+ * - Required for cross-platform npm execution (npm.cmd on Windows, npm on Unix)
+ * - Arguments are HARDCODED - no user input is passed to the shell
+ * - Command injection risk: NONE (no dynamic/user-supplied values)
+ * 
+ * Alternative considered: Using platform-specific binary names (npm.cmd vs npm)
+ * would eliminate shell:true but adds complexity and edge cases for non-standard installs.
+ * 
+ * @returns {Promise<boolean>} True if installation succeeded and was verified
+ */
 async function installBacklogCli() {
   const isWindows = process.platform === 'win32';
   const isMac = process.platform === 'darwin';
@@ -233,6 +602,8 @@ async function installBacklogCli() {
   log('\nInstalling backlog.md CLI via npm...', COLORS.cyan);
   logInfo('npm install -g backlog.md');
   
+  // SECURITY: shell:true is required for cross-platform npm execution.
+  // All arguments are hardcoded constants - no user input reaches the shell.
   return new Promise((resolve) => {
     const child = spawn('npm', ['install', '-g', 'backlog.md'], {
       stdio: 'inherit',
@@ -284,6 +655,19 @@ function showBacklogAlternatives(isMac) {
   logInfo('Learn more: https://github.com/MrLesk/Backlog.md');
 }
 
+/**
+ * Installs the beads CLI globally via npm.
+ * 
+ * SECURITY NOTE - shell:true usage:
+ * - Required for cross-platform npm execution (npm.cmd on Windows, npm on Unix)
+ * - Arguments are HARDCODED - no user input is passed to the shell
+ * - Command injection risk: NONE (no dynamic/user-supplied values)
+ * 
+ * Alternative considered: Using platform-specific binary names (npm.cmd vs npm)
+ * would eliminate shell:true but adds complexity and edge cases for non-standard installs.
+ * 
+ * @returns {Promise<boolean>} True if installation succeeded and was verified
+ */
 async function installBeads() {
   const isWindows = process.platform === 'win32';
   const isMac = process.platform === 'darwin';
@@ -291,6 +675,8 @@ async function installBeads() {
   log('\nInstalling beads CLI via npm...', COLORS.cyan);
   logInfo('npm install -g @beads/bd');
   
+  // SECURITY: shell:true is required for cross-platform npm execution.
+  // All arguments are hardcoded constants - no user input reaches the shell.
   return new Promise((resolve) => {
     const child = spawn('npm', ['install', '-g', '@beads/bd'], {
       stdio: 'inherit',
@@ -349,6 +735,23 @@ function showBeadsAlternatives(isWindows, isMac) {
   logInfo('Learn more: https://github.com/steveyegge/beads');
 }
 
+/**
+ * Initializes beads in the current project directory.
+ * 
+ * SECURITY NOTE - shell:true usage:
+ * - bdPath is validated via getBeadsPath() which only returns paths that:
+ *   1. Pass execSync('bd --version') verification, OR
+ *   2. Exist on disk (verified via existsSync) from a HARDCODED list of paths
+ * - Arguments are HARDCODED ('init') - no user input is passed to the shell
+ * - Command injection risk: LOW (bdPath is validated, no user input in args)
+ * 
+ * The shell:true is used for PATH resolution consistency, though it could be
+ * eliminated since we have an absolute path. Kept for consistency with other
+ * spawn calls and to handle edge cases in shell script wrappers.
+ * 
+ * @param {string} cwd - Current working directory (validated by caller)
+ * @returns {Promise<boolean>} True if initialization succeeded
+ */
 async function initializeBeads(cwd) {
   log('\nInitializing beads in project...', COLORS.cyan);
   
@@ -358,6 +761,8 @@ async function initializeBeads(cwd) {
     return false;
   }
   
+  // SECURITY: bdPath is validated by getBeadsPath() (existsSync check).
+  // Only 'init' argument is passed - no user input reaches the shell.
   return new Promise((resolve) => {
     const child = spawn(bdPath, ['init'], {
       stdio: 'inherit',
@@ -383,8 +788,8 @@ async function initializeBeads(cwd) {
 }
 
 function showHelp() {
-  console.log(`
-${COLORS.bright}Beth${COLORS.reset} - AI Orchestrator for GitHub Copilot
+  showBethBannerStatic({ showQuickHelp: false });
+  console.log(`${COLORS.bright}Beth${COLORS.reset} - AI Orchestrator for GitHub Copilot
 
 ${COLORS.bright}Usage:${COLORS.reset}
   npx beth-copilot init [options]     Initialize Beth in current directory
@@ -464,11 +869,14 @@ ${COLORS.yellow}╔════════════════════
 `);
   }
   
-  console.log(`
-${COLORS.bright}🤠 Beth is moving in.${COLORS.reset}
-${COLORS.cyan}"I don't do excuses. I do results."${COLORS.reset}
-${COLORS.yellow}Tip: Run with --verbose for detailed diagnostics if you hit issues.${COLORS.reset}
-`);
+  // Show Beth's fire animation
+  if (canAnimate()) {
+    await animateBethBanner();
+  } else {
+    showBethBannerStatic({ showQuickHelp: false });
+  }
+  
+  log(`${COLORS.yellow}Tip: Run with --verbose for detailed diagnostics if you hit issues.${COLORS.reset}`);
 
   // Check if templates exist
   if (!existsSync(TEMPLATES_DIR)) {
@@ -600,11 +1008,14 @@ ${COLORS.yellow}Tip: Run with --verbose for detailed diagnostics if you hit issu
             
             // Allow manual path entry
             const customPath = await promptForInput('Enter full path to bd binary (or press Enter to retry installation):');
-            if (customPath && existsSync(customPath)) {
-              bdPath = customPath;
-              logSuccess(`Found beads at: ${bdPath}`);
-            } else if (customPath) {
-              logError(`File not found: ${customPath}`);
+            if (customPath) {
+              const validation = validateBeadsPath(customPath);
+              if (validation.valid) {
+                bdPath = validation.normalizedPath;
+                logSuccess(`Found beads at: ${bdPath}`);
+              } else {
+                logError(`Invalid path: ${validation.error}`);
+              }
             }
           }
         } else {

package/bin/lib/animation.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * Beth Animation - Startup splash for the AI Agent Orchestrator
+ * "I don't speak dipshit. I speak in consequences."
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ANSI escape codes
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const AMBER = '\x1b[38;2;218;165;32m';
+const GOLD = '\x1b[38;2;255;215;0m';
+const WHITE = '\x1b[38;2;255;255;255m';
+
+// Beth's signature quotes
+const QUOTES = [
+  "I don't speak dipshit. I speak in consequences.",
+  "They broke my wings and forgot I had claws.",
+  "I believe in lovin' with your whole soul and destroying anything that wants to kill what you love.",
+  "I'm the trailer park. I'm the tornado.",
+  "Where's the fun in breaking one thing? When I fix something, I fix it for generations.",
+  "I made two decisions based on fear and they cost me everything. I'll never make another.",
+  "You want my opinion? You're getting it either way.",
+];
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function clearScreen() {
+  process.stdout.write('\x1b[2J\x1b[H');
+}
+
+function hideCursor() {
+  process.stdout.write('\x1b[?25l');
+}
+
+function showCursor() {
+  process.stdout.write('\x1b[?25h');
+}
+
+function centerText(text, width = process.stdout.columns || 80) {
+  const padding = Math.max(0, Math.floor((width - text.length) / 2));
+  return ' '.repeat(padding) + text;
+}
+
+async function typewriter(text, delay = 30) {
+  for (const char of text) {
+    process.stdout.write(char);
+    await sleep(delay);
+  }
+  console.log();
+}
+
+function getRandomQuote() {
+  return QUOTES[Math.floor(Math.random() * QUOTES.length)];
+}
+
+async function glitchEffect(iterations = 5) {
+  const glitchChars = '░▒▓█│┃┆┇┊┋╳╱╲';
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  
+  for (let i = 0; i < iterations; i++) {
+    clearScreen();
+    for (let j = 0; j < 10; j++) {
+      const col = Math.floor(Math.random() * (cols - 20));
+      const row = Math.floor(Math.random() * (rows - 5) + 2);
+      const r = Math.floor(Math.random() * 150 + 100);
+      const g = Math.floor(Math.random() * 100 + 50);
+      const b = Math.floor(Math.random() * 50);
+      const char = glitchChars[Math.floor(Math.random() * glitchChars.length)];
+      process.stdout.write(`\x1b[${row};${col}H\x1b[38;2;${r};${g};${b}m${char.repeat(4)}`);
+    }
+    await sleep(80);
+  }
+}
+
+async function displayPortrait() {
+  const artPath = join(__dirname, '..', '..', 'assets', 'beth-portrait.txt');
+  
+  if (!existsSync(artPath)) {
+    console.log(`${DIM}Portrait file not found at: ${artPath}${RESET}`);
+    return false;
+  }
+  
+  const art = readFileSync(artPath, 'utf-8');
+  console.log(art);
+  return true;
+}
+
+function displayBanner() {
+  console.log();
+  console.log(`${GOLD}${BOLD}${centerText('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')}${RESET}`);
+  console.log(`${AMBER}${BOLD}${centerText('B E T H')}${RESET}`);
+  console.log(`${DIM}${WHITE}${centerText('AI Agent Orchestrator')}${RESET}`);
+  console.log(`${GOLD}${BOLD}${centerText('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')}${RESET}`);
+}
+
+async function displayQuote() {
+  const quote = getRandomQuote();
+  console.log();
+  process.stdout.write(`${AMBER}    `);
+  await typewriter(`"${quote}"`, 40);
+  console.log(RESET);
+}
+
+/**
+ * Quick banner - no portrait, just text
+ */
+export async function quickBanner() {
+  console.log();
+  console.log(`${GOLD}${BOLD}━━━ ${AMBER}BETH${GOLD} ━━━${RESET}`);
+  console.log(`${DIM}${getRandomQuote()}${RESET}`);
+  console.log();
+}
+
+/**
+ * Full animation with portrait
+ */
+export async function fullAnimation() {
+  hideCursor();
+  
+  try {
+    clearScreen();
+    await sleep(500);
+    
+    // Glitch intro
+    await glitchEffect(5);
+    
+    // Show portrait
+    clearScreen();
+    const hasPortrait = await displayPortrait();
+    
+    if (hasPortrait) {
+      await sleep(1000);
+    }
+    
+    // Banner and quote
+    displayBanner();
+    await sleep(500);
+    await displayQuote();
+    
+    console.log();
+    console.log(`${DIM}${centerText('Press any key to continue...')}${RESET}`);
+    
+    // Wait for keypress
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      await new Promise(resolve => {
+        process.stdin.once('data', resolve);
+      });
+      process.stdin.setRawMode(false);
+    }
+  } finally {
+    showCursor();
+  }
+}
+
+/**
+ * Minimal startup text
+ */
+export function minimalBanner() {
+  console.log(`${AMBER}${BOLD}Beth${RESET} ${DIM}| The bigger bear.${RESET}`);
+}
+
+// Run if executed directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const mode = process.argv[2] || 'full';
+  
+  switch (mode) {
+    case 'quick':
+      quickBanner();
+      break;
+    case 'minimal':
+      minimalBanner();
+      break;
+    case 'full':
+    default:
+      fullAnimation().catch(console.error);
+  }
+}