@girardmedia/bootspring 2.5.0 → 2.5.2

package/generators/health.js

@@ -1,942 +0,0 @@
-/**
- * Bootspring HEALTH.md Generator
- *
- * Generates project health dashboard with code quality metrics,
- * test coverage, dependency health, security posture, and performance.
- *
- * @package bootspring
- * @module generators/health
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-/**
- * Health status levels
- */
-const HEALTH_STATUS = {
-  EXCELLENT: { label: 'Excellent', emoji: '🟢', color: 'green', min: 90 },
-  GOOD: { label: 'Good', emoji: '🟡', color: 'yellow', min: 70 },
-  FAIR: { label: 'Fair', emoji: '🟠', color: 'orange', min: 50 },
-  POOR: { label: 'Poor', emoji: '🔴', color: 'red', min: 0 }
-};
-
-/**
- * Metric categories
- */
-const METRIC_CATEGORIES = {
-  CODE_QUALITY: { label: 'Code Quality', emoji: '📊', weight: 0.25 },
-  TEST_COVERAGE: { label: 'Test Coverage', emoji: '🧪', weight: 0.25 },
-  DEPENDENCIES: { label: 'Dependencies', emoji: '📦', weight: 0.20 },
-  SECURITY: { label: 'Security', emoji: '🔐', weight: 0.20 },
-  PERFORMANCE: { label: 'Performance', emoji: '⚡', weight: 0.10 }
-};
-
-/**
- * Health Document Generator
- */
-class HealthGenerator {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.healthDataPath = path.join(this.projectRoot, '.bootspring', 'health.json');
-    this.includeHistory = options.includeHistory !== false;
-    this.maxHistoryDays = options.maxHistoryDays || 30;
-  }
-
-  /**
-   * Load health history data
-   */
-  loadHealthData() {
-    try {
-      if (fs.existsSync(this.healthDataPath)) {
-        return JSON.parse(fs.readFileSync(this.healthDataPath, 'utf-8'));
-      }
-    } catch (_err) {
-      // Return default
-    }
-
-    return {
-      project: this.getProjectName(),
-      history: [],
-      metadata: {
-        created: new Date().toISOString(),
-        lastUpdated: null
-      }
-    };
-  }
-
-  /**
-   * Save health data
-   */
-  saveHealthData(data) {
-    data.metadata.lastUpdated = new Date().toISOString();
-
-    const dir = path.dirname(this.healthDataPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(this.healthDataPath, JSON.stringify(data, null, 2));
-  }
-
-  /**
-   * Get project name
-   */
-  getProjectName() {
-    try {
-      const pkgPath = path.join(this.projectRoot, 'package.json');
-      if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        return pkg.name || 'Project';
-      }
-    } catch (_err) {
-      // Default
-    }
-    return 'Project';
-  }
-
-  /**
-   * Collect all health metrics
-   */
-  async collectMetrics() {
-    const metrics = {
-      timestamp: new Date().toISOString(),
-      codeQuality: await this.collectCodeQualityMetrics(),
-      testCoverage: await this.collectTestCoverageMetrics(),
-      dependencies: await this.collectDependencyMetrics(),
-      security: await this.collectSecurityMetrics(),
-      performance: await this.collectPerformanceMetrics()
-    };
-
-    // Calculate overall score
-    metrics.overallScore = this.calculateOverallScore(metrics);
-    metrics.status = this.getStatusFromScore(metrics.overallScore);
-
-    return metrics;
-  }
-
-  /**
-   * Collect code quality metrics
-   */
-  async collectCodeQualityMetrics() {
-    const metrics = {
-      score: 0,
-      linting: { errors: 0, warnings: 0, passed: true },
-      typescript: { errors: 0, strict: false },
-      complexity: { average: 0, high: 0 },
-      codeSmells: [],
-      duplications: 0,
-      filesAnalyzed: 0
-    };
-
-    try {
-      // Check for eslint
-      const eslintConfig = this.findFile(['.eslintrc', '.eslintrc.js', '.eslintrc.json', 'eslint.config.js']);
-      if (eslintConfig) {
-        try {
-          const output = execSync('npx eslint . --format json --quiet 2>/dev/null || true', {
-            cwd: this.projectRoot,
-            encoding: 'utf-8',
-            timeout: 30000
-          });
-          const results = JSON.parse(output || '[]');
-          metrics.linting.errors = results.reduce((sum, r) => sum + r.errorCount, 0);
-          metrics.linting.warnings = results.reduce((sum, r) => sum + r.warningCount, 0);
-          metrics.linting.passed = metrics.linting.errors === 0;
-          metrics.filesAnalyzed = results.length;
-        } catch (_err) {
-          // ESLint failed or not configured
-        }
-      }
-
-      // Check for TypeScript
-      const tsConfig = this.findFile(['tsconfig.json']);
-      if (tsConfig) {
-        metrics.typescript.configured = true;
-        try {
-          const tsConfigContent = JSON.parse(fs.readFileSync(tsConfig, 'utf-8'));
-          metrics.typescript.strict = tsConfigContent.compilerOptions?.strict === true;
-        } catch (_err) {
-          // Ignore
-        }
-
-        try {
-          const output = execSync('npx tsc --noEmit 2>&1 || true', {
-            cwd: this.projectRoot,
-            encoding: 'utf-8',
-            timeout: 60000
-          });
-          const errorCount = (output.match(/error TS\d+:/g) || []).length;
-          metrics.typescript.errors = errorCount;
-        } catch (_err) {
-          // TypeScript check failed
-        }
-      }
-
-      // Calculate score
-      let score = 100;
-
-      // Deduct for lint errors
-      score -= Math.min(30, metrics.linting.errors * 2);
-      score -= Math.min(10, metrics.linting.warnings * 0.5);
-
-      // Deduct for TypeScript errors
-      score -= Math.min(20, metrics.typescript.errors * 2);
-
-      // Bonus for strict TypeScript
-      if (metrics.typescript.strict) {
-        score += 5;
-      }
-
-      metrics.score = Math.max(0, Math.min(100, Math.round(score)));
-    } catch (_err) {
-      metrics.score = 50; // Default if analysis fails
-    }
-
-    return metrics;
-  }
-
-  /**
-   * Collect test coverage metrics
-   */
-  async collectTestCoverageMetrics() {
-    const metrics = {
-      score: 0,
-      coverage: null,
-      testFiles: 0,
-      totalTests: 0,
-      passingTests: 0,
-      failingTests: 0,
-      skippedTests: 0,
-      coverageReport: null
-    };
-
-    try {
-      // Count test files
-      const testPatterns = ['**/*.test.js', '**/*.test.ts', '**/*.spec.js', '**/*.spec.ts', '**/__tests__/**/*.js'];
-      for (const pattern of testPatterns) {
-        const files = this.globSync(pattern);
-        metrics.testFiles += files.length;
-      }
-
-      // Look for coverage report
-      const coveragePaths = [
-        'coverage/coverage-summary.json',
-        'coverage/lcov-report/index.html',
-        '.nyc_output/coverage.json'
-      ];
-
-      for (const coveragePath of coveragePaths) {
-        const fullPath = path.join(this.projectRoot, coveragePath);
-        if (fs.existsSync(fullPath)) {
-          if (coveragePath.endsWith('.json')) {
-            try {
-              const coverage = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
-              if (coverage.total) {
-                metrics.coverage = {
-                  lines: coverage.total.lines?.pct || 0,
-                  statements: coverage.total.statements?.pct || 0,
-                  branches: coverage.total.branches?.pct || 0,
-                  functions: coverage.total.functions?.pct || 0
-                };
-              }
-            } catch (_err) {
-              // Ignore
-            }
-          }
-          metrics.coverageReport = coveragePath;
-          break;
-        }
-      }
-
-      // Calculate score
-      if (metrics.coverage) {
-        // Average of all coverage types
-        const avgCoverage = (
-          metrics.coverage.lines +
-          metrics.coverage.statements +
-          metrics.coverage.branches +
-          metrics.coverage.functions
-        ) / 4;
-        metrics.score = Math.round(avgCoverage);
-      } else if (metrics.testFiles > 0) {
-        // Some tests but no coverage report
-        metrics.score = 40;
-      } else {
-        // No tests
-        metrics.score = 0;
-      }
-    } catch (_err) {
-      metrics.score = 0;
-    }
-
-    return metrics;
-  }
-
-  /**
-   * Collect dependency metrics
-   */
-  async collectDependencyMetrics() {
-    const metrics = {
-      score: 100,
-      total: 0,
-      direct: 0,
-      dev: 0,
-      outdated: [],
-      vulnerabilities: { critical: 0, high: 0, medium: 0, low: 0 },
-      deprecated: [],
-      duplicates: 0
-    };
-
-    try {
-      const pkgPath = path.join(this.projectRoot, 'package.json');
-      if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        metrics.direct = Object.keys(pkg.dependencies || {}).length;
-        metrics.dev = Object.keys(pkg.devDependencies || {}).length;
-        metrics.total = metrics.direct + metrics.dev;
-
-        // Check for outdated packages
-        try {
-          const output = execSync('npm outdated --json 2>/dev/null || echo "{}"', {
-            cwd: this.projectRoot,
-            encoding: 'utf-8',
-            timeout: 30000
-          });
-          const outdated = JSON.parse(output);
-          metrics.outdated = Object.keys(outdated).map(name => ({
-            name,
-            current: outdated[name].current,
-            wanted: outdated[name].wanted,
-            latest: outdated[name].latest
-          }));
-        } catch (_err) {
-          // npm outdated failed
-        }
-
-        // Check for vulnerabilities
-        try {
-          const output = execSync('npm audit --json 2>/dev/null || echo "{}"', {
-            cwd: this.projectRoot,
-            encoding: 'utf-8',
-            timeout: 30000
-          });
-          const audit = JSON.parse(output);
-          if (audit.metadata?.vulnerabilities) {
-            metrics.vulnerabilities = audit.metadata.vulnerabilities;
-          }
-        } catch (_err) {
-          // npm audit failed
-        }
-      }
-
-      // Calculate score
-      let score = 100;
-
-      // Deduct for vulnerabilities
-      score -= metrics.vulnerabilities.critical * 20;
-      score -= metrics.vulnerabilities.high * 10;
-      score -= metrics.vulnerabilities.medium * 3;
-      score -= metrics.vulnerabilities.low * 1;
-
-      // Deduct for outdated (minor deduction)
-      score -= Math.min(15, metrics.outdated.length * 0.5);
-
-      metrics.score = Math.max(0, Math.min(100, Math.round(score)));
-    } catch (_err) {
-      metrics.score = 50;
-    }
-
-    return metrics;
-  }
-
-  /**
-   * Collect security metrics
-   */
-  async collectSecurityMetrics() {
-    const metrics = {
-      score: 100,
-      secretsExposed: 0,
-      authConfigured: false,
-      httpsEnforced: false,
-      envVarsSecure: true,
-      csrfProtection: false,
-      inputValidation: false,
-      issues: []
-    };
-
-    try {
-      // Check for secrets in code
-      const secretPatterns = [
-        /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi,
-        /secret\s*[:=]\s*['"][^'"]+['"]/gi,
-        /password\s*[:=]\s*['"][^'"]+['"]/gi,
-        /token\s*[:=]\s*['"][^'"]+['"]/gi
-      ];
-
-      const srcFiles = this.globSync('**/*.{js,ts,jsx,tsx}', ['node_modules', 'dist', 'build']);
-      for (const file of srcFiles.slice(0, 100)) {
-        try {
-          const content = fs.readFileSync(file, 'utf-8');
-          for (const pattern of secretPatterns) {
-            const matches = content.match(pattern) || [];
-            if (matches.length > 0) {
-              // Filter out common false positives
-              const realMatches = matches.filter(m =>
-                !m.includes('process.env') &&
-                !m.includes('${') &&
-                !m.includes("''") &&
-                !m.includes('""')
-              );
-              metrics.secretsExposed += realMatches.length;
-            }
-          }
-        } catch (_err) {
-          // Skip file
-        }
-      }
-
-      // Check for auth configuration
-      const authFiles = ['lib/auth.ts', 'lib/auth.js', 'auth.config.ts', 'auth.config.js', 'next-auth.config.ts'];
-      for (const authFile of authFiles) {
-        if (fs.existsSync(path.join(this.projectRoot, authFile))) {
-          metrics.authConfigured = true;
-          break;
-        }
-      }
-
-      // Check for middleware (CSRF, etc.)
-      if (fs.existsSync(path.join(this.projectRoot, 'middleware.ts')) ||
-          fs.existsSync(path.join(this.projectRoot, 'middleware.js'))) {
-        metrics.csrfProtection = true;
-      }
-
-      // Check for Zod or other validation
-      const pkgPath = path.join(this.projectRoot, 'package.json');
-      if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-        if (deps.zod || deps.yup || deps.joi) {
-          metrics.inputValidation = true;
-        }
-      }
-
-      // Check for .env.example
-      if (fs.existsSync(path.join(this.projectRoot, '.env.example'))) {
-        metrics.envVarsSecure = true;
-      }
-
-      // Calculate score
-      let score = 100;
-
-      // Major deductions
-      score -= metrics.secretsExposed * 20;
-
-      // Minor deductions
-      if (!metrics.authConfigured) {
-        metrics.issues.push('No authentication configuration detected');
-        score -= 10;
-      }
-      if (!metrics.inputValidation) {
-        metrics.issues.push('No input validation library detected (zod, yup, joi)');
-        score -= 10;
-      }
-      if (!metrics.csrfProtection) {
-        metrics.issues.push('No middleware detected for CSRF protection');
-        score -= 5;
-      }
-
-      metrics.score = Math.max(0, Math.min(100, Math.round(score)));
-    } catch (_err) {
-      metrics.score = 50;
-    }
-
-    return metrics;
-  }
-
-  /**
-   * Collect performance metrics
-   */
-  async collectPerformanceMetrics() {
-    const metrics = {
-      score: 70, // Default score
-      bundleSize: null,
-      buildTime: null,
-      lighthouseScore: null,
-      issues: []
-    };
-
-    try {
-      // Check for bundle analysis
-      const bundleAnalysis = path.join(this.projectRoot, '.next', 'analyze', 'client.html');
-      if (fs.existsSync(bundleAnalysis)) {
-        metrics.bundleAnalysis = true;
-      }
-
-      // Check build output size
-      const buildDirs = ['dist', 'build', '.next'];
-      for (const dir of buildDirs) {
-        const buildPath = path.join(this.projectRoot, dir);
-        if (fs.existsSync(buildPath)) {
-          try {
-            const size = this.getDirectorySize(buildPath);
-            metrics.bundleSize = size;
-            break;
-          } catch (_err) {
-            // Ignore
-          }
-        }
-      }
-
-      // Check for performance optimizations
-      const pkgPath = path.join(this.projectRoot, 'package.json');
-      if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-
-        // Check for common performance tools
-        if (deps['@next/bundle-analyzer'] || deps['webpack-bundle-analyzer']) {
-          metrics.score += 5;
-        }
-        if (deps['lighthouse'] || deps['@lhci/cli']) {
-          metrics.score += 5;
-        }
-      }
-
-      // Check next.config for optimizations
-      const nextConfig = path.join(this.projectRoot, 'next.config.js');
-      if (fs.existsSync(nextConfig)) {
-        const content = fs.readFileSync(nextConfig, 'utf-8');
-        if (content.includes('images:') && content.includes('domains:')) {
-          metrics.score += 5;
-        }
-      }
-
-      metrics.score = Math.min(100, metrics.score);
-    } catch (_err) {
-      // Keep default score
-    }
-
-    return metrics;
-  }
-
-  /**
-   * Calculate overall health score
-   */
-  calculateOverallScore(metrics) {
-    let totalWeight = 0;
-    let weightedScore = 0;
-
-    for (const [key, config] of Object.entries(METRIC_CATEGORIES)) {
-      const metricKey = this.categoryToMetricKey(key);
-      const score = metrics[metricKey]?.score || 0;
-      weightedScore += score * config.weight;
-      totalWeight += config.weight;
-    }
-
-    return Math.round(weightedScore / totalWeight);
-  }
-
-  /**
-   * Get status from score
-   */
-  getStatusFromScore(score) {
-    for (const [key, config] of Object.entries(HEALTH_STATUS)) {
-      if (score >= config.min) {
-        return key;
-      }
-    }
-    return 'POOR';
-  }
-
-  /**
-   * Map category to metric key
-   */
-  categoryToMetricKey(category) {
-    const mapping = {
-      CODE_QUALITY: 'codeQuality',
-      TEST_COVERAGE: 'testCoverage',
-      DEPENDENCIES: 'dependencies',
-      SECURITY: 'security',
-      PERFORMANCE: 'performance'
-    };
-    return mapping[category];
-  }
-
-  /**
-   * Generate HEALTH.md content
-   */
-  generate(metrics) {
-    const status = HEALTH_STATUS[metrics.status];
-    const now = new Date().toISOString().split('T')[0];
-
-    const sections = [];
-
-    // Header
-    sections.push(`# Project Health Dashboard
-
-**Project:** ${this.getProjectName()}
-**Last Updated:** ${now}
-**Overall Status:** ${status.emoji} ${status.label} (${metrics.overallScore}/100)
-
----`);
-
-    // Overall Score
-    const scoreBar = this.generateProgressBar(metrics.overallScore);
-    sections.push(`## Overall Health Score
-
-${scoreBar} **${metrics.overallScore}%**
-
-| Category | Score | Status |
-|----------|-------|--------|
-${Object.entries(METRIC_CATEGORIES).map(([key, config]) => {
-    const metricKey = this.categoryToMetricKey(key);
-    const score = metrics[metricKey]?.score || 0;
-    const catStatus = this.getStatusFromScore(score);
-    const statusConfig = HEALTH_STATUS[catStatus];
-    return `| ${config.emoji} ${config.label} | ${score}/100 | ${statusConfig.emoji} ${statusConfig.label} |`;
-  }).join('\n')}
-
----`);
-
-    // Code Quality
-    const cq = metrics.codeQuality;
-    sections.push(`## ${METRIC_CATEGORIES.CODE_QUALITY.emoji} Code Quality
-
-**Score:** ${cq.score}/100
-
-| Metric | Value |
-|--------|-------|
-| Lint Errors | ${cq.linting.errors} |
-| Lint Warnings | ${cq.linting.warnings} |
-| TypeScript Errors | ${cq.typescript.errors || 'N/A'} |
-| Strict Mode | ${cq.typescript.strict ? '✅ Yes' : '❌ No'} |
-| Files Analyzed | ${cq.filesAnalyzed} |
-
-${cq.linting.errors > 0 ? `
-### Issues to Fix
-
-- Run \`npm run lint -- --fix\` to auto-fix lint errors
-` : ''}
-
----`);
-
-    // Test Coverage
-    const tc = metrics.testCoverage;
-    sections.push(`## ${METRIC_CATEGORIES.TEST_COVERAGE.emoji} Test Coverage
-
-**Score:** ${tc.score}/100
-
-| Metric | Value |
-|--------|-------|
-| Test Files | ${tc.testFiles} |
-| Line Coverage | ${tc.coverage?.lines ? tc.coverage.lines + '%' : 'N/A'} |
-| Statement Coverage | ${tc.coverage?.statements ? tc.coverage.statements + '%' : 'N/A'} |
-| Branch Coverage | ${tc.coverage?.branches ? tc.coverage.branches + '%' : 'N/A'} |
-| Function Coverage | ${tc.coverage?.functions ? tc.coverage.functions + '%' : 'N/A'} |
-
-${tc.coverage ? this.generateCoverageChart(tc.coverage) : '_No coverage data available. Run `npm test -- --coverage` to generate._'}
-
----`);
-
-    // Dependencies
-    const deps = metrics.dependencies;
-    sections.push(`## ${METRIC_CATEGORIES.DEPENDENCIES.emoji} Dependencies
-
-**Score:** ${deps.score}/100
-
-| Metric | Value |
-|--------|-------|
-| Total Dependencies | ${deps.total} |
-| Direct | ${deps.direct} |
-| Dev | ${deps.dev} |
-| Outdated | ${deps.outdated.length} |
-
-### Vulnerabilities
-
-| Severity | Count |
-|----------|-------|
-| 🔴 Critical | ${deps.vulnerabilities.critical || 0} |
-| 🟠 High | ${deps.vulnerabilities.high || 0} |
-| 🟡 Medium | ${deps.vulnerabilities.medium || 0} |
-| 🟢 Low | ${deps.vulnerabilities.low || 0} |
-
-${deps.outdated.length > 0 ? `
-### Outdated Packages (${deps.outdated.length})
-
-| Package | Current | Wanted | Latest |
-|---------|---------|--------|--------|
-${deps.outdated.slice(0, 10).map(p => `| ${p.name} | ${p.current} | ${p.wanted} | ${p.latest} |`).join('\n')}
-${deps.outdated.length > 10 ? `\n_...and ${deps.outdated.length - 10} more_` : ''}
-` : '✅ All packages are up to date'}
-
----`);
-
-    // Security
-    const sec = metrics.security;
-    sections.push(`## ${METRIC_CATEGORIES.SECURITY.emoji} Security
-
-**Score:** ${sec.score}/100
-
-| Check | Status |
-|-------|--------|
-| Secrets Exposed | ${sec.secretsExposed === 0 ? '✅ None found' : `❌ ${sec.secretsExposed} potential issues`} |
-| Authentication | ${sec.authConfigured ? '✅ Configured' : '⚠️ Not detected'} |
-| Input Validation | ${sec.inputValidation ? '✅ Configured' : '⚠️ Not detected'} |
-| CSRF Protection | ${sec.csrfProtection ? '✅ Middleware found' : '⚠️ Not detected'} |
-
-${sec.issues.length > 0 ? `
-### Issues
-
-${sec.issues.map(i => `- ⚠️ ${i}`).join('\n')}
-` : ''}
-
----`);
-
-    // Performance
-    const perf = metrics.performance;
-    sections.push(`## ${METRIC_CATEGORIES.PERFORMANCE.emoji} Performance
-
-**Score:** ${perf.score}/100
-
-| Metric | Value |
-|--------|-------|
-| Bundle Size | ${perf.bundleSize ? this.formatBytes(perf.bundleSize) : 'N/A'} |
-| Build Time | ${perf.buildTime ? perf.buildTime + 's' : 'N/A'} |
-| Lighthouse Score | ${perf.lighthouseScore || 'N/A'} |
-
-### Recommendations
-
-- Run \`npm run build\` and check bundle size
-- Use \`@next/bundle-analyzer\` to identify large dependencies
-- Run Lighthouse audits for production performance
-
----`);
-
-    // Trends (if history available)
-    const healthData = this.loadHealthData();
-    if (healthData.history.length > 1) {
-      const recent = healthData.history.slice(-7);
-      sections.push(`## Trends (Last 7 Days)
-
-\`\`\`
-${this.generateTrendChart(recent)}
-\`\`\`
-
----`);
-    }
-
-    // Footer
-    sections.push(`---
-
-*Generated by [Bootspring](https://bootspring.com) Health Generator*
-
-### Commands
-
-\`\`\`bash
-bootspring docs health          # Generate this report
-bootspring docs health --json   # Output as JSON
-bootspring docs health --watch  # Continuous monitoring
-\`\`\`
-`);
-
-    return sections.join('\n\n');
-  }
-
-  /**
-   * Generate progress bar
-   */
-  generateProgressBar(percent, width = 20) {
-    const filled = Math.round((percent / 100) * width);
-    const empty = width - filled;
-    return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
-  }
-
-  /**
-   * Generate coverage chart
-   */
-  generateCoverageChart(coverage) {
-    return `
-\`\`\`
-Lines:      ${this.generateProgressBar(coverage.lines)} ${coverage.lines}%
-Statements: ${this.generateProgressBar(coverage.statements)} ${coverage.statements}%
-Branches:   ${this.generateProgressBar(coverage.branches)} ${coverage.branches}%
-Functions:  ${this.generateProgressBar(coverage.functions)} ${coverage.functions}%
-\`\`\`
-`;
-  }
-
-  /**
-   * Generate trend chart
-   */
-  generateTrendChart(history) {
-    const height = 8;
-    const maxScore = 100;
-
-    const chart = [];
-    for (let row = 0; row <= height; row++) {
-      const scoreThreshold = maxScore - (row * (maxScore / height));
-      let line = `${Math.round(scoreThreshold).toString().padStart(3)} |`;
-
-      for (const entry of history) {
-        const score = entry.overallScore || 0;
-        if (score >= scoreThreshold - (maxScore / height / 2) && score < scoreThreshold + (maxScore / height / 2)) {
-          line += '●';
-        } else if (score > scoreThreshold) {
-          line += '│';
-        } else {
-          line += ' ';
-        }
-      }
-      chart.push(line);
-    }
-
-    chart.push('    +' + '─'.repeat(history.length));
-
-    return chart.join('\n');
-  }
-
-  /**
-   * Format bytes
-   */
-  formatBytes(bytes) {
-    if (bytes < 1024) return bytes + ' B';
-    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
-    return (bytes / 1024 / 1024).toFixed(1) + ' MB';
-  }
-
-  /**
-   * Find file in project
-   */
-  findFile(names) {
-    for (const name of names) {
-      const filePath = path.join(this.projectRoot, name);
-      if (fs.existsSync(filePath)) {
-        return filePath;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Simple glob sync
-   */
-  globSync(pattern, ignore = []) {
-    const files = [];
-    const baseDir = this.projectRoot;
-
-    const walk = (dir) => {
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          const fullPath = path.join(dir, entry.name);
-          const relativePath = path.relative(baseDir, fullPath);
-
-          // Skip ignored
-          if (ignore.some(i => relativePath.includes(i))) continue;
-
-          if (entry.isDirectory()) {
-            walk(fullPath);
-          } else if (entry.isFile()) {
-            // Simple pattern matching
-            if (this.matchPattern(relativePath, pattern)) {
-              files.push(fullPath);
-            }
-          }
-        }
-      } catch (_err) {
-        // Skip inaccessible directories
-      }
-    };
-
-    walk(baseDir);
-    return files.slice(0, 500); // Limit for performance
-  }
-
-  /**
-   * Match file against pattern
-   */
-  matchPattern(file, pattern) {
-    // Convert glob to regex
-    const regex = pattern
-      .replace(/\*\*/g, '.*')
-      .replace(/\*/g, '[^/]*')
-      .replace(/\./g, '\\.')
-      .replace(/\{([^}]+)\}/g, (_, p) => `(${p.split(',').join('|')})`);
-
-    return new RegExp(regex).test(file);
-  }
-
-  /**
-   * Get directory size
-   */
-  getDirectorySize(dirPath) {
-    let size = 0;
-    const walk = (dir) => {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          walk(fullPath);
-        } else {
-          size += fs.statSync(fullPath).size;
-        }
-      }
-    };
-    walk(dirPath);
-    return size;
-  }
-
-  /**
-   * Record metrics to history
-   */
-  recordMetrics(metrics) {
-    const data = this.loadHealthData();
-
-    data.history.push({
-      date: new Date().toISOString().split('T')[0],
-      overallScore: metrics.overallScore,
-      codeQuality: metrics.codeQuality.score,
-      testCoverage: metrics.testCoverage.score,
-      dependencies: metrics.dependencies.score,
-      security: metrics.security.score,
-      performance: metrics.performance.score
-    });
-
-    // Keep only last N days
-    const cutoff = new Date();
-    cutoff.setDate(cutoff.getDate() - this.maxHistoryDays);
-    data.history = data.history.filter(h => new Date(h.date) >= cutoff);
-
-    this.saveHealthData(data);
-  }
-}
-
-/**
- * Generate HEALTH.md
- */
-async function generate(options = {}) {
-  const generator = new HealthGenerator(options);
-  const metrics = await generator.collectMetrics();
-
-  // Record to history
-  generator.recordMetrics(metrics);
-
-  return generator.generate(metrics);
-}
-
-/**
- * Collect metrics only
- */
-async function collectMetrics(options = {}) {
-  const generator = new HealthGenerator(options);
-  return generator.collectMetrics();
-}
-
-module.exports = {
-  HealthGenerator,
-  generate,
-  collectMetrics,
-  HEALTH_STATUS,
-  METRIC_CATEGORIES
-};