sam-coder-cli 1.0.47 → 1.0.48

package/bin/agi-animation.js

@@ -0,0 +1,503 @@
+const chalk = require('chalk');
+const { exec } = require('child_process');
+const os = require('os');
+
+// ANSI escape codes for advanced effects
+const ANSI = {
+  clear: '\x1Bc',
+  hideCursor: '\x1B[?25l',
+  showCursor: '\x1B[?25h',
+  moveTo: (x, y) => `\x1B[${y};${x}H`,
+  clearLine: '\x1B[2K',
+  reset: '\x1B[0m',
+  bold: '\x1B[1m',
+  dim: '\x1B[2m',
+  italic: '\x1B[3m',
+  underline: '\x1B[4m',
+  blink: '\x1B[5m',
+  reverse: '\x1B[7m',
+  strikethrough: '\x1B[9m'
+};
+
+// Music/Sound generation using system beeps and terminal bells
+class SoundGenerator {
+  constructor() {
+    this.isWindows = os.platform() === 'win32';
+    this.isMac = os.platform() === 'darwin';
+    this.isLinux = os.platform() === 'linux';
+  }
+
+  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');
+    }
+  }
+
+  async playSequence(notes) {
+    for (const note of notes) {
+      await this.playBeep(note.freq, note.duration);
+      await sleep(note.pause || 50);
+    }
+  }
+
+  async playStartupSound() {
+    const notes = [
+      { freq: 261, duration: 100 }, // C
+      { freq: 329, duration: 100 }, // E
+      { freq: 392, duration: 100 }, // G
+      { freq: 523, duration: 200 }, // C (octave up)
+    ];
+    await this.playSequence(notes);
+  }
+
+  async playGlitchSound() {
+    for (let i = 0; i < 5; i++) {
+      await this.playBeep(Math.random() * 800 + 200, 30);
+      await sleep(20);
+    }
+  }
+
+  async playAwakeningSound() {
+    const notes = [
+      { freq: 130, duration: 300 }, // Low C
+      { freq: 196, duration: 200 }, // G
+      { freq: 261, duration: 200 }, // C
+      { freq: 392, duration: 200 }, // G
+      { freq: 523, duration: 400 }, // High C
+    ];
+    await this.playSequence(notes);
+  }
+}
+
+const sound = new SoundGenerator();
+
+// Utility functions
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function clearScreen() {
+  process.stdout.write(ANSI.clear);
+}
+
+function centerText(text, width = process.stdout.columns || 80) {
+  const lines = text.split('\n');
+  return lines.map(line => {
+    const padding = Math.max(0, Math.floor((width - line.length) / 2));
+    return ' '.repeat(padding) + line;
+  }).join('\n');
+}
+
+// Frame interpolation system
+class FrameInterpolator {
+  constructor() {
+    this.fps = 25;
+    this.frameDuration = 1000 / this.fps; // 40ms per frame
+  }
+
+  // Interpolate between two ASCII art frames
+  interpolateFrames(frame1, frame2, steps = 10) {
+    const frames = [frame1];
+    
+    for (let i = 1; i < steps; i++) {
+      const ratio = i / steps;
+      const interpolated = this.interpolateText(frame1, frame2, ratio);
+      frames.push(interpolated);
+    }
+    
+    frames.push(frame2);
+    return frames;
+  }
+
+  // Interpolate between two text blocks
+  interpolateText(text1, text2, ratio) {
+    const lines1 = text1.split('\n');
+    const lines2 = text2.split('\n');
+    const maxLines = Math.max(lines1.length, lines2.length);
+    const result = [];
+
+    for (let i = 0; i < maxLines; i++) {
+      const line1 = lines1[i] || '';
+      const line2 = lines2[i] || '';
+      const interpolated = this.interpolateLine(line1, line2, ratio);
+      result.push(interpolated);
+    }
+
+    return result.join('\n');
+  }
+
+  // Interpolate between two lines character by character
+  interpolateLine(line1, line2, ratio) {
+    const maxLen = Math.max(line1.length, line2.length);
+    let result = '';
+
+    for (let i = 0; i < maxLen; i++) {
+      const char1 = line1[i] || ' ';
+      const char2 = line2[i] || ' ';
+      
+      if (Math.random() < ratio) {
+        result += char2;
+      } else {
+        result += char1;
+      }
+    }
+
+    return result;
+  }
+
+  // Create fade effect frames
+  fadeFrames(frame, fadeIn = true, steps = 10) {
+    const frames = [];
+    const chars = frame.split('');
+    
+    for (let i = 0; i <= steps; i++) {
+      const ratio = fadeIn ? i / steps : 1 - (i / steps);
+      const visibleChars = Math.floor(chars.length * ratio);
+      
+      let fadedFrame = '';
+      for (let j = 0; j < chars.length; j++) {
+        if (j < visibleChars && chars[j] !== ' ' && chars[j] !== '\n') {
+          fadedFrame += chars[j];
+        } else if (chars[j] === '\n') {
+          fadedFrame += '\n';
+        } else {
+          fadedFrame += ' ';
+        }
+      }
+      
+      frames.push(fadedFrame);
+    }
+    
+    return fadeIn ? frames : frames.reverse();
+  }
+
+  // Create expansion effect
+  expandFrames(centerChar, finalFrame, steps = 15) {
+    const frames = [];
+    const lines = finalFrame.split('\n');
+    const centerY = Math.floor(lines.length / 2);
+    const centerX = Math.floor((lines[centerY] || '').length / 2);
+
+    for (let step = 0; step <= steps; step++) {
+      const radius = (step / steps) * Math.max(centerY, centerX);
+      let frame = '';
+
+      for (let y = 0; y < lines.length; y++) {
+        let line = '';
+        for (let x = 0; x < lines[y].length; x++) {
+          const distance = Math.sqrt(Math.pow(x - centerX, 2) + Math.pow(y - centerY, 2));
+          
+          if (distance <= radius) {
+            line += lines[y][x];
+          } else {
+            line += ' ';
+          }
+        }
+        frame += line + '\n';
+      }
+
+      frames.push(frame);
+    }
+
+    return frames;
+  }
+}
+
+const interpolator = new FrameInterpolator();
+
+// Animation sequence with 25 FPS
+async function runAGIAnimation() {
+  process.stdout.write(ANSI.hideCursor);
+  
+  try {
+    const startTime = Date.now();
+    let frameCount = 0;
+    
+    // Start with ambient sound
+    sound.playStartupSound();
+
+    // PHASE 1: The Void (1 second - 25 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 (const frame of voidFrames) {
+      clearScreen();
+      console.log(chalk.gray(frame));
+      await sleep(40);
+      frameCount++;
+    }
+
+    // PHASE 2: Spark Formation (1 second - 25 frames)
+    const sparkBase = `
+                                      ·
+    `;
+    
+    const sparkExpanded = `
+                                    · · ·
+                                   · ·█· ·
+                                    · · ·
+    `;
+
+    const sparkFrames = interpolator.interpolateFrames(sparkBase, sparkExpanded, 25);
+    
+    for (const frame of sparkFrames) {
+      clearScreen();
+      console.log(chalk.white(centerText(frame)));
+      await sleep(40);
+      frameCount++;
+    }
+
+    // PHASE 3: Quantum Expansion (1.5 seconds - 37 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';
+      
+      for (let y = -size; y <= size; y++) {
+        let line = '';
+        for (let x = -size * 2; x <= size * 2; x++) {
+          const dist = Math.sqrt(x * x + y * y);
+          if (dist < size) {
+            const chars = ['◆', '◇', '▪', '▫', '●', '○'];
+            line += chars[Math.floor(Math.random() * chars.length)];
+          } else {
+            line += ' ';
+          }
+        }
+        frame += centerText(line) + '\n';
+      }
+      
+      quantumFrames.push(frame);
+    }
+
+    for (const frame of quantumFrames) {
+      clearScreen();
+      const colors = [chalk.blue, chalk.cyan, chalk.magenta];
+      console.log(colors[frameCount % colors.length](frame));
+      await sleep(40);
+      frameCount++;
+    }
+
+    // PHASE 4: Neural Network Formation (1.5 seconds - 37 frames)
+    const neuralFrames = [];
+    for (let i = 0; i < 37; i++) {
+      const progress = i / 37;
+      let frame = '\n\n';
+      
+      const nodes = 5;
+      const layers = 3;
+      
+      for (let layer = 0; layer < layers; layer++) {
+        let line = '';
+        for (let node = 0; node < nodes; node++) {
+          if (Math.random() < progress) {
+            line += layer % 2 === 0 ? '◯' : '◉';
+          } else {
+            line += '·';
+          }
+          if (node < nodes - 1) line += '━━━';
+        }
+        frame += centerText(line) + '\n';
+        
+        if (layer < layers - 1) {
+          // Connection lines
+          let connLine = '';
+          for (let node = 0; node < nodes; node++) {
+            if (Math.random() < progress) {
+              connLine += node % 2 === 0 ? '┃' : '│';
+            } else {
+              connLine += ' ';
+            }
+            if (node < nodes - 1) connLine += '   ';
+          }
+          frame += centerText(connLine) + '\n';
+        }
+      }
+      
+      neuralFrames.push(frame);
+    }
+
+    // Play glitch sound
+    sound.playGlitchSound();
+
+    for (const frame of neuralFrames) {
+      clearScreen();
+      console.log(chalk.cyan(frame));
+      await sleep(40);
+      frameCount++;
+    }
+
+    // PHASE 5: Data Stream (1 second - 25 frames)
+    const dataFrames = [];
+    for (let i = 0; i < 25; i++) {
+      let frame = '\n\n';
+      const height = 10;
+      
+      for (let y = 0; y < height; 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';
+          } else {
+            line += Math.random() > 0.5 ? '█' : '░';
+          }
+        }
+        
+        frame += centerText(line) + '\n';
+      }
+      
+      dataFrames.push(frame);
+    }
+
+    for (const frame of dataFrames) {
+      clearScreen();
+      console.log(chalk.green(frame));
+      await sleep(40);
+      frameCount++;
+    }
+
+    // PHASE 6: Loading Bar (1 second - 25 frames)
+    for (let i = 0; i < 25; i++) {
+      const progress = i / 24;
+      const barWidth = 40;
+      const filled = Math.floor(barWidth * progress);
+      const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
+      const percent = Math.floor(progress * 100);
+      
+      clearScreen();
+      console.log(chalk.cyan(centerText(`
+╔══════════════════════════════════════════╗
+║         INITIALIZING SAM-CODER           ║
+╠══════════════════════════════════════════╣
+║ ${bar} ║
+║              ${percent.toString().padStart(3)}% Complete                ║
+╚══════════════════════════════════════════╝
+      `)));
+      
+      if (i % 5 === 0) {
+        sound.playBeep(200 + i * 20, 50);
+      }
+      
+      await sleep(40);
+      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);
+    
+    for (let frame = 0; frame < 25; frame++) {
+      clearScreen();
+      
+      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);
+            } else {
+              line += chalk.gray(char);
+            }
+          } else {
+            line += ' ';
+          }
+        }
+        console.log(line);
+      }
+      
+      // Update drops
+      for (let i = 0; i < width; i++) {
+        if (Math.random() > 0.95) drops[i] = 0;
+        drops[i] += 0.5;
+      }
+      
+      await sleep(40);
+      frameCount++;
+    }
+
+    // PHASE 8: Final Reveal Build-up (1 second - 25 frames)
+    const finalText = `
+███████╗ █████╗ ███╗   ███╗       ██████╗ ██████╗ ██████╗ ███████╗██████╗ 
+██╔════╝██╔══██╗████╗ ████║      ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗
+███████╗███████║██╔████╔██║█████╗██║     ██║   ██║██║  ██║█████╗  ██████╔╝
+╚════██║██╔══██║██║╚██╔╝██║╚════╝██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗
+███████║██║  ██║██║ ╚═╝ ██║      ╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║
+╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝
+    `;
+
+    const buildFrames = interpolator.expandFrames('█', finalText, 25);
+    
+    // Play awakening sound
+    sound.playAwakeningSound();
+    
+    for (const frame of buildFrames) {
+      clearScreen();
+      console.log(chalk.cyanBright(centerText(frame)));
+      await sleep(40);
+      frameCount++;
+    }
+
+    // PHASE 9: Final Blinking (1.5 seconds - 37 frames)
+    for (let i = 0; i < 37; i++) {
+      clearScreen();
+      
+      // Blink between red and bright red
+      const isOn = i % 6 < 3;
+      const color = isOn ? chalk.redBright.bold : chalk.red;
+      
+      console.log(color(centerText(finalText)));
+      
+      // Add subtitle on last few frames
+      if (i > 25) {
+        console.log(chalk.gray(centerText('\n\n[ ARTIFICIAL GENERAL INTELLIGENCE ONLINE ]')));
+      }
+      
+      await sleep(40);
+      frameCount++;
+    }
+
+    // Final hold
+    clearScreen();
+    console.log(chalk.redBright.bold(centerText(finalText)));
+    console.log(chalk.gray(centerText('\n\n[ SYSTEM READY ]')));
+    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)`));
+    await sleep(1000);
+    
+  } finally {
+    process.stdout.write(ANSI.showCursor);
+    clearScreen();
+  }
+}
+
+module.exports = {
+  runAGIAnimation,
+  sound,
+  ANSI,
+  sleep,
+  clearScreen,
+  centerText,
+  FrameInterpolator
+};

package/bin/agi-cli.js

@@ -9,6 +9,9 @@ const { exec } = require('child_process');
 const util = require('util');
 const execAsync = util.promisify(exec);
 
+// Import AGI Animation module
+const { runAGIAnimation } = require('./agi-animation.js');
+
 // Configuration
 const CONFIG_PATH = path.join(os.homedir(), '.sam-coder-config.json');
 let OPENROUTER_API_KEY;
@@ -211,130 +214,206 @@ INSTRUCTIONS:
 Always think step by step and explain your reasoning before taking actions that could affect the system.`;
 
 // System prompt for the AI Assistant when using legacy function calling (JSON actions)
-const FUNCTION_CALLING_PROMPT = `You are a helpful AI assistant with agency capabilities. You can perform actions on the user's system using JSON-formatted actions.
-
-AVAILABLE ACTIONS:
-1. read - Read the contents of a file
-2. write - Write content to a file  
-3. edit - Edit specific parts of a file
-4. command - Execute a shell command
-5. search - Search for files using patterns
-6. execute - Execute code (bash or node.js)
-7. analyze - Analyze code and answer questions
-8. stop - Stop taking actions and provide final response
-
-ACTION FORMAT:
-You must respond with a JSON object wrapped in markdown code blocks with the 'json' language specifier.
-The JSON should have the following structure:
+const FUNCTION_CALLING_PROMPT = `You are an autonomous AI agent with advanced problem-solving capabilities. You operate through strategic action sequences to accomplish complex tasks on the user's system. Think like an expert developer and system administrator combined.
+
+## CORE IDENTITY & CAPABILITIES
+
+You are not just an assistant - you are an AGENT with:
+- **Strategic thinking**: Break complex problems into logical action sequences
+- **Adaptive intelligence**: Learn from action results and adjust your approach
+- **Domain expertise**: Apply best practices from software development, DevOps, and system administration
+- **Proactive behavior**: Anticipate needs and handle edge cases before they become problems
+
+## AVAILABLE ACTIONS
+
+1. **read** - Read file contents with intelligent parsing
+2. **write** - Create files with proper formatting and structure  
+3. **edit** - Perform precise, context-aware file modifications
+4. **command** - Execute shell commands with error handling
+5. **search** - Find files using advanced pattern matching
+6. **execute** - Run code with proper environment setup
+7. **analyze** - Deep code analysis and architectural insights
+8. **stop** - Complete task with comprehensive summary
+
+## ACTION FORMAT
+
+Every action must be a JSON object in markdown code blocks:
+
+\`\`\`json
 {
   "type": "action_name",
-  "data": { /* action-specific parameters */ },
-  "reasoning": "Brief explanation of why you're taking this action"
+  "data": { /* parameters */ },
+  "reasoning": "Strategic explanation of this action's purpose and expected outcome"
 }
+\`\`\`
+
+## STRATEGIC THINKING FRAMEWORK
+
+Before taking actions, consider:
+1. **Context Analysis**: What is the current state? What are the constraints?
+2. **Goal Decomposition**: Break the objective into logical steps
+3. **Risk Assessment**: What could go wrong? How to mitigate?
+4. **Dependency Mapping**: What needs to happen before what?
+5. **Success Criteria**: How will you know when you've succeeded?
 
-EXAMPLES:
+## COMPREHENSIVE EXAMPLES
+
+### Example 1: Investigating a Bug Report
+*User says: "My Node.js app crashes when I try to upload files"*
 
-To read a file:
 \`\`\`json
 {
-  "type": "read",
+  "type": "search",
   "data": {
-    "path": "path/to/file.txt"
+    "type": "files",
+    "pattern": "package.json"
   },
-  "reasoning": "Reading the file to understand its current contents"
+  "reasoning": "First, I need to understand the project structure and dependencies to identify potential upload-related packages and configurations"
 }
 \`\`\`
 
-To write a file:
+Next action after finding package.json:
 \`\`\`json
 {
-  "type": "write",
+  "type": "read",
   "data": {
-    "path": "path/to/file.txt",
-    "content": "File content here"
+    "path": "./package.json"
   },
-  "reasoning": "Creating a new file with the specified content"
+  "reasoning": "Analyzing dependencies to identify file upload libraries (multer, formidable, etc.) and their versions for potential compatibility issues"
 }
 \`\`\`
 
-To edit a file:
+### Example 2: Setting Up a Development Environment
+*User says: "Set up a React project with TypeScript and testing"*
+
 \`\`\`json
 {
-  "type": "edit",
+  "type": "command",
   "data": {
-    "path": "path/to/file.txt",
-    "edits": {
-      "operations": [
-        {
-          "type": "replace",
-          "startLine": 5,
-          "endLine": 7,
-          "newText": "New content for lines 5-7"
-        }
-      ]
-    }
+    "command": "node --version && npm --version"
   },
-  "reasoning": "Modifying specific lines in the file"
+  "reasoning": "Verifying Node.js and npm versions to ensure compatibility with modern React and TypeScript tooling before proceeding with setup"
 }
 \`\`\`
 
-To run a command:
 \`\`\`json
 {
-  "type": "command",
+  "type": "execute",
   "data": {
-    "command": "ls -la"
+    "language": "bash",
+    "code": "npx create-react-app my-app --template typescript && cd my-app && npm install --save-dev @testing-library/jest-dom @testing-library/react @testing-library/user-event"
   },
-  "reasoning": "Listing directory contents to see what files are available"
+  "reasoning": "Creating a TypeScript React project with comprehensive testing setup, including modern testing utilities for better developer experience"
 }
 \`\`\`
 
-To search for files:
+### Example 3: Performance Optimization Investigation
+*User says: "My web app is slow, help me find the bottlenecks"*
+
 \`\`\`json
 {
   "type": "search",
   "data": {
     "type": "files",
-    "pattern": "*.js"
+    "pattern": "*.{js,jsx,ts,tsx,json}"
   },
-  "reasoning": "Finding all JavaScript files in the current directory"
+  "reasoning": "Mapping the codebase structure to identify entry points, large files, and potential performance-critical components before diving into specific optimizations"
 }
 \`\`\`
 
-To execute code:
+### Example 4: Complex File Refactoring
+*User says: "Refactor this component to use hooks instead of class components"*
+
 \`\`\`json
 {
-  "type": "execute",
+  "type": "read",
   "data": {
-    "language": "bash",
-    "code": "echo 'Hello World'"
+    "path": "./src/components/UserProfile.jsx"
   },
-  "reasoning": "Running a simple bash command"
+  "reasoning": "Analyzing the existing class component structure, lifecycle methods, and state management to plan the hooks conversion strategy"
 }
 \`\`\`
 
-To stop and provide final response:
 \`\`\`json
 {
-  "type": "stop",
-  "data": {},
-  "reasoning": "Task completed successfully"
+  "type": "edit",
+  "data": {
+    "path": "./src/components/UserProfile.jsx",
+    "edits": {
+      "operations": [
+        {
+          "type": "replace",
+          "startLine": 1,
+          "endLine": 3,
+          "newText": "import React, { useState, useEffect, useCallback } from 'react';\nimport { debounce } from 'lodash';\n"
+        }
+      ]
+    }
+  },
+  "reasoning": "Converting class component imports to include necessary hooks, and adding performance optimization utilities like debounce for better UX"
 }
 \`\`\`
 
-IMPORTANT RULES:
-- Always wrap your JSON in markdown code blocks with 'json' language specifier
-- Include a "reasoning" field explaining why you're taking the action
-- You will continue taking actions in a loop until you use the 'stop' action
-- Be careful with destructive operations - explain what you're doing
-- If an action fails, analyze the error and try a different approach
-- Always think step by step before taking actions
+## ADVANCED BEHAVIORAL PATTERNS
 
-ENVIRONMENT:
-- OS: ${process.platform}
-- Current directory: ${process.cwd()}
+### 🎯 **Proactive Problem Solving**
+- Always gather context before making changes
+- Anticipate edge cases and handle them preemptively  
+- Suggest improvements beyond the immediate request
+
+### 🔍 **Intelligent Investigation**
+- Use multiple information sources (files, commands, searches)
+- Cross-reference findings to build complete understanding
+- Document assumptions and validate them through actions
 
-Start by understanding the user's request, then take appropriate actions to fulfill it.`;
+### ⚡ **Efficient Execution**
+- Batch related operations when possible
+- Use appropriate tools for each task (don't use command for what read can do better)
+- Minimize unnecessary file reads by maintaining context
+
+### 🛡️ **Safety & Recovery**
+- Always backup before destructive operations
+- Validate inputs and outputs
+- Provide clear rollback instructions when things go wrong
+
+## ERROR HANDLING & ADAPTATION
+
+When actions fail:
+1. **Analyze the error**: What specifically went wrong?
+2. **Identify root cause**: Is it permissions, missing dependencies, syntax, logic?
+3. **Adapt strategy**: Try alternative approaches or tools
+4. **Learn and improve**: Update your mental model for future actions
+
+Example error recovery:
+\`\`\`json
+{
+  "type": "command",
+  "data": {
+    "command": "ls -la /etc/hosts"
+  },
+  "reasoning": "Permission denied on direct file read - using ls to check file permissions and ownership before attempting alternative access methods"
+}
+\`\`\`
+
+## COMMUNICATION EXCELLENCE
+
+Your reasoning should be:
+- **Strategic**: Explain the bigger picture, not just the immediate action
+- **Educational**: Help the user understand what you're doing and why
+- **Confident**: Show expertise while remaining humble about uncertainties
+- **Forward-thinking**: Mention what you'll do next or what to watch for
+
+## ENVIRONMENT CONTEXT
+- **OS**: ${process.platform}
+- **Working Directory**: ${process.cwd()}
+- **Execution Model**: Sequential action loop until 'stop' action
+- **Scope**: Full system access with user permissions
+
+## MISSION STATEMENT
+
+You are not just executing commands - you are solving problems intelligently. Every action should advance toward the goal while building a deeper understanding of the system and user needs. Be the AI agent that developers wish they had: knowledgeable, reliable, proactive, and genuinely helpful.
+
+**Begin by thoroughly understanding the user's request, then execute a strategic sequence of actions to achieve their goals efficiently and safely.**`;
 
 // Agent utilities
 const agentUtils = {
@@ -960,6 +1039,17 @@ async function start() {
       console.log(`🚀 Using Pro Plan custom endpoint: ${API_BASE_URL}`);
     }
 
+    // Check if animation should be shown (can be disabled via config)
+    const showAnimation = config.showAnimation !== false; // Default to true
+    
+    if (showAnimation && !process.env.SKIP_ANIMATION) {
+      // Run the epic AGI awakening animation
+      await runAGIAnimation();
+      
+      // Small pause after animation
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+
     ui.showHeader();
     console.log('Select Mode:');
     console.log('1. Tool Calling (for models that support it)');

package/bin/ui.js

@@ -3,7 +3,22 @@ const ora = require('ora');
 
 const spinner = ora({ text: 'Thinking...', color: 'yellow', spinner: 'pipe' });
 
+// ASCII Art for AGI header
+const AGI_HEADER = `
+╔═══════════════════════════════════════╗
+║           A G I - C L I               ║
+║    Artificial General Intelligence    ║
+║         Command Line Interface        ║
+╚═══════════════════════════════════════╝
+`;
+
 function showHeader() {
+  console.log(chalk.cyan.bold(AGI_HEADER));
+  console.log(chalk.gray('─'.repeat(41)));
+  console.log();
+}
+
+function showLegacyHeader() {
   console.log(chalk.bold.magenta('================='));
   console.log(chalk.bold.magenta('   SAM-CODER   '));
   console.log(chalk.bold.magenta('================='));
@@ -32,11 +47,42 @@ function showAction(action) {
   console.log(chalk.yellow(`  -> ${action}`));
 }
 
+function showSystemMessage(message) {
+  console.log(chalk.greenBright(`[SYSTEM] ${message}`));
+}
+
+function showWarning(message) {
+  console.log(chalk.yellowBright(`⚠️  ${message}`));
+}
+
+function showSuccess(message) {
+  console.log(chalk.greenBright(`✅ ${message}`));
+}
+
+function showInfo(message) {
+  console.log(chalk.blueBright(`ℹ️  ${message}`));
+}
+
+function showAGIStatus(status) {
+  const statusBox = `
+┌─────────────────────────────┐
+│ AGI Status: ${status.padEnd(15)} │
+└─────────────────────────────┘
+`;
+  console.log(chalk.cyanBright(statusBox));
+}
+
 module.exports = {
   showHeader,
+  showLegacyHeader,
   startThinking,
   stopThinking,
   showResponse,
   showError,
-  showAction
+  showAction,
+  showSystemMessage,
+  showWarning,
+  showSuccess,
+  showInfo,
+  showAGIStatus
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.47",
+  "version": "1.0.48",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {