@sun-asterisk/sunlint 1.3.9 → 1.3.11

package/core/summary-report-service.js

@@ -0,0 +1,189 @@
+/**
+ * Summary Report Service
+ * Generate summary reports for CI/CD and management dashboards
+ * Following Rule C005: Single responsibility - handle summary report generation
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class SummaryReportService {
+  constructor() {}
+
+  /**
+   * Get Git repository information
+   * @param {string} cwd - Working directory
+   * @returns {Object} Git info including repository URL, branch, and commit hash
+   */
+  getGitInfo(cwd = process.cwd()) {
+    const gitInfo = {
+      repository_url: null,
+      branch: null,
+      commit_hash: null
+    };
+
+    try {
+      // Check if it's a git repository
+      execSync('git rev-parse --git-dir', { cwd, stdio: 'ignore' });
+
+      // Get repository URL (prefer origin)
+      try {
+        const remoteUrl = execSync('git config --get remote.origin.url', { cwd, encoding: 'utf8' }).trim();
+        // Convert SSH URL to HTTPS URL if needed
+        if (remoteUrl.startsWith('git@')) {
+          gitInfo.repository_url = remoteUrl
+            .replace('git@', 'https://')
+            .replace('.com:', '.com/')
+            .replace('.git', '');
+        } else {
+          gitInfo.repository_url = remoteUrl.replace('.git', '');
+        }
+      } catch (error) {
+        // No remote configured
+      }
+
+      // Get current branch
+      try {
+        gitInfo.branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf8' }).trim();
+      } catch (error) {
+        // Can't get branch
+      }
+
+      // Get current commit hash
+      try {
+        gitInfo.commit_hash = execSync('git rev-parse HEAD', { cwd, encoding: 'utf8' }).trim();
+      } catch (error) {
+        // Can't get commit hash
+      }
+    } catch (error) {
+      // Not a git repository - return nulls
+    }
+
+    return gitInfo;
+  }
+
+  /**
+   * Generate summary report from violations
+   * @param {Array} violations - Array of violations
+   * @param {Object} scoringSummary - Scoring summary with score and metrics
+   * @param {Object} options - Additional options
+   * @returns {Object} Summary report in JSON format
+   */
+  generateSummaryReport(violations, scoringSummary, options = {}) {
+    // Get Git information
+    const gitInfo = this.getGitInfo(options.cwd);
+
+    // Override with environment variables if available (from CI/CD)
+    const repository_url = process.env.GITHUB_REPOSITORY 
+      ? `https://github.com/${process.env.GITHUB_REPOSITORY}`
+      : gitInfo.repository_url;
+    
+    const branch = process.env.GITHUB_REF_NAME || gitInfo.branch;
+    const commit_hash = process.env.GITHUB_SHA || gitInfo.commit_hash;
+
+    // Count violations by rule
+    const violationsByRule = {};
+    violations.forEach(violation => {
+      const ruleId = violation.ruleId || 'unknown';
+      if (!violationsByRule[ruleId]) {
+        violationsByRule[ruleId] = {
+          rule_code: ruleId,
+          count: 0,
+          severity: violation.severity || 'warning'
+        };
+      }
+      violationsByRule[ruleId].count++;
+    });
+
+    // Convert to array and sort by count (descending)
+    const violationsSummary = Object.values(violationsByRule)
+      .sort((a, b) => b.count - a.count);
+
+    // Build the summary report
+    const summaryReport = {
+      metadata: {
+        generated_at: new Date().toISOString(),
+        tool: 'SunLint',
+        version: options.version || '1.3.9',
+        analysis_duration_ms: options.duration || 0
+      },
+      repository: {
+        repository_url,
+        branch,
+        commit_hash
+      },
+      quality: {
+        score: scoringSummary.score,
+        grade: scoringSummary.grade,
+        metrics: scoringSummary.metrics
+      },
+      violations: {
+        total: violations.length,
+        by_severity: {
+          errors: scoringSummary.metrics.errors,
+          warnings: scoringSummary.metrics.warnings
+        },
+        by_rule: violationsSummary
+      },
+      analysis: {
+        files_analyzed: options.filesAnalyzed || 0,
+        rules_checked: scoringSummary.metrics.rulesChecked,
+        lines_of_code: scoringSummary.metrics.linesOfCode
+      }
+    };
+
+    return summaryReport;
+  }
+
+  /**
+   * Generate summary report and save to file
+   * @param {Array} violations - Array of violations
+   * @param {Object} scoringSummary - Scoring summary
+   * @param {string} outputPath - Output file path
+   * @param {Object} options - Additional options
+   */
+  saveSummaryReport(violations, scoringSummary, outputPath, options = {}) {
+    const summaryReport = this.generateSummaryReport(violations, scoringSummary, options);
+    
+    // Ensure directory exists
+    const dir = path.dirname(outputPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Write to file with pretty formatting
+    fs.writeFileSync(outputPath, JSON.stringify(summaryReport, null, 2), 'utf8');
+    
+    return summaryReport;
+  }
+
+  /**
+   * Generate a simple text summary for console display
+   * @param {Object} summaryReport - Summary report object
+   * @returns {string} Formatted text summary
+   */
+  formatTextSummary(summaryReport) {
+    const { quality, violations, analysis } = summaryReport;
+    
+    let output = '\n📊 Quality Summary Report\n';
+    output += '━'.repeat(50) + '\n';
+    output += `📈 Quality Score: ${quality.score} (Grade: ${quality.grade})\n`;
+    output += `📁 Files Analyzed: ${analysis.files_analyzed}\n`;
+    output += `📋 Rules Checked: ${analysis.rules_checked}\n`;
+    output += `📏 Lines of Code: ${analysis.lines_of_code.toLocaleString()}\n`;
+    output += `⚠️  Total Violations: ${violations.total} (${violations.by_severity.errors} errors, ${violations.by_severity.warnings} warnings)\n`;
+    output += `📊 Violations per KLOC: ${quality.metrics.violationsPerKLOC}\n`;
+    
+    if (violations.by_rule.length > 0) {
+      output += '\n🔍 Top Violations by Rule:\n';
+      violations.by_rule.slice(0, 10).forEach((item, index) => {
+        output += `  ${index + 1}. ${item.rule_code}: ${item.count} violations (${item.severity})\n`;
+      });
+    }
+    
+    return output;
+  }
+}
+
+module.exports = SummaryReportService;

package/core/upload-service.js

@@ -0,0 +1,282 @@
+/**
+ * Upload Service
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const chalk = require('chalk');
+
+class UploadService {
+  /**
+   * Upload report file to API endpoint using curl
+   */
+  async uploadReportToApi(filePath, apiUrl, options = {}) {
+    try {
+      this.validateUploadParameters(filePath, apiUrl);
+
+      const oidcToken = this.getOidcToken();
+      console.log(chalk.blue(`📤 Uploading report to: ${apiUrl}`));
+      
+      if (oidcToken) {
+        console.log(chalk.green(`🔐 Using OIDC authentication (CI detected)`));
+      }
+
+      const uploadResult = await this.executeUploadCommand(filePath, apiUrl, options);
+      
+      console.log(chalk.green(`✅ Report uploaded successfully!`));
+      return {
+        success: true,
+        url: apiUrl,
+        filePath: filePath,
+        response: uploadResult.response,
+        statusCode: uploadResult.statusCode
+      };
+      
+    } catch (error) {
+      const errorContext = {
+        filePath,
+        apiUrl,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+      
+      console.error(chalk.red('❌ Upload failed:'), error.message);
+      
+      if (options.verbose || options.debug) {
+        console.error('Upload error context:', errorContext);
+      }
+      
+      return {
+        success: false,
+        url: apiUrl,
+        filePath: filePath,
+        error: error.message,
+        errorContext
+      };
+    }
+  }
+
+  /**
+   * Validate upload parameters
+   */
+  validateUploadParameters(filePath, apiUrl) {
+    if (!filePath) {
+      throw new Error('File path is required for upload');
+    }
+    
+    if (!apiUrl) {
+      throw new Error('API URL is required for upload');
+    }
+    
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`Upload file does not exist: ${filePath}`);
+    }
+    
+    // Basic URL validation
+    try {
+      new URL(apiUrl);
+    } catch (error) {
+      throw new Error(`Invalid API URL format: ${apiUrl}`);
+    }
+  }
+
+  /**
+   * Execute curl command to upload file
+   */
+  async executeUploadCommand(filePath, apiUrl, options = {}) {
+    const fileName = path.basename(filePath);
+    const timeout = options.timeout || 30; // 30 seconds default timeout
+    
+    // Build curl command
+    const curlCommand = this.buildCurlCommand(filePath, apiUrl, fileName, timeout);
+    
+    try {
+      // Execute curl command synchronously for simplicity
+      const output = execSync(curlCommand, { 
+        encoding: 'utf8',
+        maxBuffer: 1024 * 1024, // 1MB buffer
+        timeout: timeout * 1000 // Convert to milliseconds
+      });
+      
+      // Parse response if possible
+      let response = output.trim();
+      let statusCode = null;
+      
+      // Try to extract status code from curl verbose output
+      const statusMatch = response.match(/HTTP\/[\d.]+\s+(\d{3})/);
+      if (statusMatch) {
+        statusCode = parseInt(statusMatch[1]);
+      }
+      
+      return {
+        response: response,
+        statusCode: statusCode
+      };
+      
+    } catch (error) {
+      throw new Error(`curl command failed: ${error.message}. Command: ${curlCommand}`);
+    }
+  }
+
+  /**
+   * Build curl command for file upload
+   */
+  buildCurlCommand(filePath, apiUrl, fileName, timeout) {
+    const curlOptions = [
+      'curl',
+      '-X POST',
+      `--connect-timeout ${timeout}`,
+      `--max-time ${timeout}`,
+      '-H "Content-Type: application/json"',
+      '-H "User-Agent: SunLint-Report-Uploader/1.0"'
+    ];
+
+    // Add Idempotency-Key for safe retries
+    const idempotencyKey = this.generateIdempotencyKey(filePath);
+    curlOptions.push(`-H "Idempotency-Key: ${idempotencyKey}"`);
+
+    // Add OIDC token if running in CI environment
+    const oidcToken = this.getOidcToken();
+    if (oidcToken) {
+      curlOptions.push(`-H "Authorization: Bearer ${oidcToken}"`);
+    }
+
+    curlOptions.push(
+      `--data-binary @"${filePath}"`,
+      `"${apiUrl}"`
+    );
+    
+    return curlOptions.join(' ');
+  }
+
+  /**
+   * Check if curl is available on system
+   */
+  checkCurlAvailability() {
+    try {
+      execSync('curl --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get OIDC token from environment variables (for CI authentication)
+   */
+  getOidcToken() {
+    // Try to get GitHub Actions OIDC token first (requires API call)
+    if (process.env.GITHUB_ACTIONS && process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN && process.env.ACTIONS_ID_TOKEN_REQUEST_URL) {
+      try {
+        const githubToken = this.requestGitHubOidcToken();
+        if (githubToken) {
+          return githubToken;
+        }
+      } catch (error) {
+        console.log(chalk.yellow(`⚠️  Failed to get GitHub OIDC token: ${error.message}`));
+      }
+    }
+
+    // Check if running in GitHub Actions without OIDC token
+    if (process.env.GITHUB_ACTIONS) {
+      console.log(chalk.yellow('⚠️  Running in GitHub Actions but no OIDC token available. Upload may require authentication.'));
+    }
+
+    return null;
+  }
+
+  /**
+   * Request OIDC token from GitHub Actions
+   */
+  requestGitHubOidcToken() {
+    const requestToken = process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+    const requestUrl = process.env.ACTIONS_ID_TOKEN_REQUEST_URL;
+    
+    if (!requestToken || !requestUrl) {
+      throw new Error('Missing GitHub OIDC request credentials');
+    }
+
+    try {
+      // Use curl to request OIDC token from GitHub with specific audience
+      const curlCommand = `curl -H "Authorization: bearer ${requestToken}" "${requestUrl}&audience=coding-standards-report-api"`;
+      
+      const response = execSync(curlCommand, { 
+        encoding: 'utf8',
+        timeout: 10000, // 10 second timeout
+        stdio: 'pipe'
+      });
+
+      const responseData = JSON.parse(response);
+      
+      if (responseData.value) {
+        return responseData.value;
+      } else {
+        throw new Error('No token in response');
+      }
+      
+    } catch (error) {
+      throw new Error(`GitHub OIDC request failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate idempotency key for safe retries
+   */
+  generateIdempotencyKey(filePath) {
+    // Create deterministic key based on file content and timestamp
+    const fileContent = fs.readFileSync(filePath, 'utf8');
+    const timestamp = new Date().toISOString().split('T')[0]; // YYYY-MM-DD format
+    
+    // Include CI context for uniqueness across environments and attempts
+    const ciContext = process.env.GITHUB_ACTIONS ? 
+      `${process.env.GITHUB_REPOSITORY || 'unknown'}-${process.env.GITHUB_RUN_ID || 'local'}-${process.env.GITHUB_RUN_ATTEMPT || '1'}` : 
+      'local';
+    
+    // Create hash from content + date + CI context + run attempt
+    const hashInput = `${fileContent}-${timestamp}-${ciContext}`;
+    const hash = crypto.createHash('sha256').update(hashInput).digest('hex');
+    
+    // Return first 32 characters for reasonable key length
+    return `sunlint-${hash.substring(0, 24)}`;
+  }
+
+  /**
+   * Validate API endpoint accessibility
+   */
+  async validateApiEndpoint(apiUrl, options = {}) {
+    try {
+      const timeout = options.timeout || 10;
+      
+      // Build command with auth header if available
+      let testCommand = `curl -X HEAD --connect-timeout ${timeout} --max-time ${timeout} -s -o /dev/null -w "%{http_code}"`;
+      
+      const oidcToken = this.getOidcToken();
+      if (oidcToken) {
+        testCommand += ` -H "Authorization: Bearer ${oidcToken}"`;
+      }
+      
+      testCommand += ` "${apiUrl}"`;
+      
+      const statusCode = execSync(testCommand, { encoding: 'utf8' }).trim();
+      
+      return {
+        accessible: true,
+        statusCode: parseInt(statusCode),
+        url: apiUrl,
+        authenticated: !!oidcToken
+      };
+      
+    } catch (error) {
+      return {
+        accessible: false,
+        error: error.message,
+        url: apiUrl,
+        authenticated: !!this.getOidcToken()
+      };
+    }
+  }
+}
+
+module.exports = UploadService;