@gotza02/seq-thinking 1.1.2 → 1.1.4

package/src/swarm-coordinator.ts

@@ -23,6 +23,7 @@ import {
 import { BaseAgent } from './agents/base-agent.js';
 
 import { PersistenceManager } from './utils/persistence.js';
+import { Logger } from './utils/logger.js';
 
 /**
  * Registry to track all agents in the swarm
@@ -327,8 +328,9 @@ export class TaskAssigner {
 
   constructor(private registry: AgentRegistry) {}
 
-  assignTask(task: Task, strategy: string = 'adaptive') {
+  assignTask(task: Task, strategy: string = 'adaptive', excludeAgentIds: string[] = []) {
     const availableAgents = this.registry.getAvailableAgents()
+      .filter(a => !excludeAgentIds.includes(a.config.id))
       .filter(a => this.hasRequiredCapabilities(a, task.requirements?.requiredCapabilities || task.requiredCapabilities || []));
 
     if (availableAgents.length === 0) return null;
@@ -568,24 +570,44 @@ export class SwarmCoordinator {
   }
 
   async executeTask(taskId: string, maxRetries: number = 3) {
-    let retries = 0;
+    let globalRetries = 0;
     let lastError: any = null;
+    const maxGlobalRetries = maxRetries * 2; // Allow attempts across multiple agents
+    const failedAgents = new Set<string>();
 
-    while (retries < maxRetries) {
+    while (globalRetries < maxGlobalRetries) {
       const task = this.taskQueue.getTask(taskId);
       if (!task) throw new Error(`Task not found: ${taskId}`);
 
+      // Auto-reassignment logic if not assigned
       if (!task.assignedAgentId) {
-        throw new Error(`Task ${taskId} is not assigned to any agent`);
+        const agent = this.taskAssigner.assignTask(task, 'adaptive', Array.from(failedAgents));
+        if (agent) {
+          this.taskQueue.assignTask(task.id, agent.config.id);
+          this.registry.updateAgentStatus(agent.config.id, AgentStatus.BUSY);
+          Logger.info(`Reassigned task ${taskId} to agent ${agent.config.id}`);
+        } else {
+          // No more agents available
+          Logger.warn(`No suitable agent found for task ${taskId} (Agents tried: ${Array.from(failedAgents).join(', ')})`);
+          break; 
+        }
+      }
+
+      // Check assignment validity
+      if (!task.assignedAgentId) {
+         break; // Should be handled above, but safety check
       }
 
       const agentState = this.registry.getAgent(task.assignedAgentId);
       if (!agentState || !agentState.instance) {
-        throw new Error(`Agent execution instance not found for agent: ${task.assignedAgentId}`);
+         // Agent gone? Treat as failure
+         failedAgents.add(task.assignedAgentId);
+         task.assignedAgentId = null;
+         globalRetries++;
+         continue;
       }
 
       this.taskQueue.startTask(taskId);
-      const startTime = Date.now();
       
       try {
         const result = await agentState.instance.execute(task);
@@ -595,20 +617,26 @@ export class SwarmCoordinator {
         return result;
       } catch (error) {
         lastError = error;
-        retries++;
-        console.warn(`Task ${taskId} failed (attempt ${retries}/${maxRetries}):`, error);
+        globalRetries++;
+        Logger.warn(`Task ${taskId} failed with agent ${task.assignedAgentId} (attempt ${globalRetries}/${maxGlobalRetries})`, { error });
         
-        if (retries < maxRetries) {
-          // Wait before retry
-          await new Promise(resolve => setTimeout(resolve, 1000 * retries));
-          // Reset status to ASSIGNED for retry
-          task.status = TaskStatus.ASSIGNED;
+        // Mark agent as failed for this task and unassign
+        if (task.assignedAgentId) {
+             failedAgents.add(task.assignedAgentId);
+             this.registry.updateAgentStatus(task.assignedAgentId, AgentStatus.IDLE);
+             task.assignedAgentId = null; // Unassign to trigger reassignment
         }
+
+        task.status = TaskStatus.PENDING; // Reset status for next attempt
+        
+        // Wait a bit before next loop
+        await new Promise(resolve => setTimeout(resolve, 500 * globalRetries));
       }
     }
 
     const processingTime = 0;
     this.taskQueue.failTask(taskId, String(lastError));
+    // Final cleanup if task is still assigned
     const task = this.taskQueue.getTask(taskId);
     if (task?.assignedAgentId) {
       this.registry.updateAgentStatus(task.assignedAgentId, AgentStatus.IDLE);

package/src/utils/llm-adapter.ts

@@ -3,7 +3,11 @@
  * @module utils/llm-adapter
  */
 
-import { execSync } from 'child_process';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { Logger } from './logger.js';
+
+const execAsync = promisify(exec);
 
 export interface LLMResponse {
   content: string;
@@ -12,56 +16,86 @@ export interface LLMResponse {
 
 export class LLMAdapter {
   /**
-   * Main entry point to call an LLM based on provider
+   * Main entry point to call an LLM based on provider pool
    */
-  static async call(prompt: string, systemPrompt?: string): Promise<LLMResponse> {
-    const provider = process.env.provider || 'gemini';
-    const combinedPrompt = systemPrompt ? `${systemPrompt}\n\nUser: ${prompt}` : prompt;
+  static async call(prompt: string, systemPrompt?: string, providerOverride?: string): Promise<LLMResponse> {
+    const providerEnv = process.env.provider || 'gemini';
+    const providers = providerOverride ? [providerOverride] : providerEnv.split(',').map(p => p.trim());
+    
+    let lastError = '';
 
-    // For testing/development: If MOCK_LLM is set, return mock data
-    if (process.env.MOCK_LLM === 'true') {
-      return { content: `[MOCK RESPONSE from ${provider}] I have analyzed your request: ${prompt.substring(0, 50)}...` };
-    }
+    for (const provider of providers) {
+      const combinedPrompt = systemPrompt ? `${systemPrompt}\n\nUser: ${prompt}` : prompt;
 
-    try {
-      switch (provider.toLowerCase()) {
-        case 'gemini':
-          return this.safeExec(`gemini ask ${this.escapeShell(combinedPrompt)}`);
-        case 'claude':
-          return this.safeExec(`claude ${this.escapeShell(combinedPrompt)} --non-interactive`);
-        case 'kimi':
-          return this.safeExec(`kimi chat ${this.escapeShell(combinedPrompt)}`);
-        case 'opencode':
-          return this.safeExec(`opencode ask ${this.escapeShell(combinedPrompt)}`);
-        default:
-          return { content: '', error: `Unsupported provider: ${provider}` };
+      // For testing/development: If MOCK_LLM is set, return mock data
+      if (process.env.MOCK_LLM === 'true') {
+        Logger.debug('LLM Mock Call', { provider, promptLength: prompt.length });
+        return { content: `[MOCK RESPONSE from ${provider}] I have analyzed your request: ${prompt.substring(0, 50)}...` };
+      }
+
+      Logger.info('LLM Call initiated', { provider });
+
+      try {
+        let response: LLMResponse;
+        switch (provider.toLowerCase()) {
+          case 'gemini':
+            response = await this.safeExec(`gemini ask ${this.escapeShell(combinedPrompt)}`);
+            break;
+          case 'claude':
+            response = await this.safeExec(`claude ${this.escapeShell(combinedPrompt)} --non-interactive`);
+            break;
+          case 'kimi':
+            response = await this.safeExec(`kimi chat ${this.escapeShell(combinedPrompt)}`);
+            break;
+          case 'opencode':
+            response = await this.safeExec(`opencode ask ${this.escapeShell(combinedPrompt)}`);
+            break;
+          default:
+            response = { content: '', error: `Unsupported provider: ${provider}` };
+        }
+
+        if (response.content && !response.error) {
+          return response; // Success!
+        }
+        
+        lastError = response.error || 'Unknown error';
+        Logger.warn(`Provider ${provider} failed, trying next...`, { error: lastError });
+
+      } catch (error: any) {
+        lastError = error.message;
+        Logger.error(`LLM Adapter Error with ${provider}`, { error: lastError });
       }
-    } catch (error: any) {
-      console.error(`LLM Call Error (${provider}):`, error.message);
-      return { content: '', error: error.message };
     }
+
+    return { content: '', error: `All providers failed. Last error: ${lastError}` };
   }
 
   /**
    * Safely execute CLI command with timeout and existence check
    */
-  private static safeExec(cmd: string): LLMResponse {
+  private static async safeExec(cmd: string): Promise<LLMResponse> {
     try {
       // Check if command base exists (first word)
       const baseCmd = cmd.split(' ')[0];
       try {
-        execSync(`command -v ${baseCmd}`, { stdio: 'ignore' });
+        await execAsync(`command -v ${baseCmd}`);
       } catch {
-        return { content: '', error: `CLI tool '${baseCmd}' not found or not in PATH. Please install and login.` };
+        const error = `CLI tool '${baseCmd}' not found or not in PATH. Please install and login.`;
+        Logger.warn('CLI tool missing', { baseCmd });
+        return { content: '', error };
       }
 
-      const output = execSync(cmd, { 
-        encoding: 'utf8', 
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: 30000 // 30 second timeout
+      const { stdout, stderr } = await execAsync(cmd, { 
+        timeout: 60000 // 60 second timeout
       });
-      return { content: output.trim() };
+
+      if (stderr && stderr.trim()) {
+        Logger.debug('CLI Stderr output', { baseCmd, stderr: stderr.substring(0, 100) });
+      }
+
+      return { content: stdout.trim() };
     } catch (error: any) {
+      Logger.error('Execution failed', { command: cmd.substring(0, 50), error: error.message });
       return { content: '', error: error.message };
     }
   }

package/src/utils/logger.ts

@@ -0,0 +1,56 @@
+/**
+ * Simple Structured Logging Utility
+ * @module utils/logger
+ */
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3
+}
+
+export class Logger {
+  private static level: LogLevel = LogLevel.INFO;
+
+  static setLevel(level: LogLevel) {
+    this.level = level;
+  }
+
+  static debug(message: string, context: any = {}) {
+    if (this.level <= LogLevel.DEBUG) {
+      this.log('DEBUG', message, context);
+    }
+  }
+
+  static info(message: string, context: any = {}) {
+    if (this.level <= LogLevel.INFO) {
+      this.log('INFO', message, context);
+    }
+  }
+
+  static warn(message: string, context: any = {}) {
+    if (this.level <= LogLevel.WARN) {
+      this.log('WARN', message, context);
+    }
+  }
+
+  static error(message: string, context: any = {}) {
+    if (this.level <= LogLevel.ERROR) {
+      this.log('ERROR', message, context);
+    }
+  }
+
+  private static log(level: string, message: string, context: any) {
+    const timestamp = new Date().toISOString();
+    const logEntry = {
+      timestamp,
+      level,
+      message,
+      ...context
+    };
+    
+    // Write to stderr to avoid interfering with MCP stdio protocol
+    process.stderr.write(JSON.stringify(logEntry) + '\n');
+  }
+}

package/src/utils/persistence.ts

@@ -5,6 +5,7 @@
 
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { Logger } from './logger.js';
 
 export class PersistenceManager {
   private baseDir: string;
@@ -23,7 +24,7 @@ export class PersistenceManager {
         await fs.mkdir(path.join(this.baseDir, dir), { recursive: true });
       }
     } catch (error) {
-      console.error('Failed to initialize persistence directory:', error);
+      Logger.error('Failed to initialize persistence directory', { error });
       throw error;
     }
   }
@@ -38,7 +39,7 @@ export class PersistenceManager {
       const serializedData = this.serialize(data);
       await fs.writeFile(filePath, JSON.stringify(serializedData, null, 2), 'utf8');
     } catch (error) {
-      console.error(`Failed to save ${collection}/${id}:`, error);
+      Logger.error(`Failed to save ${collection}/${id}`, { error });
       throw error;
     }
   }
@@ -53,7 +54,7 @@ export class PersistenceManager {
       return JSON.parse(content) as T;
     } catch (error: any) {
       if (error.code === 'ENOENT') return null;
-      console.error(`Failed to load ${collection}/${id}:`, error);
+      Logger.error(`Failed to load ${collection}/${id}`, { error });
       throw error;
     }
   }