@sun-asterisk/sunlint 1.0.7 → 1.1.4

package/scripts/merge-reports.js

@@ -0,0 +1,424 @@
+#!/usr/bin/env node
+
+/**
+ * Report Merger - Combines ESLint and SunLint results into unified report
+ * Usage: node merge-reports.js eslint-results.json sunlint-results.json --format=summary --output=unified.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Command } = require('commander');
+const chalk = require('chalk');
+
+class ReportMerger {
+  constructor() {
+    this.version = '1.0.0';
+  }
+
+  async mergeReports(eslintPath, sunlintPath, options = {}) {
+    const eslintReport = this.loadReport(eslintPath, 'eslint');
+    const sunlintReport = this.loadReport(sunlintPath, 'sunlint');
+
+    const unifiedReport = {
+      metadata: {
+        timestamp: new Date().toISOString(),
+        merger_version: this.version,
+        input_files: {
+          eslint: eslintPath,
+          sunlint: sunlintPath
+        },
+        tools: {
+          eslint: this.extractESLintMetadata(eslintReport),
+          sunlint: this.extractSunLintMetadata(sunlintReport)
+        }
+      },
+      summary: this.generateSummary(eslintReport, sunlintReport),
+      violations: this.mergeViolations(eslintReport, sunlintReport),
+      files: this.mergeFileAnalysis(eslintReport, sunlintReport),
+      rules: this.mergeRuleAnalysis(eslintReport, sunlintReport),
+      raw_reports: {
+        eslint: eslintReport,
+        sunlint: sunlintReport
+      }
+    };
+
+    return unifiedReport;
+  }
+
+  loadReport(filePath, toolName) {
+    if (!fs.existsSync(filePath)) {
+      console.warn(chalk.yellow(`⚠️  ${toolName} report not found: ${filePath}`));
+      return this.getEmptyReport(toolName);
+    }
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to parse ${toolName} report: ${error.message}`));
+      return this.getEmptyReport(toolName);
+    }
+  }
+
+  getEmptyReport(toolName) {
+    return {
+      tool: toolName,
+      files: [],
+      violations: [],
+      summary: { total: 0, errors: 0, warnings: 0, info: 0 }
+    };
+  }
+
+  extractESLintMetadata(report) {
+    return {
+      version: report.version || 'unknown',
+      rules_count: report.rules ? Object.keys(report.rules).length : 0,
+      files_analyzed: report.files ? report.files.length : 0
+    };
+  }
+
+  extractSunLintMetadata(report) {
+    return {
+      version: report.version || 'unknown',
+      rules_count: report.rulesRun || 0,
+      files_analyzed: report.filesAnalyzed || 0,
+      ai_enabled: report.aiEnabled || false
+    };
+  }
+
+  generateSummary(eslintReport, sunlintReport) {
+    const eslintSummary = this.getSummaryFromReport(eslintReport, 'eslint');
+    const sunlintSummary = this.getSummaryFromReport(sunlintReport, 'sunlint');
+
+    return {
+      total: {
+        files: eslintSummary.files + sunlintSummary.files,
+        violations: eslintSummary.violations + sunlintSummary.violations,
+        errors: eslintSummary.errors + sunlintSummary.errors,
+        warnings: eslintSummary.warnings + sunlintSummary.warnings,
+        info: eslintSummary.info + sunlintSummary.info
+      },
+      by_tool: {
+        eslint: eslintSummary,
+        sunlint: sunlintSummary
+      },
+      breakdown: {
+        overlap_files: this.countOverlapFiles(eslintReport, sunlintReport),
+        unique_eslint_rules: this.getUniqueRules(eslintReport, 'eslint'),
+        unique_sunlint_rules: this.getUniqueRules(sunlintReport, 'sunlint')
+      }
+    };
+  }
+
+  getSummaryFromReport(report, toolName) {
+    if (toolName === 'eslint') {
+      // ESLint format
+      const violations = this.extractESLintViolations(report);
+      return {
+        files: report.files ? report.files.length : 0,
+        violations: violations.length,
+        errors: violations.filter(v => v.severity === 'error').length,
+        warnings: violations.filter(v => v.severity === 'warning').length,
+        info: violations.filter(v => v.severity === 'info').length
+      };
+    } else {
+      // SunLint format
+      const violations = report.results ? 
+        report.results.flatMap(r => r.violations || []) : [];
+      return {
+        files: report.filesAnalyzed || 0,
+        violations: violations.length,
+        errors: violations.filter(v => v.severity === 'error').length,
+        warnings: violations.filter(v => v.severity === 'warning').length,
+        info: violations.filter(v => v.severity === 'info').length
+      };
+    }
+  }
+
+  mergeViolations(eslintReport, sunlintReport) {
+    const eslintViolations = this.extractESLintViolations(eslintReport);
+    const sunlintViolations = this.extractSunLintViolations(sunlintReport);
+
+    const allViolations = [
+      ...eslintViolations.map(v => ({ ...v, tool: 'eslint' })),
+      ...sunlintViolations.map(v => ({ ...v, tool: 'sunlint' }))
+    ];
+
+    // Sort by severity and file
+    return allViolations.sort((a, b) => {
+      const severityOrder = { error: 0, warning: 1, info: 2 };
+      if (a.severity !== b.severity) {
+        return severityOrder[a.severity] - severityOrder[b.severity];
+      }
+      return a.file.localeCompare(b.file);
+    });
+  }
+
+  extractESLintViolations(report) {
+    if (!report.files || !Array.isArray(report.files)) return [];
+    
+    return report.files.flatMap(file => 
+      (file.messages || []).map(msg => ({
+        file: file.filePath || file.file,
+        line: msg.line,
+        column: msg.column,
+        ruleId: msg.ruleId,
+        message: msg.message,
+        severity: this.mapESLintSeverity(msg.severity)
+      }))
+    );
+  }
+
+  extractSunLintViolations(report) {
+    if (!report.results || !Array.isArray(report.results)) return [];
+    
+    return report.results.flatMap(result =>
+      (result.violations || []).map(violation => ({
+        file: violation.file,
+        line: violation.line,
+        column: violation.column,
+        ruleId: violation.ruleId,
+        message: violation.message,
+        severity: violation.severity
+      }))
+    );
+  }
+
+  mapESLintSeverity(severity) {
+    switch (severity) {
+      case 1: return 'warning';
+      case 2: return 'error';
+      default: return 'info';
+    }
+  }
+
+  mergeFileAnalysis(eslintReport, sunlintReport) {
+    const fileMap = new Map();
+
+    // Process ESLint files
+    if (eslintReport.files) {
+      eslintReport.files.forEach(file => {
+        const fileName = file.filePath || file.file;
+        fileMap.set(fileName, {
+          file: fileName,
+          eslint: {
+            violations: file.messages ? file.messages.length : 0,
+            rules_triggered: [...new Set((file.messages || []).map(m => m.ruleId))]
+          },
+          sunlint: { violations: 0, rules_triggered: [] }
+        });
+      });
+    }
+
+    // Process SunLint files
+    if (sunlintReport.results) {
+      sunlintReport.results.forEach(result => {
+        const fileName = result.file;
+        if (!fileMap.has(fileName)) {
+          fileMap.set(fileName, {
+            file: fileName,
+            eslint: { violations: 0, rules_triggered: [] },
+            sunlint: { violations: 0, rules_triggered: [] }
+          });
+        }
+        
+        const fileData = fileMap.get(fileName);
+        fileData.sunlint = {
+          violations: result.violations ? result.violations.length : 0,
+          rules_triggered: [...new Set((result.violations || []).map(v => v.ruleId))]
+        };
+      });
+    }
+
+    return Array.from(fileMap.values());
+  }
+
+  mergeRuleAnalysis(eslintReport, sunlintReport) {
+    const ruleMap = new Map();
+
+    // Analyze ESLint rules
+    this.extractESLintViolations(eslintReport).forEach(violation => {
+      if (!ruleMap.has(violation.ruleId)) {
+        ruleMap.set(violation.ruleId, {
+          rule: violation.ruleId,
+          tool: 'eslint',
+          violations: 0,
+          files: new Set()
+        });
+      }
+      const rule = ruleMap.get(violation.ruleId);
+      rule.violations++;
+      rule.files.add(violation.file);
+    });
+
+    // Analyze SunLint rules
+    this.extractSunLintViolations(sunlintReport).forEach(violation => {
+      if (!ruleMap.has(violation.ruleId)) {
+        ruleMap.set(violation.ruleId, {
+          rule: violation.ruleId,
+          tool: 'sunlint',
+          violations: 0,
+          files: new Set()
+        });
+      }
+      const rule = ruleMap.get(violation.ruleId);
+      rule.violations++;
+      rule.files.add(violation.file);
+    });
+
+    // Convert Sets to arrays and sort
+    return Array.from(ruleMap.values())
+      .map(rule => ({
+        ...rule,
+        files: Array.from(rule.files),
+        files_count: rule.files.size
+      }))
+      .sort((a, b) => b.violations - a.violations);
+  }
+
+  countOverlapFiles(eslintReport, sunlintReport) {
+    const eslintFiles = new Set();
+    const sunlintFiles = new Set();
+
+    if (eslintReport.files) {
+      eslintReport.files.forEach(f => eslintFiles.add(f.filePath || f.file));
+    }
+    
+    if (sunlintReport.results) {
+      sunlintReport.results.forEach(r => sunlintFiles.add(r.file));
+    }
+
+    return [...eslintFiles].filter(file => sunlintFiles.has(file)).length;
+  }
+
+  getUniqueRules(report, toolName) {
+    if (toolName === 'eslint') {
+      return [...new Set(this.extractESLintViolations(report).map(v => v.ruleId))];
+    } else {
+      return [...new Set(this.extractSunLintViolations(report).map(v => v.ruleId))];
+    }
+  }
+
+  formatReport(unifiedReport, format) {
+    switch (format) {
+      case 'json':
+        return JSON.stringify(unifiedReport, null, 2);
+      case 'summary':
+        return this.formatSummary(unifiedReport);
+      case 'github':
+        return this.formatGitHub(unifiedReport);
+      case 'detailed':
+        return this.formatDetailed(unifiedReport);
+      default:
+        return this.formatSummary(unifiedReport);
+    }
+  }
+
+  formatSummary(report) {
+    const { summary } = report;
+    return `
+🎯 Sun* Engineering - Unified Code Quality Report
+════════════════════════════════════════════════
+
+📊 Overall Summary:
+  Files analyzed: ${summary.total.files}
+  Total violations: ${summary.total.violations}
+  
+🚨 By Severity:
+  Errors: ${summary.total.errors}
+  Warnings: ${summary.total.warnings}  
+  Info: ${summary.total.info}
+
+🔧 By Tool:
+  ESLint: ${summary.by_tool.eslint.violations} violations (${summary.by_tool.eslint.files} files)
+  SunLint: ${summary.by_tool.sunlint.violations} violations (${summary.by_tool.sunlint.files} files)
+
+📁 Coverage:
+  Overlap files: ${summary.breakdown.overlap_files}
+  ESLint rules: ${summary.breakdown.unique_eslint_rules.length}
+  SunLint rules: ${summary.breakdown.unique_sunlint_rules.length}
+
+Generated: ${report.metadata.timestamp}
+`;
+  }
+
+  formatGitHub(report) {
+    const annotations = report.violations
+      .filter(v => v.severity === 'error')
+      .slice(0, 10) // GitHub limits annotations
+      .map(v => `::error file=${v.file},line=${v.line}::${v.message} (${v.ruleId})`)
+      .join('\n');
+
+    return annotations + '\n' + this.formatSummary(report);
+  }
+
+  formatDetailed(report) {
+    let output = this.formatSummary(report);
+    
+    output += '\n🔍 Top Violated Rules:\n';
+    report.rules.slice(0, 10).forEach(rule => {
+      output += `  ${rule.rule}: ${rule.violations} violations (${rule.files_count} files) [${rule.tool}]\n`;
+    });
+
+    output += '\n📁 Most Problematic Files:\n';
+    const filesByViolations = report.files
+      .map(f => ({
+        ...f,
+        total: f.eslint.violations + f.sunlint.violations
+      }))
+      .sort((a, b) => b.total - a.total)
+      .slice(0, 10);
+
+    filesByViolations.forEach(file => {
+      output += `  ${file.file}: ${file.total} violations (ESLint: ${file.eslint.violations}, SunLint: ${file.sunlint.violations})\n`;
+    });
+
+    return output;
+  }
+}
+
+// CLI
+const program = new Command();
+
+program
+  .name('merge-reports')
+  .description('Merge ESLint and SunLint reports into unified report')
+  .version('1.0.0')
+  .argument('<eslint-report>', 'ESLint JSON report file')
+  .argument('<sunlint-report>', 'SunLint JSON report file')
+  .option('-f, --format <format>', 'Output format (json,summary,github,detailed)', 'summary')
+  .option('-o, --output <file>', 'Output file (default: console)')
+  .option('--verbose', 'Verbose logging');
+
+program.action(async (eslintReport, sunlintReport, options) => {
+  try {
+    const merger = new ReportMerger();
+    
+    if (options.verbose) {
+      console.log(chalk.blue('🔄 Merging reports...'));
+      console.log(`ESLint: ${eslintReport}`);
+      console.log(`SunLint: ${sunlintReport}`);
+    }
+
+    const unifiedReport = await merger.mergeReports(eslintReport, sunlintReport, options);
+    const formattedOutput = merger.formatReport(unifiedReport, options.format);
+
+    if (options.output) {
+      fs.writeFileSync(options.output, formattedOutput);
+      console.log(chalk.green(`✅ Unified report saved: ${options.output}`));
+    } else {
+      console.log(formattedOutput);
+    }
+
+  } catch (error) {
+    console.error(chalk.red('❌ Report merge failed:'), error.message);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+});
+
+program.parse();
+
+module.exports = ReportMerger;

package/scripts/pre-release-test.sh

@@ -0,0 +1,175 @@
+#!/bin/bash
+
+# SunLint v1.0.5 Pre-Release Test Suite
+# Comprehensive testing before triggering actual release
+
+set -e
+
+echo "🧪 =========================================="
+echo "☀️  SunLint v1.0.5 Pre-Release Test Suite"
+echo "🧪 =========================================="
+echo ""
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Test results tracking
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+# Function to run test with validation
+run_test() {
+    local test_name="$1"
+    local command="$2"
+    local expected_pattern="$3"
+    
+    echo -e "${BLUE}🧪 Testing: $test_name${NC}"
+    echo -e "${YELLOW}Command: $command${NC}"
+    
+    if output=$(eval $command 2>&1); then
+        if [[ -z "$expected_pattern" ]] || echo "$output" | grep -q "$expected_pattern"; then
+            echo -e "${GREEN}✅ PASS${NC}"
+            ((TESTS_PASSED++))
+        else
+            echo -e "${RED}❌ FAIL - Expected pattern not found: $expected_pattern${NC}"
+            echo "Output: $output"
+            ((TESTS_FAILED++))
+        fi
+    else
+        echo -e "${RED}❌ FAIL - Command failed${NC}"
+        echo "Error: $output"
+        ((TESTS_FAILED++))
+    fi
+    echo ""
+}
+
+# Test 1: Package.json validation
+run_test "Package.json Structure" "node -e 'console.log(JSON.parse(require(\"fs\").readFileSync(\"package.json\")).name)'" "@sun-asterisk/sunlint"
+
+# Test 2: GitHub Package config
+run_test "GitHub Package Config" "node -e 'console.log(JSON.parse(require(\"fs\").readFileSync(\"package-github.json\")).name)'" "@sun-asterisk/sunlint"
+
+# Test 3: CLI basic functionality
+run_test "CLI Version Check" "node cli.js --version" "1.0.5"
+
+# Test 4: Help output
+run_test "CLI Help" "node cli.js --help" "Sun Lint"
+
+# Test 5: Basic rule execution
+run_test "Basic Rule Execution" "node cli.js --rule=C006 --input=examples/integration/src --format=summary" "C006"
+
+# Test 6: Multiple rules
+run_test "Multiple Rules" "node cli.js --rules=C006,C019 --input=examples/integration/src --format=summary" "violations"
+
+# Test 7: TypeScript engine
+run_test "TypeScript Engine" "node cli.js --typescript --rule=C006 --input=examples/integration/src --format=summary" "TypeScript"
+
+# Test 8: Git integration (if in git repo)
+if git rev-parse --git-dir > /dev/null 2>&1; then
+    run_test "Git Integration Check" "node cli.js --all --changed-files --format=summary || echo 'No changed files'" ""
+else
+    echo -e "${YELLOW}⚠️  Skipping Git integration test (not in git repo)${NC}"
+fi
+
+# Test 9: Configuration file validation
+run_test "Config File Validation" "node cli.js --config=examples/integration/.sunlint.json --input=examples/integration/src --format=summary --dry-run" "Dry run"
+
+# Test 10: ESLint integration test
+if [ -f "examples/integration/.eslintrc.json" ]; then
+    run_test "ESLint Integration" "node cli.js --all --eslint-integration --input=examples/integration/src --format=summary" "integration"
+else
+    echo -e "${YELLOW}⚠️  Skipping ESLint integration test (no .eslintrc.json)${NC}"
+fi
+
+# Test 11: Package structure validation
+run_test "Required Files Check" "ls cli.js core/ rules/ config/ examples/ docs/ README.md" "cli.js"
+
+# Test 12: Dependencies check
+run_test "Dependencies Installation" "npm ls --depth=0" "sunlint"
+
+# Test 13: Build test (npm pack)
+echo -e "${BLUE}🧪 Testing: Package Build${NC}"
+if npm pack > /dev/null 2>&1; then
+    if ls *.tgz > /dev/null 2>&1; then
+        echo -e "${GREEN}✅ PASS - Package built successfully${NC}"
+        ((TESTS_PASSED++))
+        # Cleanup
+        rm -f *.tgz
+    else
+        echo -e "${RED}❌ FAIL - No tarball generated${NC}"
+        ((TESTS_FAILED++))
+    fi
+else
+    echo -e "${RED}❌ FAIL - npm pack failed${NC}"
+    ((TESTS_FAILED++))
+fi
+echo ""
+
+# Test 14: GitHub Actions workflow validation
+echo -e "${BLUE}🧪 Testing: GitHub Actions Workflow${NC}"
+if [ -f "../../../.github/workflows/release-sunlint.yml" ]; then
+    echo -e "${GREEN}✅ PASS - Release workflow exists${NC}"
+    ((TESTS_PASSED++))
+else
+    echo -e "${RED}❌ FAIL - Release workflow missing${NC}"
+    ((TESTS_FAILED++))
+fi
+echo ""
+
+# Test 15: Documentation completeness
+echo -e "${BLUE}🧪 Testing: Documentation Completeness${NC}"
+required_docs=("README.md" "docs/ESLINT_INTEGRATION.md" "docs/RELEASE_GUIDE.md" "examples/integration/package.json")
+docs_missing=0
+
+for doc in "${required_docs[@]}"; do
+    if [ ! -f "$doc" ]; then
+        echo -e "${RED}❌ Missing: $doc${NC}"
+        ((docs_missing++))
+    fi
+done
+
+if [ $docs_missing -eq 0 ]; then
+    echo -e "${GREEN}✅ PASS - All documentation present${NC}"
+    ((TESTS_PASSED++))
+else
+    echo -e "${RED}❌ FAIL - $docs_missing documentation files missing${NC}"
+    ((TESTS_FAILED++))
+fi
+echo ""
+
+# Summary
+echo "🎯 =========================================="
+echo "📊 Test Results Summary"
+echo "🎯 =========================================="
+echo -e "${GREEN}✅ Tests Passed: $TESTS_PASSED${NC}"
+echo -e "${RED}❌ Tests Failed: $TESTS_FAILED${NC}"
+echo ""
+
+if [ $TESTS_FAILED -eq 0 ]; then
+    echo -e "${GREEN}🎉 ALL TESTS PASSED! Ready for release! 🚀${NC}"
+    echo ""
+    echo "📋 Next Steps:"
+    echo "1. Run GitHub Actions release workflow"
+    echo "2. Verify GitHub Package Registry publication"
+    echo "3. Test installation from both sources"
+    echo "4. Update documentation with release links"
+    echo ""
+    echo "🔗 Trigger release workflow:"
+    echo "https://github.com/sun-asterisk/engineer-excellence/actions/workflows/release-sunlint.yml"
+    
+    exit 0
+else
+    echo -e "${RED}💥 TESTS FAILED! Please fix issues before release.${NC}"
+    echo ""
+    echo "🔧 Common fixes:"
+    echo "- Check package.json configuration"
+    echo "- Verify all dependencies are installed"
+    echo "- Ensure example files exist"
+    echo "- Check file permissions"
+    
+    exit 1
+fi