sam-coder-cli 1.0.15 → 1.0.17

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`));
+    
+    // Store task in pending tasks
+    this.pendingTasks.set(task.id, {
+      ...task,
+      status: 'pending',
+      assignedAt: new Date().toISOString()
+    });
     
-    // Add to task queue
-    this.taskQueue.push(task);
-    this.processTaskQueue();
+    // 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,68 +424,196 @@ 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}`);
+      // Update task status to in-progress
+      this.pendingTasks.set(taskId, {
+        ...this.pendingTasks.get(taskId),
+        status: 'in_progress',
+        startedAt: new Date().toISOString()
+      });
+      
+      // Notify others about task progress
+      this.send({
+        type: 'task_progress',
+        sessionId: this.sessionId,
+        taskId,
+        status: 'in_progress',
+        progress: 0,
+        timestamp: new Date().toISOString()
+      });
+      
+      console.log(chalk.blue(`\n🔄 [${this.role}] Working on: ${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));
+      // Process the task using the completeTask method
+      const completedTask = await this.completeTask(taskId);
       
-      const result = {
-        taskId: this.currentTask.id,
-        result: `Completed task: ${this.currentTask.prompt}`,
+      if (completedTask) {
+        // Task completed successfully
+        this.send({
+          type: 'task_progress',
+          sessionId: this.sessionId,
+          taskId,
+          status: 'completed',
+          progress: 100,
+          timestamp: new Date().toISOString()
+        });
+        
+        console.log(chalk.green(`\n✅ [${this.role}] Completed task: ${this.currentTask.prompt}`));
+      }
+      if (this.taskQueue.length > 0) {
+        this.processTaskQueue();
+      }
+    } 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;
+    }
+  }
+  
+  async completeTask(taskId) {
+    const task = this.pendingTasks.get(taskId);
+    if (!task) {
+      console.error('Task not found:', taskId);
+      return null;
+    }
+
+    try {
+      // Process the task using the same logic as the normal mode
+      const { processQuery } = require('./agi-cli');
+      const result = await processQuery(task.prompt, [], this.model);
+      
+      // Update task status
+      const completedTask = {
+        ...task,
+        status: 'completed',
+        completedAt: new Date().toISOString(),
+        result: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
       };
       
-      // Send result back to server
+      this.pendingTasks.set(taskId, completedTask);
+      this.taskResults.set(taskId, completedTask.result);
+      
+      // Notify server and other clients
       this.send({
-        type: 'task_result',
+        type: 'task_completed',
         sessionId: this.sessionId,
-        taskId: this.currentTask.id,
-        result: result.result,
-        timestamp: result.timestamp
+        taskId,
+        result: completedTask.result,
+        timestamp: new Date().toISOString()
       });
       
-      console.log(` Completed task: ${this.currentTask.prompt}`);
+      console.log(chalk.green(`\n✅ [${this.role}] Completed: ${task.prompt}`));
+      this.emit('task_completed', completedTask);
       
+      return completedTask;
     } catch (error) {
-      console.error('Error processing task:', error);
-    } finally {
-      this.currentTask = null;
-      // Process next task if available
-      if (this.taskQueue.length > 0) {
-        this.processTaskQueue();
-      }
+      console.error('Error completing task:', error);
+      
+      // Update task with error status
+      const failedTask = {
+        ...task,
+        status: 'failed',
+        completedAt: new Date().toISOString(),
+        error: error.message
+      };
+      
+      this.pendingTasks.set(taskId, failedTask);
+      this.emit('task_failed', { taskId, error: error.message });
+      
+      return null;
     }
   }
 
   handleTaskCompleted(data) {
-    console.log(`\n Task completed by all agents!`);
-    console.log(`Task: ${this.tasks.get(data.taskId)?.prompt || 'Unknown task'}`);
-    console.log('Results:');
+    const task = this.pendingTasks.get(data.taskId);
+    if (!task) {
+      console.error('Task not found for completion:', data.taskId);
+      return;
+    }
     
-    data.results.forEach(result => {
-      console.log(`- ${this.getClientName(result.clientId)}: ${result.result}`);
-    });
+    console.log(chalk.green(`\n✅ Task completed by all agents!`));
+    console.log(chalk.blue(`Task: ${task.prompt || 'Unknown task'}`));
     
-    this.emit('task_completed', data);
+    if (data.results && data.results.length > 0) {
+      console.log(chalk.cyan('Results:'));
+      data.results.forEach(result => {
+        console.log(chalk.yellow(`- ${this.getClientName(result.clientId) || 'Unknown'}:`));
+        console.log(result.result);
+      });
+    } else if (data.result) {
+      console.log(chalk.cyan('Result:'));
+      console.log(data.result);
+    }
+    
+    // Update the task with the final result
+    const completedTask = {
+      ...task,
+      status: 'completed',
+      completedAt: new Date().toISOString(),
+      result: data.result || 'No result provided'
+    };
+    
+    this.pendingTasks.set(data.taskId, completedTask);
+    this.taskResults.set(data.taskId, completedTask.result);
+    
+    this.emit('task_completed', completedTask);
   }
 
-  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) {
@@ -505,6 +644,12 @@ class MultiplayerClient extends EventEmitter {
       this.ws.close();
     }
   }
+  
+  getClientName(clientId) {
+    if (!clientId) return 'Unknown';
+    const client = this.clients.find(c => c.clientId === clientId || c.id === clientId);
+    return client ? (client.name || client.clientInfo?.name || 'Unknown') : 'Unknown';
+  }
 }
 
 module.exports = MultiplayerClient;

package/package.json

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