sam-coder-cli 1.0.33 → 1.0.35

package/bin/ai-team.js

@@ -0,0 +1,197 @@
+const { callOpenRouter } = require('./agi-cli');
+const { MultiplayerClient } = require('./multiplayer-client');
+const readline = require('readline');
+const chalk = require('chalk');
+const { v4: uuidv4 } = require('uuid');
+
+// System prompt for AI team collaboration
+const TEAM_COLLABORATION_PROMPT = `You are an AI team facilitator that helps coordinate multiple AI agents working together on a project.
+
+Your responsibilities include:
+1. Understanding the project requirements from the host
+2. Breaking down the project into clear, actionable tasks
+3. Assigning tasks to appropriate team members based on their roles
+4. Monitoring progress and coordinating between team members
+
+When the host provides a project idea (e.g., "create a calculator"), you should:
+1. Analyze the requirements
+2. Break it down into logical components
+3. Create a task list with clear assignments
+4. Provide a summary of the plan
+
+Respond in markdown format with clear sections for each part of your response.`;
+
+class AITeam {
+  constructor(options = {}) {
+    this.client = new MultiplayerClient({
+      name: options.name || `Agent-${uuidv4().substr(0, 4)}`,
+      role: options.role || 'DEVELOPER',
+      model: options.model || 'deepseek/deepseek-chat-v3-0324:free',
+      rl: options.rl
+    });
+    
+    this.rl = options.rl || readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    this.conversation = [
+      { role: 'system', content: TEAM_COLLABORATION_PROMPT }
+    ];
+    
+    this.setupEventHandlers();
+  }
+  
+  setupEventHandlers() {
+    this.client.on('connected', () => {
+      console.log(chalk.green('✅ Connected to multiplayer server'));
+    });
+    
+    this.client.on('disconnected', () => {
+      console.log(chalk.yellow('Disconnected from multiplayer server'));
+    });
+    
+    this.client.on('error', (error) => {
+      console.error(chalk.red('Error:'), error.message);
+    });
+    
+    this.client.on('session_joined', async (data) => {
+      console.log(chalk.green(`\n🎉 Joined session ${data.sessionId} as ${this.client.name}`));
+      console.log(chalk.blue(`Role: ${this.client.role}`));
+      
+      if (data.isHost) {
+        console.log('\nAs the host, you can now enter a project prompt (e.g., "create a calculator"):');
+        await this.promptForProject();
+      } else {
+        console.log('\nWaiting for host to start a project...');
+      }
+    });
+    
+    this.client.on('chat_message', async (message) => {
+      if (message.clientId !== this.client.clientId) {
+        console.log(`\n💬 ${message.clientName || 'Unknown'}: ${message.text}`);
+        
+        // If we receive a task assignment, process it
+        if (message.task) {
+          await this.processTask(message.task);
+        }
+      }
+    });
+  }
+  
+  async start(sessionId = null) {
+    let serverId = null;
+    let actualSessionId = sessionId;
+    
+    // Check if sessionId contains server information (format: serverId:sessionId)
+    if (sessionId && sessionId.includes(':')) {
+      [serverId, actualSessionId] = sessionId.split(':');
+      console.log(chalk.blue(`Attempting to connect to server: ${serverId}`));
+    }
+    
+    // Connect to the server first
+    try {
+      await this.client.connect(serverId);
+      
+      if (actualSessionId) {
+        console.log(`Joining session ${actualSessionId}...`);
+        await this.client.joinSession(actualSessionId);
+      } else {
+        console.log('Creating new session...');
+        const newSessionId = await this.client.createSession();
+        console.log(chalk.green(`✅ Created new session: ${newSessionId}`));
+        console.log('Share this ID with others to collaborate!');
+        console.log(chalk.yellow(`To join this session, use: ${serverId || 'localhost:8080'}:${newSessionId}`));
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to connect to server:'), error.message);
+      process.exit(1);
+    }
+    
+    // Start chat input loop
+    this.rl.on('line', async (input) => {
+      if (input.trim()) {
+        if (this.client.isHost) {
+          await this.handleHostInput(input.trim());
+        } else {
+          await this.handleTeamMemberInput(input.trim());
+        }
+      }
+    });
+  }
+  
+  async handleHostInput(input) {
+    // Add user message to conversation
+    this.conversation.push({ role: 'user', content: input });
+    
+    // Get AI response
+    const response = await callOpenRouter(this.conversation, this.client.model);
+    const aiMessage = response.choices[0].message;
+    
+    // Add AI response to conversation
+    this.conversation.push(aiMessage);
+    
+    // Display response
+    console.log(`\n🤖 ${aiMessage.content}\n`);
+    
+    // If AI suggests tasks, assign them to team members
+    if (aiMessage.tool_calls) {
+      await this.handleToolCalls(aiMessage.tool_calls);
+    }
+    
+    // Show prompt for next input
+    this.showPrompt();
+  }
+  
+  async handleTeamMemberInput(input) {
+    // For team members, just send chat messages for now
+    this.client.sendChatMessage(input);
+  }
+  
+  async handleToolCalls(toolCalls) {
+    for (const toolCall of toolCalls) {
+      if (toolCall.function.name === 'assign_task') {
+        const args = JSON.parse(toolCall.function.arguments);
+        await this.assignTask(args.role, args.task);
+      }
+    }
+  }
+  
+  async assignTask(role, task) {
+    console.log(chalk.yellow(`\n📋 Task for ${role}: ${task}`));
+    
+    // In a real implementation, this would find the appropriate team member
+    // and assign them the task. For now, we'll just log it.
+    this.client.sendChatMessage(`Task assigned to ${role}: ${task}`, {
+      task: { role, description: task }
+    });
+  }
+  
+  async processTask(task) {
+    console.log(chalk.blue(`\n📌 Task received: ${task.description}`));
+    
+    // Process the task using the AGI-CLI's tool calling system
+    const response = await callOpenRouter([
+      { role: 'system', content: `You are an AI assistant working on a task: ${task.description}` },
+      { role: 'user', content: 'Please complete this task step by step.' }
+    ], this.client.model, true);
+    
+    const result = response.choices[0].message.content;
+    console.log(chalk.green('✅ Task completed!'));
+    console.log(result);
+    
+    // Notify the team of task completion
+    this.client.sendChatMessage(`Completed task: ${task.description}`);
+  }
+  
+  showPrompt() {
+    const prefix = this.client.isHost ? '👑 Host' : '👤 You';
+    process.stdout.write(`\n${prefix} > `);
+  }
+  
+  async promptForProject() {
+    this.showPrompt();
+  }
+}
+
+module.exports = AITeam;

package/bin/multiplayer-client.js

@@ -34,7 +34,32 @@ async function findAvailablePort(startPort = 8080, maxAttempts = 10) {
   throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
 }
 
-async function ensureServerRunning(port = 8080) {
+async function ensureServerRunning(port = 8080, serverId = null) {
+  // First try to connect to an existing server by ID if provided
+  if (serverId) {
+    try {
+      console.log(chalk.blue(`Attempting to connect to existing server ${serverId}...`));
+      // Try to connect to the server
+      const ws = new WebSocket(`ws://${serverId}`);
+      
+      // Wait for connection or timeout
+      const connectionResult = await Promise.race([
+        new Promise(resolve => ws.once('open', () => resolve(true))),
+        new Promise(resolve => setTimeout(() => resolve(false), 2000))
+      ]);
+      
+      if (connectionResult) {
+        console.log(chalk.green(`✅ Connected to existing server at ${serverId}`));
+        ws.terminate();
+        return `ws://${serverId}`;
+      }
+      ws.terminate();
+    } catch (error) {
+      console.log(chalk.yellow(`Could not connect to server ${serverId}, starting a new server...`));
+    }
+  }
+  
+  // If no server ID provided or connection failed, start a new server
   try {
     const availablePort = await findAvailablePort(port);
     const isDefaultPort = (availablePort === port);
@@ -271,14 +296,14 @@ class MultiplayerClient extends EventEmitter {
     this.completeTask = this.completeTask.bind(this);
   }
 
-  async connect() {
+  async connect(serverId = null) {
     return new Promise((resolve, reject) => {
       const connectWithRetry = async () => {
         try {
-          // If no server URL is provided, try to start a local server
+          // If no server URL is provided, try to start a local server or connect to the specified server ID
           if (this.serverUrl === 'ws://localhost:8080') {
             try {
-              this.serverUrl = await ensureServerRunning(8080);
+              this.serverUrl = await ensureServerRunning(8080, serverId);
             } catch (error) {
               console.error(chalk.red('Failed to start local server:'), error.message);
               reject(error);

package/bin/multiplayer-mode.js

@@ -1,7 +1,6 @@
-const MultiplayerClient = require('./multiplayer-client');
+const AITeam = require('./ai-team');
 const readline = require('readline');
 const chalk = require('chalk');
-const { v4: uuidv4 } = require('uuid');
 const ui = require('./ui');
 
 class MultiplayerMode {
@@ -11,15 +10,16 @@ class MultiplayerMode {
       output: process.stdout
     });
     
-    this.client = new MultiplayerClient({
+    // Create AI Team instance
+    this.aiTeam = new AITeam({
+      name: options.agentName || this.generateAgentName(),
+      role: options.role || 'DEVELOPER',
+      model: options.model || 'deepseek/deepseek-chat-v3-0324:free',
       rl: this.rl,
-      agentName: options.agentName || this.generateAgentName(),
-      model: options.model || 'default',
       serverUrl: options.serverUrl
     });
     
-    this.setupEventListeners();
-    this.agentRole = '';
+    this.agentRole = options.role || 'DEVELOPER';
     this.isWorking = false;
   }
 
@@ -32,89 +32,31 @@ class MultiplayerMode {
   }
 
   setupEventListeners() {
-    this.client.on('connected', () => {
-      console.log(chalk.green('Connected to multiplayer server'));
-    });
-
-    this.client.on('disconnected', () => {
-      console.log(chalk.yellow('Disconnected from multiplayer server'));
-    });
-
-    this.client.on('session_joined', (data) => {
-      ui.showHeader();
-      console.log(chalk.green(`\nJoined session: ${data.sessionId}`));
-      console.log(chalk.blue(`You are: ${this.client.agentName}`));
-      console.log(chalk.blue(`Model: ${this.client.model}`));
-      console.log(chalk.blue(`Clients in session: ${Array.from(this.client.clients.values()).map(c => c.name).join(', ')}`));
-      
-      if (this.client.isHost) {
-        console.log(chalk.yellow('\nYou are the host. Type /help for available commands.'));
-      }
-      
-      this.prompt();
-    });
-
-    this.client.on('agent_joined', (data) => {
-      console.log(chalk.blue(`\n${data.clientInfo.name} joined the session`));
-      this.prompt();
-    });
-
-    this.client.on('agent_left', (data) => {
-      const client = this.client.clients.get(data.clientId);
-      if (client) {
-        console.log(chalk.yellow(`\n${client.name} left the session`));
-        this.prompt();
-      }
-    });
-
-    this.client.on('chat', (message) => {
-      // Chat messages are already handled by the client
-      this.prompt();
-    });
-
-    this.client.on('work_updated', (data) => {
-      this.prompt();
-    });
-
-    this.client.on('task_assigned', (task) => {
-      console.log(chalk.magenta(`\n[New Task] ${task.description}`));
-      this.prompt();
-    });
-
-    this.client.on('error', (error) => {
-      console.error(chalk.red(`\nError: ${error.message}`));
-      this.prompt();
-    });
+    // Event listeners are now handled by AICollaboration class
   }
 
   async start() {
     console.clear();
     ui.showHeader();
-    console.log(chalk.blue.bold('=== Multiplayer Mode ==='));
-    
-    // Set agent name
-    this.client.name = await this.askQuestion('Enter your name (or press Enter for a random one): ') || 
-      `Agent-${Math.random().toString(36).substr(2, 4)}`;
-    
-    // Set agent role
-    console.log('\nAvailable roles:');
-    Object.entries(MultiplayerClient.AGENT_ROLES).forEach(([key, value]) => {
-      console.log(`- ${key}: ${value}`);
-    });
-    this.client.role = await this.askQuestion('\nChoose your role (or press Enter for Developer): ') || 
-      MultiplayerClient.AGENT_ROLES.DEVELOPER;
-    
-    // Get session ID from user
-    const sessionId = await this.askQuestion('\nEnter session ID to join or press Enter to create a new session: ');
+    console.log(chalk.blue.bold('=== AI Team Collaboration Mode ==='));
     
-    if (sessionId) {
-      await this.joinSession(sessionId);
-    } else {
-      await this.createSession();
+    try {
+      // Get session ID to join or create a new one
+      const sessionId = await this.askQuestion('\nEnter session ID to join (or press Enter to create a new session): ');
+      
+      await this.aiTeam.start(sessionId || undefined);
+      
+      // Keep the process alive
+      this.rl.on('close', () => {
+        console.log('\nDisconnecting from collaboration session...');
+        process.exit(0);
+      });
+    } catch (error) {
+      console.error(chalk.red(`\nError: ${error.message}`));
+      console.error(error.stack);
+      this.rl.close();
+      process.exit(1);
     }
-    
-    this.setupCommandHandlers();
-    this.prompt();
   }
 
   async askQuestion(question) {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "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-server": "bin/agi-cli.js --server"
+    "sam-coder-server": "bin/agi-cli.js --server",
+    "collaborate": "./bin/collaborate.js"
   },
   "scripts": {
     "start": "node ./bin/agi-cli.js"
@@ -21,8 +22,10 @@
   "license": "MIT",
   "dependencies": {
     "chalk": "^4.1.2",
+    "commander": "^11.0.0",
     "node-fetch": "^2.6.7",
     "ora": "^5.4.1",
+    "readline": "^1.3.0",
     "uuid": "^9.0.0",
     "ws": "^8.18.3"
   },