claude-flow 2.0.0-alpha.2 → 2.0.0-alpha.21

package/src/swarm/optimizations/optimized-executor.ts

@@ -17,8 +17,7 @@ import type {
   AgentId,
   TaskStatus,
   TaskType,
-  TaskPriority,
-  TaskId
+  TaskPriority
 } from '../types.js';
 
 export interface ExecutorConfig {
@@ -52,49 +51,12 @@ export interface ExecutionMetrics {
   activeExecutions: number;
 }
 
-// Extended TaskResult interface for optimized executor
-export interface OptimizedTaskResult extends TaskResult {
-  taskId: string;
-  agentId: string;
-  success: boolean;
-  error?: {
-    type: string;
-    message: string;
-    code?: string;
-    stack?: string;
-    context: Record<string, any>;
-    recoverable: boolean;
-    retryable: boolean;
-  };
-  tokensUsed?: {
-    inputTokens: number;
-    outputTokens: number;
-  };
-  timestamp: Date;
-}
-
-// Extended TaskDefinition interface for optimized executor
-export interface OptimizedTaskDefinition extends TaskDefinition {
-  objective: string;
-  metadata?: {
-    model?: string;
-    temperature?: number;
-    systemPrompt?: string;
-    [key: string]: any;
-  };
-  context: {
-    previousResults?: OptimizedTaskResult[];
-    relatedTasks?: OptimizedTaskDefinition[];
-    [key: string]: any;
-  };
-}
-
 export class OptimizedExecutor extends EventEmitter {
   private logger: Logger;
   private connectionPool: ClaudeConnectionPool;
   private fileManager: AsyncFileManager;
   private executionQueue: PQueue;
-  private resultCache: TTLMap<string, OptimizedTaskResult>;
+  private resultCache: TTLMap<string, TaskResult>;
   private executionHistory: CircularBuffer<{
     taskId: string;
     duration: number;
@@ -163,7 +125,7 @@ export class OptimizedExecutor extends EventEmitter {
     }
   }
   
-  async executeTask(task: OptimizedTaskDefinition, agentId: AgentId): Promise<OptimizedTaskResult> {
+  async executeTask(task: TaskDefinition, agentId: AgentId): Promise<TaskResult> {
     const startTime = Date.now();
     const taskKey = this.getTaskCacheKey(task);
     
@@ -172,17 +134,17 @@ export class OptimizedExecutor extends EventEmitter {
       const cached = this.resultCache.get(taskKey);
       if (cached) {
         this.metrics.cacheHits++;
-        this.logger.debug('Cache hit for task', { taskId: task.id.id });
+        this.logger.debug('Cache hit for task', { taskId: task.id });
         return cached;
       }
       this.metrics.cacheMisses++;
     }
     
     // Add to active executions
-    this.activeExecutions.add(task.id.id);
+    this.activeExecutions.add(task.id);
     
     // Queue the execution
-    const result = await this.executionQueue.add<OptimizedTaskResult>(async (): Promise<OptimizedTaskResult> => {
+    const result = await this.executionQueue.add(async () => {
       try {
         // Execute with connection pool
         const executionResult = await this.connectionPool.execute(async (api) => {
@@ -205,9 +167,9 @@ export class OptimizedExecutor extends EventEmitter {
         
         // Save result to file asynchronously
         if (this.config.fileOperations?.outputDir) {
-          const outputPath = `${this.config.fileOperations.outputDir}/${task.id.id}.json`;
+          const outputPath = `${this.config.fileOperations.outputDir}/${task.id}.json`;
           await this.fileManager.writeJSON(outputPath, {
-            taskId: task.id.id,
+            taskId: task.id,
             agentId: agentId.id,
             result: executionResult,
             timestamp: new Date()
@@ -215,20 +177,13 @@ export class OptimizedExecutor extends EventEmitter {
         }
         
         // Create task result
-        const taskResult: OptimizedTaskResult = {
-          taskId: task.id.id,
+        const taskResult: TaskResult = {
+          taskId: task.id,
           agentId: agentId.id,
           success: executionResult.success,
           output: executionResult.output,
-          artifacts: {},
-          metadata: {},
-          quality: 1.0,
-          completeness: 1.0,
-          accuracy: 1.0,
-          executionTime: Date.now() - startTime,
-          resourcesUsed: { tokens: (executionResult.usage?.inputTokens || 0) + (executionResult.usage?.outputTokens || 0) },
-          validated: false,
           error: undefined,
+          executionTime: Date.now() - startTime,
           tokensUsed: executionResult.usage,
           timestamp: new Date()
         };
@@ -245,7 +200,7 @@ export class OptimizedExecutor extends EventEmitter {
         
         // Record in history
         this.executionHistory.push({
-          taskId: task.id.id,
+          taskId: task.id,
           duration: taskResult.executionTime,
           status: 'success',
           timestamp: new Date()
@@ -255,7 +210,7 @@ export class OptimizedExecutor extends EventEmitter {
         if (this.config.monitoring?.slowTaskThreshold && 
             taskResult.executionTime > this.config.monitoring.slowTaskThreshold) {
           this.logger.warn('Slow task detected', {
-            taskId: task.id.id,
+            taskId: task.id,
             duration: taskResult.executionTime,
             threshold: this.config.monitoring.slowTaskThreshold
           });
@@ -268,60 +223,52 @@ export class OptimizedExecutor extends EventEmitter {
         this.metrics.totalExecuted++;
         this.metrics.totalFailed++;
         
-        const errorResult: OptimizedTaskResult = {
-          taskId: task.id.id,
+        const errorResult: TaskResult = {
+          taskId: task.id,
           agentId: agentId.id,
           success: false,
           output: '',
-          artifacts: {},
-          metadata: {},
-          quality: 0,
-          completeness: 0,
-          accuracy: 0,
-          executionTime: Date.now() - startTime,
-          resourcesUsed: {},
-          validated: false,
           error: {
             type: error instanceof Error ? error.constructor.name : 'UnknownError',
             message: error instanceof Error ? error.message : 'Unknown error',
             code: (error as any).code,
             stack: error instanceof Error ? error.stack : undefined,
-            context: { taskId: task.id.id, agentId: agentId.id },
+            context: { taskId: task.id, agentId: agentId.id },
             recoverable: this.isRecoverableError(error),
             retryable: this.isRetryableError(error)
           },
+          executionTime: Date.now() - startTime,
           timestamp: new Date()
         };
         
         // Record in history
         this.executionHistory.push({
-          taskId: task.id.id,
+          taskId: task.id,
           duration: errorResult.executionTime,
           status: 'failed',
           timestamp: new Date()
         });
         
         this.emit('task:failed', errorResult);
-        return errorResult;
+        throw error;
       } finally {
-        this.activeExecutions.delete(task.id.id);
+        this.activeExecutions.delete(task.id);
       }
     });
     
-    return result as OptimizedTaskResult;
+    return result;
   }
   
   async executeBatch(
-    tasks: OptimizedTaskDefinition[], 
+    tasks: TaskDefinition[], 
     agentId: AgentId
-  ): Promise<OptimizedTaskResult[]> {
-    const results = await Promise.all(
+  ): Promise<TaskResult[]> {
+    return Promise.all(
       tasks.map(task => this.executeTask(task, agentId))
     );
-    return results;
   }
   
-  private buildMessages(task: OptimizedTaskDefinition): any[] {
+  private buildMessages(task: TaskDefinition): any[] {
     const messages = [];
     
     // Add system message if needed
@@ -360,7 +307,7 @@ export class OptimizedExecutor extends EventEmitter {
     return messages;
   }
   
-  private getTaskCacheKey(task: OptimizedTaskDefinition): string {
+  private getTaskCacheKey(task: TaskDefinition): string {
     // Create a cache key based on task properties
     return `${task.type}-${task.objective}-${JSON.stringify(task.metadata || {})}`;
   }

package/src/swarm/prompt-copier-enhanced.ts

@@ -1,18 +1,13 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
 import { getErrorMessage } from '../utils/error-handler.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { Worker } from 'worker_threads';
 import { PromptCopier } from './prompt-copier.js';
 import type { CopyOptions, CopyResult, FileInfo } from './prompt-copier.js';
-
-// Re-export types for external use
-export type { CopyOptions, CopyResult, FileInfo };
 import { logger } from '../core/logger.js';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-// Handle __dirname for CommonJS compatibility
-const __dirname = process.cwd();
 
 interface WorkerPool {
   workers: Worker[];
@@ -28,8 +23,8 @@ export class EnhancedPromptCopier extends PromptCopier {
     super(options);
   }
 
-  protected override async copyFilesParallel(): Promise<void> {
-    const workerCount = Math.min(this.options.maxWorkers || 4, this.fileQueue.length);
+  protected async copyFilesParallel(): Promise<void> {
+    const workerCount = Math.min(this.options.maxWorkers, this.fileQueue.length);
     
     // Initialize worker pool
     this.workerPool = await this.initializeWorkerPool(workerCount);
@@ -81,11 +76,7 @@ export class EnhancedPromptCopier extends PromptCopier {
   }
 
   private async processWithWorkerPool(): Promise<void> {
-    if (!this.workerPool) {
-      throw new Error('Worker pool not initialized');
-    }
-    
-    const chunkSize = Math.max(1, Math.floor(this.fileQueue.length / this.workerPool.workers.length / 2));
+    const chunkSize = Math.max(1, Math.floor(this.fileQueue.length / this.workerPool!.workers.length / 2));
     const chunks: FileInfo[][] = [];
     
     // Create chunks for better distribution
@@ -105,12 +96,7 @@ export class EnhancedPromptCopier extends PromptCopier {
 
   private async processChunkWithWorker(chunk: FileInfo[]): Promise<void> {
     return new Promise((resolve, reject) => {
-      if (!this.workerPool) {
-        reject(new Error('Worker pool not initialized'));
-        return;
-      }
-      
-      const pool = this.workerPool;
+      const pool = this.workerPool!;
       
       const tryAssignWork = () => {
         // Find available worker
@@ -165,7 +151,6 @@ export class EnhancedPromptCopier extends PromptCopier {
         pool.workers[availableWorkerIndex].postMessage(workerData);
       };
       
-      
       tryAssignWork();
     });
   }
@@ -206,7 +191,7 @@ export class EnhancedPromptCopier extends PromptCopier {
   }
 
   // Override verification to use worker results
-  protected override async verifyFiles(): Promise<void> {
+  protected async verifyFiles(): Promise<void> {
     logger.info('Verifying copied files...');
     
     for (const file of this.fileQueue) {
@@ -252,7 +237,4 @@ export class EnhancedPromptCopier extends PromptCopier {
 export async function copyPromptsEnhanced(options: CopyOptions): Promise<CopyResult> {
   const copier = new EnhancedPromptCopier(options);
   return copier.copy();
-}
-
-// Export alias for backward compatibility
-export { copyPromptsEnhanced as copyPrompts };
+}

package/src/swarm/prompt-copier.ts

@@ -57,12 +57,12 @@ export interface FileInfo {
 }
 
 export class PromptCopier extends EventEmitter {
-  protected options: Required<CopyOptions>;
-  protected fileQueue: FileInfo[] = [];
-  protected copiedFiles: Set<string> = new Set();
-  protected errors: CopyError[] = [];
-  protected backupMap: Map<string, string> = new Map();
-  protected rollbackStack: Array<() => Promise<void>> = [];
+  private options: Required<CopyOptions>;
+  private fileQueue: FileInfo[] = [];
+  private copiedFiles: Set<string> = new Set();
+  private errors: CopyError[] = [];
+  private backupMap: Map<string, string> = new Map();
+  private rollbackStack: Array<() => Promise<void>> = [];
 
   constructor(options: CopyOptions) {
     super();
@@ -97,7 +97,6 @@ export class PromptCopier extends EventEmitter {
           copiedFiles: 0,
           failedFiles: 0,
           skippedFiles: 0,
-          errors: [],
           duration: Date.now() - startTime
         };
       }
@@ -249,7 +248,7 @@ export class PromptCopier extends EventEmitter {
     }
   }
 
-  protected async copyFilesParallel(): Promise<void> {
+  private async copyFilesParallel(): Promise<void> {
     const workerCount = Math.min(this.options.maxWorkers, this.fileQueue.length);
     const chunkSize = Math.ceil(this.fileQueue.length / workerCount);
     const workers: Promise<void>[] = [];
@@ -267,7 +266,7 @@ export class PromptCopier extends EventEmitter {
     await Promise.all(workers);
   }
 
-  protected async processChunk(files: FileInfo[], workerId: number): Promise<void> {
+  private async processChunk(files: FileInfo[], workerId: number): Promise<void> {
     for (const file of files) {
       try {
         await this.copyFile(file);
@@ -366,7 +365,7 @@ export class PromptCopier extends EventEmitter {
     await fs.writeFile(destPath, mergedContent, 'utf-8');
   }
 
-  protected async verifyFiles(): Promise<void> {
+  private async verifyFiles(): Promise<void> {
     logger.info('Verifying copied files...');
     
     for (const file of this.fileQueue) {
@@ -406,12 +405,12 @@ export class PromptCopier extends EventEmitter {
     }
   }
 
-  protected async calculateFileHash(filePath: string): Promise<string> {
+  private async calculateFileHash(filePath: string): Promise<string> {
     const content = await fs.readFile(filePath);
     return createHash('sha256').update(content).digest('hex');
   }
 
-  protected async fileExists(filePath: string): Promise<boolean> {
+  private async fileExists(filePath: string): Promise<boolean> {
     try {
       await fs.access(filePath);
       return true;
@@ -465,7 +464,7 @@ export class PromptCopier extends EventEmitter {
     }
   }
 
-  protected reportProgress(completed: number): void {
+  private reportProgress(completed: number): void {
     const progress: CopyProgress = {
       total: this.fileQueue.length,
       completed,

package/src/swarm/types.ts

@@ -643,13 +643,7 @@ export type LoadBalancingStrategy =
   | 'centralized'      // Central dispatcher
   | 'distributed'      // Distributed load balancing
   | 'predictive'       // Predict and prevent overload
-  | 'reactive'         // React to overload conditions
-  | 'load-based'       // Select based on current load
-  | 'performance-based' // Select based on performance
-  | 'capability-based' // Select based on capabilities
-  | 'affinity-based'   // Prefer agents with domain affinity
-  | 'cost-based'       // Select based on cost
-  | 'hybrid';          // Combination of strategies
+  | 'reactive';        // React to overload conditions
 
 export type FaultToleranceStrategy = 
   | 'retry'            // Retry failed tasks

package/src/utils/error-handler.ts

@@ -2,6 +2,8 @@
  * Utility for proper error handling in TypeScript
  */
 
+import { getErrorMessage as getErrorMsg, getErrorStack as getErrorStk, isError as isErr } from './type-guards.js';
+
 export class AppError extends Error {
   constructor(
     message: string,
@@ -14,29 +16,10 @@ export class AppError extends Error {
   }
 }
 
-export function isError(error: unknown): error is Error {
-  return error instanceof Error;
-}
-
-export function getErrorMessage(error: unknown): string {
-  if (isError(error)) {
-    return error.message;
-  }
-  if (typeof error === 'string') {
-    return error;
-  }
-  if (error && typeof error === 'object' && 'message' in error) {
-    return String(error.message);
-  }
-  return 'An unknown error occurred';
-}
-
-export function getErrorStack(error: unknown): string | undefined {
-  if (isError(error)) {
-    return error.stack;
-  }
-  return undefined;
-}
+// Re-export from type-guards for backward compatibility
+export const isError = isErr;
+export const getErrorMessage = getErrorMsg;
+export const getErrorStack = getErrorStk;
 
 export function handleError(error: unknown, context?: string): never {
   const message = getErrorMessage(error);

package/src/utils/type-guards.ts

@@ -0,0 +1,188 @@
+/**
+ * Type guard utility functions for safe type checking
+ */
+
+/**
+ * Check if a value is an object (non-null and typeof object)
+ */
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+/**
+ * Check if a value is an Error instance or has error-like properties
+ */
+export function isError(value: unknown): value is Error {
+  return value instanceof Error;
+}
+
+/**
+ * Check if a value has a message property (error-like)
+ */
+export function hasMessage(value: unknown): value is { message: string } {
+  return isObject(value) && 'message' in value && typeof value.message === 'string';
+}
+
+/**
+ * Check if a value has a stack property (error-like)
+ */
+export function hasStack(value: unknown): value is { stack: string } {
+  return isObject(value) && 'stack' in value && typeof value.stack === 'string';
+}
+
+/**
+ * Check if a value is an error-like object
+ */
+export function isErrorLike(value: unknown): value is { message: string; stack?: string } {
+  return hasMessage(value);
+}
+
+/**
+ * Check if a value has a code property
+ */
+export function hasCode(value: unknown): value is { code: string | number } {
+  return isObject(value) && 'code' in value && 
+    (typeof value.code === 'string' || typeof value.code === 'number');
+}
+
+/**
+ * Check if a value has an agentId property
+ */
+export function hasAgentId(value: unknown): value is { agentId: { id: string } } {
+  return isObject(value) && 
+    'agentId' in value && 
+    isObject(value.agentId) && 
+    'id' in value.agentId &&
+    typeof value.agentId.id === 'string';
+}
+
+/**
+ * Check if a value has a pid property (process-like)
+ */
+export function hasPid(value: unknown): value is { pid: number } {
+  return isObject(value) && 'pid' in value && typeof value.pid === 'number';
+}
+
+/**
+ * Safely get error message from unknown value
+ */
+export function getErrorMessage(error: unknown): string {
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (isError(error)) {
+    return error.message;
+  }
+  if (hasMessage(error)) {
+    return error.message;
+  }
+  return String(error);
+}
+
+/**
+ * Safely get error stack from unknown value
+ */
+export function getErrorStack(error: unknown): string | undefined {
+  if (isError(error)) {
+    return error.stack;
+  }
+  if (hasStack(error)) {
+    return error.stack;
+  }
+  return undefined;
+}
+
+/**
+ * Type guard for checking if value is a string
+ */
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+/**
+ * Type guard for checking if value is a number
+ */
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number' && !isNaN(value);
+}
+
+/**
+ * Type guard for checking if value is a boolean
+ */
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean';
+}
+
+/**
+ * Type guard for checking if value is an array
+ */
+export function isArray<T = unknown>(value: unknown): value is T[] {
+  return Array.isArray(value);
+}
+
+/**
+ * Type guard for checking if value is a function
+ */
+export function isFunction(value: unknown): value is Function {
+  return typeof value === 'function';
+}
+
+/**
+ * Type guard for checking if value is null or undefined
+ */
+export function isNullOrUndefined(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}
+
+/**
+ * Type guard for checking if value is defined (not null or undefined)
+ */
+export function isDefined<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined;
+}
+
+/**
+ * Type guard for agent load update event data
+ */
+export function hasAgentLoad(value: unknown): value is { agentId: { id: string }; load: number } {
+  return isObject(value) && 
+    'agentId' in value && 
+    isObject(value.agentId) && 
+    'id' in value.agentId &&
+    typeof value.agentId.id === 'string' &&
+    'load' in value &&
+    typeof value.load === 'number';
+}
+
+/**
+ * Type guard for task event data
+ */
+export function hasAgentTask(value: unknown): value is { agentId: { id: string }; task: unknown } {
+  return isObject(value) && 
+    'agentId' in value && 
+    isObject(value.agentId) && 
+    'id' in value.agentId &&
+    typeof value.agentId.id === 'string' &&
+    'task' in value;
+}
+
+/**
+ * Type guard for work stealing event data
+ */
+export function hasWorkStealingData(value: unknown): value is { 
+  sourceAgent: { id: string }; 
+  targetAgent: { id: string }; 
+  taskCount: number 
+} {
+  return isObject(value) && 
+    'sourceAgent' in value && 
+    isObject(value.sourceAgent) && 
+    'id' in value.sourceAgent &&
+    typeof value.sourceAgent.id === 'string' &&
+    'targetAgent' in value && 
+    isObject(value.targetAgent) && 
+    'id' in value.targetAgent &&
+    typeof value.targetAgent.id === 'string' &&
+    'taskCount' in value &&
+    typeof value.taskCount === 'number';
+}

package/.claude/commands/analysis/README.md

@@ -1,9 +0,0 @@
-# Analysis Commands
-
-Commands for analysis operations in Claude Flow.
-
-## Available Commands
-
-- [bottleneck-detect](./bottleneck-detect.md)
-- [token-usage](./token-usage.md)
-- [performance-report](./performance-report.md)