@claude-flow/cli 3.0.0-alpha.13 → 3.0.0-alpha.14

package/src/commands/performance.ts

@@ -1,292 +0,0 @@
-/**
- * V3 CLI Performance Command
- * Performance profiling, benchmarking, optimization, metrics
- *
- * Created with ❤️ by ruv.io
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-
-// Benchmark subcommand
-const benchmarkCommand: Command = {
-  name: 'benchmark',
-  description: 'Run performance benchmarks',
-  options: [
-    { name: 'suite', short: 's', type: 'string', description: 'Benchmark suite: all, wasm, neural, memory, search', default: 'all' },
-    { name: 'iterations', short: 'i', type: 'number', description: 'Number of iterations', default: '100' },
-    { name: 'warmup', short: 'w', type: 'number', description: 'Warmup iterations', default: '10' },
-    { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json, csv', default: 'text' },
-  ],
-  examples: [
-    { command: 'claude-flow performance benchmark -s neural', description: 'Benchmark neural operations' },
-    { command: 'claude-flow performance benchmark -i 1000', description: 'Run with 1000 iterations' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const suite = ctx.flags.suite as string || 'all';
-    const iterations = parseInt(ctx.flags.iterations as string || '100', 10);
-
-    output.writeln();
-    output.writeln(output.bold('Performance Benchmark'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: `Running ${suite} benchmarks...`, spinner: 'dots' });
-    spinner.start();
-
-    const benchmarks = ['WASM SIMD', 'Flash Attention', 'HNSW Search', 'Memory Ops', 'Neural Inference'];
-    for (const bench of benchmarks) {
-      spinner.setText(`Benchmarking ${bench}...`);
-      await new Promise(r => setTimeout(r, 300));
-    }
-
-    spinner.succeed(`Completed ${iterations} iterations`);
-
-    output.writeln();
-    output.printTable({
-      columns: [
-        { key: 'operation', header: 'Operation', width: 20 },
-        { key: 'mean', header: 'Mean', width: 12 },
-        { key: 'p95', header: 'P95', width: 12 },
-        { key: 'p99', header: 'P99', width: 12 },
-        { key: 'improvement', header: 'vs Baseline', width: 15 },
-      ],
-      data: [
-        { operation: 'WASM SIMD MatMul', mean: '0.42ms', p95: '0.58ms', p99: '0.71ms', improvement: output.success('+4.2x') },
-        { operation: 'Flash Attention', mean: '1.23ms', p95: '1.45ms', p99: '1.67ms', improvement: output.success('+2.49x') },
-        { operation: 'HNSW Search', mean: '0.08ms', p95: '0.12ms', p99: '0.15ms', improvement: output.success('+150x') },
-        { operation: 'Memory Store', mean: '0.15ms', p95: '0.22ms', p99: '0.28ms', improvement: output.success('+3.1x') },
-        { operation: 'Neural Inference', mean: '12.4ms', p95: '15.2ms', p99: '18.1ms', improvement: output.success('+2.8x') },
-      ],
-    });
-
-    output.writeln();
-    output.printBox([
-      `Suite: ${suite}`,
-      `Iterations: ${iterations}`,
-      `Total Time: 2.34s`,
-      ``,
-      `Overall Performance: ${output.success('Excellent')}`,
-      `All targets met or exceeded`,
-    ].join('\n'), 'Benchmark Summary');
-
-    return { success: true };
-  },
-};
-
-// Profile subcommand
-const profileCommand: Command = {
-  name: 'profile',
-  description: 'Profile application performance',
-  options: [
-    { name: 'type', short: 't', type: 'string', description: 'Profile type: cpu, memory, io, all', default: 'all' },
-    { name: 'duration', short: 'd', type: 'number', description: 'Duration in seconds', default: '30' },
-    { name: 'output', short: 'o', type: 'string', description: 'Output file for profile data' },
-  ],
-  examples: [
-    { command: 'claude-flow performance profile -t cpu', description: 'Profile CPU usage' },
-    { command: 'claude-flow performance profile -d 60', description: 'Profile for 60 seconds' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const type = ctx.flags.type as string || 'all';
-    const duration = parseInt(ctx.flags.duration as string || '30', 10);
-
-    output.writeln();
-    output.writeln(output.bold('Performance Profiler'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: 'Collecting profile data...', spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 1000));
-    spinner.succeed('Profile complete');
-
-    output.writeln();
-    output.printTable({
-      columns: [
-        { key: 'metric', header: 'Metric', width: 25 },
-        { key: 'current', header: 'Current', width: 15 },
-        { key: 'peak', header: 'Peak', width: 15 },
-        { key: 'status', header: 'Status', width: 15 },
-      ],
-      data: [
-        { metric: 'CPU Usage', current: '23%', peak: '67%', status: output.success('Normal') },
-        { metric: 'Memory (Heap)', current: '145 MB', peak: '312 MB', status: output.success('Normal') },
-        { metric: 'Memory (RSS)', current: '287 MB', peak: '456 MB', status: output.success('Normal') },
-        { metric: 'Event Loop Lag', current: '1.2ms', peak: '8.4ms', status: output.success('Normal') },
-        { metric: 'Active Handles', current: '24', peak: '89', status: output.success('Normal') },
-        { metric: 'GC Pause Time', current: '2.1ms', peak: '12.3ms', status: output.warning('Elevated') },
-      ],
-    });
-
-    return { success: true };
-  },
-};
-
-// Metrics subcommand
-const metricsCommand: Command = {
-  name: 'metrics',
-  description: 'View and export performance metrics',
-  options: [
-    { name: 'timeframe', short: 't', type: 'string', description: 'Timeframe: 1h, 24h, 7d, 30d', default: '24h' },
-    { name: 'format', short: 'f', type: 'string', description: 'Output format: text, json, prometheus', default: 'text' },
-    { name: 'component', short: 'c', type: 'string', description: 'Component to filter' },
-  ],
-  examples: [
-    { command: 'claude-flow performance metrics -t 7d', description: 'Show 7-day metrics' },
-    { command: 'claude-flow performance metrics -f prometheus', description: 'Export as Prometheus format' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const timeframe = ctx.flags.timeframe as string || '24h';
-
-    output.writeln();
-    output.writeln(output.bold(`Performance Metrics (${timeframe})`));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    output.printTable({
-      columns: [
-        { key: 'metric', header: 'Metric', width: 25 },
-        { key: 'avg', header: 'Avg', width: 12 },
-        { key: 'min', header: 'Min', width: 12 },
-        { key: 'max', header: 'Max', width: 12 },
-        { key: 'trend', header: 'Trend', width: 12 },
-      ],
-      data: [
-        { metric: 'Request Latency', avg: '45ms', min: '12ms', max: '234ms', trend: output.success('↓ 12%') },
-        { metric: 'Throughput', avg: '1,247/s', min: '892/s', max: '2,103/s', trend: output.success('↑ 8%') },
-        { metric: 'Error Rate', avg: '0.12%', min: '0%', max: '0.89%', trend: output.success('↓ 45%') },
-        { metric: 'Cache Hit Rate', avg: '94.2%', min: '87.1%', max: '98.7%', trend: output.success('↑ 3%') },
-        { metric: 'Token Usage', avg: '45K/h', min: '12K/h', max: '89K/h', trend: output.warning('↑ 15%') },
-      ],
-    });
-
-    return { success: true };
-  },
-};
-
-// Optimize subcommand
-const optimizeCommand: Command = {
-  name: 'optimize',
-  description: 'Run performance optimization recommendations',
-  options: [
-    { name: 'target', short: 't', type: 'string', description: 'Target: memory, cpu, latency, all', default: 'all' },
-    { name: 'apply', short: 'a', type: 'boolean', description: 'Apply recommended optimizations' },
-    { name: 'dry-run', short: 'd', type: 'boolean', description: 'Show changes without applying' },
-  ],
-  examples: [
-    { command: 'claude-flow performance optimize -t memory', description: 'Optimize memory usage' },
-    { command: 'claude-flow performance optimize --apply', description: 'Apply all optimizations' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const target = ctx.flags.target as string || 'all';
-
-    output.writeln();
-    output.writeln(output.bold('Performance Optimization'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: 'Analyzing performance...', spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 800));
-    spinner.succeed('Analysis complete');
-
-    output.writeln();
-    output.writeln(output.bold('Recommendations:'));
-    output.writeln();
-
-    output.printTable({
-      columns: [
-        { key: 'priority', header: 'Priority', width: 10 },
-        { key: 'area', header: 'Area', width: 15 },
-        { key: 'recommendation', header: 'Recommendation', width: 40 },
-        { key: 'impact', header: 'Impact', width: 15 },
-      ],
-      data: [
-        { priority: output.error('P0'), area: 'Memory', recommendation: 'Enable HNSW index quantization', impact: '+50% reduction' },
-        { priority: output.warning('P1'), area: 'CPU', recommendation: 'Enable WASM SIMD acceleration', impact: '+4x speedup' },
-        { priority: output.warning('P1'), area: 'Latency', recommendation: 'Enable Flash Attention', impact: '+2.49x speedup' },
-        { priority: output.info('P2'), area: 'Cache', recommendation: 'Increase pattern cache size', impact: '+15% hit rate' },
-        { priority: output.info('P2'), area: 'Network', recommendation: 'Enable request batching', impact: '-30% latency' },
-      ],
-    });
-
-    return { success: true };
-  },
-};
-
-// Bottleneck subcommand
-const bottleneckCommand: Command = {
-  name: 'bottleneck',
-  description: 'Identify performance bottlenecks',
-  options: [
-    { name: 'component', short: 'c', type: 'string', description: 'Component to analyze' },
-    { name: 'depth', short: 'd', type: 'string', description: 'Analysis depth: quick, full', default: 'quick' },
-  ],
-  examples: [
-    { command: 'claude-flow performance bottleneck', description: 'Find bottlenecks' },
-    { command: 'claude-flow performance bottleneck -d full', description: 'Full analysis' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Bottleneck Analysis'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: 'Analyzing system...', spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 600));
-    spinner.succeed('Analysis complete');
-
-    output.writeln();
-    output.printTable({
-      columns: [
-        { key: 'component', header: 'Component', width: 20 },
-        { key: 'bottleneck', header: 'Bottleneck', width: 25 },
-        { key: 'severity', header: 'Severity', width: 12 },
-        { key: 'solution', header: 'Solution', width: 30 },
-      ],
-      data: [
-        { component: 'Vector Search', bottleneck: 'Linear scan O(n)', severity: output.error('High'), solution: 'Enable HNSW indexing' },
-        { component: 'Neural Inference', bottleneck: 'Sequential attention', severity: output.warning('Medium'), solution: 'Enable Flash Attention' },
-        { component: 'Memory Store', bottleneck: 'Lock contention', severity: output.info('Low'), solution: 'Use sharded storage' },
-      ],
-    });
-
-    return { success: true };
-  },
-};
-
-// Main performance command
-export const performanceCommand: Command = {
-  name: 'performance',
-  description: 'Performance profiling, benchmarking, optimization, metrics',
-  aliases: ['perf'],
-  subcommands: [benchmarkCommand, profileCommand, metricsCommand, optimizeCommand, bottleneckCommand],
-  examples: [
-    { command: 'claude-flow performance benchmark', description: 'Run benchmarks' },
-    { command: 'claude-flow performance profile', description: 'Profile application' },
-    { command: 'claude-flow perf metrics', description: 'View metrics (alias)' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Claude Flow Performance Suite'));
-    output.writeln(output.dim('Advanced performance profiling and optimization'));
-    output.writeln();
-    output.writeln('Subcommands:');
-    output.printList([
-      'benchmark  - Run performance benchmarks (WASM, neural, search)',
-      'profile    - Profile CPU, memory, I/O usage',
-      'metrics    - View and export performance metrics',
-      'optimize   - Get optimization recommendations',
-      'bottleneck - Identify performance bottlenecks',
-    ]);
-    output.writeln();
-    output.writeln('Performance Targets:');
-    output.printList([
-      'HNSW Search: 150x-12,500x faster than brute force',
-      'Flash Attention: 2.49x-7.47x speedup',
-      'Memory: 50-75% reduction with quantization',
-    ]);
-    output.writeln();
-    output.writeln(output.dim('Created with ❤️ by ruv.io'));
-    return { success: true };
-  },
-};
-
-export default performanceCommand;

package/src/commands/plugins.ts

@@ -1,316 +0,0 @@
-/**
- * V3 CLI Plugins Command
- * Plugin management, installation, and lifecycle
- *
- * Created with ❤️ by ruv.io
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-
-// List subcommand
-const listCommand: Command = {
-  name: 'list',
-  description: 'List installed and available plugins',
-  options: [
-    { name: 'installed', short: 'i', type: 'boolean', description: 'Show only installed plugins' },
-    { name: 'available', short: 'a', type: 'boolean', description: 'Show available plugins from registry' },
-    { name: 'category', short: 'c', type: 'string', description: 'Filter by category' },
-  ],
-  examples: [
-    { command: 'claude-flow plugins list', description: 'List all plugins' },
-    { command: 'claude-flow plugins list --installed', description: 'List installed only' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const installedOnly = ctx.flags.installed as boolean;
-
-    output.writeln();
-    output.writeln(output.bold(installedOnly ? 'Installed Plugins' : 'All Plugins'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    output.printTable({
-      columns: [
-        { key: 'name', header: 'Plugin', width: 22 },
-        { key: 'version', header: 'Version', width: 10 },
-        { key: 'category', header: 'Category', width: 15 },
-        { key: 'status', header: 'Status', width: 12 },
-      ],
-      data: [
-        { name: '@claude-flow/neural', version: '3.0.0', category: 'AI/ML', status: output.success('Active') },
-        { name: '@claude-flow/security', version: '3.0.0', category: 'Security', status: output.success('Active') },
-        { name: '@claude-flow/performance', version: '3.0.0', category: 'DevOps', status: output.success('Active') },
-        { name: '@claude-flow/embeddings', version: '3.0.0', category: 'AI/ML', status: output.success('Active') },
-        { name: '@claude-flow/claims', version: '3.0.0', category: 'Auth', status: output.success('Active') },
-        { name: 'community-analytics', version: '1.2.0', category: 'Analytics', status: output.dim('Available') },
-        { name: 'custom-agents', version: '2.0.1', category: 'Agents', status: output.dim('Available') },
-      ],
-    });
-
-    return { success: true };
-  },
-};
-
-// Install subcommand
-const installCommand: Command = {
-  name: 'install',
-  description: 'Install a plugin from registry or local path',
-  options: [
-    { name: 'name', short: 'n', type: 'string', description: 'Plugin name or path', required: true },
-    { name: 'version', short: 'v', type: 'string', description: 'Specific version to install' },
-    { name: 'global', short: 'g', type: 'boolean', description: 'Install globally' },
-    { name: 'dev', short: 'd', type: 'boolean', description: 'Install as dev dependency' },
-  ],
-  examples: [
-    { command: 'claude-flow plugins install -n community-analytics', description: 'Install plugin' },
-    { command: 'claude-flow plugins install -n ./my-plugin --dev', description: 'Install local plugin' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const name = ctx.flags.name as string;
-    const version = ctx.flags.version as string || 'latest';
-
-    if (!name) {
-      output.printError('Plugin name is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Installing Plugin'));
-    output.writeln(output.dim('─'.repeat(40)));
-
-    const spinner = output.createSpinner({ text: `Resolving ${name}@${version}...`, spinner: 'dots' });
-    spinner.start();
-
-    const steps = ['Downloading package', 'Verifying integrity', 'Installing dependencies', 'Registering hooks'];
-    for (const step of steps) {
-      spinner.setText(step + '...');
-      await new Promise(r => setTimeout(r, 300));
-    }
-
-    spinner.succeed(`Installed ${name}@${version}`);
-
-    output.writeln();
-    output.printBox([
-      `Plugin: ${name}`,
-      `Version: ${version}`,
-      `Location: node_modules/${name}`,
-      ``,
-      `Hooks registered: 3`,
-      `Commands added: 2`,
-    ].join('\n'), 'Installation Complete');
-
-    return { success: true };
-  },
-};
-
-// Uninstall subcommand
-const uninstallCommand: Command = {
-  name: 'uninstall',
-  description: 'Uninstall a plugin',
-  options: [
-    { name: 'name', short: 'n', type: 'string', description: 'Plugin name', required: true },
-    { name: 'force', short: 'f', type: 'boolean', description: 'Force uninstall without confirmation' },
-  ],
-  examples: [
-    { command: 'claude-flow plugins uninstall -n community-analytics', description: 'Uninstall plugin' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const name = ctx.flags.name as string;
-
-    if (!name) {
-      output.printError('Plugin name is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    const spinner = output.createSpinner({ text: `Uninstalling ${name}...`, spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 500));
-    spinner.succeed(`Uninstalled ${name}`);
-
-    return { success: true };
-  },
-};
-
-// Enable/Disable subcommand
-const toggleCommand: Command = {
-  name: 'toggle',
-  description: 'Enable or disable a plugin',
-  options: [
-    { name: 'name', short: 'n', type: 'string', description: 'Plugin name', required: true },
-    { name: 'enable', short: 'e', type: 'boolean', description: 'Enable the plugin' },
-    { name: 'disable', short: 'd', type: 'boolean', description: 'Disable the plugin' },
-  ],
-  examples: [
-    { command: 'claude-flow plugins toggle -n analytics --enable', description: 'Enable plugin' },
-    { command: 'claude-flow plugins toggle -n analytics --disable', description: 'Disable plugin' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const name = ctx.flags.name as string;
-    const enable = ctx.flags.enable as boolean;
-
-    if (!name) {
-      output.printError('Plugin name is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    const action = enable ? 'Enabling' : 'Disabling';
-    const spinner = output.createSpinner({ text: `${action} ${name}...`, spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 300));
-    spinner.succeed(`${name} ${enable ? 'enabled' : 'disabled'}`);
-
-    return { success: true };
-  },
-};
-
-// Info subcommand
-const infoCommand: Command = {
-  name: 'info',
-  description: 'Show detailed plugin information',
-  options: [
-    { name: 'name', short: 'n', type: 'string', description: 'Plugin name', required: true },
-  ],
-  examples: [
-    { command: 'claude-flow plugins info -n @claude-flow/neural', description: 'Show plugin info' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const name = ctx.flags.name as string;
-
-    if (!name) {
-      output.printError('Plugin name is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold(`Plugin: ${name}`));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    output.printBox([
-      `Name: ${name}`,
-      `Version: 3.0.0`,
-      `Author: ruv.io`,
-      `License: MIT`,
-      ``,
-      `Description:`,
-      `  Neural pattern training and inference with`,
-      `  WASM SIMD acceleration, MoE routing, and`,
-      `  Flash Attention optimization.`,
-      ``,
-      `Dependencies:`,
-      `  - @claude-flow/core ^3.0.0`,
-      `  - onnxruntime-web ^1.17.0`,
-      ``,
-      `Hooks:`,
-      `  - neural:train (pre, post)`,
-      `  - neural:inference (pre, post)`,
-      `  - pattern:learn`,
-      ``,
-      `Commands:`,
-      `  - neural train`,
-      `  - neural predict`,
-      `  - neural patterns`,
-    ].join('\n'), 'Plugin Details');
-
-    return { success: true };
-  },
-};
-
-// Create subcommand
-const createCommand: Command = {
-  name: 'create',
-  description: 'Scaffold a new plugin project',
-  options: [
-    { name: 'name', short: 'n', type: 'string', description: 'Plugin name', required: true },
-    { name: 'template', short: 't', type: 'string', description: 'Template: basic, advanced, hooks', default: 'basic' },
-    { name: 'path', short: 'p', type: 'string', description: 'Output path', default: '.' },
-  ],
-  examples: [
-    { command: 'claude-flow plugins create -n my-plugin', description: 'Create basic plugin' },
-    { command: 'claude-flow plugins create -n my-plugin -t hooks', description: 'Create hooks plugin' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const name = ctx.flags.name as string;
-    const template = ctx.flags.template as string || 'basic';
-
-    if (!name) {
-      output.printError('Plugin name is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Creating Plugin'));
-    output.writeln(output.dim('─'.repeat(40)));
-
-    const spinner = output.createSpinner({ text: 'Scaffolding project...', spinner: 'dots' });
-    spinner.start();
-
-    const files = ['package.json', 'src/index.ts', 'src/hooks.ts', 'README.md', 'tsconfig.json'];
-    for (const file of files) {
-      spinner.setText(`Creating ${file}...`);
-      await new Promise(r => setTimeout(r, 150));
-    }
-
-    spinner.succeed('Plugin scaffolded');
-
-    output.writeln();
-    output.printBox([
-      `Plugin: ${name}`,
-      `Template: ${template}`,
-      `Location: ./${name}/`,
-      ``,
-      `Files created:`,
-      `  - package.json`,
-      `  - src/index.ts`,
-      `  - src/hooks.ts`,
-      `  - README.md`,
-      `  - tsconfig.json`,
-      ``,
-      `Next steps:`,
-      `  cd ${name}`,
-      `  npm install`,
-      `  npm run build`,
-    ].join('\n'), 'Success');
-
-    return { success: true };
-  },
-};
-
-// Main plugins command
-export const pluginsCommand: Command = {
-  name: 'plugins',
-  description: 'Plugin management, installation, and lifecycle',
-  subcommands: [listCommand, installCommand, uninstallCommand, toggleCommand, infoCommand, createCommand],
-  examples: [
-    { command: 'claude-flow plugins list', description: 'List all plugins' },
-    { command: 'claude-flow plugins install -n my-plugin', description: 'Install a plugin' },
-    { command: 'claude-flow plugins create -n my-plugin', description: 'Create new plugin' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Claude Flow Plugin System'));
-    output.writeln(output.dim('Extensible plugin architecture'));
-    output.writeln();
-    output.writeln('Subcommands:');
-    output.printList([
-      'list      - List installed and available plugins',
-      'install   - Install a plugin from registry or local path',
-      'uninstall - Remove an installed plugin',
-      'toggle    - Enable or disable a plugin',
-      'info      - Show detailed plugin information',
-      'create    - Scaffold a new plugin project',
-    ]);
-    output.writeln();
-    output.writeln('Core Plugins:');
-    output.printList([
-      '@claude-flow/neural     - Neural patterns and inference',
-      '@claude-flow/security   - Security scanning and CVE detection',
-      '@claude-flow/embeddings - Vector embeddings service',
-      '@claude-flow/claims     - Claims-based authorization',
-    ]);
-    output.writeln();
-    output.writeln(output.dim('Created with ❤️ by ruv.io'));
-    return { success: true };
-  },
-};
-
-export default pluginsCommand;