@claude-flow/cli 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/commands/daemon.ts

@@ -0,0 +1,395 @@
+/**
+ * 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;