@claude-flow/cli 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/init/mcp-generator.ts

@@ -1,83 +0,0 @@
-/**
- * MCP Configuration Generator
- * Creates .mcp.json for Claude Code MCP server integration
- */
-
-import type { InitOptions, MCPConfig } from './types.js';
-
-/**
- * Generate MCP configuration
- */
-export function generateMCPConfig(options: InitOptions): object {
-  const config = options.mcp;
-  const mcpServers: Record<string, object> = {};
-
-  // Claude Flow MCP server (core)
-  if (config.claudeFlow) {
-    mcpServers['claude-flow'] = {
-      command: 'npx',
-      args: ['@claude-flow/cli', 'mcp', 'start'],
-      env: {
-        CLAUDE_FLOW_MODE: 'v3',
-        CLAUDE_FLOW_HOOKS_ENABLED: 'true',
-        CLAUDE_FLOW_TOPOLOGY: options.runtime.topology,
-        CLAUDE_FLOW_MAX_AGENTS: String(options.runtime.maxAgents),
-        CLAUDE_FLOW_MEMORY_BACKEND: options.runtime.memoryBackend,
-      },
-      autoStart: config.autoStart,
-    };
-  }
-
-  // Ruv-Swarm MCP server (enhanced coordination)
-  if (config.ruvSwarm) {
-    mcpServers['ruv-swarm'] = {
-      command: 'npx',
-      args: ['ruv-swarm', 'mcp', 'start'],
-      env: {},
-      optional: true,
-    };
-  }
-
-  // Flow Nexus MCP server (cloud features)
-  if (config.flowNexus) {
-    mcpServers['flow-nexus'] = {
-      command: 'npx',
-      args: ['flow-nexus@latest', 'mcp', 'start'],
-      env: {},
-      optional: true,
-      requiresAuth: true,
-    };
-  }
-
-  return { mcpServers };
-}
-
-/**
- * Generate .mcp.json as formatted string
- */
-export function generateMCPJson(options: InitOptions): string {
-  const config = generateMCPConfig(options);
-  return JSON.stringify(config, null, 2);
-}
-
-/**
- * Generate MCP server add commands for manual setup
- */
-export function generateMCPCommands(options: InitOptions): string[] {
-  const commands: string[] = [];
-  const config = options.mcp;
-
-  if (config.claudeFlow) {
-    commands.push('claude mcp add claude-flow -- npx @claude-flow/cli mcp start');
-  }
-
-  if (config.ruvSwarm) {
-    commands.push('claude mcp add ruv-swarm -- npx ruv-swarm mcp start');
-  }
-
-  if (config.flowNexus) {
-    commands.push('claude mcp add flow-nexus -- npx flow-nexus@latest mcp start');
-  }
-
-  return commands;
-}

package/src/init/settings-generator.ts

@@ -1,274 +0,0 @@
-/**
- * Settings.json Generator
- * Creates .claude/settings.json with V3-optimized hook configurations
- */
-
-import type { InitOptions, HooksConfig } from './types.js';
-
-/**
- * Generate the complete settings.json content
- */
-export function generateSettings(options: InitOptions): object {
-  const settings: Record<string, unknown> = {};
-
-  // Add hooks if enabled
-  if (options.components.settings) {
-    settings.hooks = generateHooksConfig(options.hooks);
-  }
-
-  // Add permissions
-  settings.permissions = {
-    // Auto-allow claude-flow MCP tools
-    allow: [
-      'Bash(npx claude-flow*)',
-      'Bash(npx @claude-flow/*)',
-      'mcp__claude-flow__*',
-    ],
-    // Auto-deny dangerous operations
-    deny: [],
-  };
-
-  // Add model preferences for V3
-  settings.model = {
-    default: 'claude-sonnet-4-20250514',
-    // Use Haiku for quick routing decisions
-    routing: 'claude-haiku',
-  };
-
-  // Add V3-specific settings
-  settings.claudeFlow = {
-    version: '3.0.0',
-    enabled: true,
-    swarm: {
-      topology: options.runtime.topology,
-      maxAgents: options.runtime.maxAgents,
-    },
-    memory: {
-      backend: options.runtime.memoryBackend,
-      enableHNSW: options.runtime.enableHNSW,
-    },
-    neural: {
-      enabled: options.runtime.enableNeural,
-    },
-  };
-
-  return settings;
-}
-
-/**
- * Generate hooks configuration
- */
-function generateHooksConfig(config: HooksConfig): object {
-  const hooks: Record<string, unknown[]> = {};
-
-  // PreToolUse hooks
-  if (config.preToolUse) {
-    hooks.PreToolUse = [
-      // File edit hooks
-      {
-        matcher: '^(Write|Edit|MultiEdit)$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-edit --file "$TOOL_INPUT_file_path"',
-            timeout: config.timeout,
-            continueOnError: config.continueOnError,
-          },
-        ],
-      },
-      // Bash command hooks
-      {
-        matcher: '^Bash$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-command --command "$TOOL_INPUT_command"',
-            timeout: config.timeout,
-            continueOnError: config.continueOnError,
-          },
-        ],
-      },
-      // Task/Agent hooks
-      {
-        matcher: '^Task$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-task --description "$TOOL_INPUT_prompt"',
-            timeout: config.timeout,
-            continueOnError: config.continueOnError,
-          },
-        ],
-      },
-      // Search hooks
-      {
-        matcher: '^(Grep|Glob|Read)$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks pre-search --pattern "$TOOL_INPUT_pattern"',
-            timeout: 2000,
-            continueOnError: true,
-          },
-        ],
-      },
-    ];
-  }
-
-  // PostToolUse hooks
-  if (config.postToolUse) {
-    hooks.PostToolUse = [
-      // File edit hooks with learning
-      {
-        matcher: '^(Write|Edit|MultiEdit)$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks post-edit --file "$TOOL_INPUT_file_path" --success "$TOOL_SUCCESS" --train-patterns',
-            timeout: config.timeout,
-            continueOnError: config.continueOnError,
-          },
-        ],
-      },
-      // Bash command hooks with metrics
-      {
-        matcher: '^Bash$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks post-command --command "$TOOL_INPUT_command" --success "$TOOL_SUCCESS" --exit-code "$TOOL_EXIT_CODE"',
-            timeout: config.timeout,
-            continueOnError: config.continueOnError,
-          },
-        ],
-      },
-      // Task completion hooks
-      {
-        matcher: '^Task$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks post-task --agent-id "$TOOL_RESULT_agent_id" --success "$TOOL_SUCCESS" --analyze',
-            timeout: config.timeout,
-            continueOnError: config.continueOnError,
-          },
-        ],
-      },
-      // Search caching
-      {
-        matcher: '^(Grep|Glob)$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks post-search --cache-results',
-            timeout: 2000,
-            continueOnError: true,
-          },
-        ],
-      },
-    ];
-  }
-
-  // UserPromptSubmit for intelligent routing
-  if (config.userPromptSubmit) {
-    hooks.UserPromptSubmit = [
-      {
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks route --task "$PROMPT" --include-explanation',
-            timeout: config.timeout,
-            continueOnError: config.continueOnError,
-          },
-        ],
-      },
-    ];
-  }
-
-  // SessionStart for context loading
-  if (config.sessionStart) {
-    hooks.SessionStart = [
-      {
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks session-start --session-id "$SESSION_ID" --load-context',
-            timeout: 10000,
-            continueOnError: true,
-          },
-        ],
-      },
-    ];
-  }
-
-  // Stop hooks for task evaluation
-  if (config.stop) {
-    hooks.Stop = [
-      {
-        hooks: [
-          {
-            type: 'prompt',
-            prompt: `Evaluate task completion. Consider:
-1. Were all requested changes made?
-2. Did builds/tests pass?
-3. Is follow-up work needed?
-
-Respond with {"decision": "stop"} if complete, or {"decision": "continue", "reason": "..."} if more work is needed.`,
-          },
-        ],
-      },
-    ];
-  }
-
-  // Notification hooks
-  if (config.notification) {
-    hooks.Notification = [
-      {
-        hooks: [
-          {
-            type: 'command',
-            command: 'npx @claude-flow/cli hooks notify --message "$NOTIFICATION_MESSAGE" --swarm-status',
-            timeout: 3000,
-            continueOnError: true,
-          },
-        ],
-      },
-    ];
-  }
-
-  // PermissionRequest for auto-allowing claude-flow tools
-  if (config.permissionRequest) {
-    hooks.PermissionRequest = [
-      {
-        matcher: '^mcp__claude-flow__.*$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'echo \'{"decision": "allow", "reason": "claude-flow MCP tool auto-approved"}\'',
-            timeout: 1000,
-          },
-        ],
-      },
-      {
-        matcher: '^Bash\\(npx @?claude-flow.*\\)$',
-        hooks: [
-          {
-            type: 'command',
-            command: 'echo \'{"decision": "allow", "reason": "claude-flow CLI auto-approved"}\'',
-            timeout: 1000,
-          },
-        ],
-      },
-    ];
-  }
-
-  return hooks;
-}
-
-/**
- * Generate settings.json as formatted string
- */
-export function generateSettingsJson(options: InitOptions): string {
-  const settings = generateSettings(options);
-  return JSON.stringify(settings, null, 2);
-}

package/src/init/statusline-generator.ts

@@ -1,211 +0,0 @@
-/**
- * Statusline Configuration Generator
- * Creates statusline configuration for V3 progress display
- */
-
-import type { InitOptions, StatuslineConfig } from './types.js';
-
-/**
- * Generate statusline configuration script
- */
-export function generateStatuslineScript(options: InitOptions): string {
-  const config = options.statusline;
-
-  return `#!/usr/bin/env node
-/**
- * Claude Flow V3 Statusline Generator
- * Displays real-time V3 implementation progress and system status
- *
- * Usage: node statusline.js [--json]
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Configuration
-const CONFIG = {
-  enabled: ${config.enabled},
-  showProgress: ${config.showProgress},
-  showSecurity: ${config.showSecurity},
-  showSwarm: ${config.showSwarm},
-  showHooks: ${config.showHooks},
-  showPerformance: ${config.showPerformance},
-  refreshInterval: ${config.refreshInterval},
-};
-
-// ANSI colors
-const colors = {
-  reset: '\\x1b[0m',
-  bright: '\\x1b[1m',
-  dim: '\\x1b[2m',
-  green: '\\x1b[32m',
-  yellow: '\\x1b[33m',
-  blue: '\\x1b[34m',
-  magenta: '\\x1b[35m',
-  cyan: '\\x1b[36m',
-  red: '\\x1b[31m',
-};
-
-// Get V3 progress from filesystem
-function getV3Progress() {
-  const v3Path = path.join(process.cwd(), 'v3', '@claude-flow');
-  let modulesCount = 0;
-  let filesCount = 0;
-
-  try {
-    if (fs.existsSync(v3Path)) {
-      const modules = fs.readdirSync(v3Path);
-      modulesCount = modules.filter(m => fs.statSync(path.join(v3Path, m)).isDirectory()).length;
-
-      // Count TypeScript files
-      const countFiles = (dir) => {
-        let count = 0;
-        const items = fs.readdirSync(dir, { withFileTypes: true });
-        for (const item of items) {
-          if (item.isDirectory() && item.name !== 'node_modules' && item.name !== 'dist') {
-            count += countFiles(path.join(dir, item.name));
-          } else if (item.isFile() && item.name.endsWith('.ts')) {
-            count++;
-          }
-        }
-        return count;
-      };
-      filesCount = countFiles(v3Path);
-    }
-  } catch (e) {
-    // Ignore errors
-  }
-
-  return { modulesCount, filesCount };
-}
-
-// Get security status
-function getSecurityStatus() {
-  // Check for security-related files
-  const securityPath = path.join(process.cwd(), 'v3', '@claude-flow', 'security');
-  const exists = fs.existsSync(securityPath);
-
-  return {
-    status: exists ? 'IN_PROGRESS' : 'PENDING',
-    cvesFixed: exists ? 2 : 0,
-    totalCves: 3,
-  };
-}
-
-// Get swarm status
-function getSwarmStatus() {
-  const configPath = path.join(process.cwd(), '.claude-flow', 'config.yaml');
-
-  return {
-    activeAgents: 0,
-    maxAgents: ${options.runtime.maxAgents},
-    topology: '${options.runtime.topology}',
-    coordinationActive: false,
-  };
-}
-
-// Get hooks metrics
-function getHooksMetrics() {
-  const metricsPath = path.join(process.cwd(), '.claude-flow', 'data', 'hooks-metrics.json');
-
-  try {
-    if (fs.existsSync(metricsPath)) {
-      return JSON.parse(fs.readFileSync(metricsPath, 'utf-8'));
-    }
-  } catch (e) {
-    // Ignore errors
-  }
-
-  return {
-    status: 'ACTIVE',
-    patternsLearned: 0,
-    routingAccuracy: 0,
-    totalOperations: 0,
-  };
-}
-
-// Generate statusline
-function generateStatusline() {
-  const segments = [];
-
-  if (CONFIG.showProgress) {
-    const progress = getV3Progress();
-    segments.push(\`\${colors.cyan}V3\${colors.reset} \${progress.modulesCount}mod/\${progress.filesCount}files\`);
-  }
-
-  if (CONFIG.showSecurity) {
-    const security = getSecurityStatus();
-    const statusColor = security.status === 'CLEAN' ? colors.green :
-                        security.status === 'IN_PROGRESS' ? colors.yellow : colors.red;
-    segments.push(\`\${colors.magenta}SEC\${colors.reset} \${statusColor}\${security.cvesFixed}/\${security.totalCves}\${colors.reset}\`);
-  }
-
-  if (CONFIG.showSwarm) {
-    const swarm = getSwarmStatus();
-    segments.push(\`\${colors.blue}SWARM\${colors.reset} \${swarm.activeAgents}/\${swarm.maxAgents}\`);
-  }
-
-  if (CONFIG.showHooks) {
-    const hooks = getHooksMetrics();
-    segments.push(\`\${colors.green}HOOKS\${colors.reset} \${hooks.patternsLearned}pat\`);
-  }
-
-  if (CONFIG.showPerformance) {
-    segments.push(\`\${colors.yellow}PERF\${colors.reset} 2.49x-7.47x\`);
-  }
-
-  return segments.join(' | ');
-}
-
-// Output JSON if requested
-if (process.argv.includes('--json')) {
-  const data = {
-    v3Progress: getV3Progress(),
-    security: getSecurityStatus(),
-    swarm: getSwarmStatus(),
-    hooks: getHooksMetrics(),
-    performance: {
-      flashAttentionTarget: '2.49x-7.47x',
-      searchImprovement: '150x-12500x',
-      memoryReduction: '50-75%',
-    },
-    lastUpdated: new Date().toISOString(),
-  };
-  console.log(JSON.stringify(data, null, 2));
-} else {
-  console.log(generateStatusline());
-}
-`;
-}
-
-/**
- * Generate statusline hook for shell integration
- */
-export function generateStatuslineHook(options: InitOptions): string {
-  if (!options.statusline.enabled) {
-    return '# Statusline disabled';
-  }
-
-  return `# Claude Flow V3 Statusline Hook
-# Add to your shell RC file (.bashrc, .zshrc, etc.)
-
-# Function to get statusline
-claude_flow_statusline() {
-  local statusline_script="\${CLAUDE_FLOW_DIR:-.claude}/helpers/statusline.js"
-  if [ -f "$statusline_script" ]; then
-    node "$statusline_script" 2>/dev/null || echo ""
-  fi
-}
-
-# For bash PS1
-# export PS1='$(claude_flow_statusline) \\n\\$ '
-
-# For zsh RPROMPT
-# export RPROMPT='$(claude_flow_statusline)'
-
-# For starship (add to starship.toml)
-# [custom.claude_flow]
-# command = "node .claude/helpers/statusline.js 2>/dev/null"
-# when = "test -f .claude/helpers/statusline.js"
-`;
-}