@claude-flow/cli 3.0.0-alpha.8 → 3.0.0-alpha.81

package/src/commands/daemon.ts

@@ -1,395 +0,0 @@
-/**
- * V3 CLI Daemon Command
- * Manages background worker daemon (Node.js-based, similar to shell helpers)
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-import { WorkerDaemon, getDaemon, startDaemon, stopDaemon, type WorkerType } from '../services/worker-daemon.js';
-
-// Start daemon subcommand
-const startCommand: Command = {
-  name: 'start',
-  description: 'Start the worker daemon with all enabled background workers',
-  options: [
-    { name: 'workers', short: 'w', type: 'string', description: 'Comma-separated list of workers to enable (default: map,audit,optimize,consolidate,testgaps)' },
-    { name: 'quiet', short: 'q', type: 'boolean', description: 'Suppress output' },
-  ],
-  examples: [
-    { command: 'claude-flow daemon start', description: 'Start daemon with default workers' },
-    { command: 'claude-flow daemon start -w map,audit,optimize', description: 'Start with specific workers' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const quiet = ctx.flags.quiet as boolean;
-    const projectRoot = process.cwd();
-
-    try {
-      if (!quiet) {
-        const spinner = output.createSpinner({ text: 'Starting worker daemon...', spinner: 'dots' });
-        spinner.start();
-
-        const daemon = await startDaemon(projectRoot);
-        const status = daemon.getStatus();
-
-        spinner.succeed('Worker daemon started');
-
-        output.writeln();
-        output.printBox(
-          [
-            `PID: ${status.pid}`,
-            `Started: ${status.startedAt?.toISOString()}`,
-            `Workers: ${status.config.workers.filter(w => w.enabled).length} enabled`,
-            `Max Concurrent: ${status.config.maxConcurrent}`,
-          ].join('\n'),
-          'Daemon Status'
-        );
-
-        output.writeln();
-        output.writeln(output.bold('Scheduled Workers'));
-        output.printTable({
-          columns: [
-            { key: 'type', header: 'Worker', width: 15 },
-            { key: 'interval', header: 'Interval', width: 12 },
-            { key: 'priority', header: 'Priority', width: 10 },
-            { key: 'description', header: 'Description', width: 30 },
-          ],
-          data: status.config.workers
-            .filter(w => w.enabled)
-            .map(w => ({
-              type: output.highlight(w.type),
-              interval: `${Math.round(w.intervalMs / 60000)}min`,
-              priority: w.priority === 'critical' ? output.error(w.priority) :
-                       w.priority === 'high' ? output.warning(w.priority) :
-                       output.dim(w.priority),
-              description: w.description,
-            })),
-        });
-
-        // Listen for worker events
-        daemon.on('worker:start', ({ type }: { type: string }) => {
-          output.writeln(output.dim(`[daemon] Worker starting: ${type}`));
-        });
-
-        daemon.on('worker:complete', ({ type, durationMs }: { type: string; durationMs: number }) => {
-          output.writeln(output.success(`[daemon] Worker completed: ${type} (${durationMs}ms)`));
-        });
-
-        daemon.on('worker:error', ({ type, error }: { type: string; error: string }) => {
-          output.writeln(output.error(`[daemon] Worker failed: ${type} - ${error}`));
-        });
-      } else {
-        await startDaemon(projectRoot);
-      }
-
-      return { success: true };
-    } catch (error) {
-      output.printError(`Failed to start daemon: ${error instanceof Error ? error.message : String(error)}`);
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Stop daemon subcommand
-const stopCommand: Command = {
-  name: 'stop',
-  description: 'Stop the worker daemon and all background workers',
-  options: [
-    { name: 'quiet', short: 'q', type: 'boolean', description: 'Suppress output' },
-  ],
-  examples: [
-    { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const quiet = ctx.flags.quiet as boolean;
-
-    try {
-      if (!quiet) {
-        const spinner = output.createSpinner({ text: 'Stopping worker daemon...', spinner: 'dots' });
-        spinner.start();
-
-        await stopDaemon();
-
-        spinner.succeed('Worker daemon stopped');
-      } else {
-        await stopDaemon();
-      }
-
-      return { success: true };
-    } catch (error) {
-      output.printError(`Failed to stop daemon: ${error instanceof Error ? error.message : String(error)}`);
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Status subcommand
-const statusCommand: Command = {
-  name: 'status',
-  description: 'Show daemon and worker status',
-  options: [
-    { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed worker statistics' },
-  ],
-  examples: [
-    { command: 'claude-flow daemon status', description: 'Show daemon status' },
-    { command: 'claude-flow daemon status -v', description: 'Show detailed status' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const verbose = ctx.flags.verbose as boolean;
-
-    try {
-      const daemon = getDaemon(process.cwd());
-      const status = daemon.getStatus();
-
-      output.writeln();
-
-      // Daemon status box
-      const statusIcon = status.running ? output.success('●') : output.error('○');
-      const statusText = status.running ? output.success('RUNNING') : output.error('STOPPED');
-
-      output.printBox(
-        [
-          `Status: ${statusIcon} ${statusText}`,
-          `PID: ${status.pid}`,
-          status.startedAt ? `Started: ${status.startedAt.toISOString()}` : '',
-          `Workers Enabled: ${status.config.workers.filter(w => w.enabled).length}`,
-          `Max Concurrent: ${status.config.maxConcurrent}`,
-        ].filter(Boolean).join('\n'),
-        'Worker Daemon'
-      );
-
-      output.writeln();
-      output.writeln(output.bold('Worker Status'));
-
-      const workerData = status.config.workers.map(w => {
-        const state = status.workers.get(w.type);
-        return {
-          type: w.enabled ? output.highlight(w.type) : output.dim(w.type),
-          enabled: w.enabled ? output.success('✓') : output.dim('○'),
-          status: state?.isRunning ? output.warning('running') :
-                  w.enabled ? output.success('idle') : output.dim('disabled'),
-          runs: state?.runCount ?? 0,
-          success: state ? `${Math.round((state.successCount / Math.max(state.runCount, 1)) * 100)}%` : '-',
-          lastRun: state?.lastRun ? formatTimeAgo(state.lastRun) : output.dim('never'),
-          nextRun: state?.nextRun && w.enabled ? formatTimeUntil(state.nextRun) : output.dim('-'),
-        };
-      });
-
-      output.printTable({
-        columns: [
-          { key: 'type', header: 'Worker', width: 12 },
-          { key: 'enabled', header: 'On', width: 4 },
-          { key: 'status', header: 'Status', width: 10 },
-          { key: 'runs', header: 'Runs', width: 6 },
-          { key: 'success', header: 'Success', width: 8 },
-          { key: 'lastRun', header: 'Last Run', width: 12 },
-          { key: 'nextRun', header: 'Next Run', width: 12 },
-        ],
-        data: workerData,
-      });
-
-      if (verbose) {
-        output.writeln();
-        output.writeln(output.bold('Worker Configuration'));
-        output.printTable({
-          columns: [
-            { key: 'type', header: 'Worker', width: 12 },
-            { key: 'interval', header: 'Interval', width: 10 },
-            { key: 'priority', header: 'Priority', width: 10 },
-            { key: 'avgDuration', header: 'Avg Duration', width: 12 },
-            { key: 'description', header: 'Description', width: 30 },
-          ],
-          data: status.config.workers.map(w => {
-            const state = status.workers.get(w.type);
-            return {
-              type: w.type,
-              interval: `${Math.round(w.intervalMs / 60000)}min`,
-              priority: w.priority,
-              avgDuration: state?.averageDurationMs ? `${Math.round(state.averageDurationMs)}ms` : '-',
-              description: w.description,
-            };
-          }),
-        });
-      }
-
-      return { success: true, data: status };
-    } catch (error) {
-      // Daemon not initialized
-      output.writeln();
-      output.printBox(
-        [
-          `Status: ${output.error('○')} ${output.error('NOT INITIALIZED')}`,
-          '',
-          'Run "claude-flow daemon start" to start the daemon',
-        ].join('\n'),
-        'Worker Daemon'
-      );
-
-      return { success: true };
-    }
-  },
-};
-
-// Trigger subcommand - manually run a worker
-const triggerCommand: Command = {
-  name: 'trigger',
-  description: 'Manually trigger a specific worker',
-  options: [
-    { name: 'worker', short: 'w', type: 'string', description: 'Worker type to trigger', required: true },
-  ],
-  examples: [
-    { command: 'claude-flow daemon trigger -w map', description: 'Trigger the map worker' },
-    { command: 'claude-flow daemon trigger -w audit', description: 'Trigger security audit' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const workerType = ctx.flags.worker as WorkerType;
-
-    if (!workerType) {
-      output.printError('Worker type is required. Use --worker or -w flag.');
-      output.writeln();
-      output.writeln('Available workers: map, audit, optimize, consolidate, testgaps, predict, document, ultralearn, refactor, benchmark, deepdive, preload');
-      return { success: false, exitCode: 1 };
-    }
-
-    try {
-      const daemon = getDaemon(process.cwd());
-
-      const spinner = output.createSpinner({ text: `Running ${workerType} worker...`, spinner: 'dots' });
-      spinner.start();
-
-      const result = await daemon.triggerWorker(workerType);
-
-      if (result.success) {
-        spinner.succeed(`Worker ${workerType} completed in ${result.durationMs}ms`);
-
-        if (result.output) {
-          output.writeln();
-          output.writeln(output.bold('Output'));
-          output.printJson(result.output);
-        }
-      } else {
-        spinner.fail(`Worker ${workerType} failed: ${result.error}`);
-      }
-
-      return { success: result.success, data: result };
-    } catch (error) {
-      output.printError(`Failed to trigger worker: ${error instanceof Error ? error.message : String(error)}`);
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Enable/disable worker subcommand
-const enableCommand: Command = {
-  name: 'enable',
-  description: 'Enable or disable a specific worker',
-  options: [
-    { name: 'worker', short: 'w', type: 'string', description: 'Worker type', required: true },
-    { name: 'disable', short: 'd', type: 'boolean', description: 'Disable instead of enable' },
-  ],
-  examples: [
-    { command: 'claude-flow daemon enable -w predict', description: 'Enable predict worker' },
-    { command: 'claude-flow daemon enable -w document --disable', description: 'Disable document worker' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const workerType = ctx.flags.worker as WorkerType;
-    const disable = ctx.flags.disable as boolean;
-
-    if (!workerType) {
-      output.printError('Worker type is required. Use --worker or -w flag.');
-      return { success: false, exitCode: 1 };
-    }
-
-    try {
-      const daemon = getDaemon(process.cwd());
-      daemon.setWorkerEnabled(workerType, !disable);
-
-      output.printSuccess(`Worker ${workerType} ${disable ? 'disabled' : 'enabled'}`);
-
-      return { success: true };
-    } catch (error) {
-      output.printError(`Failed to ${disable ? 'disable' : 'enable'} worker: ${error instanceof Error ? error.message : String(error)}`);
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Helper functions for time formatting
-function formatTimeAgo(date: Date): string {
-  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
-
-  if (seconds < 60) return `${seconds}s ago`;
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
-  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
-  return `${Math.floor(seconds / 86400)}d ago`;
-}
-
-function formatTimeUntil(date: Date): string {
-  const seconds = Math.floor((date.getTime() - Date.now()) / 1000);
-
-  if (seconds < 0) return 'now';
-  if (seconds < 60) return `in ${seconds}s`;
-  if (seconds < 3600) return `in ${Math.floor(seconds / 60)}m`;
-  if (seconds < 86400) return `in ${Math.floor(seconds / 3600)}h`;
-  return `in ${Math.floor(seconds / 86400)}d`;
-}
-
-// Main daemon command
-export const daemonCommand: Command = {
-  name: 'daemon',
-  description: 'Manage background worker daemon (Node.js-based, auto-runs like shell helpers)',
-  subcommands: [
-    startCommand,
-    stopCommand,
-    statusCommand,
-    triggerCommand,
-    enableCommand,
-  ],
-  options: [],
-  examples: [
-    { command: 'claude-flow daemon start', description: 'Start the daemon' },
-    { command: 'claude-flow daemon status', description: 'Check daemon status' },
-    { command: 'claude-flow daemon stop', description: 'Stop the daemon' },
-    { command: 'claude-flow daemon trigger -w audit', description: 'Run security audit' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Worker Daemon - Background Task Management'));
-    output.writeln();
-    output.writeln('Node.js-based background worker system that auto-runs like shell daemons.');
-    output.writeln('Manages 12 specialized workers for continuous optimization and monitoring.');
-    output.writeln();
-
-    output.writeln(output.bold('Available Workers'));
-    output.printList([
-      `${output.highlight('map')}         - Codebase mapping (5 min interval)`,
-      `${output.highlight('audit')}       - Security analysis (10 min interval)`,
-      `${output.highlight('optimize')}    - Performance optimization (15 min interval)`,
-      `${output.highlight('consolidate')} - Memory consolidation (30 min interval)`,
-      `${output.highlight('testgaps')}    - Test coverage analysis (20 min interval)`,
-      `${output.highlight('predict')}     - Predictive preloading (2 min, disabled by default)`,
-      `${output.highlight('document')}    - Auto-documentation (60 min, disabled by default)`,
-      `${output.highlight('ultralearn')}  - Deep knowledge acquisition (manual trigger)`,
-      `${output.highlight('refactor')}    - Code refactoring suggestions (manual trigger)`,
-      `${output.highlight('benchmark')}   - Performance benchmarking (manual trigger)`,
-      `${output.highlight('deepdive')}    - Deep code analysis (manual trigger)`,
-      `${output.highlight('preload')}     - Resource preloading (manual trigger)`,
-    ]);
-
-    output.writeln();
-    output.writeln(output.bold('Subcommands'));
-    output.printList([
-      `${output.highlight('start')}   - Start the daemon`,
-      `${output.highlight('stop')}    - Stop the daemon`,
-      `${output.highlight('status')}  - Show daemon status`,
-      `${output.highlight('trigger')} - Manually run a worker`,
-      `${output.highlight('enable')}  - Enable/disable a worker`,
-    ]);
-
-    output.writeln();
-    output.writeln('Run "claude-flow daemon <subcommand> --help" for details');
-
-    return { success: true };
-  },
-};
-
-export default daemonCommand;