sam-coder-cli 1.0.46 → 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,11 +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.
+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": { /* 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?
+
+## COMPREHENSIVE EXAMPLES
+
+### Example 1: Investigating a Bug Report
+*User says: "My Node.js app crashes when I try to upload files"*
+
+\`\`\`json
+{
+  "type": "search",
+  "data": {
+    "type": "files",
+    "pattern": "package.json"
+  },
+  "reasoning": "First, I need to understand the project structure and dependencies to identify potential upload-related packages and configurations"
+}
+\`\`\`
+
+Next action after finding package.json:
+\`\`\`json
+{
+  "type": "read",
+  "data": {
+    "path": "./package.json"
+  },
+  "reasoning": "Analyzing dependencies to identify file upload libraries (multer, formidable, etc.) and their versions for potential compatibility issues"
+}
+\`\`\`
+
+### Example 2: Setting Up a Development Environment
+*User says: "Set up a React project with TypeScript and testing"*
+
+\`\`\`json
+{
+  "type": "command",
+  "data": {
+    "command": "node --version && npm --version"
+  },
+  "reasoning": "Verifying Node.js and npm versions to ensure compatibility with modern React and TypeScript tooling before proceeding with setup"
+}
+\`\`\`
+
+\`\`\`json
+{
+  "type": "execute",
+  "data": {
+    "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": "Creating a TypeScript React project with comprehensive testing setup, including modern testing utilities for better developer experience"
+}
+\`\`\`
+
+### 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,jsx,ts,tsx,json}"
+  },
+  "reasoning": "Mapping the codebase structure to identify entry points, large files, and potential performance-critical components before diving into specific optimizations"
+}
+\`\`\`
+
+### Example 4: Complex File Refactoring
+*User says: "Refactor this component to use hooks instead of class components"*
+
+\`\`\`json
+{
+  "type": "read",
+  "data": {
+    "path": "./src/components/UserProfile.jsx"
+  },
+  "reasoning": "Analyzing the existing class component structure, lifecycle methods, and state management to plan the hooks conversion strategy"
+}
+\`\`\`
+
+\`\`\`json
+{
+  "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"
+}
+\`\`\`
+
+## ADVANCED BEHAVIORAL PATTERNS
+
+### 🎯 **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
+
+### ⚡ **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
 
-   By default, you will continue to take actions in a loop until you decide to stop with the 'stop' action type.
-   Always wrap your JSON in markdown code blocks with the json language specifier.
-   When executing code or commands that might be potentially harmful, explain what the code does before executing it.`;
+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 = {
@@ -357,26 +555,68 @@ const agentUtils = {
 
 // Extract JSON from markdown code blocks
 function extractJsonFromMarkdown(text) {
-  // Try to find a markdown code block with JSON content
-  const codeBlockRegex = /```json\s*([\s\S]*?)\s*```/;
+  if (!text || typeof text !== 'string') {
+    console.error('Invalid input to extractJsonFromMarkdown:', typeof text);
+    return null;
+  }
+
+  // Try to find a markdown code block with JSON content (case insensitive)
+  const codeBlockRegex = /```(?:json|JSON)\s*([\s\S]*?)\s*```/i;
   const match = text.match(codeBlockRegex);
   
-  if (match) {
+  if (match && match[1]) {
     try {
-      return JSON.parse(match[1]);
+      const jsonStr = match[1].trim();
+      if (!jsonStr) {
+        console.error('Empty JSON content in markdown block');
+        return null;
+      }
+      return JSON.parse(jsonStr);
     } catch (error) {
-      console.error('Error parsing JSON from markdown:', error);
+      console.error('Error parsing JSON from markdown block:', error.message);
+      console.error('JSON content was:', match[1]);
+    }
+  }
+  
+  // If no code block found, look for JSON-like patterns in the text
+  const jsonPatterns = [
+    // Look for objects that start with { and end with }
+    /\{[\s\S]*?\}/g,
+    // Look for arrays that start with [ and end with ]
+    /\[[\s\S]*?\]/g
+  ];
+  
+  for (const pattern of jsonPatterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      for (const match of matches) {
+        try {
+          const parsed = JSON.parse(match.trim());
+          // Validate that it looks like an action object
+          if (parsed && typeof parsed === 'object' && parsed.type) {
+            return parsed;
+          }
+        } catch (error) {
+          // Continue to next match
+          continue;
+        }
+      }
     }
   }
   
-  // If no code block, try to parse the entire text as JSON
+  // If still no valid JSON found, try to parse the entire text as JSON
   try {
-    return JSON.parse(text);
+    const trimmed = text.trim();
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+      return JSON.parse(trimmed);
+    }
   } catch (error) {
-    console.error('Error parsing JSON:', error);
-    ui.stopThinking();
-    return null;
+    // Last resort failed
   }
+  
+  console.error('Failed to extract valid JSON from response');
+  console.error('Response text was:', text);
+  return null;
 }
 
 // Call OpenRouter API with tool calling
@@ -542,10 +782,15 @@ async function executeAction(action) {
       }
       throw new Error('Text search is not implemented yet');
     case 'execute':
-      const cmd = data.language === 'bash' 
-        ? data.code 
-        : `node -e "${data.code.replace(/"/g, '\"')}"`;
-      return await agentUtils.runCommand(cmd);
+      if (data.language === 'bash' || data.language === 'sh') {
+        return await agentUtils.runCommand(data.code);
+      } else if (data.language === 'node' || data.language === 'javascript' || data.language === 'js') {
+        // For node.js code, escape quotes properly and handle multiline code
+        const escapedCode = data.code.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return await agentUtils.runCommand(`node -e "${escapedCode}"`);
+      } else {
+        throw new Error(`Unsupported execution language: ${data.language}`);
+      }
     case 'browse':
       throw new Error('Web browsing is not implemented yet');
     case 'analyze':
@@ -560,44 +805,77 @@ async function executeAction(action) {
 async function processQuery(query, conversation = [], currentModel) {
   try {
     const userMessage = { role: 'user', content: query };
+    
+    // Use existing conversation (which should already have system prompt from chat function)
     let messages = [...conversation, userMessage];
+    
     let actionCount = 0;
     const MAX_ACTIONS = 10;
+    let finalResponse = '';
 
     ui.startThinking();
     
-    const responseText = await callOpenRouter(messages, currentModel, true);
-    const assistantMessage = responseText.choices[0].message;
-    messages.push(assistantMessage);
-    
-    const actionData = extractJsonFromMarkdown(assistantMessage.content);
-    
-    if (!actionData || actionData.type === 'stop') {
-      ui.stopThinking();
-      return {
-        response: assistantMessage.content,
-        conversation: messages
-      };
-    }
-
-    let currentAction = actionData;
-    while (currentAction && currentAction.type !== 'stop' && actionCount < MAX_ACTIONS) {
-      actionCount++;
-      const result = await executeAction(currentAction);
+    while (actionCount < MAX_ACTIONS) {
+      const responseObj = await callOpenRouter(messages, currentModel, true);
+      const assistantMessage = responseObj.choices[0].message;
+      messages.push(assistantMessage);
       
-      messages.push({ role: 'assistant', content: `Action result: ${result}` });
+      const actionData = extractJsonFromMarkdown(assistantMessage.content);
       
-      ui.startThinking();
-      const nextResponse = await callOpenRouter(messages, currentModel, true);
-      const nextAssistantMessage = nextResponse.choices[0].message;
-      messages.push(nextAssistantMessage);
+      // If no valid action found, treat as final response
+      if (!actionData || !actionData.type) {
+        finalResponse = assistantMessage.content;
+        break;
+      }
+      
+      // If stop action, break with the reasoning or content
+      if (actionData.type === 'stop') {
+        finalResponse = actionData.reasoning || assistantMessage.content;
+        break;
+      }
+      
+      actionCount++;
+      console.log(`🔧 Executing action ${actionCount}: ${actionData.type}`);
+      if (actionData.reasoning) {
+        console.log(`📝 Reasoning: ${actionData.reasoning}`);
+      }
+      
+      try {
+        const result = await executeAction(actionData);
+        console.log('✅ Action executed successfully');
+        
+        // Add action result to conversation
+        const resultMessage = {
+          role: 'user', 
+          content: `Action result (${actionData.type}): ${result}`
+        };
+        messages.push(resultMessage);
+        
+      } catch (error) {
+        console.error('❌ Action execution failed:', error.message);
+        
+        // Add error result to conversation
+        const errorMessage = {
+          role: 'user', 
+          content: `Action failed (${actionData.type}): ${error.message}`
+        };
+        messages.push(errorMessage);
+      }
+    }
+    
+    // If we hit max actions, get a final response
+    if (actionCount >= MAX_ACTIONS && !finalResponse) {
+      const finalMsg = { role: 'user', content: 'Please provide a final summary of what was accomplished.' };
+      messages.push(finalMsg);
       
-      currentAction = extractJsonFromMarkdown(nextAssistantMessage.content);
+      const finalResponseObj = await callOpenRouter(messages, currentModel, true);
+      finalResponse = finalResponseObj.choices[0].message.content;
+      messages.push(finalResponseObj.choices[0].message);
     }
 
     ui.stopThinking();
     return {
-      response: messages[messages.length - 1].content,
+      response: finalResponse || 'Task completed.',
       conversation: messages
     };
   } catch (error) {
@@ -613,6 +891,14 @@ async function processQuery(query, conversation = [], currentModel) {
 async function chat(rl, useToolCalling, initialModel) {
   let currentModel = initialModel;
   const conversation = [];
+  
+  // Initialize conversation with appropriate system prompt
+  if (useToolCalling) {
+    conversation.push({ role: 'system', content: TOOL_CALLING_PROMPT });
+  } else {
+    conversation.push({ role: 'system', content: FUNCTION_CALLING_PROMPT });
+  }
+  
   console.log('Type your message, or "exit" to quit.');
   
   rl.setPrompt('> ');
@@ -753,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.46",
+  "version": "1.0.48",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {