@hanzo/dev 1.2.0 → 2.0.0

package/src/lib/agent-loop.ts

@@ -0,0 +1,552 @@
+import { EventEmitter } from 'events';
+import chalk from 'chalk';
+import { FunctionCallingSystem, FunctionCall } from './function-calling';
+import { MCPClient, MCPSession } from './mcp-client';
+
+export interface LLMProvider {
+  name: string;
+  type: 'openai' | 'anthropic' | 'local' | 'hanzo-app';
+  apiKey?: string;
+  baseUrl?: string;
+  model: string;
+  supportsTools: boolean;
+  supportsStreaming: boolean;
+}
+
+export interface AgentLoopConfig {
+  provider: LLMProvider;
+  maxIterations: number;
+  enableMCP: boolean;
+  enableBrowser: boolean;
+  enableSwarm: boolean;
+  streamOutput: boolean;
+  confirmActions: boolean;
+}
+
+export interface AgentMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string;
+  toolCalls?: FunctionCall[];
+  toolResults?: any[];
+}
+
+export class ConfigurableAgentLoop extends EventEmitter {
+  private config: AgentLoopConfig;
+  private functionCalling: FunctionCallingSystem;
+  private mcpClient: MCPClient;
+  private messages: AgentMessage[] = [];
+  private iterations: number = 0;
+
+  constructor(config: AgentLoopConfig) {
+    super();
+    this.config = config;
+    this.functionCalling = new FunctionCallingSystem();
+    this.mcpClient = new MCPClient();
+  }
+
+  // Get available LLM providers
+  static getAvailableProviders(): LLMProvider[] {
+    const providers: LLMProvider[] = [];
+
+    // Check for API keys
+    if (process.env.ANTHROPIC_API_KEY) {
+      providers.push({
+        name: 'Claude (Anthropic)',
+        type: 'anthropic',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        model: 'claude-3-opus-20240229',
+        supportsTools: true,
+        supportsStreaming: true
+      });
+    }
+
+    if (process.env.OPENAI_API_KEY) {
+      providers.push({
+        name: 'GPT-4 (OpenAI)',
+        type: 'openai',
+        apiKey: process.env.OPENAI_API_KEY,
+        model: 'gpt-4-turbo-preview',
+        supportsTools: true,
+        supportsStreaming: true
+      });
+    }
+
+    // Check for local Hanzo App
+    if (process.env.HANZO_APP_URL || this.isHanzoAppRunning()) {
+      providers.push({
+        name: 'Hanzo Local AI',
+        type: 'hanzo-app',
+        baseUrl: process.env.HANZO_APP_URL || 'http://localhost:8080',
+        model: 'hanzo-zen',
+        supportsTools: true,
+        supportsStreaming: false
+      });
+    }
+
+    // Check for other local models
+    if (process.env.LOCAL_LLM_URL) {
+      providers.push({
+        name: 'Local LLM',
+        type: 'local',
+        baseUrl: process.env.LOCAL_LLM_URL,
+        model: process.env.LOCAL_LLM_MODEL || 'llama2',
+        supportsTools: false,
+        supportsStreaming: true
+      });
+    }
+
+    return providers;
+  }
+
+  private static isHanzoAppRunning(): boolean {
+    // Check if Hanzo App is running locally
+    try {
+      const { execSync } = require('child_process');
+      execSync('curl -s http://localhost:8080/health', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Initialize tools and connections
+  async initialize(): Promise<void> {
+    console.log(chalk.cyan('\n🔧 Initializing agent loop...\n'));
+
+    // Initialize MCP tools if enabled
+    if (this.config.enableMCP) {
+      await this.initializeMCPTools();
+    }
+
+    // Initialize browser connection if enabled
+    if (this.config.enableBrowser) {
+      await this.initializeBrowserTools();
+    }
+
+    // Initialize swarm if enabled
+    if (this.config.enableSwarm) {
+      await this.initializeSwarmTools();
+    }
+
+    console.log(chalk.green('✓ Agent loop initialized\n'));
+  }
+
+  private async initializeMCPTools(): Promise<void> {
+    console.log(chalk.gray('Loading MCP tools...'));
+    
+    // Load configured MCP servers from config file
+    const mcpConfig = await this.loadMCPConfig();
+    
+    for (const server of mcpConfig.servers) {
+      try {
+        console.log(chalk.gray(`  Connecting to ${server.name}...`));
+        const session = await this.mcpClient.connect(server);
+        await this.functionCalling.registerMCPServer(server.name, session);
+        console.log(chalk.green(`  ✓ Connected to ${server.name} (${session.tools.length} tools)`));
+      } catch (error) {
+        console.log(chalk.yellow(`  ⚠ Failed to connect to ${server.name}`));
+      }
+    }
+  }
+
+  private async initializeBrowserTools(): Promise<void> {
+    console.log(chalk.gray('Connecting to browser...'));
+    
+    // Check for Hanzo Browser Extension
+    if (await this.checkBrowserExtension()) {
+      console.log(chalk.green('  ✓ Connected to Hanzo Browser Extension'));
+      this.registerBrowserTools('extension');
+    }
+    // Check for Hanzo Browser
+    else if (await this.checkHanzoBrowser()) {
+      console.log(chalk.green('  ✓ Connected to Hanzo Browser'));
+      this.registerBrowserTools('browser');
+    } else {
+      console.log(chalk.yellow('  ⚠ No browser connection available'));
+    }
+  }
+
+  private async checkBrowserExtension(): Promise<boolean> {
+    // Check if browser extension is available via WebSocket
+    try {
+      const ws = new (require('ws'))('ws://localhost:9222/hanzo-extension');
+      return new Promise((resolve) => {
+        ws.on('open', () => {
+          ws.close();
+          resolve(true);
+        });
+        ws.on('error', () => resolve(false));
+        setTimeout(() => {
+          ws.close();
+          resolve(false);
+        }, 1000);
+      });
+    } catch {
+      return false;
+    }
+  }
+
+  private async checkHanzoBrowser(): Promise<boolean> {
+    // Check if Hanzo Browser is running
+    try {
+      const response = await fetch('http://localhost:9223/status');
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  private registerBrowserTools(type: 'extension' | 'browser'): void {
+    // Register browser automation tools
+    const browserTools = [
+      {
+        name: 'browser_navigate',
+        description: 'Navigate to a URL in the browser',
+        parameters: {
+          type: 'object',
+          properties: {
+            url: { type: 'string', description: 'URL to navigate to' }
+          },
+          required: ['url']
+        },
+        handler: async (args: any) => this.browserNavigate(args.url)
+      },
+      {
+        name: 'browser_click',
+        description: 'Click on an element in the browser',
+        parameters: {
+          type: 'object',
+          properties: {
+            selector: { type: 'string', description: 'CSS selector or element ID' }
+          },
+          required: ['selector']
+        },
+        handler: async (args: any) => this.browserClick(args.selector)
+      },
+      {
+        name: 'browser_screenshot',
+        description: 'Take a screenshot of the current page',
+        parameters: {
+          type: 'object',
+          properties: {
+            fullPage: { type: 'boolean', description: 'Capture full page' }
+          }
+        },
+        handler: async (args: any) => this.browserScreenshot(args.fullPage)
+      },
+      {
+        name: 'browser_fill',
+        description: 'Fill a form field in the browser',
+        parameters: {
+          type: 'object',
+          properties: {
+            selector: { type: 'string', description: 'CSS selector' },
+            value: { type: 'string', description: 'Value to fill' }
+          },
+          required: ['selector', 'value']
+        },
+        handler: async (args: any) => this.browserFill(args.selector, args.value)
+      }
+    ];
+
+    browserTools.forEach(tool => this.functionCalling.registerTool(tool));
+  }
+
+  private async initializeSwarmTools(): Promise<void> {
+    console.log(chalk.gray('Initializing swarm tools...'));
+    
+    // Register swarm coordination tools
+    this.functionCalling.registerTool({
+      name: 'spawn_agent',
+      description: 'Spawn a new agent for a specific task',
+      parameters: {
+        type: 'object',
+        properties: {
+          task: { type: 'string', description: 'Task for the agent' },
+          agentType: { type: 'string', enum: ['claude-code', 'aider', 'openhands'] }
+        },
+        required: ['task']
+      },
+      handler: async (args: any) => this.spawnAgent(args.task, args.agentType)
+    });
+
+    this.functionCalling.registerTool({
+      name: 'delegate_to_swarm',
+      description: 'Delegate multiple tasks to agent swarm',
+      parameters: {
+        type: 'object',
+        properties: {
+          tasks: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'List of tasks to delegate'
+          }
+        },
+        required: ['tasks']
+      },
+      handler: async (args: any) => this.delegateToSwarm(args.tasks)
+    });
+  }
+
+  // Execute agent loop
+  async execute(initialPrompt: string): Promise<void> {
+    console.log(chalk.cyan(`\n🤖 Starting agent loop with ${this.config.provider.name}\n`));
+    
+    // Add system message
+    this.messages.push({
+      role: 'system',
+      content: this.getSystemPrompt()
+    });
+
+    // Add user message
+    this.messages.push({
+      role: 'user',
+      content: initialPrompt
+    });
+
+    // Main agent loop
+    while (this.iterations < this.config.maxIterations) {
+      this.iterations++;
+      console.log(chalk.blue(`\n▶ Iteration ${this.iterations}`));
+
+      try {
+        // Get LLM response
+        const response = await this.callLLM();
+        
+        // Process response
+        if (response.toolCalls && response.toolCalls.length > 0) {
+          // Execute tool calls
+          const results = await this.executeToolCalls(response.toolCalls);
+          
+          // Add tool results to messages
+          this.messages.push({
+            role: 'tool',
+            content: JSON.stringify(results),
+            toolResults: results
+          });
+        } else {
+          // No more tool calls, task complete
+          console.log(chalk.green('\n✅ Task completed'));
+          break;
+        }
+      } catch (error) {
+        console.error(chalk.red(`Error in iteration ${this.iterations}: ${error}`));
+        this.emit('error', error);
+        break;
+      }
+    }
+
+    if (this.iterations >= this.config.maxIterations) {
+      console.log(chalk.yellow('\n⚠ Maximum iterations reached'));
+    }
+  }
+
+  private getSystemPrompt(): string {
+    const tools = this.functionCalling.getAvailableTools();
+    
+    return `You are an AI assistant with access to various tools. You can:
+- Edit files using view_file, create_file, str_replace
+- Run commands using run_command
+- Search files using search_files
+- List directories using list_directory
+${this.config.enableBrowser ? '- Control the browser using browser_* tools' : ''}
+${this.config.enableSwarm ? '- Spawn agents and delegate tasks using swarm tools' : ''}
+${this.config.enableMCP ? '- Use MCP tools for extended functionality' : ''}
+
+Available tools: ${tools.map(t => t.name).join(', ')}
+
+Always use tools to accomplish tasks. Think step by step.`;
+  }
+
+  private async callLLM(): Promise<AgentMessage> {
+    const { provider } = this.config;
+    
+    switch (provider.type) {
+      case 'anthropic':
+        return this.callAnthropic();
+      case 'openai':
+        return this.callOpenAI();
+      case 'hanzo-app':
+        return this.callHanzoApp();
+      case 'local':
+        return this.callLocalLLM();
+      default:
+        throw new Error(`Unknown provider type: ${provider.type}`);
+    }
+  }
+
+  private async callAnthropic(): Promise<AgentMessage> {
+    // Implementation for Anthropic Claude
+    console.log(chalk.gray('Calling Claude...'));
+    
+    // This is a simplified version - in production you'd use the actual API
+    const tools = this.functionCalling.getAllToolSchemas();
+    
+    // Simulate API call
+    const response = {
+      role: 'assistant' as const,
+      content: 'I will help you with this task.',
+      toolCalls: [
+        {
+          id: 'call_1',
+          name: 'view_file',
+          arguments: { path: 'package.json' }
+        }
+      ]
+    };
+    
+    this.messages.push(response);
+    return response;
+  }
+
+  private async callOpenAI(): Promise<AgentMessage> {
+    // Implementation for OpenAI
+    console.log(chalk.gray('Calling GPT-4...'));
+    
+    // Similar to Anthropic but with OpenAI API format
+    const response = {
+      role: 'assistant' as const,
+      content: 'I will analyze and complete this task.',
+      toolCalls: []
+    };
+    
+    this.messages.push(response);
+    return response;
+  }
+
+  private async callHanzoApp(): Promise<AgentMessage> {
+    // Implementation for local Hanzo App
+    console.log(chalk.gray('Calling Hanzo Local AI...'));
+    
+    const response = await fetch(`${this.config.provider.baseUrl}/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        messages: this.messages,
+        tools: this.functionCalling.getAllToolSchemas()
+      })
+    });
+    
+    const data = await response.json();
+    this.messages.push(data);
+    return data;
+  }
+
+  private async callLocalLLM(): Promise<AgentMessage> {
+    // Implementation for generic local LLM
+    console.log(chalk.gray('Calling Local LLM...'));
+    
+    // Local LLMs might not support tools, so we use a different approach
+    const response = {
+      role: 'assistant' as const,
+      content: 'Processing your request...',
+      toolCalls: []
+    };
+    
+    this.messages.push(response);
+    return response;
+  }
+
+  private async executeToolCalls(calls: FunctionCall[]): Promise<any[]> {
+    if (this.config.confirmActions) {
+      console.log(chalk.yellow('\n⚠ Tool calls requested:'));
+      calls.forEach(call => {
+        console.log(`  - ${call.name}(${JSON.stringify(call.arguments)})`);
+      });
+      
+      const { confirm } = await require('inquirer').prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Execute these actions?',
+        default: true
+      }]);
+      
+      if (!confirm) {
+        throw new Error('User cancelled tool execution');
+      }
+    }
+    
+    return this.functionCalling.callFunctions(calls);
+  }
+
+  // Browser tool implementations
+  private async browserNavigate(url: string): Promise<any> {
+    console.log(chalk.gray(`Navigating to ${url}...`));
+    // Implementation would connect to browser
+    return { success: true, url };
+  }
+
+  private async browserClick(selector: string): Promise<any> {
+    console.log(chalk.gray(`Clicking ${selector}...`));
+    return { success: true, selector };
+  }
+
+  private async browserScreenshot(fullPage: boolean = false): Promise<any> {
+    console.log(chalk.gray(`Taking screenshot (fullPage: ${fullPage})...`));
+    return { success: true, screenshot: 'base64_image_data' };
+  }
+
+  private async browserFill(selector: string, value: string): Promise<any> {
+    console.log(chalk.gray(`Filling ${selector} with "${value}"...`));
+    return { success: true, selector, value };
+  }
+
+  // Swarm tool implementations
+  private async spawnAgent(task: string, agentType?: string): Promise<any> {
+    console.log(chalk.gray(`Spawning ${agentType || 'default'} agent for: ${task}`));
+    return { success: true, agentId: `agent-${Date.now()}`, task };
+  }
+
+  private async delegateToSwarm(tasks: string[]): Promise<any> {
+    console.log(chalk.gray(`Delegating ${tasks.length} tasks to swarm...`));
+    return { success: true, tasks, status: 'delegated' };
+  }
+
+  // Load MCP configuration
+  private async loadMCPConfig(): Promise<{ servers: any[] }> {
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+    
+    // Check multiple locations for MCP config
+    const configPaths = [
+      path.join(process.cwd(), '.mcp.json'),
+      path.join(os.homedir(), '.config', 'hanzo-dev', 'mcp.json'),
+      path.join(os.homedir(), '.hanzo', 'mcp.json')
+    ];
+    
+    for (const configPath of configPaths) {
+      if (fs.existsSync(configPath)) {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+      }
+    }
+    
+    // Default MCP servers
+    return {
+      servers: [
+        {
+          name: 'filesystem',
+          command: 'npx',
+          args: ['@modelcontextprotocol/server-filesystem'],
+          env: { MCP_ALLOWED_PATHS: process.cwd() }
+        },
+        {
+          name: 'git',
+          command: 'npx',
+          args: ['@modelcontextprotocol/server-git']
+        }
+      ]
+    };
+  }
+
+  // Get current configuration
+  getConfig(): AgentLoopConfig {
+    return this.config;
+  }
+
+  // Update configuration
+  updateConfig(updates: Partial<AgentLoopConfig>): void {
+    this.config = { ...this.config, ...updates };
+  }
+}