sam-coder-cli 1.0.31 → 1.0.33

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/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,
@@ -775,7 +779,7 @@ class MultiplayerClient extends EventEmitter {
     });
   }
   
-  async joinSession(sessionId) {
+  async joinSession(sessionId, createIfNotExists = true) {
     if (!sessionId) {
       throw new Error('Session ID is required');
     }
@@ -791,9 +795,10 @@ class MultiplayerClient extends EventEmitter {
       
       const timeout = setTimeout(() => {
         this.off('session_joined', onSessionJoined);
+        this.off('session_created', onSessionCreated);
         this.off('error', onError);
         reject(new Error('Session join timed out'));
-      }, 10000); // 10 second timeout
+      }, 15000); // Increased timeout to 15 seconds
       
       const onSessionJoined = (data) => {
         if (data.sessionId === sessionId) {
@@ -802,21 +807,54 @@ class MultiplayerClient extends EventEmitter {
           this.isHost = data.isHost || false;
           this.emit('session_joined', data);
           this.off('session_joined', onSessionJoined);
+          this.off('session_created', onSessionCreated);
           this.off('error', onError);
+          console.log(`✅ Successfully joined session ${sessionId}`);
           resolve(data);
         }
       };
       
+      const onSessionCreated = (data) => {
+        if (data.sessionId === sessionId) {
+          clearTimeout(timeout);
+          this.sessionId = sessionId;
+          this.isHost = true;
+          this.emit('session_joined', { ...data, isHost: true });
+          this.off('session_joined', onSessionJoined);
+          this.off('session_created', onSessionCreated);
+          this.off('error', onError);
+          console.log(`✅ Created and joined new session ${sessionId}`);
+          resolve({ ...data, isHost: true });
+        }
+      };
+      
       const onError = (error) => {
+        if (error.message === 'Session not found' && createIfNotExists) {
+          // If session doesn't exist and we're allowed to create it
+          this.off('session_joined', onSessionJoined);
+          this.off('error', onError);
+          console.log(`Session ${sessionId} not found, creating new session...`);
+          this.createSession(sessionId)
+            .then(() => {
+              this.once('session_created', onSessionCreated);
+              this.once('error', onError);
+            })
+            .catch(reject);
+          return;
+        }
+        
         clearTimeout(timeout);
         this.off('session_joined', onSessionJoined);
+        this.off('session_created', onSessionCreated);
         this.off('error', onError);
+        console.error('Error joining session:', error.message);
         reject(error);
       };
       
       this.on('session_joined', onSessionJoined);
       this.on('error', onError);
       
+      console.log(`Attempting to join session ${sessionId}...`);
       this.send({
         type: 'join_session',
         sessionId: sessionId,

package/package.json

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