claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

package/src/cli/help-formatter.ts

@@ -38,9 +38,7 @@ export class HelpFormatter {
     const sections: string[] = [];
 
     // NAME section
-    sections.push(this.formatSection('NAME', [
-      `${info.name} - ${info.description}`
-    ]));
+    sections.push(this.formatSection('NAME', [`${info.name} - ${info.description}`]));
 
     // SYNOPSIS section
     if (info.usage) {
@@ -49,23 +47,17 @@ export class HelpFormatter {
 
     // COMMANDS section
     if (info.commands && info.commands.length > 0) {
-      sections.push(this.formatSection('COMMANDS', 
-        this.formatCommands(info.commands)
-      ));
+      sections.push(this.formatSection('COMMANDS', this.formatCommands(info.commands)));
     }
 
     // OPTIONS section
     if (info.options && info.options.length > 0) {
-      sections.push(this.formatSection('OPTIONS',
-        this.formatOptions(info.options)
-      ));
+      sections.push(this.formatSection('OPTIONS', this.formatOptions(info.options)));
     }
 
     // GLOBAL OPTIONS section
     if (info.globalOptions && info.globalOptions.length > 0) {
-      sections.push(this.formatSection('GLOBAL OPTIONS',
-        this.formatOptions(info.globalOptions)
-      ));
+      sections.push(this.formatSection('GLOBAL OPTIONS', this.formatOptions(info.globalOptions)));
     }
 
     // EXAMPLES section
@@ -85,10 +77,7 @@ export class HelpFormatter {
    * Format error message with usage hint
    */
   static formatError(error: string, command: string, usage?: string): string {
-    const lines: string[] = [
-      `Error: ${error}`,
-      ''
-    ];
+    const lines: string[] = [`Error: ${error}`, ''];
 
     if (usage) {
       lines.push(`Usage: ${usage}`);
@@ -106,29 +95,29 @@ export class HelpFormatter {
     value: string,
     paramName: string,
     validOptions: string[],
-    command: string
+    command: string,
   ): string {
     return this.formatError(
       `'${value}' is not a valid ${paramName}. Valid options are: ${validOptions.join(', ')}.`,
-      command
+      command,
     );
   }
 
   private static formatSection(title: string, content: string[]): string {
-    return `${title}\n${content.map(line => `${this.INDENT}${line}`).join('\n')}`;
+    return `${title}\n${content.map((line) => `${this.INDENT}${line}`).join('\n')}`;
   }
 
   private static formatCommands(commands: CommandItem[]): string[] {
     const maxNameLength = Math.max(
       this.MIN_DESCRIPTION_COLUMN,
-      ...commands.map(cmd => {
+      ...commands.map((cmd) => {
         const nameLength = cmd.name.length;
         const aliasLength = cmd.aliases ? ` (${cmd.aliases.join(', ')})`.length : 0;
         return nameLength + aliasLength;
-      })
+      }),
     );
 
-    return commands.map(cmd => {
+    return commands.map((cmd) => {
       let name = cmd.name;
       if (cmd.aliases && cmd.aliases.length > 0) {
         name += ` (${cmd.aliases.join(', ')})`;
@@ -141,25 +130,25 @@ export class HelpFormatter {
   private static formatOptions(options: OptionItem[]): string[] {
     const maxFlagsLength = Math.max(
       this.MIN_DESCRIPTION_COLUMN,
-      ...options.map(opt => opt.flags.length)
+      ...options.map((opt) => opt.flags.length),
     );
 
-    return options.map(opt => {
+    return options.map((opt) => {
       const padding = ' '.repeat(maxFlagsLength - opt.flags.length + this.COLUMN_GAP);
       let description = opt.description;
-      
+
       // Add default value
       if (opt.defaultValue !== undefined) {
         description += ` [default: ${opt.defaultValue}]`;
       }
-      
+
       // Add valid values on next line if present
       if (opt.validValues && opt.validValues.length > 0) {
-        const validValuesLine = ' '.repeat(maxFlagsLength + this.COLUMN_GAP) + 
-          `Valid: ${opt.validValues.join(', ')}`;
+        const validValuesLine =
+          ' '.repeat(maxFlagsLength + this.COLUMN_GAP) + `Valid: ${opt.validValues.join(', ')}`;
         return `${opt.flags}${padding}${description}\n${this.INDENT}${validValuesLine}`;
       }
-      
+
       return `${opt.flags}${padding}${description}`;
     });
   }
@@ -170,14 +159,15 @@ export class HelpFormatter {
   static stripFormatting(text: string): string {
     // Remove ANSI color codes
     text = text.replace(/\x1b\[[0-9;]*m/g, '');
-    
+
     // Remove common emojis used in the CLI
-    const emojiPattern = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{27BF}]|[\u{1F000}-\u{1F6FF}]|[\u{1F680}-\u{1F6FF}]/gu;
+    const emojiPattern =
+      /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{27BF}]|[\u{1F000}-\u{1F6FF}]|[\u{1F680}-\u{1F6FF}]/gu;
     text = text.replace(emojiPattern, '').trim();
-    
+
     // Remove multiple spaces
     text = text.replace(/\s+/g, ' ');
-    
+
     return text;
   }
-}
+}

package/src/cli/help-text.js

@@ -458,7 +458,8 @@ SWARM-INIT OPTIONS:
 
 AGENT-SPAWN OPTIONS:
   --type <type>        Agent type (default: general)
-                       Options: coordinator, developer, researcher, analyzer, tester, general
+                       Options: coordinator, coder, developer, researcher, analyst, analyzer, 
+                       tester, architect, reviewer, optimizer, general
   --name <name>        Custom agent name (auto-generated if not provided)
   --swarm-id <id>      Target swarm for agent coordination
   --capabilities <cap> Custom capabilities specification
@@ -630,7 +631,7 @@ EXAMPLES:
   • Coordination synchronization
   • Error prevention
   • Insight generation
-`
+`,
 };
 
 export function getCommandHelp(command) {
@@ -640,7 +641,7 @@ export function getCommandHelp(command) {
 
 export function getStandardizedCommandHelp(command) {
   const commandConfigs = {
-    'agent': {
+    agent: {
       name: 'claude-flow agent',
       description: 'Manage individual agents',
       usage: 'claude-flow agent <action> [options]',
@@ -650,39 +651,48 @@ export function getStandardizedCommandHelp(command) {
         { name: 'info', description: 'Show agent details' },
         { name: 'terminate', description: 'Stop an agent' },
         { name: 'hierarchy', description: 'Manage agent hierarchies' },
-        { name: 'ecosystem', description: 'View agent ecosystem' }
+        { name: 'ecosystem', description: 'View agent ecosystem' },
       ],
       options: [
         {
           flags: '--type <type>',
           description: 'Agent type',
-          validValues: ['coordinator', 'researcher', 'coder', 'analyst', 'architect', 'tester', 'reviewer', 'optimizer']
+          validValues: [
+            'coordinator',
+            'researcher',
+            'coder',
+            'analyst',
+            'architect',
+            'tester',
+            'reviewer',
+            'optimizer',
+          ],
         },
         {
           flags: '--name <name>',
-          description: 'Agent name'
+          description: 'Agent name',
         },
         {
           flags: '--verbose',
-          description: 'Detailed output'
+          description: 'Detailed output',
         },
         {
           flags: '--json',
-          description: 'Output in JSON format'
+          description: 'Output in JSON format',
         },
         {
           flags: '--help',
-          description: 'Show this help message'
-        }
+          description: 'Show this help message',
+        },
       ],
       examples: [
         'claude-flow agent spawn researcher --name "Research Bot"',
         'claude-flow agent list --json',
         'claude-flow agent terminate agent-123',
-        'claude-flow agent info agent-456 --verbose'
-      ]
+        'claude-flow agent info agent-456 --verbose',
+      ],
     },
-    'sparc': {
+    sparc: {
       name: 'claude-flow sparc',
       description: 'Execute SPARC development modes',
       usage: 'claude-flow sparc <mode> [task] [options]',
@@ -692,35 +702,35 @@ export function getStandardizedCommandHelp(command) {
         { name: 'tdd', description: 'Test-driven development mode' },
         { name: 'integration', description: 'Integration mode - Component connection' },
         { name: 'refactor', description: 'Refactoring mode - Code improvement' },
-        { name: 'modes', description: 'List all available SPARC modes' }
+        { name: 'modes', description: 'List all available SPARC modes' },
       ],
       options: [
         {
           flags: '--file <path>',
-          description: 'Input/output file path'
+          description: 'Input/output file path',
         },
         {
           flags: '--format <type>',
           description: 'Output format',
-          validValues: ['markdown', 'json', 'yaml']
+          validValues: ['markdown', 'json', 'yaml'],
         },
         {
           flags: '--verbose',
-          description: 'Detailed output'
+          description: 'Detailed output',
         },
         {
           flags: '--help',
-          description: 'Show this help message'
-        }
+          description: 'Show this help message',
+        },
       ],
       examples: [
         'claude-flow sparc spec "User authentication system"',
         'claude-flow sparc tdd "Payment processing module"',
         'claude-flow sparc architect "Microservices architecture"',
-        'claude-flow sparc modes'
-      ]
+        'claude-flow sparc modes',
+      ],
     },
-    'memory': {
+    memory: {
       name: 'claude-flow memory',
       description: 'Manage persistent memory operations',
       usage: 'claude-flow memory <action> [key] [value] [options]',
@@ -730,35 +740,35 @@ export function getStandardizedCommandHelp(command) {
         { name: 'list', description: 'List memory namespaces' },
         { name: 'export', description: 'Export memory to file' },
         { name: 'import', description: 'Import memory from file' },
-        { name: 'clear', description: 'Clear memory namespace' }
+        { name: 'clear', description: 'Clear memory namespace' },
       ],
       options: [
         {
           flags: '--namespace <name>',
           description: 'Memory namespace',
-          defaultValue: 'default'
+          defaultValue: 'default',
         },
         {
           flags: '--ttl <seconds>',
-          description: 'Time to live in seconds'
+          description: 'Time to live in seconds',
         },
         {
           flags: '--format <type>',
           description: 'Export format',
-          validValues: ['json', 'yaml']
+          validValues: ['json', 'yaml'],
         },
         {
           flags: '--help',
-          description: 'Show this help message'
-        }
+          description: 'Show this help message',
+        },
       ],
       examples: [
         'claude-flow memory store "api_design" "REST endpoints specification"',
         'claude-flow memory query "authentication"',
         'claude-flow memory export backup.json',
-        'claude-flow memory list --namespace project'
-      ]
-    }
+        'claude-flow memory list --namespace project',
+      ],
+    },
   };
 
   const config = commandConfigs[command];
@@ -766,7 +776,7 @@ export function getStandardizedCommandHelp(command) {
     return HelpFormatter.formatError(
       `Unknown command: ${command}`,
       'claude-flow',
-      'claude-flow <command> --help'
+      'claude-flow <command> --help',
     );
   }
 
@@ -778,7 +788,7 @@ export function getMainHelp(plain = false) {
   if (!plain) {
     return MAIN_HELP;
   }
-  
+
   // Return plain standardized format when requested
   const helpInfo = {
     name: 'claude-flow',
@@ -790,99 +800,99 @@ export function getMainHelp(plain = false) {
       {
         name: 'hive-mind',
         description: 'Manage hive mind swarm intelligence',
-        aliases: ['hm']
+        aliases: ['hm'],
       },
       {
         name: 'init',
-        description: 'Initialize Claude Flow configuration'
+        description: 'Initialize Claude Flow configuration',
       },
       {
         name: 'start',
-        description: 'Start orchestration system'
+        description: 'Start orchestration system',
       },
       {
         name: 'swarm',
-        description: 'Execute multi-agent swarm coordination'
+        description: 'Execute multi-agent swarm coordination',
       },
       {
         name: 'agent',
-        description: 'Manage individual agents'
+        description: 'Manage individual agents',
       },
       {
         name: 'sparc',
-        description: 'Execute SPARC development modes'
+        description: 'Execute SPARC development modes',
       },
       {
         name: 'memory',
-        description: 'Manage persistent memory operations'
+        description: 'Manage persistent memory operations',
       },
       {
         name: 'github',
-        description: 'Automate GitHub workflows'
+        description: 'Automate GitHub workflows',
       },
       {
         name: 'status',
-        description: 'Show system status and health'
+        description: 'Show system status and health',
       },
       {
         name: 'config',
-        description: 'Manage configuration settings'
+        description: 'Manage configuration settings',
       },
       {
         name: 'session',
-        description: 'Manage sessions and state persistence'
+        description: 'Manage sessions and state persistence',
       },
       {
         name: 'terminal',
-        description: 'Terminal pool management'
+        description: 'Terminal pool management',
       },
       {
         name: 'workflow',
-        description: 'Manage automated workflows'
+        description: 'Manage automated workflows',
       },
       {
         name: 'training',
-        description: 'Neural pattern training'
+        description: 'Neural pattern training',
       },
       {
         name: 'coordination',
-        description: 'Swarm coordination commands'
+        description: 'Swarm coordination commands',
       },
       {
         name: 'help',
-        description: 'Show help information'
-      }
+        description: 'Show help information',
+      },
     ],
     globalOptions: [
       {
         flags: '--config <path>',
         description: 'Configuration file path',
-        defaultValue: '.claude/config.json'
+        defaultValue: '.claude/config.json',
       },
       {
         flags: '--verbose',
-        description: 'Enable verbose output'
+        description: 'Enable verbose output',
       },
       {
         flags: '--quiet',
-        description: 'Suppress non-error output'
+        description: 'Suppress non-error output',
       },
       {
         flags: '--json',
-        description: 'Output in JSON format'
+        description: 'Output in JSON format',
       },
       {
         flags: '--plain',
-        description: 'Show plain help without emojis'
+        description: 'Show plain help without emojis',
       },
       {
         flags: '--help',
-        description: 'Show help information'
+        description: 'Show help information',
       },
       {
         flags: '--version',
-        description: 'Show version information'
-      }
+        description: 'Show version information',
+      },
     ],
     examples: [
       'npx claude-flow@alpha init --sparc',
@@ -890,9 +900,9 @@ export function getMainHelp(plain = false) {
       'claude-flow swarm "Build REST API"',
       'claude-flow agent spawn researcher --name "Research Bot"',
       'claude-flow status --json',
-      'claude-flow memory query "API design"'
-    ]
+      'claude-flow memory query "API design"',
+    ],
   };
 
   return HelpFormatter.formatHelp(helpInfo);
-}
+}

package/src/cli/index-remote.ts

@@ -1,5 +1,4 @@
 #!/usr/bin/env -S deno run --allow-all
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Claude-Flow CLI entry point - Remote execution friendly version
  * This version can be run directly from GitHub
@@ -80,13 +79,13 @@ async function main() {
     case 'help':
       printHelp();
       break;
-      
+
     case '--version':
     case '-v':
     case 'version':
       console.log(`Claude-Flow v${VERSION}`);
       break;
-      
+
     case 'init':
       printSuccess('Initializing Claude Code integration files...');
       console.log('📝 This command would create:');
@@ -100,7 +99,7 @@ async function main() {
       console.log('   npm install -g claude-flow');
       console.log('   claude-flow init');
       break;
-      
+
     case 'install':
       console.log(chalk.blue('📦 Installing Claude-Flow...'));
       console.log('\nRun these commands to install:');
@@ -109,21 +108,25 @@ async function main() {
       console.log('');
       console.log(chalk.gray('  # Or using Deno'));
       console.log('  deno install --allow-all --name claude-flow \\');
-      console.log('    https://raw.githubusercontent.com/ruvnet/claude-code-flow/main/src/cli/index.ts');
+      console.log(
+        '    https://raw.githubusercontent.com/ruvnet/claude-code-flow/main/src/cli/index.ts',
+      );
       console.log('');
       console.log(chalk.gray('  # Or clone and build from source'));
       console.log('  git clone https://github.com/ruvnet/claude-code-flow.git');
       console.log('  cd claude-code-flow');
       console.log('  deno task build');
       break;
-      
+
     default:
       printWarning(`Command '${command}' requires local installation.`);
       console.log('\n📥 To use all features, install Claude-Flow:');
       console.log('   npm install -g claude-flow');
       console.log('\n🌐 Or run directly with Deno:');
       console.log('   deno install --allow-all --name claude-flow \\');
-      console.log('     https://raw.githubusercontent.com/ruvnet/claude-code-flow/main/src/cli/index.ts');
+      console.log(
+        '     https://raw.githubusercontent.com/ruvnet/claude-code-flow/main/src/cli/index.ts',
+      );
       console.log('\n📚 Documentation: https://github.com/ruvnet/claude-code-flow');
       console.log('💬 Issues: https://github.com/ruvnet/claude-code-flow/issues');
       break;
@@ -132,7 +135,7 @@ async function main() {
 
 if (import.meta.url === `file://${Deno.execPath()}`) {
   main().catch((error) => {
-    printError(`Error: ${(error instanceof Error ? error.message : String(error))}`);
+    printError(`Error: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   });
-}
+}