claude-flow 2.5.0-alpha.141 → 2.7.0-alpha

package/src/execution/agent-executor.ts

@@ -0,0 +1,306 @@
+/**
+ * Agent Executor - Wrapper around agentic-flow execution engine
+ * Integrates agentic-flow agents with claude-flow hooks and coordination
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import fs from 'fs-extra';
+
+const execAsync = promisify(exec);
+
+export interface AgentExecutionOptions {
+  agent: string;
+  task: string;
+  provider?: 'anthropic' | 'openrouter' | 'onnx' | 'gemini';
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  outputFormat?: 'text' | 'json' | 'markdown';
+  stream?: boolean;
+  verbose?: boolean;
+  retryOnError?: boolean;
+  timeout?: number;
+
+  // ReasoningBank memory options
+  enableMemory?: boolean;           // Enable ReasoningBank learning
+  memoryDatabase?: string;          // Path to .swarm/memory.db
+  memoryRetrievalK?: number;        // Top-k memories to retrieve (default: 3)
+  memoryLearning?: boolean;         // Enable post-task learning (default: true)
+  memoryDomain?: string;            // Domain filter for memories
+  memoryMinConfidence?: number;     // Minimum confidence threshold (default: 0.5)
+  memoryTaskId?: string;            // Unique task ID for tracking
+}
+
+export interface AgentExecutionResult {
+  success: boolean;
+  output: string;
+  error?: string;
+  provider: string;
+  model: string;
+  tokens?: number;
+  cost?: number;
+  duration: number;
+  agent: string;
+  task: string;
+
+  // ReasoningBank metrics
+  memoryEnabled?: boolean;
+  memoriesRetrieved?: number;
+  memoriesUsed?: string[];          // IDs of memories applied
+  memoryLearned?: boolean;          // Whether new memories were created
+  memoryVerdict?: 'success' | 'failure';
+  memoryConfidence?: number;
+  newMemoryIds?: string[];          // IDs of newly created memories
+}
+
+export class AgentExecutor {
+  private readonly agenticFlowPath: string;
+  private readonly hooksManager: any;
+  private memoryEnabled: boolean = false;
+  private memoryDatabase: string = '.swarm/memory.db';
+
+  constructor(hooksManager?: any) {
+    this.hooksManager = hooksManager;
+    // Agentic-flow is installed as npm dependency
+    this.agenticFlowPath = 'npx agentic-flow';
+  }
+
+  /**
+   * Initialize ReasoningBank database
+   */
+  async initializeMemory(dbPath?: string): Promise<void> {
+    const db = dbPath || this.memoryDatabase;
+
+    try {
+      const { stdout } = await execAsync(
+        `${this.agenticFlowPath} reasoningbank init`
+      );
+
+      this.memoryEnabled = true;
+      this.memoryDatabase = db;
+      console.log('✅ ReasoningBank initialized:', db);
+    } catch (error: any) {
+      console.error('Failed to initialize ReasoningBank:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Get memory statistics
+   */
+  async getMemoryStats(): Promise<any> {
+    if (!this.memoryEnabled) {
+      return { enabled: false, totalMemories: 0 };
+    }
+
+    try {
+      const { stdout } = await execAsync(
+        `${this.agenticFlowPath} reasoningbank status`
+      );
+      return { enabled: true, output: stdout };
+    } catch (error: any) {
+      return { enabled: true, error: error.message };
+    }
+  }
+
+  /**
+   * Run memory consolidation (dedup + prune)
+   */
+  async consolidateMemories(): Promise<void> {
+    if (!this.memoryEnabled) return;
+
+    try {
+      await execAsync(
+        `${this.agenticFlowPath} reasoningbank consolidate`
+      );
+      console.log('✅ Memory consolidation complete');
+    } catch (error: any) {
+      console.warn('Consolidation failed:', error.message);
+    }
+  }
+
+  /**
+   * Execute an agent with agentic-flow
+   */
+  async execute(options: AgentExecutionOptions): Promise<AgentExecutionResult> {
+    const startTime = Date.now();
+    const taskId = options.memoryTaskId || `task-${Date.now()}`;
+
+    try {
+      // Initialize memory if requested
+      if (options.enableMemory && !this.memoryEnabled) {
+        try {
+          await this.initializeMemory(options.memoryDatabase);
+        } catch (error) {
+          console.warn('Memory initialization failed, continuing without memory');
+        }
+      }
+
+      // Trigger pre-execution hook
+      if (this.hooksManager) {
+        await this.hooksManager.trigger('pre-agent-execute', {
+          agent: options.agent,
+          task: options.task,
+          provider: options.provider || 'anthropic',
+          timestamp: Date.now(),
+          memoryEnabled: this.memoryEnabled || options.enableMemory,
+        });
+      }
+
+      // Build agentic-flow command
+      const command = this.buildCommand(options);
+
+      // Execute command
+      const { stdout, stderr } = await execAsync(command, {
+        timeout: options.timeout || 300000, // 5 minutes default
+        maxBuffer: 10 * 1024 * 1024, // 10MB buffer,
+      });
+
+      const duration = Date.now() - startTime;
+
+      // Parse output
+      const result: AgentExecutionResult = {
+        success: true,
+        output: stdout,
+        provider: options.provider || 'anthropic',
+        model: options.model || 'default',
+        duration,
+        agent: options.agent,
+        task: options.task,
+        memoryEnabled: this.memoryEnabled || options.enableMemory || false,
+      };
+
+      // Trigger post-execution hook
+      if (this.hooksManager) {
+        await this.hooksManager.trigger('post-agent-execute', {
+          agent: options.agent,
+          task: options.task,
+          result,
+          success: true,
+        });
+      }
+
+      return result;
+    } catch (error: any) {
+      const duration = Date.now() - startTime;
+
+      const result: AgentExecutionResult = {
+        success: false,
+        output: '',
+        error: error.message,
+        provider: options.provider || 'anthropic',
+        model: options.model || 'default',
+        duration,
+        agent: options.agent,
+        task: options.task,
+        memoryEnabled: this.memoryEnabled || options.enableMemory || false,
+      };
+
+      // Trigger error hook
+      if (this.hooksManager) {
+        await this.hooksManager.trigger('agent-execute-error', {
+          agent: options.agent,
+          task: options.task,
+          error: error.message,
+        });
+      }
+
+      return result;
+    }
+  }
+
+  /**
+   * List available agents from agentic-flow
+   */
+  async listAgents(source?: 'all' | 'package' | 'local'): Promise<string[]> {
+    try {
+      // Agentic-flow uses 'agent list' command
+      const command = source
+        ? `${this.agenticFlowPath} agent list --filter ${source}`
+        : `${this.agenticFlowPath} agent list`;
+
+      const { stdout } = await execAsync(command);
+
+      // Parse agent list from output
+      const agents = stdout
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => line.trim());
+
+      return agents;
+    } catch (error: any) {
+      console.error('Failed to list agents:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Get agent information
+   */
+  async getAgentInfo(agentName: string): Promise<any> {
+    try {
+      // Agentic-flow uses 'agent info' command
+      const command = `${this.agenticFlowPath} agent info ${agentName}`;
+      const { stdout } = await execAsync(command);
+
+      // Try to parse as JSON if it looks like JSON
+      if (stdout.trim().startsWith('{')) {
+        return JSON.parse(stdout);
+      }
+
+      // Otherwise return as plain text
+      return { name: agentName, description: stdout };
+    } catch (error: any) {
+      console.error('Failed to get agent info:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Build agentic-flow command from options
+   */
+  private buildCommand(options: AgentExecutionOptions): string {
+    const parts = [this.agenticFlowPath];
+
+    // Agentic-flow uses --agent flag directly (no 'execute' subcommand)
+    parts.push('--agent', options.agent);
+    parts.push('--task', `"${options.task.replace(/"/g, '\\"')}"`);
+
+    if (options.provider) {
+      parts.push('--provider', options.provider);
+    }
+
+    if (options.model) {
+      parts.push('--model', options.model);
+    }
+
+    if (options.temperature !== undefined) {
+      parts.push('--temperature', options.temperature.toString());
+    }
+
+    if (options.maxTokens) {
+      parts.push('--max-tokens', options.maxTokens.toString());
+    }
+
+    if (options.outputFormat) {
+      parts.push('--output-format', options.outputFormat);
+    }
+
+    if (options.stream) {
+      parts.push('--stream');
+    }
+
+    if (options.verbose) {
+      parts.push('--verbose');
+    }
+
+    // Note: agentic-flow doesn't have a --retry flag
+    // Retry logic should be handled by AgentExecutor if needed
+
+    return parts.join(' ');
+  }
+}
+
+export default AgentExecutor;

package/src/execution/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Execution Layer - Agentic-Flow Integration
+ * Entry point for multi-provider agent execution
+ */
+
+export { AgentExecutor, type AgentExecutionOptions, type AgentExecutionResult } from './agent-executor.js';
+export { ProviderManager, type ProviderConfig, type ExecutionConfig } from './provider-manager.js';
+
+// Convenience exports
+import { AgentExecutor } from './agent-executor.js';
+import { ProviderManager } from './provider-manager.js';
+
+export function createExecutor(hooksManager?: any) {
+  return new AgentExecutor(hooksManager);
+}
+
+export function createProviderManager() {
+  return new ProviderManager();
+}

package/src/execution/provider-manager.ts

@@ -0,0 +1,187 @@
+/**
+ * Provider Manager - Handles multi-provider configuration and selection
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+export interface ProviderConfig {
+  name: 'anthropic' | 'openrouter' | 'onnx' | 'gemini';
+  model?: string;
+  apiKey?: string;
+  enabled: boolean;
+  priority?: 'cost' | 'quality' | 'speed' | 'privacy';
+}
+
+export interface ExecutionConfig {
+  defaultProvider: string;
+  providers: Record<string, ProviderConfig>;
+  optimization?: {
+    strategy: 'balanced' | 'cost' | 'quality' | 'speed' | 'privacy';
+    maxCostPerTask?: number;
+  };
+}
+
+export class ProviderManager {
+  private config: ExecutionConfig;
+  private configPath: string;
+
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.claude', 'settings.json');
+    this.config = this.loadConfig();
+  }
+
+  /**
+   * Get default provider
+   */
+  getDefaultProvider(): string {
+    return this.config.defaultProvider || 'anthropic';
+  }
+
+  /**
+   * Get provider configuration
+   */
+  getProviderConfig(provider: string): ProviderConfig | null {
+    return this.config.providers?.[provider] || null;
+  }
+
+  /**
+   * Set default provider
+   */
+  async setDefaultProvider(provider: string): Promise<void> {
+    this.config.defaultProvider = provider;
+    await this.saveConfig();
+  }
+
+  /**
+   * Configure a provider
+   */
+  async configureProvider(
+    provider: string,
+    config: Partial<ProviderConfig>
+  ): Promise<void> {
+    if (!this.config.providers) {
+      this.config.providers = {};
+    }
+
+    this.config.providers[provider] = {
+      ...this.config.providers[provider],
+      name: provider as any,
+      ...config,
+    };
+
+    await this.saveConfig();
+  }
+
+  /**
+   * List available providers
+   */
+  listProviders(): ProviderConfig[] {
+    if (!this.config.providers) {
+      return this.getDefaultProviders();
+    }
+
+    return Object.values(this.config.providers);
+  }
+
+  /**
+   * Get optimization strategy
+   */
+  getOptimizationStrategy(): string {
+    return this.config.optimization?.strategy || 'balanced';
+  }
+
+  /**
+   * Load configuration from file
+   */
+  private loadConfig(): ExecutionConfig {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const data = fs.readFileSync(this.configPath, 'utf-8');
+        const settings = JSON.parse(data);
+        return settings['claude-flow']?.execution || this.getDefaultConfig();
+      }
+    } catch (error) {
+      console.warn('Failed to load provider config, using defaults');
+    }
+
+    return this.getDefaultConfig();
+  }
+
+  /**
+   * Save configuration to file
+   */
+  private async saveConfig(): Promise<void> {
+    try {
+      await fs.ensureDir(path.dirname(this.configPath));
+
+      let settings: any = {};
+      if (await fs.pathExists(this.configPath)) {
+        const data = await fs.readFile(this.configPath, 'utf-8');
+        settings = JSON.parse(data);
+      }
+
+      if (!settings['claude-flow']) {
+        settings['claude-flow'] = {};
+      }
+
+      settings['claude-flow'].execution = this.config;
+
+      await fs.writeFile(
+        this.configPath,
+        JSON.stringify(settings, null, 2),
+        'utf-8'
+      );
+    } catch (error: any) {
+      console.error('Failed to save provider config:', error.message);
+    }
+  }
+
+  /**
+   * Get default configuration
+   */
+  private getDefaultConfig(): ExecutionConfig {
+    return {
+      defaultProvider: 'anthropic',
+      providers: {
+        anthropic: {
+          name: 'anthropic',
+          model: 'claude-sonnet-4-5-20250929',
+          enabled: true,
+          priority: 'quality',
+        },
+        openrouter: {
+          name: 'openrouter',
+          model: 'meta-llama/llama-3.1-8b-instruct',
+          enabled: true,
+          priority: 'cost',
+        },
+        onnx: {
+          name: 'onnx',
+          model: 'Xenova/gpt2',
+          enabled: true,
+          priority: 'privacy',
+        },
+        gemini: {
+          name: 'gemini',
+          enabled: true,
+          priority: 'cost',
+        },
+      },
+      optimization: {
+        strategy: 'balanced',
+        maxCostPerTask: 0.5,
+      },
+    };
+  }
+
+  /**
+   * Get default providers list
+   */
+  private getDefaultProviders(): ProviderConfig[] {
+    return Object.values(this.getDefaultConfig().providers);
+  }
+}
+
+export default ProviderManager;

package/src/hooks/redaction-hook.ts

@@ -0,0 +1,115 @@
+/**
+ * Git Pre-commit Hook for API Key Redaction
+ * Prevents sensitive data from being committed
+ */
+
+import { KeyRedactor } from '../utils/key-redactor.js';
+import { readFileSync } from 'fs';
+import { execSync } from 'child_process';
+
+export async function validateNoSensitiveData(): Promise<{ safe: boolean; issues: string[] }> {
+  const issues: string[] = [];
+
+  try {
+    // Get staged files
+    const stagedFiles = execSync('git diff --cached --name-only', { encoding: 'utf-8' })
+      .split('\n')
+      .filter(f => f.trim() && !f.includes('.env') && !f.includes('node_modules') && !f.endsWith('.map'));
+
+    // Common documentation placeholder patterns (these are safe)
+    const placeholderPatterns = [
+      /API_KEY=\(paste/i,
+      /API_KEY=\(your/i,
+      /API_KEY=\.\.\./i,
+      /API_KEY="\.\.\."/i,
+      /API_KEY="\(paste/i,
+      /API_KEY="\(your/i,
+      /API_KEY=sk-ant-\.\.\./i,       // Truncated example keys
+      /API_KEY=sk-or-v1-\.\.\./i,     // Truncated example keys
+      /API_KEY="sk-ant-\.\.\."/i,     // Quoted truncated keys
+      /API_KEY="sk-or-v1-\.\.\."/i,   // Quoted truncated keys
+      /API_KEY=sk-ant-xxxxx/i,        // xxxxx format examples
+      /API_KEY=sk-or-v1-xxxxx/i,      // xxxxx format examples
+      /TOKEN=\(paste/i,
+      /TOKEN=\(your/i,
+      /SECRET=\(paste/i,
+      /SECRET=\(your/i,
+    ];
+
+    // Check each staged file
+    for (const file of stagedFiles) {
+      try {
+        // Skip documentation files with obvious placeholders
+        if (file.startsWith('docs/') || file.includes('/docs/')) {
+          const content = readFileSync(file, 'utf-8');
+          // Check if file only contains placeholder patterns
+          const hasOnlyPlaceholders = placeholderPatterns.some(pattern => pattern.test(content));
+          if (hasOnlyPlaceholders) {
+            continue; // Skip - these are documentation examples
+          }
+        }
+
+        const content = readFileSync(file, 'utf-8');
+
+        // Check for placeholder patterns in the content
+        const hasPlaceholders = placeholderPatterns.some(pattern => pattern.test(content));
+        if (hasPlaceholders && (file.includes('example') || file.includes('template') || file.includes('/docs/'))) {
+          continue; // Skip - these are examples/templates with placeholders
+        }
+
+        const validation = KeyRedactor.validate(content);
+
+        if (!validation.safe) {
+          // Double-check: if warnings are only about placeholder patterns, skip
+          const warningsText = validation.warnings.join(' ');
+          if (hasPlaceholders && !warningsText.includes('sk-ant-a') && !warningsText.includes('sk-or-v')) {
+            continue; // Likely a false positive from documentation
+          }
+          issues.push(`⚠️  ${file}: ${validation.warnings.join(', ')}`);
+        }
+      } catch (error) {
+        // File might be deleted or binary
+        continue;
+      }
+    }
+
+    return {
+      safe: issues.length === 0,
+      issues,
+    };
+  } catch (error) {
+    console.error('Error validating sensitive data:', error);
+    return {
+      safe: false,
+      issues: ['Failed to validate files'],
+    };
+  }
+}
+
+export async function runRedactionCheck(): Promise<number> {
+  console.log('🔒 Running API key redaction check...\n');
+
+  const result = await validateNoSensitiveData();
+
+  if (!result.safe) {
+    console.error('❌ COMMIT BLOCKED - Sensitive data detected:\n');
+    result.issues.forEach(issue => console.error(issue));
+    console.error('\n⚠️  Please remove sensitive data before committing.');
+    console.error('💡 Tip: Use environment variables instead of hardcoding keys.\n');
+    return 1;
+  }
+
+  console.log('✅ No sensitive data detected - safe to commit\n');
+  return 0;
+}
+
+// CLI execution (ES module compatible)
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+  runRedactionCheck()
+    .then(code => process.exit(code))
+    .catch(error => {
+      console.error('Error:', error);
+      process.exit(1);
+    });
+}