sam-coder-cli 1.0.48 → 1.0.49

package/bin/agi-animation.js

@@ -9,6 +9,7 @@ const ANSI = {
   showCursor: '\x1B[?25h',
   moveTo: (x, y) => `\x1B[${y};${x}H`,
   clearLine: '\x1B[2K',
+  clearScreen: '\x1B[2J\x1B[0;0H',
   reset: '\x1B[0m',
   bold: '\x1B[1m',
   dim: '\x1B[2m',
@@ -16,7 +17,9 @@ const ANSI = {
   underline: '\x1B[4m',
   blink: '\x1B[5m',
   reverse: '\x1B[7m',
-  strikethrough: '\x1B[9m'
+  strikethrough: '\x1B[9m',
+  saveCursor: '\x1B[s',
+  restoreCursor: '\x1B[u'
 };
 
 // Music/Sound generation using system beeps and terminal bells
@@ -25,17 +28,30 @@ class SoundGenerator {
     this.isWindows = os.platform() === 'win32';
     this.isMac = os.platform() === 'darwin';
     this.isLinux = os.platform() === 'linux';
+    this.soundEnabled = true;
   }
 
   async playBeep(frequency = 440, duration = 100) {
-    if (this.isWindows) {
-      exec(`powershell -c "[console]::beep(${frequency},${duration})"`, { stdio: 'ignore' });
-    } else if (this.isMac) {
-      exec(`osascript -e 'beep'`, { stdio: 'ignore' });
-    } else if (this.isLinux) {
-      exec(`beep -f ${frequency} -l ${duration} 2>/dev/null || echo -e '\\a'`, { stdio: 'ignore' });
-    } else {
-      process.stdout.write('\x07');
+    if (!this.soundEnabled) return;
+    
+    try {
+      return new Promise((resolve) => {
+        if (this.isWindows) {
+          exec(`powershell -c "[console]::beep(${frequency},${duration})"`, { stdio: 'ignore' }, () => resolve());
+        } else if (this.isMac) {
+          exec(`osascript -e 'beep'`, { stdio: 'ignore' }, () => resolve());
+        } else if (this.isLinux) {
+          exec(`beep -f ${frequency} -l ${duration} 2>/dev/null || echo -e '\\a'`, { stdio: 'ignore' }, () => resolve());
+        } else {
+          process.stdout.write('\x07');
+          resolve();
+        }
+        // Fallback timeout
+        setTimeout(resolve, duration + 50);
+      });
+    } catch (error) {
+      // Silently fail for sound issues
+      this.soundEnabled = false;
     }
   }
 
@@ -83,22 +99,42 @@ function sleep(ms) {
 }
 
 function clearScreen() {
-  process.stdout.write(ANSI.clear);
+  // Use more reliable screen clearing
+  process.stdout.write(ANSI.clearScreen);
 }
 
-function centerText(text, width = process.stdout.columns || 80) {
+function getTerminalSize() {
+  return {
+    width: process.stdout.columns || 80,
+    height: process.stdout.rows || 24
+  };
+}
+
+function centerText(text, width = getTerminalSize().width) {
+  if (!text) return '';
   const lines = text.split('\n');
   return lines.map(line => {
-    const padding = Math.max(0, Math.floor((width - line.length) / 2));
+    // Strip ANSI codes to calculate actual text length
+    const cleanLine = line.replace(/\x1b\[[0-9;]*m/g, '');
+    const padding = Math.max(0, Math.floor((width - cleanLine.length) / 2));
     return ' '.repeat(padding) + line;
   }).join('\n');
 }
 
+function safeWrite(content) {
+  try {
+    process.stdout.write(content);
+  } catch (error) {
+    // Fallback for terminal issues
+    console.log(content);
+  }
+}
+
 // Frame interpolation system
 class FrameInterpolator {
   constructor() {
-    this.fps = 25;
-    this.frameDuration = 1000 / this.fps; // 40ms per frame
+    this.fps = 30;
+    this.frameDuration = 1000 / this.fps; // ~33ms per frame for smoother animation
   }
 
   // Interpolate between two ASCII art frames
@@ -211,66 +247,96 @@ class FrameInterpolator {
 
 const interpolator = new FrameInterpolator();
 
-// Animation sequence with 25 FPS
+// Animation sequence with 30 FPS
 async function runAGIAnimation() {
+  const { width, height } = getTerminalSize();
   process.stdout.write(ANSI.hideCursor);
   
   try {
     const startTime = Date.now();
     let frameCount = 0;
+    const frameTime = interpolator.frameDuration;
     
-    // Start with ambient sound
-    sound.playStartupSound();
+    // Start with ambient sound (non-blocking)
+    sound.playStartupSound().catch(() => {}); // Ignore sound errors
 
-    // PHASE 1: The Void (1 second - 25 frames)
+    // PHASE 1: The Void (1 second - 30 frames)
     const voidFrames = [];
-    for (let i = 0; i < 25; i++) {
-      const dots = '.'.repeat((i % 3) + 1);
-      const spaces = ' '.repeat(40 - Math.floor(dots.length / 2));
-      voidFrames.push(`\n\n\n\n\n${spaces}${dots}\n\n\n\n`);
+    for (let i = 0; i < 30; i++) {
+      const dotCount = (i % 4) + 1;
+      const dots = '•'.repeat(dotCount) + ' '.repeat(4 - dotCount);
+      const frame = '\n'.repeat(Math.floor(height / 2) - 2) + 
+                   centerText(dots) + 
+                   '\n'.repeat(Math.floor(height / 2) - 2);
+      voidFrames.push(frame);
     }
 
     for (const frame of voidFrames) {
       clearScreen();
-      console.log(chalk.gray(frame));
-      await sleep(40);
+      safeWrite(chalk.dim.gray(frame));
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 2: Spark Formation (1 second - 25 frames)
-    const sparkBase = `
-                                      ·
-    `;
-    
-    const sparkExpanded = `
-                                    · · ·
-                                   · ·█· ·
-                                    · · ·
-    `;
-
-    const sparkFrames = interpolator.interpolateFrames(sparkBase, sparkExpanded, 25);
+    // PHASE 2: Spark Formation (1 second - 30 frames)
+    const sparkFrames = [];
+    for (let i = 0; i < 30; i++) {
+      const progress = i / 29;
+      const intensity = Math.sin(progress * Math.PI * 2) * 0.5 + 0.5;
+      
+      let sparkPattern;
+      if (progress < 0.3) {
+        sparkPattern = '·';
+      } else if (progress < 0.6) {
+        sparkPattern = `  ·\n ·•·\n  ·`;
+      } else {
+        const core = intensity > 0.7 ? '█' : '●';
+        sparkPattern = ` · · ·\n· ·${core}· ·\n · · ·`;
+      }
+      
+      const frame = '\n'.repeat(Math.floor(height / 2) - 3) + 
+                   centerText(sparkPattern) + 
+                   '\n'.repeat(Math.floor(height / 2) - 3);
+      sparkFrames.push(frame);
+    }
     
     for (const frame of sparkFrames) {
       clearScreen();
-      console.log(chalk.white(centerText(frame)));
-      await sleep(40);
+      safeWrite(chalk.white.bright(frame));
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 3: Quantum Expansion (1.5 seconds - 37 frames)
+    // PHASE 3: Quantum Expansion (1.5 seconds - 45 frames)
     const quantumFrames = [];
-    for (let i = 0; i < 37; i++) {
-      const phase = (i / 37) * Math.PI * 2;
-      const size = 3 + Math.sin(phase) * 2;
-      let frame = '\n\n\n';
+    const quantumChars = ['◆', '◇', '▪', '▫', '●', '○', '◊', '◉'];
+    
+    for (let i = 0; i < 45; i++) {
+      const progress = i / 44;
+      const phase = progress * Math.PI * 4;
+      const baseSize = 2 + progress * 4;
+      const pulseSize = baseSize + Math.sin(phase * 2) * 1.5;
+      
+      let frame = '\n'.repeat(Math.floor(height / 2) - Math.floor(pulseSize) - 2);
       
-      for (let y = -size; y <= size; y++) {
+      for (let y = -Math.floor(pulseSize); y <= Math.floor(pulseSize); y++) {
         let line = '';
-        for (let x = -size * 2; x <= size * 2; x++) {
+        for (let x = -Math.floor(pulseSize * 1.5); x <= Math.floor(pulseSize * 1.5); x++) {
           const dist = Math.sqrt(x * x + y * y);
-          if (dist < size) {
-            const chars = ['◆', '◇', '▪', '▫', '●', '○'];
-            line += chars[Math.floor(Math.random() * chars.length)];
+          const normalizedDist = dist / pulseSize;
+          
+          if (normalizedDist <= 1) {
+            // Use consistent pattern based on position and time
+            const charIndex = (Math.floor(x + y + i * 0.5)) % quantumChars.length;
+            const char = quantumChars[Math.abs(charIndex)];
+            
+            // Add wave effect
+            const wave = Math.sin(dist * 0.5 + phase) * 0.5 + 0.5;
+            if (wave > 0.3) {
+              line += char;
+            } else {
+              line += '·';
+            }
           } else {
             line += ' ';
           }
@@ -281,45 +347,81 @@ async function runAGIAnimation() {
       quantumFrames.push(frame);
     }
 
-    for (const frame of quantumFrames) {
+    for (let i = 0; i < quantumFrames.length; i++) {
       clearScreen();
-      const colors = [chalk.blue, chalk.cyan, chalk.magenta];
-      console.log(colors[frameCount % colors.length](frame));
-      await sleep(40);
+      const colorCycle = i / 15; // Slower color cycling
+      let color;
+      if (colorCycle < 1) {
+        color = chalk.blue;
+      } else if (colorCycle < 2) {
+        color = chalk.cyan;
+      } else {
+        color = chalk.magenta;
+      }
+      
+      safeWrite(color(quantumFrames[i]));
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 4: Neural Network Formation (1.5 seconds - 37 frames)
+    // PHASE 4: Neural Network Formation (1.5 seconds - 45 frames)
     const neuralFrames = [];
-    for (let i = 0; i < 37; i++) {
-      const progress = i / 37;
-      let frame = '\n\n';
-      
-      const nodes = 5;
-      const layers = 3;
+    const nodes = 6;
+    const layers = 4;
+    
+    // Play glitch sound (non-blocking)
+    sound.playGlitchSound().catch(() => {});
+
+    for (let i = 0; i < 45; i++) {
+      const progress = i / 44;
+      let frame = '\n'.repeat(Math.floor(height / 2) - layers * 2);
       
       for (let layer = 0; layer < layers; layer++) {
         let line = '';
+        const layerProgress = Math.max(0, (progress - layer * 0.2) * 2);
+        
         for (let node = 0; node < nodes; node++) {
-          if (Math.random() < progress) {
-            line += layer % 2 === 0 ? '◯' : '◉';
+          const nodeProgress = Math.max(0, (layerProgress - node * 0.1) * 3);
+          
+          if (nodeProgress > 0.5) {
+            // Animate node activation
+            const activation = Math.sin(i * 0.3 + layer + node) * 0.5 + 0.5;
+            if (activation > 0.7) {
+              line += chalk.cyan.bright('◉');
+            } else if (activation > 0.3) {
+              line += chalk.cyan('◯');
+            } else {
+              line += chalk.dim('○');
+            }
           } else {
             line += '·';
           }
-          if (node < nodes - 1) line += '━━━';
+          
+          if (node < nodes - 1) {
+            // Animate connections
+            const connProgress = Math.max(0, (layerProgress - (node + 0.5) * 0.1) * 3);
+            if (connProgress > 0.5) {
+              const pulse = Math.sin(i * 0.4 + layer + node) > 0;
+              line += pulse ? chalk.cyan('━━') : chalk.dim('──');
+            } else {
+              line += '  ';
+            }
+          }
         }
         frame += centerText(line) + '\n';
         
         if (layer < layers - 1) {
-          // Connection lines
+          // Vertical connection lines
           let connLine = '';
           for (let node = 0; node < nodes; node++) {
-            if (Math.random() < progress) {
-              connLine += node % 2 === 0 ? '┃' : '│';
+            const nodeProgress = Math.max(0, (layerProgress - node * 0.1) * 3);
+            if (nodeProgress > 0.5) {
+              const pulse = Math.sin(i * 0.2 + layer + node) > 0;
+              connLine += pulse ? chalk.cyan('┃') : chalk.dim('│');
             } else {
               connLine += ' ';
             }
-            if (node < nodes - 1) connLine += '   ';
+            if (node < nodes - 1) connLine += '  ';
           }
           frame += centerText(connLine) + '\n';
         }
@@ -328,31 +430,46 @@ async function runAGIAnimation() {
       neuralFrames.push(frame);
     }
 
-    // Play glitch sound
-    sound.playGlitchSound();
-
     for (const frame of neuralFrames) {
       clearScreen();
-      console.log(chalk.cyan(frame));
-      await sleep(40);
+      safeWrite(frame);
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 5: Data Stream (1 second - 25 frames)
+    // PHASE 5: Data Stream (1 second - 30 frames)
     const dataFrames = [];
-    for (let i = 0; i < 25; i++) {
-      let frame = '\n\n';
-      const height = 10;
+    const streamHeight = Math.min(12, Math.floor(height * 0.4));
+    const streamWidth = Math.min(60, Math.floor(width * 0.7));
+    
+    for (let i = 0; i < 30; i++) {
+      let frame = '\n'.repeat(Math.floor((height - streamHeight) / 2));
       
-      for (let y = 0; y < height; y++) {
+      for (let y = 0; y < streamHeight; y++) {
         let line = '';
-        const width = 40;
         
-        for (let x = 0; x < width; x++) {
-          if ((x + i) % 8 < 4) {
-            line += Math.random() > 0.5 ? '1' : '0';
+        for (let x = 0; x < streamWidth; x++) {
+          // Create flowing data pattern
+          const wave1 = Math.sin((x + i * 2) * 0.1) * 0.5 + 0.5;
+          const wave2 = Math.cos((y + i * 1.5) * 0.15) * 0.5 + 0.5;
+          const combined = wave1 * wave2;
+          
+          if (combined > 0.7) {
+            // Binary data
+            const bit = ((x + y + i) % 7) < 3 ? '1' : '0';
+            line += chalk.green.bright(bit);
+          } else if (combined > 0.4) {
+            // Block characters
+            const blocks = ['█', '▓', '▒', '░'];
+            const blockIndex = ((x + y + i) % blocks.length);
+            line += chalk.green(blocks[blockIndex]);
+          } else if (combined > 0.2) {
+            // Hexadecimal
+            const hex = '0123456789ABCDEF';
+            const hexChar = hex[((x * 7 + y * 3 + i) % hex.length)];
+            line += chalk.green.dim(hexChar);
           } else {
-            line += Math.random() > 0.5 ? '█' : '░';
+            line += ' ';
           }
         }
         
@@ -364,126 +481,260 @@ async function runAGIAnimation() {
 
     for (const frame of dataFrames) {
       clearScreen();
-      console.log(chalk.green(frame));
-      await sleep(40);
+      safeWrite(frame);
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 6: Loading Bar (1 second - 25 frames)
-    for (let i = 0; i < 25; i++) {
-      const progress = i / 24;
-      const barWidth = 40;
+    // PHASE 6: Loading Bar (1 second - 30 frames)
+    for (let i = 0; i < 30; i++) {
+      const progress = i / 29;
+      const barWidth = 38;
       const filled = Math.floor(barWidth * progress);
-      const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+      const remaining = barWidth - filled;
+      
+      // Animated loading bar with gradient effect
+      let bar = '';
+      for (let j = 0; j < filled; j++) {
+        const intensity = (j / filled) * 0.7 + 0.3;
+        if (intensity > 0.8) {
+          bar += chalk.cyan.bright('█');
+        } else if (intensity > 0.5) {
+          bar += chalk.cyan('█');
+        } else {
+          bar += chalk.cyan.dim('█');
+        }
+      }
+      
+      // Add loading cursor
+      if (remaining > 0 && i < 29) {
+        const cursor = ['▌', '▐'][i % 2];
+        bar += chalk.cyan.bright(cursor);
+        bar += chalk.gray('░').repeat(remaining - 1);
+      } else {
+        bar += chalk.gray('░').repeat(remaining);
+      }
+      
       const percent = Math.floor(progress * 100);
       
-      clearScreen();
-      console.log(chalk.cyan(centerText(`
-╔══════════════════════════════════════════╗
-║         INITIALIZING SAM-CODER           ║
-╠══════════════════════════════════════════╣
+      const loadingBox = `
+╔════════════════════════════════════════════╗
+║          INITIALIZING SAM-CODER            ║
+╠════════════════════════════════════════════╣
 ║ ${bar} ║
-║              ${percent.toString().padStart(3)}% Complete                ║
-╚══════════════════════════════════════════╝
-      `)));
+║               ${percent.toString().padStart(3)}% Complete               ║
+╚════════════════════════════════════════════╝`;
+      
+      clearScreen();
+      safeWrite(chalk.cyan(centerText(loadingBox)));
       
-      if (i % 5 === 0) {
-        sound.playBeep(200 + i * 20, 50);
+      if (i % 6 === 0) {
+        sound.playBeep(200 + i * 15, 40).catch(() => {});
       }
       
-      await sleep(40);
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 7: Matrix Rain (1 second - 25 frames)
-    const width = process.stdout.columns || 80;
-    const height = process.stdout.rows || 24;
-    const drops = Array(width).fill(0).map(() => Math.random() * height);
+    // PHASE 7: Matrix Rain (1 second - 30 frames)
+    const matrixChars = '01SAMCODERサムコーダー※◆◇▪▫●○';
+    const drops = Array(width).fill(0).map(() => ({
+      y: Math.random() * height,
+      speed: 0.5 + Math.random() * 1.5,
+      chars: Array(15).fill(0).map(() => matrixChars[Math.floor(Math.random() * matrixChars.length)])
+    }));
     
-    for (let frame = 0; frame < 25; frame++) {
+    for (let frame = 0; frame < 30; frame++) {
       clearScreen();
       
+      // Build frame buffer for better performance
+      const frameBuffer = Array(height).fill(0).map(() => Array(width).fill(' '));
+      
+      for (let x = 0; x < width; x++) {
+        const drop = drops[x];
+        
+        for (let i = 0; i < 15; i++) {
+          const y = Math.floor(drop.y - i);
+          if (y >= 0 && y < height) {
+            const brightness = Math.max(0, 1 - i / 10);
+            const char = drop.chars[i % drop.chars.length];
+            
+            // Store character with brightness info
+            frameBuffer[y][x] = { char, brightness };
+          }
+        }
+      }
+      
+      // Render frame buffer
       for (let y = 0; y < height; y++) {
         let line = '';
         for (let x = 0; x < width; x++) {
-          if (drops[x] > y && drops[x] - y < 10) {
-            const brightness = 1 - (drops[x] - y) / 10;
-            const chars = '01SAMCODERサムコーダー';
-            const char = chars[Math.floor(Math.random() * chars.length)];
-            
-            if (brightness > 0.8) {
-              line += chalk.greenBright(char);
-            } else if (brightness > 0.4) {
-              line += chalk.green(char);
+          const cell = frameBuffer[y][x];
+          if (typeof cell === 'object') {
+            if (cell.brightness > 0.8) {
+              line += chalk.greenBright(cell.char);
+            } else if (cell.brightness > 0.5) {
+              line += chalk.green(cell.char);
+            } else if (cell.brightness > 0.2) {
+              line += chalk.green.dim(cell.char);
             } else {
-              line += chalk.gray(char);
+              line += chalk.gray(cell.char);
             }
           } else {
             line += ' ';
           }
         }
-        console.log(line);
+        safeWrite(line + '\n');
       }
       
       // Update drops
       for (let i = 0; i < width; i++) {
-        if (Math.random() > 0.95) drops[i] = 0;
-        drops[i] += 0.5;
+        drops[i].y += drops[i].speed;
+        if (drops[i].y > height + 15 || Math.random() > 0.98) {
+          drops[i].y = -5;
+          drops[i].speed = 0.5 + Math.random() * 1.5;
+          // Refresh character set occasionally
+          if (Math.random() > 0.7) {
+            drops[i].chars = Array(15).fill(0).map(() => matrixChars[Math.floor(Math.random() * matrixChars.length)]);
+          }
+        }
       }
       
-      await sleep(40);
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 8: Final Reveal Build-up (1 second - 25 frames)
+    // PHASE 8: Final Reveal Build-up (1 second - 30 frames)
     const finalText = `
 ███████╗ █████╗ ███╗   ███╗       ██████╗ ██████╗ ██████╗ ███████╗██████╗ 
 ██╔════╝██╔══██╗████╗ ████║      ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗
 ███████╗███████║██╔████╔██║█████╗██║     ██║   ██║██║  ██║█████╗  ██████╔╝
 ╚════██║██╔══██║██║╚██╔╝██║╚════╝██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗
 ███████║██║  ██║██║ ╚═╝ ██║      ╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║
-╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝
-    `;
+╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝`;
 
-    const buildFrames = interpolator.expandFrames('█', finalText, 25);
+    // Play awakening sound (non-blocking)
+    sound.playAwakeningSound().catch(() => {});
+    
+    // Create smoother reveal animation
+    const revealFrames = [];
+    const lines = finalText.trim().split('\n');
+    const maxWidth = Math.max(...lines.map(line => line.length));
+    const centerY = Math.floor((height - lines.length) / 2);
     
-    // Play awakening sound
-    sound.playAwakeningSound();
+    for (let frame = 0; frame < 30; frame++) {
+      const progress = frame / 29;
+      let revealFrame = '\n'.repeat(Math.max(0, centerY));
+      
+      for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const lineProgress = Math.max(0, Math.min(1, (progress - lineIndex * 0.1) * 2));
+        const revealWidth = Math.floor(line.length * lineProgress);
+        
+        let revealedLine = '';
+        for (let charIndex = 0; charIndex < line.length; charIndex++) {
+          if (charIndex < revealWidth) {
+            // Add slight randomness to reveal
+            if (Math.random() < 0.95 || frame > 25) {
+              revealedLine += line[charIndex];
+            } else {
+              revealedLine += Math.random() > 0.5 ? '▓' : '▒';
+            }
+          } else {
+            revealedLine += ' ';
+          }
+        }
+        
+        revealFrame += centerText(revealedLine) + '\n';
+      }
+      
+      revealFrames.push(revealFrame);
+    }
     
-    for (const frame of buildFrames) {
+    for (const frame of revealFrames) {
       clearScreen();
-      console.log(chalk.cyanBright(centerText(frame)));
-      await sleep(40);
+      safeWrite(chalk.cyanBright(frame));
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // PHASE 9: Final Blinking (1.5 seconds - 37 frames)
-    for (let i = 0; i < 37; i++) {
+    // PHASE 9: Final Blinking (1.5 seconds - 45 frames)
+    const blinkFrames = 45;
+    for (let i = 0; i < blinkFrames; i++) {
       clearScreen();
       
-      // Blink between red and bright red
-      const isOn = i % 6 < 3;
-      const color = isOn ? chalk.redBright.bold : chalk.red;
+      // More sophisticated blinking pattern
+      const blinkCycle = i % 8;
+      let color;
+      
+      if (blinkCycle < 2) {
+        color = chalk.redBright.bold;
+      } else if (blinkCycle < 4) {
+        color = chalk.red.bold;
+      } else if (blinkCycle < 6) {
+        color = chalk.red;
+      } else {
+        color = chalk.red.dim;
+      }
       
-      console.log(color(centerText(finalText)));
+      // Add subtle glow effect
+      const glowIntensity = Math.sin(i * 0.3) * 0.3 + 0.7;
+      let finalFrame = '\n'.repeat(Math.max(0, centerY));
       
-      // Add subtitle on last few frames
+      for (const line of lines) {
+        if (glowIntensity > 0.8) {
+          finalFrame += centerText(line) + '\n';
+        } else {
+          // Slightly dim some characters for glow effect
+          let glowLine = '';
+          for (let j = 0; j < line.length; j++) {
+            if (Math.random() < glowIntensity) {
+              glowLine += line[j];
+            } else {
+              glowLine += line[j] === '█' ? '▓' : line[j];
+            }
+          }
+          finalFrame += centerText(glowLine) + '\n';
+        }
+      }
+      
+      safeWrite(color(finalFrame));
+      
+      // Add subtitle with typewriter effect
       if (i > 25) {
-        console.log(chalk.gray(centerText('\n\n[ ARTIFICIAL GENERAL INTELLIGENCE ONLINE ]')));
+        const subtitle = '[ ARTIFICIAL GENERAL INTELLIGENCE ONLINE ]';
+        const typeProgress = Math.min(subtitle.length, Math.floor((i - 25) * 2.5));
+        const typedSubtitle = subtitle.substring(0, typeProgress);
+        const cursor = (i % 4 < 2) ? '_' : ' ';
+        
+        safeWrite(chalk.gray(centerText(`\n\n${typedSubtitle}${cursor}`)));
       }
       
-      await sleep(40);
+      await sleep(frameTime);
       frameCount++;
     }
 
-    // Final hold
+    // Final hold with status
     clearScreen();
-    console.log(chalk.redBright.bold(centerText(finalText)));
-    console.log(chalk.gray(centerText('\n\n[ SYSTEM READY ]')));
+    let finalDisplay = '\n'.repeat(Math.max(0, centerY));
+    for (const line of lines) {
+      finalDisplay += centerText(line) + '\n';
+    }
+    
+    safeWrite(chalk.redBright.bold(finalDisplay));
+    safeWrite(chalk.gray(centerText('\n\n[ SYSTEM READY ]')));
+    safeWrite(chalk.dim(centerText('\n\nPress any key to continue...')));
+    
     await sleep(500);
 
     const totalTime = Date.now() - startTime;
-    console.log(chalk.gray(`\n\nAnimation completed: ${frameCount} frames in ${totalTime}ms (${Math.round(frameCount / (totalTime / 1000))} FPS)`));
+    const actualFPS = Math.round(frameCount / (totalTime / 1000));
+    
+    // Performance stats (optional, can be hidden)
+    if (process.env.DEBUG_ANIMATION) {
+      console.log(chalk.gray(`\n\nAnimation completed: ${frameCount} frames in ${totalTime}ms (${actualFPS} FPS)`));
+    }
+    
     await sleep(1000);
     
   } finally {
@@ -499,5 +750,7 @@ module.exports = {
   sleep,
   clearScreen,
   centerText,
+  getTerminalSize,
+  safeWrite,
   FrameInterpolator
 };

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {
-    "sam-coder": "bin/agi-cli.js"
+    "sam-coder": "bin/agi-cli.js",
+    "agi-cli": "bin/agi-cli.js"
   },
   "scripts": {
     "start": "node ./bin/agi-cli.js"