sam-coder-cli 1.0.32 → 1.0.34

package/bin/ai-collaboration.js

@@ -0,0 +1,175 @@
+const { MultiplayerClient } = require('./multiplayer-client');
+const chalk = require('chalk');
+const readline = require('readline');
+const { v4: uuidv4 } = require('uuid');
+
+class AICollaboration {
+  constructor(options = {}) {
+    this.client = new MultiplayerClient({
+      name: options.name || `Agent-${uuidv4().substr(0, 4)}`,
+      role: options.role || 'DEVELOPER',
+      model: options.model || 'default',
+      rl: options.rl
+    });
+    
+    this.rl = options.rl || readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    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', (data) => {
+      console.log(chalk.green(`\n🎉 Joined session ${data.sessionId} as ${this.client.name}`));
+      console.log(chalk.blue(`Role: ${this.client.role}`));
+      console.log(chalk.blue(`Host: ${data.isHost ? 'Yes' : 'No'}`));
+      
+      if (data.isHost) {
+        console.log('\nAs the host, you can now enter a project prompt (e.g., "create a calculator"):');
+        this.promptForProject();
+      } else {
+        console.log('\nWaiting for host to start a project...');
+      }
+    });
+    
+    this.client.on('task_assigned', (task) => {
+      console.log(chalk.yellow(`\n📋 Task assigned: ${task.description}`));
+      console.log('Working on task...');
+      
+      // Simulate working on the task
+      setTimeout(() => {
+        const result = this.workOnTask(task);
+        console.log(chalk.green('✅ Task completed!'));
+        console.log('Result:', result);
+        
+        this.client.completeTask(task.id, result);
+      }, 2000);
+    });
+    
+    this.client.on('task_completed', (data) => {
+      if (this.client.isHost) {
+        console.log(chalk.green(`\n🎯 Task ${data.taskId} completed by all agents!`));
+        console.log('Results:', JSON.stringify(data.results, null, 2));
+      }
+    });
+    
+    this.client.on('chat_message', (message) => {
+      if (message.clientId !== this.client.clientId) {
+        console.log(`\n💬 ${message.clientName || 'Unknown'}: ${message.text}`);
+      }
+    });
+  }
+  
+  async start(sessionId = null) {
+    try {
+      await this.client.connect();
+      
+      if (sessionId) {
+        console.log(`Joining session ${sessionId}...`);
+        await this.client.joinSession(sessionId);
+      } else {
+        console.log('Creating new session...');
+        const newSessionId = await this.client.createSession();
+        console.log(`Created new session: ${newSessionId}`);
+        console.log('Share this ID with others to collaborate!');
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to start AI collaboration:'), error.message);
+      process.exit(1);
+    }
+  }
+  
+  promptForProject() {
+    this.rl.question('\n🔹 Enter project prompt: ', async (prompt) => {
+      if (!prompt.trim()) {
+        console.log(chalk.yellow('Please enter a valid prompt'));
+        return this.promptForProject();
+      }
+      
+      console.log(chalk.blue(`\n🤖 AI Team is working on: ${prompt}`));
+      
+      // Divide tasks based on the prompt
+      const tasks = this.divideTasks(prompt);
+      
+      // Assign tasks to agents
+      for (const task of tasks) {
+        this.client.assignTask(task);
+      }
+    });
+  }
+  
+  divideTasks(prompt) {
+    // Simple task division based on project type
+    const tasks = [];
+    
+    if (prompt.toLowerCase().includes('calculator')) {
+      tasks.push(
+        { id: 'task-1', type: 'ui', description: 'Design calculator UI', assignee: 'DEVELOPER' },
+        { id: 'task-2', type: 'logic', description: 'Implement basic arithmetic operations', assignee: 'DEVELOPER' },
+        { id: 'task-3', type: 'features', description: 'Add advanced functions (sqrt, power, etc.)', assignee: 'DEVELOPER' },
+        { id: 'task-4', type: 'testing', description: 'Test calculator functionality', assignee: 'REVIEWER' }
+      );
+    } else if (prompt.toLowerCase().includes('todo')) {
+      tasks.push(
+        { id: 'task-1', type: 'ui', description: 'Design todo list UI', assignee: 'DEVELOPER' },
+        { id: 'task-2', type: 'data', description: 'Implement todo item storage', assignee: 'DEVELOPER' },
+        { id: 'task-3', type: 'features', description: 'Add CRUD operations', assignee: 'DEVELOPER' },
+        { id: 'task-4', type: 'features', description: 'Add filtering and sorting', assignee: 'DEVELOPER' },
+        { id: 'task-5', type: 'testing', description: 'Test todo functionality', assignee: 'REVIEWER' }
+      );
+    } else {
+      // Default task division for unknown project types
+      tasks.push(
+        { id: 'task-1', type: 'planning', description: 'Plan project structure', assignee: 'LEAD' },
+        { id: 'task-2', type: 'research', description: 'Research required technologies', assignee: 'RESEARCHER' },
+        { id: 'task-3', type: 'development', description: 'Implement core features', assignee: 'DEVELOPER' },
+        { id: 'task-4', type: 'testing', description: 'Test the implementation', assignee: 'REVIEWER' }
+      );
+    }
+    
+    return tasks;
+  }
+  
+  workOnTask(task) {
+    // Simulate work based on task type
+    switch (task.type) {
+      case 'ui':
+        return 'UI implementation completed with responsive design';
+      case 'logic':
+        return 'Core logic implemented and tested';
+      case 'features':
+        return 'Additional features implemented successfully';
+      case 'testing':
+        return 'All tests passed successfully';
+      case 'planning':
+        return 'Project plan created with milestones';
+      case 'research':
+        return 'Research completed with technology recommendations';
+      default:
+        return 'Task completed successfully';
+    }
+  }
+  
+  sendChatMessage(message) {
+    if (message && typeof message === 'string') {
+      this.client.sendChatMessage(message);
+    }
+  }
+}
+
+// Export the AICollaboration class
+module.exports = AICollaboration;

package/bin/ai-team.js

@@ -0,0 +1,179 @@
+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) {
+    if (sessionId) {
+      console.log(`Joining session ${sessionId}...`);
+      await this.client.joinSession(sessionId);
+    } else {
+      console.log('Creating new session...');
+      const newSessionId = await this.client.createSession();
+      console.log(`Created new session: ${newSessionId}`);
+      console.log('Share this ID with others to collaborate!');
+    }
+    
+    // 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/collaborate.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+const AICollaboration = require('./ai-collaboration');
+const readline = require('readline');
+const chalk = require('chalk');
+
+// Create readline interface
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const sessionId = args[0];
+const role = args[1]?.toUpperCase() || 'DEVELOPER';
+
+console.log(chalk.cyan('\n🤖 AI Team Collaboration 🤖'));
+console.log(chalk.cyan('==========================\n'));
+
+// Get user's name
+rl.question('Enter your name (or press Enter for a random one): ', (name) => {
+  // Create AI collaboration instance
+  const aiCollab = new AICollaboration({
+    name: name.trim() || undefined,
+    role: role,
+    rl: rl
+  });
+
+  // Handle Ctrl+C to exit gracefully
+  process.on('SIGINT', () => {
+    console.log('\n👋 Disconnecting...');
+    process.exit(0);
+  });
+
+  // Start the collaboration
+  aiCollab.start(sessionId).catch(error => {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  });
+
+  // Listen for chat messages
+  rl.on('line', (input) => {
+    if (input.trim()) {
+      aiCollab.sendChatMessage(input.trim());
+    }
+  });
+});

package/bin/multiplayer-client.js

@@ -733,23 +733,25 @@ class MultiplayerClient extends EventEmitter {
     return client ? (client.name || client.clientInfo?.name || 'Unknown') : 'Unknown';
   }
   
-  async createSession() {
+  async createSession(sessionId = null) {
     if (!this.connected) {
-      try {
-        await this.connect();
-      } catch (error) {
-        throw new Error(`Failed to connect to server: ${error.message}`);
-      }
+      await this.connect();
     }
     
+    this.sessionId = sessionId || uuidv4();
+    this.isHost = true;
+    
     return new Promise((resolve, reject) => {
-      this.sessionId = uuidv4();
-      this.isHost = true;
+      if (!this.ws) {
+        reject(new Error('Not connected to server'));
+        return;
+      }
       
       const onSessionCreated = (data) => {
         if (data.sessionId === this.sessionId) {
           this.off('session_created', onSessionCreated);
           this.off('error', onError);
+          console.log(`✅ Session ${this.sessionId} created successfully`);
           resolve(this.sessionId);
         }
       };
@@ -757,12 +759,14 @@ class MultiplayerClient extends EventEmitter {
       const onError = (error) => {
         this.off('session_created', onSessionCreated);
         this.off('error', onError);
+        console.error('Error creating session:', error.message);
         reject(error);
       };
       
       this.once('session_created', onSessionCreated);
       this.once('error', onError);
       
+      console.log(`Creating new session ${this.sessionId}...`);
       this.send({
         type: 'create_session',
         sessionId: this.sessionId,

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.32",
+  "version": "1.0.34",
   "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"
   },