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

package/src/commands/doctor.ts

@@ -1,382 +0,0 @@
-/**
- * V3 CLI Doctor Command
- * System diagnostics, dependency checks, config validation
- *
- * Created with ruv.io
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { execSync } from 'child_process';
-
-interface HealthCheck {
-  name: string;
-  status: 'pass' | 'warn' | 'fail';
-  message: string;
-  fix?: string;
-}
-
-// Check Node.js version
-async function checkNodeVersion(): Promise<HealthCheck> {
-  const requiredMajor = 20;
-  const version = process.version;
-  const major = parseInt(version.slice(1).split('.')[0], 10);
-
-  if (major >= requiredMajor) {
-    return { name: 'Node.js Version', status: 'pass', message: `${version} (>= ${requiredMajor} required)` };
-  } else if (major >= 18) {
-    return { name: 'Node.js Version', status: 'warn', message: `${version} (>= ${requiredMajor} recommended)`, fix: 'nvm install 20 && nvm use 20' };
-  } else {
-    return { name: 'Node.js Version', status: 'fail', message: `${version} (>= ${requiredMajor} required)`, fix: 'nvm install 20 && nvm use 20' };
-  }
-}
-
-// Check npm version
-async function checkNpmVersion(): Promise<HealthCheck> {
-  try {
-    const version = execSync('npm --version', { encoding: 'utf8' }).trim();
-    const major = parseInt(version.split('.')[0], 10);
-    if (major >= 9) {
-      return { name: 'npm Version', status: 'pass', message: `v${version}` };
-    } else {
-      return { name: 'npm Version', status: 'warn', message: `v${version} (>= 9 recommended)`, fix: 'npm install -g npm@latest' };
-    }
-  } catch {
-    return { name: 'npm Version', status: 'fail', message: 'npm not found', fix: 'Install Node.js from https://nodejs.org' };
-  }
-}
-
-// Check config file
-async function checkConfigFile(): Promise<HealthCheck> {
-  const configPaths = [
-    '.claude-flow/config.json',
-    'claude-flow.config.json',
-    '.claude-flow.json'
-  ];
-
-  for (const configPath of configPaths) {
-    if (existsSync(configPath)) {
-      try {
-        const content = readFileSync(configPath, 'utf8');
-        JSON.parse(content);
-        return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
-      } catch (e) {
-        return { name: 'Config File', status: 'fail', message: `Invalid JSON: ${configPath}`, fix: 'Fix JSON syntax in config file' };
-      }
-    }
-  }
-
-  return { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'claude-flow config init' };
-}
-
-// Check daemon status
-async function checkDaemonStatus(): Promise<HealthCheck> {
-  try {
-    const pidFile = '.claude-flow/daemon.pid';
-    if (existsSync(pidFile)) {
-      const pid = readFileSync(pidFile, 'utf8').trim();
-      try {
-        process.kill(parseInt(pid, 10), 0); // Check if process exists
-        return { name: 'Daemon Status', status: 'pass', message: `Running (PID: ${pid})` };
-      } catch {
-        return { name: 'Daemon Status', status: 'warn', message: 'Stale PID file', fix: 'rm .claude-flow/daemon.pid && claude-flow daemon start' };
-      }
-    }
-    return { name: 'Daemon Status', status: 'warn', message: 'Not running', fix: 'claude-flow daemon start' };
-  } catch {
-    return { name: 'Daemon Status', status: 'warn', message: 'Unable to check', fix: 'claude-flow daemon status' };
-  }
-}
-
-// Check memory database
-async function checkMemoryDatabase(): Promise<HealthCheck> {
-  const dbPaths = [
-    '.claude-flow/memory.db',
-    '.swarm/memory.db',
-    'data/memory.db'
-  ];
-
-  for (const dbPath of dbPaths) {
-    if (existsSync(dbPath)) {
-      try {
-        const stats = require('fs').statSync(dbPath);
-        const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-        return { name: 'Memory Database', status: 'pass', message: `${dbPath} (${sizeMB} MB)` };
-      } catch {
-        return { name: 'Memory Database', status: 'warn', message: `${dbPath} (unable to stat)` };
-      }
-    }
-  }
-
-  return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'claude-flow memory configure --backend hybrid' };
-}
-
-// Check API keys
-async function checkApiKeys(): Promise<HealthCheck> {
-  const keys = ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY', 'OPENAI_API_KEY'];
-  const found: string[] = [];
-
-  for (const key of keys) {
-    if (process.env[key]) {
-      found.push(key);
-    }
-  }
-
-  if (found.includes('ANTHROPIC_API_KEY') || found.includes('CLAUDE_API_KEY')) {
-    return { name: 'API Keys', status: 'pass', message: `Found: ${found.join(', ')}` };
-  } else if (found.length > 0) {
-    return { name: 'API Keys', status: 'warn', message: `Found: ${found.join(', ')} (no Claude key)`, fix: 'export ANTHROPIC_API_KEY=your_key' };
-  } else {
-    return { name: 'API Keys', status: 'warn', message: 'No API keys found', fix: 'export ANTHROPIC_API_KEY=your_key' };
-  }
-}
-
-// Check git
-async function checkGit(): Promise<HealthCheck> {
-  try {
-    const version = execSync('git --version', { encoding: 'utf8' }).trim();
-    return { name: 'Git', status: 'pass', message: version.replace('git version ', 'v') };
-  } catch {
-    return { name: 'Git', status: 'warn', message: 'Not installed', fix: 'Install git from https://git-scm.com' };
-  }
-}
-
-// Check if in git repo
-async function checkGitRepo(): Promise<HealthCheck> {
-  try {
-    execSync('git rev-parse --git-dir', { encoding: 'utf8', stdio: 'pipe' });
-    return { name: 'Git Repository', status: 'pass', message: 'In a git repository' };
-  } catch {
-    return { name: 'Git Repository', status: 'warn', message: 'Not a git repository', fix: 'git init' };
-  }
-}
-
-// Check MCP servers
-async function checkMcpServers(): Promise<HealthCheck> {
-  const mcpConfigPaths = [
-    join(process.env.HOME || '', '.claude/claude_desktop_config.json'),
-    join(process.env.HOME || '', '.config/claude/mcp.json'),
-    '.mcp.json'
-  ];
-
-  for (const configPath of mcpConfigPaths) {
-    if (existsSync(configPath)) {
-      try {
-        const content = JSON.parse(readFileSync(configPath, 'utf8'));
-        const servers = content.mcpServers || content.servers || {};
-        const count = Object.keys(servers).length;
-        const hasClaudeFlow = 'claude-flow' in servers || 'claude-flow_alpha' in servers;
-        if (hasClaudeFlow) {
-          return { name: 'MCP Servers', status: 'pass', message: `${count} servers (claude-flow configured)` };
-        } else {
-          return { name: 'MCP Servers', status: 'warn', message: `${count} servers (claude-flow not found)`, fix: 'claude mcp add claude-flow npx @claude-flow/cli@v3alpha mcp start' };
-        }
-      } catch {
-        // continue to next path
-      }
-    }
-  }
-
-  return { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add claude-flow npx @claude-flow/cli@v3alpha mcp start' };
-}
-
-// Check disk space
-async function checkDiskSpace(): Promise<HealthCheck> {
-  try {
-    if (process.platform === 'win32') {
-      return { name: 'Disk Space', status: 'pass', message: 'Check skipped on Windows' };
-    }
-    const output_str = execSync('df -h . | tail -1', { encoding: 'utf8' });
-    const parts = output_str.split(/\s+/);
-    const available = parts[3];
-    const usePercent = parseInt(parts[4]?.replace('%', '') || '0', 10);
-
-    if (usePercent > 90) {
-      return { name: 'Disk Space', status: 'fail', message: `${available} available (${usePercent}% used)`, fix: 'Free up disk space' };
-    } else if (usePercent > 80) {
-      return { name: 'Disk Space', status: 'warn', message: `${available} available (${usePercent}% used)` };
-    }
-    return { name: 'Disk Space', status: 'pass', message: `${available} available` };
-  } catch {
-    return { name: 'Disk Space', status: 'warn', message: 'Unable to check' };
-  }
-}
-
-// Check TypeScript/build
-async function checkBuildTools(): Promise<HealthCheck> {
-  try {
-    // Use stdio: 'pipe' for cross-platform stderr suppression (works on Windows)
-    const tscVersion = execSync('npx tsc --version', {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'] // Suppress stderr on all platforms
-    }).trim();
-    if (!tscVersion || tscVersion.includes('not found')) {
-      return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
-    }
-    return { name: 'TypeScript', status: 'pass', message: tscVersion.replace('Version ', 'v') };
-  } catch {
-    return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
-  }
-}
-
-// Format health check result
-function formatCheck(check: HealthCheck): string {
-  const icon = check.status === 'pass' ? output.success('✓') :
-               check.status === 'warn' ? output.warning('⚠') :
-               output.error('✗');
-  return `${icon} ${check.name}: ${check.message}`;
-}
-
-// Main doctor command
-export const doctorCommand: Command = {
-  name: 'doctor',
-  description: 'System diagnostics and health checks',
-  options: [
-    {
-      name: 'fix',
-      short: 'f',
-      description: 'Show fix commands for issues',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'component',
-      short: 'c',
-      description: 'Check specific component (node, config, daemon, memory, api, git, mcp)',
-      type: 'string'
-    },
-    {
-      name: 'verbose',
-      short: 'v',
-      description: 'Verbose output',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  examples: [
-    { command: 'claude-flow doctor', description: 'Run full health check' },
-    { command: 'claude-flow doctor --fix', description: 'Show fixes for issues' },
-    { command: 'claude-flow doctor -c daemon', description: 'Check specific component' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const showFix = ctx.flags.fix as boolean;
-    const component = ctx.flags.component as string;
-    const verbose = ctx.flags.verbose as boolean;
-
-    output.writeln();
-    output.writeln(output.bold('Claude Flow Doctor'));
-    output.writeln(output.dim('System diagnostics and health check'));
-    output.writeln(output.dim('─'.repeat(50)));
-    output.writeln();
-
-    const allChecks: (() => Promise<HealthCheck>)[] = [
-      checkNodeVersion,
-      checkNpmVersion,
-      checkGit,
-      checkGitRepo,
-      checkConfigFile,
-      checkDaemonStatus,
-      checkMemoryDatabase,
-      checkApiKeys,
-      checkMcpServers,
-      checkDiskSpace,
-      checkBuildTools
-    ];
-
-    const componentMap: Record<string, () => Promise<HealthCheck>> = {
-      'node': checkNodeVersion,
-      'npm': checkNpmVersion,
-      'config': checkConfigFile,
-      'daemon': checkDaemonStatus,
-      'memory': checkMemoryDatabase,
-      'api': checkApiKeys,
-      'git': checkGit,
-      'mcp': checkMcpServers,
-      'disk': checkDiskSpace,
-      'typescript': checkBuildTools
-    };
-
-    let checksToRun = allChecks;
-    if (component && componentMap[component]) {
-      checksToRun = [componentMap[component]];
-    }
-
-    const results: HealthCheck[] = [];
-    const fixes: string[] = [];
-
-    for (const check of checksToRun) {
-      const spinner = output.createSpinner({ text: 'Checking...', spinner: 'dots' });
-      spinner.start();
-
-      try {
-        const result = await check();
-        results.push(result);
-
-        spinner.stop();
-        output.writeln(formatCheck(result));
-
-        if (result.fix && (result.status === 'fail' || result.status === 'warn')) {
-          fixes.push(`${result.name}: ${result.fix}`);
-        }
-      } catch (error) {
-        spinner.stop();
-        const errorResult: HealthCheck = {
-          name: 'Check',
-          status: 'fail',
-          message: error instanceof Error ? error.message : 'Unknown error'
-        };
-        results.push(errorResult);
-        output.writeln(formatCheck(errorResult));
-      }
-    }
-
-    // Summary
-    const passed = results.filter(r => r.status === 'pass').length;
-    const warnings = results.filter(r => r.status === 'warn').length;
-    const failed = results.filter(r => r.status === 'fail').length;
-
-    output.writeln();
-    output.writeln(output.dim('─'.repeat(50)));
-    output.writeln();
-
-    const summaryParts = [
-      output.success(`${passed} passed`),
-      warnings > 0 ? output.warning(`${warnings} warnings`) : null,
-      failed > 0 ? output.error(`${failed} failed`) : null
-    ].filter(Boolean);
-
-    output.writeln(`Summary: ${summaryParts.join(', ')}`);
-
-    // Show fixes
-    if (showFix && fixes.length > 0) {
-      output.writeln();
-      output.writeln(output.bold('Suggested Fixes:'));
-      output.writeln();
-      for (const fix of fixes) {
-        output.writeln(output.dim(`  ${fix}`));
-      }
-    } else if (fixes.length > 0 && !showFix) {
-      output.writeln();
-      output.writeln(output.dim(`Run with --fix to see ${fixes.length} suggested fix${fixes.length > 1 ? 'es' : ''}`));
-    }
-
-    // Overall result
-    if (failed > 0) {
-      output.writeln();
-      output.writeln(output.error('Some checks failed. Please address the issues above.'));
-      return { success: false, exitCode: 1, data: { passed, warnings, failed, results } };
-    } else if (warnings > 0) {
-      output.writeln();
-      output.writeln(output.warning('All checks passed with some warnings.'));
-      return { success: true, data: { passed, warnings, failed, results } };
-    } else {
-      output.writeln();
-      output.writeln(output.success('All checks passed! System is healthy.'));
-      return { success: true, data: { passed, warnings, failed, results } };
-    }
-  }
-};
-
-export default doctorCommand;