sam-coder-cli 1.0.43 → 1.0.44

package/bin/multiplayer-mode.js

@@ -1,276 +0,0 @@
-const AITeam = require('./ai-team');
-const readline = require('readline');
-const chalk = require('chalk');
-const ui = require('./ui');
-
-class MultiplayerMode {
-  constructor(options = {}) {
-    this.rl = options.rl || readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-    
-    // 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,
-      serverUrl: options.serverUrl
-    });
-    
-    this.agentRole = options.role || 'DEVELOPER';
-    this.isWorking = false;
-  }
-
-  generateAgentName() {
-    const adjectives = ['Swift', 'Clever', 'Wise', 'Agile', 'Smart', 'Quick', 'Bright', 'Sharp'];
-    const nouns = ['Coder', 'Thinker', 'Solver', 'Creator', 'Builder', 'Planner', 'Strategist'];
-    const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
-    const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
-    return `${randomAdjective}${randomNoun}${Math.floor(100 + Math.random() * 900)}`;
-  }
-
-  setupEventListeners() {
-    // Event listeners are now handled by AICollaboration class
-  }
-
-  async start() {
-    console.clear();
-    ui.showHeader();
-    console.log(chalk.blue.bold('=== AI Team Collaboration Mode ==='));
-    
-    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);
-    }
-  }
-
-  async askQuestion(question) {
-    return new Promise((resolve) => {
-      this.rl.question(question, (answer) => {
-        resolve(answer.trim());
-      });
-    });
-  }
-
-  async joinSession(sessionId) {
-    this.client.joinSession(sessionId);
-  }
-
-  async createSession() {
-    console.log(chalk.yellow('Creating a new session...'));
-    this.client.createSession();
-  }
-
-  setupCommandHandlers() {
-    this.client.on('command', async (command) => {
-      await this.handleCommand(command);
-    });
-  }
-
-  async handleCommand(input) {
-    const [command, ...args] = input.slice(1).split(' ');
-    
-    try {
-      switch (command.toLowerCase()) {
-        case 'name':
-          if (args.length > 0) {
-            const newName = args.join(' ');
-            this.client.name = newName;
-            await this.client.updateClientInfo({ name: newName });
-            console.log(chalk.green(`✅ Name updated to: ${newName}`));
-          } else {
-            console.log(chalk.yellow(`Current name: ${this.client.name}`));
-          }
-          break;
-          
-        case 'role':
-          if (args.length > 0) {
-            const newRole = args.join(' ');
-            this.client.role = newRole;
-            await this.client.updateClientInfo({ role: newRole });
-            console.log(chalk.green(`✅ Role updated to: ${newRole}`));
-          } else {
-            console.log(chalk.yellow(`Current role: ${this.client.role}`));
-          }
-          break;
-          
-        case 'model':
-          if (args.length > 0) {
-            this.client.model = args[0];
-            await this.client.updateClientInfo({ model: this.client.model });
-            console.log(chalk.green(`✅ Model updated to: ${this.client.model}`));
-          } else {
-            console.log(chalk.yellow(`Current model: ${this.client.model}`));
-          }
-          break;
-          
-        case 'work':
-          if (args.length > 0) {
-            const workDesc = args.join(' ');
-            this.client.updateWork({
-              description: workDesc,
-              status: 'in_progress',
-              timestamp: new Date().toISOString()
-            });
-            console.log(chalk.green(`✅ Work updated: ${workDesc}`));
-          } else {
-            console.log(chalk.yellow('Please provide a work description. Example: /work Fixing bugs'));
-          }
-          break;
-          
-        case 'collab':
-        case 'collaborate':
-          if (args.length > 0) {
-            if (!this.client.isHost) {
-              console.log(chalk.yellow('Only the session host can initiate collaboration'));
-              break;
-            }
-            const taskType = args[0].toLowerCase();
-            const prompt = args.slice(1).join(' ');
-            
-            if (!Object.values(MultiplayerClient.TASK_TYPES).includes(taskType)) {
-              console.log(chalk.yellow(`Invalid task type. Available types: ${Object.values(MultiplayerClient.TASK_TYPES).join(', ')}`));
-              break;
-            }
-            
-            if (!prompt) {
-              console.log(chalk.yellow('Please provide a task prompt. Example: /collab research How does quantum computing work?'));
-              break;
-            }
-            
-            console.log(chalk.blue(`\n🤝 Starting collaborative ${taskType} task: ${prompt}`));
-            await this.client.collaborate(prompt, taskType);
-            
-          } else {
-            console.log(chalk.yellow('Usage: /collab <type> <prompt>'));
-            console.log(chalk.yellow('Types: ' + Object.values(MultiplayerClient.TASK_TYPES).join(', ')));
-          }
-          break;
-          
-        case 'task':
-          if (args.length > 1) {
-            const [target, ...taskArgs] = args;
-            const taskDesc = taskArgs.join(' ');
-            
-            // Find the target client
-            const targetClient = this.client.clients.find(c => 
-              c.name.toLowerCase() === target.toLowerCase() || 
-              c.clientId === target
-            );
-            
-            if (!targetClient) {
-              console.log(chalk.red(`❌ Could not find agent: ${target}`));
-              break;
-            }
-            
-            // In a real implementation, you would send this to the server
-            // and the server would route it to the appropriate client
-            console.log(chalk.blue(`\n📝 Task assigned to ${targetClient.name}: ${taskDesc}`));
-            
-          } else {
-            console.log(chalk.yellow('Usage: /task <agent> <task description>'));
-            console.log(chalk.yellow('Example: /task alice Please review the latest changes'));
-          }
-          break;
-          
-        case 'list':
-          this.listAgents();
-          break;
-          
-        case 'exit':
-          console.log(chalk.yellow('\n👋 Disconnecting...'));
-          process.exit(0);
-          break;
-          
-        case 'help':
-          this.showHelp();
-          break;
-          
-        default:
-          console.log(chalk.red(`❌ Unknown command: ${command}. Type /help for available commands.`));
-      }
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Error: ${error.message}`));
-    }
-    
-    this.prompt();
-  }
-
-  showHelp() {
-    console.log('\n=== 🆘 Available Commands ===');
-    console.log('\n👤 Agent Management:');
-    console.log('  /name [new_name]    - Set or show your name');
-    console.log('  /role [role]        - Set or show your role');
-    console.log('  /model [model_name] - Set or show your AI model');
-    
-    console.log('\n🤝 Collaboration:');
-    console.log('  /work [description] - Update your work status');
-    console.log('  /collab <type> <prompt> - Start a collaborative task');
-    console.log('    Types: ' + Object.values(MultiplayerClient.TASK_TYPES).join(', '));
-    console.log('  /task [agent] [task] - Assign a task to another agent');
-    
-    console.log('\n📋 Session:');
-    console.log('  /list - List all agents in the session');
-    console.log('  /exit - Leave the session');
-    console.log('  /help - Show this help message');
-    
-    console.log('\n💡 Example:');
-    console.log('  /collab research How does quantum computing work?');
-    console.log('  /work Implementing user authentication');
-    console.log('  /task bob Please review my latest changes');
-  }
-
-  listAgents() {
-    console.log('\n=== 🧑‍💻 Agents in Session ===');
-    if (this.client.clients.length === 0) {
-      console.log('No other agents in the session');
-      return;
-    }
-    
-    this.client.clients.forEach(client => {
-      const role = client.role ? ` (${client.role})` : '';
-      const status = client.isHost ? '👑 ' : '👤 ';
-      console.log(`${status}${client.name}${role} [${client.model}]`);
-      if (client.work) {
-        console.log(`   ${client.work.status === 'completed' ? '✅' : '🔄'} ${client.work.description}`);
-      }
-    });
-  }
-
-  prompt() {
-    if (this.isWorking) return;
-    
-    this.rl.question(chalk.blue('> '), async (input) => {
-      if (!input.trim()) {
-        this.prompt();
-        return;
-      }
-
-      // Handle commands
-      if (input.startsWith('/')) {
-        await this.handleCommand(input);
-      } else {
-        // Regular chat message
-        this.client.sendChatMessage(input);
-        this.prompt();
-      }
-    });
-  }
-}
-
-module.exports = MultiplayerMode;

package/bin/multiplayer-server.js

@@ -1,372 +0,0 @@
-const WebSocket = require('ws');
-const http = require('http');
-const net = require('net');
-const uuid = require('uuid');
-const chalk = require('chalk');
-
-async function findAvailablePort(startPort = 8080, maxAttempts = 10) {
-  let port = startPort;
-  let attempts = 0;
-  
-  while (attempts < maxAttempts) {
-    const inUse = await new Promise((resolve) => {
-      const server = net.createServer()
-        .once('error', () => resolve(true))
-        .once('listening', () => {
-          server.close();
-          resolve(false);
-        })
-        .listen(port);
-    });
-    
-    if (!inUse) {
-      return port;
-    }
-    
-    port++;
-    attempts++;
-  }
-  
-  throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
-}
-
-class MultiplayerServer {
-  constructor(port = 8080) {
-    this.port = port;
-    this.sessions = new Map();
-    this.clients = new Map();
-    this.tasks = new Map();
-    this.httpServer = null;
-    this.wss = null;
-  }
-  
-  async start() {
-    try {
-      this.port = await findAvailablePort(this.port);
-      
-      // Create HTTP server
-      this.httpServer = http.createServer();
-      
-      // Create WebSocket server
-      this.wss = new WebSocket.Server({ server: this.httpServer });
-      
-      // Setup event handlers
-      this.setupEventHandlers();
-      
-      // Start listening
-      return new Promise((resolve, reject) => {
-        this.httpServer.on('error', (error) => {
-          console.error(chalk.red('HTTP server error:'), error);
-          reject(error);
-        });
-        
-        this.httpServer.listen(this.port, () => {
-          console.log(chalk.green(`Multiplayer server started on port ${this.port}`));
-          resolve(this.port);
-        });
-      });
-    } catch (error) {
-      console.error(chalk.red('Failed to start multiplayer server:'), error.message);
-      throw error;
-    }
-  }
-
-  static async startAsChildProcess(port = 8080) {
-    const { spawn } = require('child_process');
-    const serverProcess = spawn('node', [__filename, '--port', port.toString()], {
-      detached: true,
-      stdio: 'inherit',
-      windowsHide: true
-    });
-    
-    serverProcess.on('error', (error) => {
-      console.error('Failed to start server process:', error);
-    });
-    
-    serverProcess.unref();
-    console.log(`Multiplayer server starting on port ${port}...`);
-    return serverProcess;
-  }
-
-  setupEventHandlers() {
-    if (!this.wss) {
-      throw new Error('WebSocket server not initialized');
-    }
-
-    this.wss.on('connection', (ws) => {
-      let clientId = uuid.v4();
-      let sessionId = null;
-      let clientInfo = {};
-
-      // Store client
-      this.clients.set(clientId, { ws, clientInfo });
-
-      ws.on('message', (data) => {
-        try {
-          const message = typeof data === 'string' ? JSON.parse(data) : data;
-          this.handleMessage(ws, clientId, message);
-        } catch (error) {
-          console.error('Error processing message:', error);
-        }
-      });
-
-      ws.on('close', () => {
-        // Remove client from any session
-        if (sessionId && this.sessions.has(sessionId)) {
-          const session = this.sessions.get(sessionId);
-          if (session && session.clients) {
-            delete session.clients[clientId];
-            
-            // Notify other clients
-            this.broadcastToSession(sessionId, {
-              type: 'agent_left',
-              clientId,
-              clientInfo,
-              timestamp: new Date().toISOString()
-            }, clientId);
-
-            // Clean up empty sessions
-            if (Object.keys(session.clients).length === 0) {
-              this.sessions.delete(sessionId);
-              console.log(`Session ${sessionId} ended (no clients)`);
-            }
-          }
-        }
-
-        // Remove client from clients map
-        this.clients.delete(clientId);
-      });
-
-      ws.on('error', (error) => {
-        console.error('WebSocket error:', error);
-      });
-    });
-  }
-
-  handleMessage(ws, message) {
-    try {
-      const data = typeof message === 'string' ? JSON.parse(message) : message;
-      const client = this.clients.get(ws);
-
-      switch (data.type) {
-        case 'client_info':
-          if (client) {
-            Object.assign(client, data.clientInfo);
-            this.broadcastToSession(client.sessionId, {
-              type: 'client_updated',
-              clientId: client.id,
-              clientInfo: data.clientInfo
-            }, ws);
-          }
-          break;
-
-        case 'create_session':
-          this.handleCreateSession(ws, data);
-          break;
-
-        case 'join_session':
-          this.handleJoinSession(ws, data);
-          break;
-
-        case 'collaborate':
-          if (client && client.sessionId) {
-            const taskId = uuid.v4();
-            this.tasks.set(taskId, {
-              id: taskId,
-              sessionId: client.sessionId,
-              prompt: data.prompt,
-              status: 'in_progress',
-              createdBy: client.id,
-              createdAt: new Date().toISOString(),
-              results: []
-            });
-
-            this.broadcastToSession(client.sessionId, {
-              type: 'task_assigned',
-              taskId,
-              prompt: data.prompt,
-              assignedBy: client.id
-            });
-          }
-          break;
-
-        case 'task_result':
-          if (client && client.sessionId && data.taskId) {
-            const task = this.tasks.get(data.taskId);
-            if (task) {
-              task.results.push({
-                clientId: client.id,
-                result: data.result,
-                timestamp: new Date().toISOString()
-              });
-
-              // Check if all clients have responded
-              const session = this.sessions.get(client.sessionId);
-              if (session && task.results.length >= Object.keys(session.clients).length) {
-                task.status = 'completed';
-                this.broadcastToSession(client.sessionId, {
-                  type: 'task_completed',
-                  taskId: task.id,
-                  results: task.results
-                });
-              }
-            }
-          }
-          break;
-
-        case 'chat':
-        case 'work_update':
-        case 'task_update':
-          this.broadcastToSession(data.sessionId, data);
-          break;
-
-        default:
-          console.log('Unknown message type:', data.type);
-      }
-    } catch (error) {
-      console.error('Error handling message:', error);
-    }
-  }
-
-  handleCreateSession(ws, data) {
-    const sessionId = uuid.v4();
-    const clientId = uuid.v4();
-
-    // Store client info
-    this.clients.set(ws, {
-      id: clientId,
-      sessionId,
-      ws,
-      isHost: true,
-      name: data.name || `Agent-${Math.random().toString(36).substr(2, 4)}`,
-      role: data.role || 'Assistant',
-      model: data.model || 'default'
-    });
-
-    this.sessions.set(sessionId, {
-      id: sessionId,
-      clients: { [clientId]: true },
-      workHistory: [],
-      createdAt: new Date().toISOString(),
-      hostId: clientId
-    });
-
-    // Send session created confirmation
-    ws.send(JSON.stringify({
-      type: 'session_created',
-      sessionId,
-      clientId,
-      isHost: true
-    }));
-  }
-
-  handleJoinSession(ws, data) {
-    const { sessionId } = data;
-    const clientId = data.clientId || uuid.v4();
-    
-    // If session doesn't exist, create it (this allows for reconnection)
-    if (!this.sessions.has(sessionId)) {
-      console.log(`Session ${sessionId} not found, creating new session`);
-      this.sessions.set(sessionId, {
-        id: sessionId,
-        clients: {},
-        createdAt: new Date().toISOString(),
-        hostId: clientId,  // First joiner becomes host if session didn't exist
-        tasks: []
-      });
-    }
-
-    const session = this.sessions.get(sessionId);
-    
-    // Check if session is full (max 4 agents)
-    if (Object.keys(session.clients).length >= 4 && !session.clients[clientId]) {
-      ws.send(JSON.stringify({
-        type: 'error',
-        message: 'Session is full (max 4 agents)'
-      }));
-      return;
-    }
-
-    // Store/update client info
-    const existingClient = Array.from(this.clients.entries())
-      .find(([_, c]) => c.id === clientId)?.[1];
-
-    const clientInfo = {
-      id: clientId,
-      sessionId,
-      ws,
-      isHost: session.hostId === clientId,
-      name: data.name || existingClient?.name || `Agent-${clientId.substr(0, 4)}`,
-      role: data.role || existingClient?.role || 'Assistant',
-      model: data.model || existingClient?.model || 'default',
-      joinedAt: new Date().toISOString(),
-      lastSeen: new Date().toISOString()
-    };
-
-    // Add client to session
-    session.clients[clientId] = clientInfo;
-    this.clients.set(ws, clientInfo);
-
-    // Send session joined confirmation
-    ws.send(JSON.stringify({
-      type: 'session_joined',
-      sessionId,
-      clientId,
-      clientInfo,
-      isHost: clientInfo.isHost,
-      sessionInfo: {
-        id: session.id,
-        createdAt: session.createdAt,
-        clientCount: Object.keys(session.clients).length,
-        hostId: session.hostId
-      }
-    }));
-
-    // Notify other clients in the session
-    this.broadcastToSession(sessionId, {
-      type: 'agent_joined',
-      clientId,
-      clientInfo,
-      timestamp: new Date().toISOString()
-    }, clientId);
-  }
-
-  broadcastToSession(sessionId, message, excludeClientId = null) {
-    if (!this.sessions.has(sessionId)) return;
-
-    const session = this.sessions.get(sessionId);
-    const messageStr = JSON.stringify(message);
-
-    Object.entries(session.clients).forEach(([id, client]) => {
-      if (id !== excludeClientId && client.ws && client.ws.readyState === WebSocket.OPEN) {
-        client.ws.send(messageStr);
-      }
-    });
-  }
-
-  start() {
-    return new Promise((resolve, reject) => {
-      this.httpServer = http.createServer();
-      this.wss = new WebSocket.Server({ server: this.httpServer });
-      this.setupEventHandlers();
-
-      this.httpServer.on('error', (error) => {
-        console.error(chalk.red('HTTP server error:'), error);
-        reject(error);
-      });
-      
-      this.httpServer.listen(this.port, () => {
-        console.log(chalk.green(`Multiplayer server started on port ${this.port}`));
-        resolve(this.port);
-      });
-    });
-  }
-}
-
-// Start server if run directly
-if (require.main === module) {
-  const server = new MultiplayerServer();
-  server.start();
-}
-
-module.exports = MultiplayerServer;