sam-coder-cli 1.0.15 → 1.0.16

package/bin/multiplayer-client.js

@@ -235,59 +235,61 @@ class MultiplayerClient extends EventEmitter {
     this.clients = [];
     this.currentTask = null;
     this.taskQueue = [];
+    this.pendingTasks = new Map();
+    this.taskResults = new Map();
     this.rl = options.rl || readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
+    
+    // Bind methods
+    this.processTaskQueue = this.processTaskQueue.bind(this);
+    this.completeTask = this.completeTask.bind(this);
   }
 
   async connect() {
     try {
-      // Ensure server is running and get the correct URL
-      const url = new URL(this.serverUrl);
-      const serverPort = url.port || 8080;
-      this.serverUrl = await ensureServerRunning(serverPort);
+      // Ensure server is running
+      this.serverUrl = await ensureServerRunning(this.port);
       
-      return new Promise((resolve, reject) => {
-        this.ws = new WebSocket(this.serverUrl);
-        
-        this.ws.on('open', () => {
-          this.connected = true;
-          // Send client info immediately after connection
-          this.send({
-            type: 'client_info',
-            clientInfo: {
-              name: this.name || `Agent-${Math.random().toString(36).substr(2, 4)}`,
-              role: this.role || 'Assistant',
-              model: this.model || 'default'
-            }
-          });
-          this.emit('connected');
-          resolve();
-        });
-        
-        this.ws.on('message', (data) => {
-          try {
-            const message = JSON.parse(data);
-            this.handleMessage(message);
-          } catch (error) {
-            console.error('Error parsing message:', error);
-          }
-        });
-        
-        this.ws.on('close', () => {
-          this.connected = false;
-          this.emit('disconnected');
-        });
+      this.ws = new WebSocket(this.serverUrl);
+      
+      this.ws.on('open', () => {
+        this.connected = true;
+        this.emit('connected');
+        console.log(chalk.green('✅ Connected to multiplayer server'));
         
-        this.ws.on('error', (error) => {
-          this.connected = false;
-          reject(error);
+        // Send client info immediately after connection
+        this.updateClientInfo({
+          name: this.name,
+          role: this.role,
+          model: this.model
         });
       });
+      
+      this.ws.on('message', (data) => {
+        try {
+          const message = JSON.parse(data);
+          this.handleMessage(message);
+        } catch (error) {
+          console.error('Error parsing message:', error);
+        }
+      });
+      
+      this.ws.on('close', () => {
+        this.connected = false;
+        this.emit('disconnected');
+        console.log(chalk.yellow('\n🔌 Disconnected from multiplayer server'));
+      });
+      
+      this.ws.on('error', (error) => {
+        console.error('WebSocket error:', error);
+        this.emit('error', error);
+      });
+      
     } catch (error) {
-      console.error('Failed to start multiplayer server:', error);
-      throw error;
+      console.error('Failed to connect to server:', error);
+      this.emit('error', error);
     }
   }
 
@@ -398,13 +400,22 @@ class MultiplayerClient extends EventEmitter {
     this.emit('work_updated', message);
   }
 
-  handleTaskAssigned(task) {
-    console.log(`\n New task assigned: ${task.prompt}`);
-    console.log(`Type: ${task.taskType} | Assigned by: ${this.getClientName(task.assignedBy)}\n`);
+  async handleTaskAssigned(task) {
+    console.log(chalk.magenta(`\n📋 New Task: ${task.prompt}`));
+    console.log(chalk.dim(`Type: ${task.taskType} | Assigned by: ${this.getClientName(task.assignedBy)}\n`));
     
-    // Add to task queue
-    this.taskQueue.push(task);
-    this.processTaskQueue();
+    // Store task in pending tasks
+    this.pendingTasks.set(task.id, {
+      ...task,
+      status: 'pending',
+      assignedAt: new Date().toISOString()
+    });
+    
+    // Add to task queue if it's assigned to this client or to all
+    if (!task.assignedTo || task.assignedTo === this.clientId) {
+      this.taskQueue.push(task);
+      this.processTaskQueue();
+    }
     
     this.emit('task_assigned', task);
   }
@@ -413,34 +424,57 @@ class MultiplayerClient extends EventEmitter {
     if (this.currentTask || this.taskQueue.length === 0) return;
     
     this.currentTask = this.taskQueue.shift();
+    const taskId = this.currentTask.id;
     
     try {
-      // Simulate working on the task
-      console.log(`\n Working on task: ${this.currentTask.prompt}`);
-      
-      // Here you would integrate with your AI to process the task
-      // For now, we'll just simulate work
-      await new Promise(resolve => setTimeout(resolve, 2000));
-      
-      const result = {
-        taskId: this.currentTask.id,
-        result: `Completed task: ${this.currentTask.prompt}`,
-        timestamp: new Date().toISOString()
-      };
+      // Update task status to in-progress
+      this.pendingTasks.set(taskId, {
+        ...this.pendingTasks.get(taskId),
+        status: 'in_progress',
+        startedAt: new Date().toISOString()
+      });
       
-      // Send result back to server
+      // Notify others about task progress
       this.send({
-        type: 'task_result',
+        type: 'task_progress',
         sessionId: this.sessionId,
-        taskId: this.currentTask.id,
-        result: result.result,
-        timestamp: result.timestamp
+        taskId,
+        status: 'in_progress',
+        progress: 0,
+        timestamp: new Date().toISOString()
       });
       
-      console.log(` Completed task: ${this.currentTask.prompt}`);
+      console.log(chalk.blue(`\n🔄 [${this.role}] Working on: ${this.currentTask.prompt}`));
+      
+      // Simulate work with progress updates
+      const totalSteps = 5;
+      for (let i = 0; i < totalSteps; i++) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+        const progress = Math.floor(((i + 1) / totalSteps) * 100);
+        
+        // Update progress
+        this.send({
+          type: 'task_progress',
+          sessionId: this.sessionId,
+          taskId,
+          status: 'in_progress',
+          progress,
+          timestamp: new Date().toISOString()
+        });
+      }
+      
+      // Complete the task
+      await this.completeTask(taskId);
       
     } catch (error) {
       console.error('Error processing task:', error);
+      this.send({
+        type: 'task_failed',
+        sessionId: this.sessionId,
+        taskId,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      });
     } finally {
       this.currentTask = null;
       // Process next task if available
@@ -449,6 +483,52 @@ class MultiplayerClient extends EventEmitter {
       }
     }
   }
+  
+  async completeTask(taskId) {
+    const task = this.pendingTasks.get(taskId);
+    if (!task) return null;
+    
+    // Generate task result based on task type
+    let result;
+    switch (task.taskType) {
+      case 'research':
+        result = `Research completed on: ${task.prompt}\nSummary: This is a simulated research result.`;
+        break;
+      case 'code':
+        result = `Code implementation for: ${task.prompt}\n// Simulated code implementation\nfunction ${task.prompt.split(' ')[0].toLowerCase()}() {\n  // TODO: Implement\n}`;
+        break;
+      case 'debug':
+        result = `Debugging analysis for: ${task.prompt}\n- Issue identified: Simulated issue\n- Solution: Simulated fix`;
+        break;
+      default:
+        result = `Completed: ${task.prompt}`;
+    }
+    
+    // Update task status
+    const completedTask = {
+      ...task,
+      status: 'completed',
+      completedAt: new Date().toISOString(),
+      result
+    };
+    
+    this.pendingTasks.set(taskId, completedTask);
+    this.taskResults.set(taskId, result);
+    
+    // Notify server and other clients
+    this.send({
+      type: 'task_completed',
+      sessionId: this.sessionId,
+      taskId,
+      result,
+      timestamp: new Date().toISOString()
+    });
+    
+    console.log(chalk.green(`\n✅ [${this.role}] Completed: ${task.prompt}`));
+    this.emit('task_completed', completedTask);
+    
+    return completedTask;
+  }
 
   handleTaskCompleted(data) {
     console.log(`\n Task completed by all agents!`);
@@ -462,19 +542,52 @@ class MultiplayerClient extends EventEmitter {
     this.emit('task_completed', data);
   }
 
-  updateWork(work) {
+  async updateWork(work) {
     const workItem = {
+      id: uuidv4(),
       ...work,
       clientId: this.clientId,
-      status: work.status || 'in_progress',
-      timestamp: new Date().toISOString()
+      clientName: this.name,
+      timestamp: new Date().toISOString(),
+      status: work.status || 'in_progress'
     };
-
+    
+    this.workHistory.push(workItem);
+    
+    // Keep only the last 10 work items
+    if (this.workHistory.length > 10) {
+      this.workHistory = this.workHistory.slice(-10);
+    }
+    
     this.send({
       type: 'work_update',
       sessionId: this.sessionId,
-      work: workUpdate
+      ...workItem
     });
+    
+    this.emit('work_updated', workItem);
+    return workItem;
+  }
+  
+  async updateClientInfo(updates) {
+    // Update local client info
+    Object.assign(this, updates);
+    
+    // Notify server about the update
+    if (this.connected) {
+      this.send({
+        type: 'client_update',
+        sessionId: this.sessionId,
+        clientId: this.clientId,
+        updates: {
+          name: this.name,
+          role: this.role,
+          model: this.model,
+          updatedAt: new Date().toISOString()
+        },
+        timestamp: new Date().toISOString()
+      });
+    }
   }
 
   assignTask(task, assigneeClientId) {

package/package.json

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