claude-flow-novice 2.3.5 → 2.3.6

package/dist/scripts/test/coverage-report.ts

@@ -1,692 +0,0 @@
-#!/usr/bin/env -S deno run --allow-all
-/**
- * Advanced coverage analysis and reporting
- */
-
-import { parseArgs } from "https://deno.land/std@0.220.0/cli/parse_args.ts";
-import { exists } from "https://deno.land/std@0.220.0/fs/exists.ts";
-import { ensureDir } from "https://deno.land/std@0.220.0/fs/ensure_dir.ts";
-import { walk } from "https://deno.land/std@0.220.0/fs/walk.ts";
-
-interface CoverageData {
-  url: string;
-  ranges: Array<{
-    start: { line: number; col: number };
-    end: { line: number; col: number };
-  }>;
-}
-
-interface FileCoverage {
-  path: string;
-  totalLines: number;
-  coveredLines: number;
-  uncoveredLines: number[];
-  coverage: number;
-  functions: FunctionCoverage[];
-}
-
-interface FunctionCoverage {
-  name: string;
-  line: number;
-  covered: boolean;
-}
-
-interface CoverageReport {
-  timestamp: string;
-  summary: {
-    totalFiles: number;
-    totalLines: number;
-    coveredLines: number;
-    coverage: number;
-    thresholds: {
-      statements: number;
-      branches: number;
-      functions: number;
-      lines: number;
-    };
-    passed: boolean;
-  };
-  files: FileCoverage[];
-  uncoveredFiles: string[];
-}
-
-class CoverageAnalyzer {
-  private sourceDir: string;
-  private coverageDir: string;
-  private outputDir: string;
-  private thresholds: {
-    statements: number;
-    branches: number;
-    functions: number;
-    lines: number;
-  };
-
-  constructor(options: {
-    sourceDir: string;
-    coverageDir: string;
-    outputDir: string;
-    thresholds: {
-      statements: number;
-      branches: number;
-      functions: number;
-      lines: number;
-    };
-  }) {
-    this.sourceDir = options.sourceDir;
-    this.coverageDir = options.coverageDir;
-    this.outputDir = options.outputDir;
-    this.thresholds = options.thresholds;
-  }
-
-  async generateReport(): Promise<CoverageReport> {
-    console.log("📊 Analyzing coverage data...");
-
-    await ensureDir(this.outputDir);
-
-    // Load coverage data
-    const coverageData = await this.loadCoverageData();
-    
-    // Get all source files
-    const sourceFiles = await this.getSourceFiles();
-    
-    // Analyze each file
-    const fileAnalysis = await this.analyzeFiles(sourceFiles, coverageData);
-    
-    // Find uncovered files
-    const coveredFiles = new Set(coverageData.map(d => this.normalizePath(d.url)));
-    const uncoveredFiles = sourceFiles.filter(file => !coveredFiles.has(file));
-
-    // Calculate summary
-    const summary = this.calculateSummary(fileAnalysis, uncoveredFiles.length);
-
-    const report: CoverageReport = {
-      timestamp: new Date().toISOString(),
-      summary,
-      files: fileAnalysis,
-      uncoveredFiles,
-    };
-
-    // Generate various report formats
-    await this.generateHTMLReport(report);
-    await this.generateJSONReport(report);
-    await this.generateTextReport(report);
-    await this.generateBadges(report);
-
-    return report;
-  }
-
-  private async loadCoverageData(): Promise<CoverageData[]> {
-    const coverageFiles: CoverageData[] = [];
-
-    if (!await exists(this.coverageDir)) {
-      throw new Error(`Coverage directory not found: ${this.coverageDir}`);
-    }
-
-    for await (const entry of walk(this.coverageDir, { 
-      exts: [".json"],
-      includeDirs: false 
-    })) {
-      const content = await Deno.readTextFile(entry.path);
-      const data = JSON.parse(content);
-      
-      if (data.url && data.ranges) {
-        coverageFiles.push(data);
-      }
-    }
-
-    return coverageFiles;
-  }
-
-  private async getSourceFiles(): Promise<string[]> {
-    const files: string[] = [];
-
-    for await (const entry of walk(this.sourceDir, {
-      exts: [".ts"],
-      includeDirs: false,
-      skip: [/\.test\.ts$/, /test\.ts$/, /tests?\//]
-    })) {
-      // Normalize path
-      const relativePath = entry.path.replace(Deno.cwd() + "/", "");
-      files.push(relativePath);
-    }
-
-    return files;
-  }
-
-  private normalizePath(url: string): string {
-    // Convert file:// URLs to relative paths
-    if (url.startsWith("file://")) {
-      url = url.replace("file://", "");
-    }
-    
-    // Remove leading slash and make relative to cwd
-    const cwd = Deno.cwd();
-    if (url.startsWith(cwd)) {
-      url = url.replace(cwd + "/", "");
-    }
-    
-    return url;
-  }
-
-  private async analyzeFiles(sourceFiles: string[], coverageData: CoverageData[]): Promise<FileCoverage[]> {
-    const analysis: FileCoverage[] = [];
-
-    for (const file of sourceFiles) {
-      const coverage = coverageData.find(d => this.normalizePath(d.url) === file);
-      const fileAnalysis = await this.analyzeFile(file, coverage);
-      analysis.push(fileAnalysis);
-    }
-
-    return analysis;
-  }
-
-  private async analyzeFile(filePath: string, coverage?: CoverageData): Promise<FileCoverage> {
-    const content = await Deno.readTextFile(filePath);
-    const lines = content.split('\n');
-    const totalLines = lines.filter(line => line.trim() && !line.trim().startsWith('//')).length;
-
-    if (!coverage) {
-      return {
-        path: filePath,
-        totalLines,
-        coveredLines: 0,
-        uncoveredLines: Array.from({ length: totalLines }, (_, i) => i + 1),
-        coverage: 0,
-        functions: this.extractFunctions(content, false),
-      };
-    }
-
-    // Analyze covered lines
-    const coveredLines = new Set<number>();
-    
-    for (const range of coverage.ranges) {
-      for (let line = range.start.line; line <= range.end.line; line++) {
-        coveredLines.add(line);
-      }
-    }
-
-    const uncoveredLines: number[] = [];
-    for (let i = 1; i <= lines.length; i++) {
-      const line = lines[i - 1].trim();
-      if (line && !line.startsWith('//') && !coveredLines.has(i)) {
-        uncoveredLines.push(i);
-      }
-    }
-
-    const coveragePercent = totalLines > 0 ? ((totalLines - uncoveredLines.length) / totalLines) * 100 : 100;
-
-    return {
-      path: filePath,
-      totalLines,
-      coveredLines: totalLines - uncoveredLines.length,
-      uncoveredLines,
-      coverage: coveragePercent,
-      functions: this.extractFunctions(content, true, coveredLines),
-    };
-  }
-
-  private extractFunctions(content: string, checkCoverage: boolean, coveredLines?: Set<number>): FunctionCoverage[] {
-    const functions: FunctionCoverage[] = [];
-    const lines = content.split('\n');
-
-    // Simple regex patterns for TypeScript functions
-    const patterns = [
-      /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/,
-      /^\s*(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/,
-      /^\s*(?:public|private|protected)?\s*(?:async\s+)?(\w+)\s*\(/,
-      /^\s*(\w+)\s*:\s*\([^)]*\)\s*=>/,
-    ];
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      
-      for (const pattern of patterns) {
-        const match = line.match(pattern);
-        if (match) {
-          const functionName = match[1];
-          const lineNumber = i + 1;
-          const covered = checkCoverage ? (coveredLines?.has(lineNumber) ?? false) : false;
-          
-          functions.push({
-            name: functionName,
-            line: lineNumber,
-            covered,
-          });
-          break;
-        }
-      }
-    }
-
-    return functions;
-  }
-
-  private calculateSummary(files: FileCoverage[], uncoveredFileCount: number): CoverageReport['summary'] {
-    const totalFiles = files.length + uncoveredFileCount;
-    const totalLines = files.reduce((sum, file) => sum + file.totalLines, 0);
-    const coveredLines = files.reduce((sum, file) => sum + file.coveredLines, 0);
-    const coverage = totalLines > 0 ? (coveredLines / totalLines) * 100 : 100;
-
-    const passed = coverage >= this.thresholds.lines;
-
-    return {
-      totalFiles,
-      totalLines,
-      coveredLines,
-      coverage,
-      thresholds: this.thresholds,
-      passed,
-    };
-  }
-
-  private async generateHTMLReport(report: CoverageReport): Promise<void> {
-    const fileRows = report.files
-      .sort((a, b) => a.coverage - b.coverage)
-      .map(file => {
-        const coverageClass = file.coverage >= 80 ? 'high' : file.coverage >= 60 ? 'medium' : 'low';
-        const coverageBar = `<div class="coverage-bar"><div class="coverage-fill ${coverageClass}" style="width: ${file.coverage}%"></div></div>`;
-        
-        return `
-          <tr class="${coverageClass}">
-            <td><a href="#file-${file.path.replace(/[^a-zA-Z0-9]/g, '-')}">${file.path}</a></td>
-            <td>${file.coverage.toFixed(2)}%</td>
-            <td>${coverageBar}</td>
-            <td>${file.coveredLines}/${file.totalLines}</td>
-            <td>${file.uncoveredLines.length}</td>
-            <td>${file.functions.filter(f => f.covered).length}/${file.functions.length}</td>
-          </tr>`;
-      }).join('');
-
-    const uncoveredRows = report.uncoveredFiles.map(file => `
-      <tr class="uncovered">
-        <td>${file}</td>
-        <td>0%</td>
-        <td><div class="coverage-bar"><div class="coverage-fill low" style="width: 0%"></div></div></td>
-        <td>0/0</td>
-        <td>-</td>
-        <td>0/0</td>
-      </tr>
-    `).join('');
-
-    const fileDetails = report.files.map(file => {
-      const uncoveredLinesStr = file.uncoveredLines.length > 0
-        ? file.uncoveredLines.slice(0, 20).join(', ') + (file.uncoveredLines.length > 20 ? '...' : '')
-        : 'All lines covered';
-
-      const functionRows = file.functions.map(func => `
-        <tr class="${func.covered ? 'covered' : 'uncovered'}">
-          <td>${func.name}</td>
-          <td>${func.line}</td>
-          <td>${func.covered ? '✅' : '❌'}</td>
-        </tr>
-      `).join('');
-
-      return `
-        <div class="file-detail" id="file-${file.path.replace(/[^a-zA-Z0-9]/g, '-')}">
-          <h3>📄 ${file.path}</h3>
-          <div class="file-summary">
-            <div class="metric">
-              <span class="label">Coverage:</span>
-              <span class="value ${file.coverage >= 80 ? 'high' : file.coverage >= 60 ? 'medium' : 'low'}">${file.coverage.toFixed(2)}%</span>
-            </div>
-            <div class="metric">
-              <span class="label">Lines:</span>
-              <span class="value">${file.coveredLines}/${file.totalLines}</span>
-            </div>
-            <div class="metric">
-              <span class="label">Functions:</span>
-              <span class="value">${file.functions.filter(f => f.covered).length}/${file.functions.length}</span>
-            </div>
-          </div>
-          
-          ${file.uncoveredLines.length > 0 ? `
-            <div class="uncovered-lines">
-              <h4>Uncovered Lines:</h4>
-              <p>${uncoveredLinesStr}</p>
-            </div>
-          ` : ''}
-          
-          ${file.functions.length > 0 ? `
-            <div class="functions">
-              <h4>Functions:</h4>
-              <table>
-                <thead>
-                  <tr>
-                    <th>Function</th>
-                    <th>Line</th>
-                    <th>Covered</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  ${functionRows}
-                </tbody>
-              </table>
-            </div>
-          ` : ''}
-        </div>`;
-    }).join('');
-
-    const html = `<!DOCTYPE html>
-<html>
-<head>
-    <title>Claude-Flow Coverage Report</title>
-    <style>
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 20px; background: #f8f9fa; }
-        .header { background: white; padding: 30px; border-radius: 8px; margin-bottom: 30px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
-        .header h1 { margin: 0; color: #2c3e50; }
-        .header .timestamp { color: #7f8c8d; margin-top: 5px; }
-        
-        .summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-bottom: 30px; }
-        .summary-card { background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); text-align: center; }
-        .summary-card h3 { margin: 0 0 10px 0; color: #2c3e50; font-size: 14px; text-transform: uppercase; }
-        .summary-card .value { font-size: 32px; font-weight: bold; margin: 10px 0; }
-        .summary-card .value.high { color: #27ae60; }
-        .summary-card .value.medium { color: #f39c12; }
-        .summary-card .value.low { color: #e74c3c; }
-        .summary-card .threshold { font-size: 12px; color: #7f8c8d; }
-        
-        .coverage-status { padding: 15px; border-radius: 8px; margin-bottom: 30px; text-align: center; font-weight: bold; }
-        .coverage-status.passed { background: #d4edda; color: #155724; }
-        .coverage-status.failed { background: #f8d7da; color: #721c24; }
-        
-        .files-table { background: white; border-radius: 8px; overflow: hidden; box-shadow: 0 2px 4px rgba(0,0,0,0.1); margin-bottom: 30px; }
-        .files-table h2 { margin: 0; padding: 20px; background: #2c3e50; color: white; }
-        table { width: 100%; border-collapse: collapse; }
-        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ecf0f1; }
-        th { background: #f8f9fa; font-weight: 600; }
-        
-        .coverage-bar { width: 100px; height: 20px; background: #ecf0f1; border-radius: 10px; overflow: hidden; }
-        .coverage-fill { height: 100%; transition: width 0.3s ease; }
-        .coverage-fill.high { background: linear-gradient(90deg, #27ae60, #2ecc71); }
-        .coverage-fill.medium { background: linear-gradient(90deg, #f39c12, #e67e22); }
-        .coverage-fill.low { background: linear-gradient(90deg, #e74c3c, #c0392b); }
-        
-        .high { background-color: rgba(39, 174, 96, 0.1); }
-        .medium { background-color: rgba(243, 156, 18, 0.1); }
-        .low { background-color: rgba(231, 76, 60, 0.1); }
-        .uncovered { background-color: rgba(231, 76, 60, 0.2); }
-        
-        .file-detail { background: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
-        .file-detail h3 { margin: 0 0 15px 0; color: #2c3e50; }
-        .file-summary { display: flex; gap: 20px; margin-bottom: 20px; }
-        .metric { display: flex; flex-direction: column; }
-        .metric .label { font-size: 12px; color: #7f8c8d; text-transform: uppercase; }
-        .metric .value { font-size: 18px; font-weight: bold; margin-top: 5px; }
-        
-        .uncovered-lines { margin: 15px 0; }
-        .uncovered-lines h4 { margin: 0 0 10px 0; color: #e74c3c; }
-        .functions { margin: 15px 0; }
-        .functions h4 { margin: 0 0 10px 0; color: #2c3e50; }
-        .functions table { margin-top: 10px; }
-        .covered { background-color: rgba(39, 174, 96, 0.1); }
-        
-        .footer { text-align: center; margin-top: 40px; color: #7f8c8d; }
-    </style>
-</head>
-<body>
-    <div class="header">
-        <h1>📊 Claude-Flow Coverage Report</h1>
-        <div class="timestamp">Generated: ${report.timestamp}</div>
-    </div>
-    
-    <div class="coverage-status ${report.summary.passed ? 'passed' : 'failed'}">
-        ${report.summary.passed ? '✅ Coverage thresholds passed' : '❌ Coverage thresholds not met'}
-    </div>
-    
-    <div class="summary">
-        <div class="summary-card">
-            <h3>Overall Coverage</h3>
-            <div class="value ${report.summary.coverage >= 80 ? 'high' : report.summary.coverage >= 60 ? 'medium' : 'low'}">${report.summary.coverage.toFixed(2)}%</div>
-            <div class="threshold">Threshold: ${this.thresholds.lines}%</div>
-        </div>
-        <div class="summary-card">
-            <h3>Total Files</h3>
-            <div class="value">${report.summary.totalFiles}</div>
-        </div>
-        <div class="summary-card">
-            <h3>Covered Lines</h3>
-            <div class="value">${report.summary.coveredLines}</div>
-            <div class="threshold">of ${report.summary.totalLines}</div>
-        </div>
-        <div class="summary-card">
-            <h3>Uncovered Files</h3>
-            <div class="value ${report.uncoveredFiles.length === 0 ? 'high' : 'low'}">${report.uncoveredFiles.length}</div>
-        </div>
-    </div>
-    
-    <div class="files-table">
-        <h2>📁 File Coverage</h2>
-        <table>
-            <thead>
-                <tr>
-                    <th>File</th>
-                    <th>Coverage</th>
-                    <th>Progress</th>
-                    <th>Lines</th>
-                    <th>Uncovered</th>
-                    <th>Functions</th>
-                </tr>
-            </thead>
-            <tbody>
-                ${fileRows}
-                ${uncoveredRows}
-            </tbody>
-        </table>
-    </div>
-    
-    <div class="file-details">
-        <h2>📄 File Details</h2>
-        ${fileDetails}
-    </div>
-    
-    <div class="footer">
-        <p>Claude-Flow Coverage Report - Advanced AI Agent Orchestration System</p>
-    </div>
-</body>
-</html>`;
-
-    await Deno.writeTextFile(`${this.outputDir}/coverage-detailed.html`, html);
-    console.log("  ✅ Detailed HTML coverage report generated");
-  }
-
-  private async generateJSONReport(report: CoverageReport): Promise<void> {
-    await Deno.writeTextFile(
-      `${this.outputDir}/coverage-report.json`,
-      JSON.stringify(report, null, 2)
-    );
-    console.log("  ✅ JSON coverage report generated");
-  }
-
-  private async generateTextReport(report: CoverageReport): Promise<void> {
-    const lines: string[] = [];
-    
-    lines.push("📊 CLAUDE-FLOW COVERAGE REPORT");
-    lines.push("=".repeat(50));
-    lines.push(`Generated: ${report.timestamp}`);
-    lines.push("");
-    
-    lines.push("📈 SUMMARY");
-    lines.push("-".repeat(20));
-    lines.push(`Overall Coverage: ${report.summary.coverage.toFixed(2)}%`);
-    lines.push(`Total Files: ${report.summary.totalFiles}`);
-    lines.push(`Covered Lines: ${report.summary.coveredLines}/${report.summary.totalLines}`);
-    lines.push(`Uncovered Files: ${report.uncoveredFiles.length}`);
-    lines.push("");
-    
-    lines.push("🎯 THRESHOLDS");
-    lines.push("-".repeat(20));
-    lines.push(`Lines: ${report.summary.coverage.toFixed(2)}% (threshold: ${report.summary.thresholds.lines}%)`);
-    lines.push(`Status: ${report.summary.passed ? '✅ PASSED' : '❌ FAILED'}`);
-    lines.push("");
-    
-    if (report.files.length > 0) {
-      lines.push("📁 FILES BY COVERAGE");
-      lines.push("-".repeat(20));
-      
-      const sortedFiles = [...report.files].sort((a, b) => a.coverage - b.coverage);
-      
-      for (const file of sortedFiles) {
-        const status = file.coverage >= 80 ? '✅' : file.coverage >= 60 ? '⚠️' : '❌';
-        lines.push(`${status} ${file.path}: ${file.coverage.toFixed(2)}% (${file.coveredLines}/${file.totalLines} lines)`);
-        
-        if (file.uncoveredLines.length > 0 && file.uncoveredLines.length <= 10) {
-          lines.push(`   Uncovered lines: ${file.uncoveredLines.join(', ')}`);
-        } else if (file.uncoveredLines.length > 10) {
-          lines.push(`   Uncovered lines: ${file.uncoveredLines.slice(0, 10).join(', ')}... (+${file.uncoveredLines.length - 10} more)`);
-        }
-      }
-      lines.push("");
-    }
-    
-    if (report.uncoveredFiles.length > 0) {
-      lines.push("🚫 UNCOVERED FILES");
-      lines.push("-".repeat(20));
-      for (const file of report.uncoveredFiles) {
-        lines.push(`❌ ${file}`);
-      }
-      lines.push("");
-    }
-    
-    lines.push("💡 RECOMMENDATIONS");
-    lines.push("-".repeat(20));
-    
-    const lowCoverageFiles = report.files.filter(f => f.coverage < 60);
-    if (lowCoverageFiles.length > 0) {
-      lines.push("• Focus on improving coverage for these files:");
-      for (const file of lowCoverageFiles.slice(0, 5)) {
-        lines.push(`  - ${file.path} (${file.coverage.toFixed(2)}%)`);
-      }
-    }
-    
-    if (report.uncoveredFiles.length > 0) {
-      lines.push("• Add tests for uncovered files:");
-      for (const file of report.uncoveredFiles.slice(0, 5)) {
-        lines.push(`  - ${file}`);
-      }
-    }
-    
-    if (report.summary.coverage >= 90) {
-      lines.push("• Excellent coverage! Consider adding edge case tests.");
-    } else if (report.summary.coverage >= 80) {
-      lines.push("• Good coverage! Focus on critical paths and error handling.");
-    } else {
-      lines.push("• Coverage needs improvement. Add tests for core functionality first.");
-    }
-
-    await Deno.writeTextFile(`${this.outputDir}/coverage-report.txt`, lines.join('\n'));
-    console.log("  ✅ Text coverage report generated");
-  }
-
-  private async generateBadges(report: CoverageReport): Promise<void> {
-    const coverage = report.summary.coverage;
-    const color = coverage >= 90 ? 'brightgreen' :
-                 coverage >= 80 ? 'green' :
-                 coverage >= 70 ? 'yellow' :
-                 coverage >= 60 ? 'orange' : 'red';
-    
-    const badgeUrl = `https://img.shields.io/badge/coverage-${coverage.toFixed(1)}%25-${color}`;
-    
-    const badgeMarkdown = `![Coverage](${badgeUrl})`;
-    const badgeHTML = `<img src="${badgeUrl}" alt="Coverage ${coverage.toFixed(1)}%">`;
-    
-    const badges = {
-      url: badgeUrl,
-      markdown: badgeMarkdown,
-      html: badgeHTML,
-      coverage: coverage.toFixed(1),
-      color,
-      status: report.summary.passed ? 'passed' : 'failed',
-    };
-    
-    await Deno.writeTextFile(
-      `${this.outputDir}/coverage-badges.json`,
-      JSON.stringify(badges, null, 2)
-    );
-    
-    console.log("  ✅ Coverage badges generated");
-  }
-}
-
-async function main(): Promise<void> {
-  const args = parseArgs(Deno.args, {
-    string: ["source-dir", "coverage-dir", "output-dir"],
-    boolean: ["help"],
-    default: {
-      "source-dir": "./src",
-      "coverage-dir": "./tests/results/coverage",
-      "output-dir": "./tests/results",
-    },
-    alias: {
-      h: "help",
-      s: "source-dir",
-      c: "coverage-dir",
-      o: "output-dir",
-    },
-  });
-
-  if (args.help) {
-    console.log(`
-📊 Claude-Flow Coverage Analysis Tool
-
-USAGE:
-  coverage-report.ts [OPTIONS]
-
-OPTIONS:
-  --source-dir, -s     Source code directory (default: ./src)
-  --coverage-dir, -c   Coverage data directory (default: ./tests/results/coverage)
-  --output-dir, -o     Output directory for reports (default: ./tests/results)
-  --help, -h           Show this help
-
-EXAMPLES:
-  # Generate coverage report with defaults
-  ./scripts/coverage-report.ts
-
-  # Custom directories
-  ./scripts/coverage-report.ts --source-dir ./lib --coverage-dir ./coverage --output-dir ./reports
-`);
-    return;
-  }
-
-  const thresholds = {
-    statements: 80,
-    branches: 75,
-    functions: 80,
-    lines: 80,
-  };
-
-  const analyzer = new CoverageAnalyzer({
-    sourceDir: args["source-dir"],
-    coverageDir: args["coverage-dir"],
-    outputDir: args["output-dir"],
-    thresholds,
-  });
-
-  try {
-    const report = await analyzer.generateReport();
-    
-    console.log("\n📊 COVERAGE SUMMARY");
-    console.log("=".repeat(40));
-    console.log(`Overall Coverage: ${report.summary.coverage.toFixed(2)}%`);
-    console.log(`Total Files: ${report.summary.totalFiles}`);
-    console.log(`Covered Lines: ${report.summary.coveredLines}/${report.summary.totalLines}`);
-    console.log(`Uncovered Files: ${report.uncoveredFiles.length}`);
-    
-    const status = report.summary.passed ? "✅ PASSED" : "❌ FAILED";
-    console.log(`Status: ${status}`);
-    
-    console.log(`\n📄 Reports generated in: ${args["output-dir"]}`);
-    console.log(`  - Detailed HTML: coverage-detailed.html`);
-    console.log(`  - JSON Data: coverage-report.json`);
-    console.log(`  - Text Summary: coverage-report.txt`);
-    console.log(`  - Badges: coverage-badges.json`);
-    
-    Deno.exit(report.summary.passed ? 0 : 1);
-    
-  } catch (error) {
-    console.error("❌ Coverage analysis failed:", error.message);
-    Deno.exit(1);
-  }
-}
-
-if (import.meta.main) {
-  main();
-}