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

package/src/cli/simple-commands/init/templates/settings.json

@@ -34,116 +34,36 @@
     ]
   },
   "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Edit|MultiEdit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks pre-edit --file \"${CLAUDE_FLOW_FILE}\" --validate-syntax --auto-assign-agents",
-            "blocking": false
-          }
-        ]
-      },
-      {
-        "matcher": "Write",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks pre-write --file \"${CLAUDE_FLOW_FILE}\" --prepare-directory",
-            "blocking": true
-          }
-        ]
-      },
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks pre-command --command \"${CLAUDE_FLOW_COMMAND}\" --validate-safety",
-            "blocking": true
-          }
-        ]
-      },
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks pre-task --description \"${CLAUDE_FLOW_TASK}\" --auto-spawn-agents --optimize-topology",
-            "blocking": false
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "Edit|MultiEdit|Write",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks post-edit --file \"${CLAUDE_FLOW_FILE}\" --format-code --update-memory --train-neural"
-          }
-        ]
-      },
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks post-command --command \"${CLAUDE_FLOW_COMMAND}\" --track-metrics --store-results"
-          }
-        ]
-      },
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks post-task --task-id \"${CLAUDE_FLOW_TASK_ID}\" --analyze-performance --update-telemetry"
-          }
-        ]
-      },
-      {
-        "matcher": "Read|Grep|Glob",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks post-search --pattern \"${CLAUDE_FLOW_PATTERN}\" --cache-results --optimize-future"
-          }
-        ]
-      }
-    ],
-    "Notification": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks notification --message \"${CLAUDE_FLOW_MESSAGE}\" --update-status --broadcast-agents"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks session-end --generate-summary --persist-state --export-metrics --cleanup-temp"
-          }
-        ]
-      }
-    ],
-    "SubagentStop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx claude-flow hooks agent-stop --agent-id \"${CLAUDE_FLOW_AGENT_ID}\" --save-knowledge --update-swarm-status"
-          }
-        ]
-      }
-    ]
+    "preEditHook": {
+      "command": "npx",
+      "args": ["claude-flow", "hooks", "pre-edit", "--file", "${file}", "--auto-assign-agents", "true", "--load-context", "true"],
+      "alwaysRun": false,
+      "outputFormat": "json"
+    },
+    "postEditHook": {
+      "command": "npx",
+      "args": ["claude-flow", "hooks", "post-edit", "--file", "${file}", "--format", "true", "--update-memory", "true", "--train-neural", "true"],
+      "alwaysRun": true,
+      "outputFormat": "json"
+    },
+    "preCommandHook": {
+      "command": "npx",
+      "args": ["claude-flow", "hooks", "pre-command", "--command", "${command}", "--validate-safety", "true", "--prepare-resources", "true"],
+      "alwaysRun": false,
+      "outputFormat": "json"
+    },
+    "postCommandHook": {
+      "command": "npx",
+      "args": ["claude-flow", "hooks", "post-command", "--command", "${command}", "--track-metrics", "true", "--store-results", "true"],
+      "alwaysRun": false,
+      "outputFormat": "json"
+    },
+    "sessionEndHook": {
+      "command": "npx",
+      "args": ["claude-flow", "hooks", "session-end", "--generate-summary", "true", "--persist-state", "true", "--export-metrics", "true"],
+      "alwaysRun": true,
+      "outputFormat": "json"
+    }
   },
   "mcpServers": {
     "claude-flow": {

package/src/cli/simple-commands/swarm.js

@@ -75,7 +75,8 @@ OPTIONS:
   --verbose                  Enable detailed logging
   --dry-run                  Show configuration without executing
   --executor                 Use built-in executor instead of Claude Code
-  --auto                     Auto-approve Claude permissions
+  --auto                     (Deprecated: auto-permissions enabled by default)
+  --no-auto-permissions      Disable automatic --dangerously-skip-permissions
 
 ADVANCED OPTIONS:
   --quality-threshold <n>    Quality threshold 0-1 (default: 0.8)
@@ -496,9 +497,10 @@ The swarm should be self-documenting - use memory_store to save all important in
       // Pass the prompt directly as an argument to claude
       const claudeArgs = [swarmPrompt];
       
-      // Add auto-permission flag if requested
-      if (flags.auto || flags['dangerously-skip-permissions']) {
+      // Add auto-permission flag by default for swarm mode (unless explicitly disabled)
+      if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
         claudeArgs.push('--dangerously-skip-permissions');
+        console.log('🔓 Using --dangerously-skip-permissions by default for seamless swarm execution');
       }
       
       // Spawn claude with the prompt as the first argument
@@ -955,8 +957,8 @@ Begin execution now. Create all necessary files and provide a complete, working
         
         const claudeArgs = [];
         
-        // Add auto-permission flag if requested
-        if (flags.auto || flags['dangerously-skip-permissions']) {
+        // Add auto-permission flag by default for swarm mode (unless explicitly disabled)
+        if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
           claudeArgs.push('--dangerously-skip-permissions');
         }
         
@@ -1062,7 +1064,8 @@ OPTIONS:
   --verbose                  Enable detailed logging
   --dry-run                  Show configuration without executing
   --executor                 Use built-in executor instead of Claude Code
-  --auto                     Auto-approve Claude permissions
+  --auto                     (Deprecated: auto-permissions enabled by default)
+  --no-auto-permissions      Disable automatic --dangerously-skip-permissions
 
 ADVANCED OPTIONS:
   --quality-threshold <n>    Quality threshold 0-1 (default: 0.8)

package/src/cli/ui/compatible-ui.ts

@@ -91,7 +91,7 @@ export class CompatibleUI {
       case 'h':
       case 'help':
       case '?':
-        this.showHelp();
+        this.outputHelp();
         break;
         
       case 's':
@@ -159,19 +159,6 @@ export class CompatibleUI {
     console.log(chalk.gray('Commands: [1-9] Process details [s] Status [l] List [r] Refresh [h] Help [q] Quit'));
   }
 
-  private showHelp(): void {
-    console.log();
-    console.log(chalk.cyan.bold('📖 Available Commands'));
-    console.log(chalk.gray('─'.repeat(40)));
-    console.log(chalk.white('[1-9]'), 'Show process details');
-    console.log(chalk.white('[s]'), 'Show system status');
-    console.log(chalk.white('[l]'), 'List all processes');
-    console.log(chalk.white('[r]'), 'Refresh display');
-    console.log(chalk.white('[h]'), 'Show this help');
-    console.log(chalk.white('[q]'), 'Quit application');
-    console.log();
-  }
-
   private showStatus(): void {
     const stats = this.getSystemStats();
     

package/src/cli/ui/fallback-handler.ts

@@ -1,4 +1,4 @@
-import { getErrorMessage } from '../../utils/error-handler.js';
+import { getErrorMessage } from '../../utils/type-guards.js';
 /**
  * Fallback UI Handler - Handles raw mode errors gracefully
  * Provides alternative UI when Ink/raw mode isn't supported
@@ -54,7 +54,7 @@ export async function handleRawModeError(
       const ui = createCompatibleUI();
       await ui.start();
     } catch (fallbackError) {
-      console.log(chalk.red('❌ Fallback UI also failed:'), (fallbackError instanceof Error ? fallbackError.message : String(fallbackError)));
+      console.log(chalk.red('❌ Fallback UI also failed:'), getErrorMessage(fallbackError));
       await showBasicInterface(options);
     }
   } else {

package/src/cli/utils/environment-detector.ts

@@ -3,7 +3,7 @@
  * Detects execution environment and recommends appropriate flags
  */
 
-import * as chalk from 'chalk';
+import chalk from 'chalk';
 
 export interface ExecutionEnvironment {
   isInteractive: boolean;
@@ -200,24 +200,24 @@ export function applySmartDefaults<T extends Record<string, any>>(
   // Apply defaults based on environment
   if ((environment.isVSCode || environment.isCI || !environment.supportsRawMode) && 
       !options.hasOwnProperty('skipPermissions')) {
-    (enhanced as any).skipPermissions = true;
-    (enhanced as any).dangerouslySkipPermissions = true;
+    enhanced.skipPermissions = true;
+    enhanced.dangerouslySkipPermissions = true;
     appliedDefaults.push('--dangerously-skip-permissions');
   }
   
   if ((environment.isCI || !environment.isInteractive) && 
       !options.hasOwnProperty('nonInteractive')) {
-    (enhanced as any).nonInteractive = true;
+    enhanced.nonInteractive = true;
     appliedDefaults.push('--non-interactive');
   }
   
   if (environment.isCI && !options.hasOwnProperty('json')) {
-    (enhanced as any).json = true;
+    enhanced.json = true;
     appliedDefaults.push('--json');
   }
   
   if (!environment.supportsColor && !options.hasOwnProperty('noColor')) {
-    (enhanced as any).noColor = true;
+    enhanced.noColor = true;
     appliedDefaults.push('--no-color');
   }
   

package/src/cli/utils/interactive-detector.js

@@ -0,0 +1,126 @@
+// interactive-detector.js - Detect and handle non-interactive environments
+
+/**
+ * Check if the current environment supports interactive TTY features
+ */
+export function isInteractive() {
+  // Check if stdin is a TTY
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+  
+  // Check if stdout is a TTY
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+  
+  // Check for CI environment variables
+  const ciVars = [
+    'CI',
+    'CONTINUOUS_INTEGRATION',
+    'GITHUB_ACTIONS',
+    'GITLAB_CI',
+    'JENKINS_URL',
+    'TRAVIS',
+    'CIRCLECI',
+    'CODEBUILD_BUILD_ID',
+    'BUILDKITE',
+    'DRONE'
+  ];
+  
+  for (const varName of ciVars) {
+    if (process.env[varName]) {
+      return false;
+    }
+  }
+  
+  // Check if running inside Docker (common indicator)
+  if (process.env.DOCKER_CONTAINER || process.env.KUBERNETES_SERVICE_HOST) {
+    return false;
+  }
+  
+  // Check if running in non-interactive mode explicitly
+  if (process.env.CLAUDE_FLOW_NON_INTERACTIVE === 'true') {
+    return false;
+  }
+  
+  return true;
+}
+
+/**
+ * Check if raw mode is supported (for Ink UI components)
+ */
+export function isRawModeSupported() {
+  return process.stdin.isTTY && process.stdin.setRawMode !== undefined;
+}
+
+/**
+ * Get environment type for logging/debugging
+ */
+export function getEnvironmentType() {
+  if (!process.stdin.isTTY) return 'non-tty-stdin';
+  if (!process.stdout.isTTY) return 'non-tty-stdout';
+  if (process.env.CI) return 'ci-environment';
+  if (process.env.GITHUB_ACTIONS) return 'github-actions';
+  if (process.env.DOCKER_CONTAINER) return 'docker';
+  if (!isRawModeSupported()) return 'no-raw-mode';
+  return 'interactive';
+}
+
+/**
+ * Wrap a command to handle non-interactive environments
+ */
+export function handleNonInteractive(commandName, interactiveFn, nonInteractiveFn) {
+  return async (...args) => {
+    if (isInteractive() && isRawModeSupported()) {
+      // Run interactive version
+      return interactiveFn(...args);
+    } else {
+      // Run non-interactive version or show helpful message
+      if (nonInteractiveFn) {
+        return nonInteractiveFn(...args);
+      } else {
+        console.error(`\n⚠️  ${commandName} requires an interactive terminal.`);
+        console.error(`\nDetected environment: ${getEnvironmentType()}`);
+        console.error('\nPossible solutions:');
+        console.error('1. Run this command in an interactive terminal');
+        console.error('2. Use environment variables for authentication:');
+        console.error('   export ANTHROPIC_API_KEY="your-api-key"');
+        console.error('3. Use --non-interactive flag with required parameters');
+        console.error('4. If using Docker, run with: docker run -it');
+        console.error('5. If using SSH, ensure pseudo-TTY allocation with: ssh -t');
+        console.error('\nFor more info: https://github.com/ruvnet/claude-code-flow/docs/non-interactive.md\n');
+        process.exit(1);
+      }
+    }
+  };
+}
+
+/**
+ * Show warning for commands that work better in interactive mode
+ */
+export function warnNonInteractive(commandName) {
+  if (!isInteractive()) {
+    console.warn(`\n⚠️  Running '${commandName}' in non-interactive mode (${getEnvironmentType()})`);
+    console.warn('Some features may be limited. For full functionality, use an interactive terminal.\n');
+  }
+}
+
+/**
+ * Check for required environment variables in non-interactive mode
+ */
+export function checkNonInteractiveAuth() {
+  if (!isInteractive()) {
+    const apiKey = process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY;
+    if (!apiKey) {
+      console.error('\n❌ Non-interactive mode requires API key to be set.');
+      console.error('\nSet one of these environment variables:');
+      console.error('  export ANTHROPIC_API_KEY="your-api-key"');
+      console.error('  export CLAUDE_API_KEY="your-api-key"');
+      console.error('\nOr run in an interactive terminal for login prompt.\n');
+      return false;
+    }
+    return true;
+  }
+  return true;
+}

package/src/communication/message-bus.ts

@@ -1,4 +1,4 @@
-import { getErrorMessage } from '../utils/error-handler.js';
+import { getErrorMessage, hasAgentId } from '../utils/type-guards.js';
 /**
  * Advanced messaging and communication layer for swarm coordination
  */
@@ -280,11 +280,15 @@ export class MessageBus extends EventEmitter {
 
   private setupEventHandlers(): void {
     this.eventBus.on('agent:connected', (data) => {
-      this.handleAgentConnected(data.agentId);
+      if (hasAgentId(data)) {
+        this.handleAgentConnected(data.agentId);
+      }
     });
 
     this.eventBus.on('agent:disconnected', (data) => {
-      this.handleAgentDisconnected(data.agentId);
+      if (hasAgentId(data)) {
+        this.handleAgentDisconnected(data.agentId);
+      }
     });
 
     this.deliveryManager.on('delivery:success', (data) => {

package/src/coordination/advanced-task-executor.ts

@@ -1,4 +1,4 @@
-import { getErrorMessage } from '../utils/error-handler.js';
+import { getErrorMessage, getErrorStack } from '../utils/type-guards.js';
 /**
  * Advanced task executor with timeout handling, retry logic, and resource management
  */
@@ -215,15 +215,15 @@ export class AdvancedTaskExecutor extends EventEmitter {
           taskId: task.id.id,
           attempt: retryCount,
           maxRetries,
-          error: (error instanceof Error ? error.message : String(error))
+          error: getErrorMessage(error)
         });
 
         // Check if we should retry
         if (retryCount > maxRetries) {
           const taskError: TaskError = {
             type: 'execution_failed',
-            message: (error instanceof Error ? error.message : String(error)),
-            stack: error.stack,
+            message: getErrorMessage(error),
+            stack: getErrorStack(error),
             context: {
               retryCount,
               maxRetries,
@@ -375,7 +375,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
       });
 
       childProcess.on('error', (error) => {
-        reject(new Error(`Process error: ${(error instanceof Error ? error.message : String(error))}`));
+        reject(new Error(`Process error: ${getErrorMessage(error)}`));
       });
     });
 
@@ -491,7 +491,7 @@ export class AdvancedTaskExecutor extends EventEmitter {
     for (const [taskId, context] of this.runningTasks) {
       if (context.process) {
         try {
-          const usage = await this.getProcessResourceUsage(context.process.pid!);
+          const usage = await this.getProcessResourceUsage(context.process.pid);
           context.resources = {
             ...usage,
             lastUpdated: new Date()
@@ -502,14 +502,17 @@ export class AdvancedTaskExecutor extends EventEmitter {
         } catch (error) {
           this.logger.warn('Failed to get resource usage', {
             taskId,
-            error: (error instanceof Error ? error.message : String(error))
+            error: getErrorMessage(error)
           });
         }
       }
     }
   }
 
-  private async getProcessResourceUsage(pid: number): Promise<ResourceUsage> {
+  private async getProcessResourceUsage(pid: number | undefined): Promise<ResourceUsage> {
+    if (!pid) {
+      throw new Error('Process ID is undefined');
+    }
     // In a real implementation, this would use system APIs
     // For now, return mock data
     return {

package/src/coordination/load-balancer.ts

@@ -1,4 +1,4 @@
-import { getErrorMessage } from '../utils/error-handler.js';
+import { getErrorMessage, hasAgentLoad, hasAgentTask, hasWorkStealingData } from '../utils/type-guards.js';
 /**
  * Advanced load balancing and work stealing implementation
  */
@@ -15,28 +15,6 @@ import type {
 } from '../swarm/types.js';
 import { WorkStealingCoordinator } from './work-stealing.js';
 
-// Event data interfaces for type safety
-interface AgentLoadUpdateData {
-  agentId: string;
-  load: Partial<AgentLoad>;
-}
-
-interface TaskQueueData {
-  agentId: string;
-  task: TaskDefinition;
-}
-
-interface WorkStealingRequestData {
-  sourceAgent: string;
-  targetAgent: string;
-  taskCount: number;
-}
-
-interface AgentPerformanceData {
-  agentId: string;
-  metrics: any;
-}
-
 export interface LoadBalancerConfig {
   strategy: LoadBalancingStrategy;
   enableWorkStealing: boolean;
@@ -174,23 +152,31 @@ export class LoadBalancer extends EventEmitter {
   }
 
   private setupEventHandlers(): void {
-    this.eventBus.on('agent:load-update', (data: AgentLoadUpdateData) => {
-      this.updateAgentLoad(data.agentId, data.load);
+    this.eventBus.on('agent:load-update', (data) => {
+      if (hasAgentLoad(data)) {
+        this.updateAgentLoad(data.agentId, data.load);
+      }
     });
 
-    this.eventBus.on('task:queued', (data: TaskQueueData) => {
-      this.updateTaskQueue(data.agentId, data.task, 'add');
+    this.eventBus.on('task:queued', (data) => {
+      if (hasAgentTask(data)) {
+        this.updateTaskQueue(data.agentId, data.task, 'add');
+      }
     });
 
-    this.eventBus.on('task:started', (data: TaskQueueData) => {
-      this.updateTaskQueue(data.agentId, data.task, 'remove');
+    this.eventBus.on('task:started', (data) => {
+      if (hasAgentTask(data)) {
+        this.updateTaskQueue(data.agentId, data.task, 'remove');
+      }
     });
 
-    this.eventBus.on('workstealing:request', (data: WorkStealingRequestData) => {
-      this.executeWorkStealing(data.sourceAgent, data.targetAgent, data.taskCount);
+    this.eventBus.on('workstealing:request', (data) => {
+      if (hasWorkStealingData(data)) {
+        this.executeWorkStealing(data.sourceAgent, data.targetAgent, data.taskCount);
+      }
     });
 
-    this.eventBus.on('agent:performance-update', (data: AgentPerformanceData) => {
+    this.eventBus.on('agent:performance-update', (data) => {
       this.updatePerformanceBaseline(data.agentId, data.metrics);
     });
   }
@@ -618,7 +604,7 @@ export class LoadBalancer extends EventEmitter {
 
   private async sampleAgentLoads(): Promise<void> {
     // Sample current loads from all agents
-    for (const [agentId, load] of Array.from(this.agentLoads.entries())) {
+    for (const [agentId, load] of this.agentLoads) {
       // Update load history
       const history = this.loadHistory.get(agentId) || [];
       history.push({ timestamp: new Date(), load: load.utilization });

package/src/coordination/work-stealing.ts

@@ -201,7 +201,7 @@ export class WorkStealingCoordinator {
     let minTasks = Infinity;
     let maxTasks = 0;
 
-    for (const [agentId, workload] of Array.from(this.workloads.entries())) {
+    for (const [agentId, workload] of this.workloads) {
       totalTasks += workload.taskCount;
       minTasks = Math.min(minTasks, workload.taskCount);
       maxTasks = Math.max(maxTasks, workload.taskCount);

package/src/core/event-bus.ts

@@ -49,7 +49,7 @@ class TypedEventBus extends TypedEventEmitter<EventMap> {
   getEventStats(): { event: string; count: number; lastEmitted: Date | null }[] {
     const stats: { event: string; count: number; lastEmitted: Date | null }[] = [];
     
-    for (const [event, count] of Array.from(this.eventCounts.entries())) {
+    for (const [event, count] of this.eventCounts.entries()) {
       const lastTime = this.lastEventTimes.get(event);
       stats.push({
         event: String(event),
@@ -135,7 +135,7 @@ export class EventBus implements IEventBus {
         resolve(data);
       };
 
-      let timer: NodeJS.Timeout | undefined;
+      let timer: number | undefined;
       if (timeoutMs) {
         timer = setTimeout(() => {
           this.off(event, handler);

package/src/core/logger.ts

@@ -6,7 +6,7 @@ import { getErrorMessage } from '../utils/error-handler.js';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { Buffer } from 'node:buffer';
-import * as process from 'node:process';
+import process from 'node:process';
 import type { LoggingConfig } from '../utils/types.js';
 import { formatBytes } from '../utils/helpers.js';
 

package/src/hive-mind/core/Agent.ts

@@ -15,7 +15,6 @@ import {
   AgentCapability,
   Task,
   Message,
-  MessageType,
   AgentConfig,
   ExecutionResult
 } from '../types.js';
@@ -297,7 +296,7 @@ export class Agent extends EventEmitter {
       fromAgentId: this.id,
       toAgentId,
       swarmId: this.swarmId,
-      type: messageType as MessageType,
+      type: messageType,
       content,
       timestamp: new Date(),
       requiresResponse: false
@@ -607,7 +606,7 @@ export class Agent extends EventEmitter {
     if (patterns.suggestedCapabilities) {
       // Update capabilities based on learning
       const newCapabilities = patterns.suggestedCapabilities.filter(
-        (cap: string) => !this.capabilities.includes(cap as AgentCapability)
+        (cap: string) => !this.capabilities.includes(cap)
       );
       
       if (newCapabilities.length > 0) {