@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/health.ts

@@ -0,0 +1,599 @@
+/**
+ * Bootspring Health Command
+ * Quick project health overview and status check
+ *
+ * @package bootspring
+ * @module cli/health
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+// Import JS modules with type interfaces
+interface Config {
+  _projectRoot: string;
+  project?: { name: string };
+}
+
+interface ConfigModule {
+  load(): Config;
+}
+
+interface Phase {
+  status: string;
+}
+
+interface WorkflowState {
+  phases?: Record<string, Phase>;
+  lastUpdated?: string;
+}
+
+interface WorkflowStatus {
+  exists: boolean;
+  progress?: number | undefined;
+  lastUpdated?: string | undefined;
+  isComplete?: boolean | undefined;
+  error?: boolean | undefined;
+}
+
+interface TodoSummary {
+  exists: boolean;
+  pending?: number;
+  completed?: number;
+  total?: number;
+  error?: boolean;
+}
+
+interface Vulnerabilities {
+  total?: number;
+  critical?: number;
+  high?: number;
+}
+
+interface DependencyHealth {
+  exists: boolean;
+  dependencies?: number;
+  devDependencies?: number;
+  total?: number;
+  vulnerabilities?: Vulnerabilities;
+  error?: boolean;
+}
+
+interface QualityMetrics {
+  hasTypeScript: boolean;
+  hasEslint: boolean;
+  hasPrettier: boolean;
+  hasTests: boolean;
+  testCoverage: number | null;
+}
+
+interface MonitorMetrics {
+  exists: boolean;
+  noData?: boolean | undefined;
+  bundleSize?: number | undefined;
+  dependencies?: number | undefined;
+  timestamp?: string | undefined;
+  error?: boolean | undefined;
+}
+
+interface CheckpointProgress {
+  completed: number;
+  total: number;
+  percentage: number;
+}
+
+interface ProjectStateModule {
+  getCheckpointProgress(projectRoot: string): CheckpointProgress | null;
+}
+
+interface CheckpointEngineModule {
+  getColoredProgressBar(percentage: number, width: number): string;
+}
+
+interface HealthData {
+  workflows: Record<string, WorkflowStatus>;
+  todos: TodoSummary;
+  quality: QualityMetrics;
+  deps: DependencyHealth;
+  monitor: MonitorMetrics;
+  checkpoints: CheckpointProgress | null;
+  score?: number;
+  grade?: string;
+}
+
+interface ParsedArgs {
+  _: string[];
+  json?: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const config = require('../../core/config') as ConfigModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const utils = require('../../core/utils') as typeof import('../core/utils');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const projectState = require('../../core/project-state') as ProjectStateModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const checkpointEngine = require('../../core/checkpoint-engine') as CheckpointEngineModule;
+
+/**
+ * Get workflow status
+ */
+export function getWorkflowStatus(projectRoot: string): Record<string, WorkflowStatus> {
+  const workflows = ['analyze', 'audit', 'onboard', 'deploy'];
+  const status: Record<string, WorkflowStatus> = {};
+
+  for (const workflow of workflows) {
+    const stateFile = path.join(projectRoot, '.bootspring', workflow, 'workflow-state.json');
+    if (fs.existsSync(stateFile)) {
+      try {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8')) as WorkflowState;
+        const completedPhases = Object.values(state.phases || {})
+          .filter(p => p.status === 'completed').length;
+        const totalPhases = Object.keys(state.phases || {}).length;
+
+        status[workflow] = {
+          exists: true,
+          progress: totalPhases > 0 ? Math.round((completedPhases / totalPhases) * 100) : 0,
+          lastUpdated: state.lastUpdated,
+          isComplete: completedPhases === totalPhases && totalPhases > 0
+        };
+      } catch {
+        status[workflow] = { exists: true, error: true };
+      }
+    } else {
+      status[workflow] = { exists: false };
+    }
+  }
+
+  return status;
+}
+
+/**
+ * Get todo summary
+ */
+export function getTodoSummary(projectRoot: string): TodoSummary {
+  const todoPath = path.join(projectRoot, 'todo.md');
+  if (!fs.existsSync(todoPath)) {
+    return { exists: false };
+  }
+
+  try {
+    const content = fs.readFileSync(todoPath, 'utf-8');
+    const pending = (content.match(/- \[ \]/g) || []).length;
+    const completed = (content.match(/- \[x\]/gi) || []).length;
+
+    return {
+      exists: true,
+      pending,
+      completed,
+      total: pending + completed
+    };
+  } catch {
+    return { exists: true, error: true };
+  }
+}
+
+interface PackageJson {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+interface AuditResult {
+  metadata?: {
+    vulnerabilities?: Vulnerabilities;
+  };
+}
+
+/**
+ * Get dependency health
+ */
+export function getDependencyHealth(projectRoot: string): DependencyHealth {
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return { exists: false };
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')) as PackageJson;
+    const deps = Object.keys(pkg.dependencies || {}).length;
+    const devDeps = Object.keys(pkg.devDependencies || {}).length;
+
+    let vulnerabilities: Vulnerabilities = { total: 0, critical: 0, high: 0 };
+
+    try {
+      const auditResult = execSync('npm audit --json 2>/dev/null', {
+        cwd: projectRoot,
+        encoding: 'utf-8',
+        timeout: 10000,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      const audit = JSON.parse(auditResult) as AuditResult;
+      if (audit.metadata && audit.metadata.vulnerabilities) {
+        vulnerabilities = audit.metadata.vulnerabilities;
+      }
+    } catch {
+      // Audit failed or timed out
+    }
+
+    return {
+      exists: true,
+      dependencies: deps,
+      devDependencies: devDeps,
+      total: deps + devDeps,
+      vulnerabilities
+    };
+  } catch {
+    return { exists: true, error: true };
+  }
+}
+
+interface CoverageSummary {
+  total?: {
+    lines?: {
+      pct?: number;
+    };
+  };
+}
+
+/**
+ * Get quality metrics
+ */
+export function getQualityMetrics(projectRoot: string): QualityMetrics {
+  const metrics: QualityMetrics = {
+    hasTypeScript: false,
+    hasEslint: false,
+    hasPrettier: false,
+    hasTests: false,
+    testCoverage: null
+  };
+
+  // Check for TypeScript
+  if (fs.existsSync(path.join(projectRoot, 'tsconfig.json'))) {
+    metrics.hasTypeScript = true;
+  }
+
+  // Check for ESLint
+  const eslintConfigs = ['.eslintrc', '.eslintrc.json', '.eslintrc.js', 'eslint.config.js'];
+  metrics.hasEslint = eslintConfigs.some(f => fs.existsSync(path.join(projectRoot, f)));
+
+  // Check for Prettier
+  const prettierConfigs = ['.prettierrc', '.prettierrc.json', 'prettier.config.js'];
+  metrics.hasPrettier = prettierConfigs.some(f => fs.existsSync(path.join(projectRoot, f)));
+
+  // Check for tests
+  const testDirs = ['__tests__', 'tests', 'test', 'spec'];
+  metrics.hasTests = testDirs.some(d => fs.existsSync(path.join(projectRoot, d)));
+
+  // Check for coverage
+  const coveragePath = path.join(projectRoot, 'coverage', 'coverage-summary.json');
+  if (fs.existsSync(coveragePath)) {
+    try {
+      const coverage = JSON.parse(fs.readFileSync(coveragePath, 'utf-8')) as CoverageSummary;
+      metrics.testCoverage = coverage.total?.lines?.pct ?? null;
+    } catch {
+      // Coverage file invalid
+    }
+  }
+
+  return metrics;
+}
+
+interface MetricsData {
+  bundleSize?: number;
+  dependencies?: number;
+  timestamp?: string;
+}
+
+/**
+ * Get monitor metrics
+ */
+function getMonitorMetrics(projectRoot: string): MonitorMetrics {
+  const metricsDir = path.join(projectRoot, '.bootspring', 'monitor', 'metrics');
+  if (!fs.existsSync(metricsDir)) {
+    return { exists: false };
+  }
+
+  try {
+    const files = fs.readdirSync(metricsDir).sort().slice(-1);
+    if (files.length === 0) {
+      return { exists: true, noData: true };
+    }
+
+    const fileName = files[0];
+    if (!fileName) {
+      return { exists: true, noData: true };
+    }
+
+    const latest = JSON.parse(fs.readFileSync(path.join(metricsDir, fileName), 'utf-8')) as MetricsData;
+    return {
+      exists: true,
+      bundleSize: latest.bundleSize,
+      dependencies: latest.dependencies,
+      timestamp: latest.timestamp
+    };
+  } catch {
+    return { exists: true, error: true };
+  }
+}
+
+/**
+ * Calculate overall health score
+ */
+export function calculateHealthScore(data: HealthData): number {
+  let score = 0;
+  let maxScore = 0;
+
+  // Checkpoints (20 points max)
+  if (data.checkpoints && data.checkpoints.total > 0) {
+    maxScore += 20;
+    score += (data.checkpoints.percentage / 100) * 20;
+  }
+
+  // Workflows (15 points max)
+  maxScore += 15;
+  const workflowsDone = Object.values(data.workflows)
+    .filter(w => w.isComplete).length;
+  score += (workflowsDone / 4) * 15;
+
+  // Todos (10 points max)
+  if (data.todos.exists && data.todos.total && data.todos.total > 0 && data.todos.completed !== undefined) {
+    maxScore += 10;
+    const completionRate = data.todos.completed / data.todos.total;
+    score += completionRate * 10;
+  }
+
+  // Quality tooling (25 points max)
+  maxScore += 25;
+  if (data.quality.hasTypeScript) score += 8;
+  if (data.quality.hasEslint) score += 8;
+  if (data.quality.hasPrettier) score += 4;
+  if (data.quality.hasTests) score += 5;
+
+  // Test coverage (15 points max)
+  if (data.quality.testCoverage !== null) {
+    maxScore += 15;
+    score += (data.quality.testCoverage / 100) * 15;
+  }
+
+  // Dependencies (15 points max)
+  maxScore += 15;
+  if (data.deps.exists) {
+    const vulns = data.deps.vulnerabilities || {};
+    if ((vulns.critical || 0) === 0 && (vulns.high || 0) === 0) {
+      score += 15;
+    } else if ((vulns.critical || 0) === 0) {
+      score += 8;
+    }
+  }
+
+  return Math.round((score / maxScore) * 100);
+}
+
+/**
+ * Get health grade
+ */
+function getHealthGrade(score: number): { grade: string; color: string } {
+  if (score >= 90) return { grade: 'A', color: utils.COLORS.green };
+  if (score >= 80) return { grade: 'B', color: utils.COLORS.green };
+  if (score >= 70) return { grade: 'C', color: utils.COLORS.yellow };
+  if (score >= 60) return { grade: 'D', color: utils.COLORS.yellow };
+  return { grade: 'F', color: utils.COLORS.red };
+}
+
+/**
+ * Show health report
+ */
+function showHealth(projectRoot: string): { score: number; grade: string; data: HealthData } {
+  const cfg = config.load();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Project Health Report${utils.COLORS.reset}
+${utils.COLORS.dim}${cfg.project?.name || 'Unknown Project'}${utils.COLORS.reset}
+`);
+
+  // Collect all data
+  const data: HealthData = {
+    workflows: getWorkflowStatus(projectRoot),
+    todos: getTodoSummary(projectRoot),
+    quality: getQualityMetrics(projectRoot),
+    deps: getDependencyHealth(projectRoot),
+    monitor: getMonitorMetrics(projectRoot),
+    checkpoints: projectState.getCheckpointProgress(projectRoot)
+  };
+
+  // Calculate score
+  const score = calculateHealthScore(data);
+  const { grade, color } = getHealthGrade(score);
+
+  // Health Score
+  console.log(`${utils.COLORS.bold}Overall Health${utils.COLORS.reset}`);
+  console.log(`  ${color}${utils.COLORS.bold}${grade}${utils.COLORS.reset} - ${score}/100`);
+  console.log();
+
+  // Checkpoints
+  if (data.checkpoints && data.checkpoints.total > 0) {
+    console.log(`${utils.COLORS.bold}Checkpoints${utils.COLORS.reset}`);
+    const cpBar = checkpointEngine.getColoredProgressBar(data.checkpoints.percentage, 20);
+    console.log(`  ${cpBar} ${data.checkpoints.completed}/${data.checkpoints.total} (${data.checkpoints.percentage}%)`);
+    console.log();
+  }
+
+  // Workflows
+  console.log(`${utils.COLORS.bold}Workflows${utils.COLORS.reset}`);
+  for (const [name, status] of Object.entries(data.workflows)) {
+    if (status.error) {
+      console.log(`  ${utils.COLORS.yellow}⚠${utils.COLORS.reset} ${name}: Error reading state`);
+    } else if (!status.exists) {
+      console.log(`  ${utils.COLORS.dim}○${utils.COLORS.reset} ${name}: Not started`);
+    } else if (status.isComplete) {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${name}: Complete`);
+    } else {
+      console.log(`  ${utils.COLORS.yellow}◐${utils.COLORS.reset} ${name}: ${status.progress}% complete`);
+    }
+  }
+  console.log();
+
+  // Todos
+  console.log(`${utils.COLORS.bold}Tasks${utils.COLORS.reset}`);
+  if (!data.todos.exists) {
+    console.log(`  ${utils.COLORS.dim}No todo.md found${utils.COLORS.reset}`);
+  } else {
+    const pendingIcon = data.todos.pending === 0 ?
+      `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+      `${utils.COLORS.yellow}●${utils.COLORS.reset}`;
+    console.log(`  ${pendingIcon} ${data.todos.pending} pending, ${data.todos.completed} completed`);
+  }
+  console.log();
+
+  // Quality
+  console.log(`${utils.COLORS.bold}Quality Tooling${utils.COLORS.reset}`);
+  const qIcon = (has: boolean): string => has ?
+    `${utils.COLORS.green}✓${utils.COLORS.reset}` :
+    `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+  console.log(`  ${qIcon(data.quality.hasTypeScript)} TypeScript`);
+  console.log(`  ${qIcon(data.quality.hasEslint)} ESLint`);
+  console.log(`  ${qIcon(data.quality.hasPrettier)} Prettier`);
+  console.log(`  ${qIcon(data.quality.hasTests)} Tests`);
+  if (data.quality.testCoverage !== null) {
+    const covColor = data.quality.testCoverage >= 80 ? utils.COLORS.green :
+      data.quality.testCoverage >= 60 ? utils.COLORS.yellow : utils.COLORS.red;
+    console.log(`  ${covColor}●${utils.COLORS.reset} Coverage: ${data.quality.testCoverage}%`);
+  }
+  console.log();
+
+  // Dependencies
+  console.log(`${utils.COLORS.bold}Dependencies${utils.COLORS.reset}`);
+  if (!data.deps.exists) {
+    console.log(`  ${utils.COLORS.dim}No package.json found${utils.COLORS.reset}`);
+  } else {
+    console.log(`  ${utils.COLORS.dim}●${utils.COLORS.reset} ${data.deps.dependencies} deps, ${data.deps.devDependencies} devDeps`);
+    const vulns = data.deps.vulnerabilities || {};
+    if ((vulns.critical || 0) > 0) {
+      console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${vulns.critical} critical vulnerabilities`);
+    } else if ((vulns.high || 0) > 0) {
+      console.log(`  ${utils.COLORS.yellow}⚠${utils.COLORS.reset} ${vulns.high} high vulnerabilities`);
+    } else if ((vulns.total || 0) > 0) {
+      console.log(`  ${utils.COLORS.yellow}○${utils.COLORS.reset} ${vulns.total} vulnerabilities (low/moderate)`);
+    } else {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} No vulnerabilities`);
+    }
+  }
+  console.log();
+
+  // Metrics
+  if (data.monitor.exists && !data.monitor.noData && !data.monitor.error) {
+    console.log(`${utils.COLORS.bold}Latest Metrics${utils.COLORS.reset}`);
+    if (data.monitor.bundleSize) {
+      console.log(`  Bundle size: ${data.monitor.bundleSize} KB`);
+    }
+    if (data.monitor.timestamp) {
+      const date = new Date(data.monitor.timestamp).toLocaleDateString();
+      console.log(`  ${utils.COLORS.dim}Collected: ${date}${utils.COLORS.reset}`);
+    }
+    console.log();
+  }
+
+  // Recommendations
+  const recommendations: string[] = [];
+
+  // Checkpoint recommendations
+  if (!data.checkpoints || data.checkpoints.total === 0) {
+    recommendations.push('Run `bootspring checkpoint init` to start tracking progress');
+  } else if (data.checkpoints.percentage < 50) {
+    recommendations.push('Complete more checkpoints with `bootspring checkpoint sync`');
+  }
+
+  if (!data.quality.hasTypeScript) {
+    recommendations.push('Add TypeScript for type safety');
+  }
+  if (!data.quality.hasEslint) {
+    recommendations.push('Add ESLint for code quality');
+  }
+  if (!data.quality.hasTests) {
+    recommendations.push('Add tests for reliability');
+  }
+  if (data.todos.pending && data.todos.pending > 5) {
+    recommendations.push(`Address ${data.todos.pending} pending tasks`);
+  }
+  if (!data.workflows.analyze?.isComplete) {
+    recommendations.push('Run `bootspring analyze` for codebase insights');
+  }
+  if (!data.workflows.audit?.isComplete) {
+    recommendations.push('Run `bootspring audit` for quality assessment');
+  }
+  const vulns = data.deps.vulnerabilities || {};
+  if ((vulns.critical || 0) > 0 || (vulns.high || 0) > 0) {
+    recommendations.push('Run `npm audit fix` to address vulnerabilities');
+  }
+
+  if (recommendations.length > 0) {
+    console.log(`${utils.COLORS.bold}Recommendations${utils.COLORS.reset}`);
+    recommendations.slice(0, 5).forEach(rec => {
+      console.log(`  ${utils.COLORS.cyan}→${utils.COLORS.reset} ${rec}`);
+    });
+    console.log();
+  }
+
+  return { score, grade, data };
+}
+
+/**
+ * Show help
+ */
+function showHelp(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Health${utils.COLORS.reset}
+${utils.COLORS.dim}Quick project health overview${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring health [options]
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --json          Output as JSON
+
+${utils.COLORS.bold}What it checks:${utils.COLORS.reset}
+  - Workflow completion status
+  - Todo/task progress
+  - Quality tooling (TypeScript, ESLint, Prettier)
+  - Test coverage
+  - Dependency vulnerabilities
+  - Recent metrics
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring health
+  bootspring health --json
+`);
+}
+
+/**
+ * Run health command
+ */
+export async function run(args: string[]): Promise<void> {
+  const parsedArgs = utils.parseArgs(args) as ParsedArgs;
+  const subcommand = parsedArgs._[0];
+
+  if (subcommand === 'help' || subcommand === '-h' || subcommand === '--help') {
+    showHelp();
+    return;
+  }
+
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+
+  if (parsedArgs.json) {
+    const data: HealthData = {
+      workflows: getWorkflowStatus(projectRoot),
+      todos: getTodoSummary(projectRoot),
+      quality: getQualityMetrics(projectRoot),
+      deps: getDependencyHealth(projectRoot),
+      monitor: getMonitorMetrics(projectRoot),
+      checkpoints: projectState.getCheckpointProgress(projectRoot)
+    };
+    data.score = calculateHealthScore(data);
+    data.grade = getHealthGrade(data.score).grade;
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    showHealth(projectRoot);
+  }
+}