@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/scripts/generate_insights.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { SimpleRuleParser } = require('../rules/parser/rule-parser-simple.js');
+
+class SunLintInsightGenerator {
+    constructor() {
+        this.parser = new SimpleRuleParser();
+        this.heuristicRulesPath = path.join(__dirname, '../rules/common');
+    }
+
+    // Get implemented rules
+    getImplementedRules() {
+        const implemented = new Set();
+        if (fs.existsSync(this.heuristicRulesPath)) {
+            const dirs = fs.readdirSync(this.heuristicRulesPath);
+            dirs.forEach(dir => {
+                const match = dir.match(/^([A-Z]\d+)_/);
+                if (match) {
+                    implemented.add(match[1]);
+                }
+            });
+        }
+        return implemented;
+    }
+
+    // Assess priority based on rule content
+    assessPriority(rule) {
+        const text = `${rule.title} ${rule.description} ${rule.detail || ''}`.toLowerCase();
+        const principles = rule.principles || [];
+        
+        if (principles.includes('SECURITY')) return 'High';
+        if (principles.includes('PERFORMANCE')) return 'High';
+        if (principles.includes('RELIABILITY')) return 'Medium-High';
+        
+        const impactKeywords = {
+            high: ['security', 'memory', 'performance', 'crash', 'null pointer', 'xss', 'injection', 'vulnerability', 'race condition'],
+            medium: ['testability', 'maintainability', 'readability', 'coupling', 'cohesion', 'dependency'],
+            low: ['naming', 'style', 'convention', 'formatting', 'comment']
+        };
+        
+        for (const keyword of impactKeywords.high) {
+            if (text.includes(keyword)) return 'High';
+        }
+        for (const keyword of impactKeywords.medium) {
+            if (text.includes(keyword)) return 'Medium';
+        }
+        for (const keyword of impactKeywords.low) {
+            if (text.includes(keyword)) return 'Low';
+        }
+        
+        return 'Medium';
+    }
+
+    // Generate actionable insights
+    generateInsights() {
+        console.log('🔍 Analyzing SunLint rules...');
+        const allRules = this.parser.parseAllRules();
+        const activatedRules = this.parser.filterRules(allRules, { status: 'activated' });
+        const implementedRules = this.getImplementedRules();
+        
+        console.log('\n📊 === SUNLINT HEURISTIC ENGINE ANALYSIS ===\n');
+        
+        // Overall statistics
+        const totalImplemented = activatedRules.filter(rule => implementedRules.has(rule.id)).length;
+        const implementationRate = ((totalImplemented / activatedRules.length) * 100).toFixed(1);
+        
+        console.log(`🎯 **Current Implementation Status:**`);
+        console.log(`   • Total Activated Rules: ${activatedRules.length}`);
+        console.log(`   • Implemented in Heuristic: ${totalImplemented} (${implementationRate}%)`);
+        console.log(`   • Remaining to Implement: ${activatedRules.length - totalImplemented}\n`);
+
+        // Priority analysis
+        const priorities = { 'High': 0, 'Medium-High': 0, 'Medium': 0, 'Low': 0 };
+        const notImplementedByPriority = { 'High': [], 'Medium-High': [], 'Medium': [], 'Low': [] };
+        
+        activatedRules.forEach(rule => {
+            const priority = this.assessPriority(rule);
+            priorities[priority]++;
+            
+            if (!implementedRules.has(rule.id)) {
+                notImplementedByPriority[priority].push(rule);
+            }
+        });
+
+        console.log(`🔥 **Priority Breakdown:**`);
+        Object.entries(priorities).forEach(([priority, count]) => {
+            const missing = notImplementedByPriority[priority].length;
+            const implemented = count - missing;
+            const rate = count > 0 ? ((implemented / count) * 100).toFixed(1) : '0.0';
+            console.log(`   • ${priority}: ${implemented}/${count} implemented (${rate}%) - ${missing} missing`);
+        });
+
+        // Category analysis
+        console.log(`\n📂 **Implementation by Category:**`);
+        const categories = {
+            'C': 'Common Code Quality',
+            'T': 'TypeScript',
+            'R': 'ReactJS',
+            'S': 'Security',
+            'J': 'Java',
+            'K': 'Kotlin Mobile',
+            'D': 'Dart/Flutter',
+            'SW': 'Swift'
+        };
+
+        Object.entries(categories).forEach(([prefix, name]) => {
+            const categoryRules = activatedRules.filter(rule => rule.id.startsWith(prefix));
+            const categoryImplemented = categoryRules.filter(rule => implementedRules.has(rule.id)).length;
+            const rate = categoryRules.length > 0 ? ((categoryImplemented / categoryRules.length) * 100).toFixed(1) : '0.0';
+            console.log(`   • ${name}: ${categoryImplemented}/${categoryRules.length} (${rate}%)`);
+        });
+
+        // Top missing high-priority rules
+        console.log(`\n🚨 **Top 10 Missing High-Priority Rules:**`);
+        notImplementedByPriority['High'].slice(0, 10).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title}`);
+            console.log(`      → ${rule.description?.substring(0, 80)}...`);
+        });
+
+        // Quick wins (easy to implement)
+        console.log(`\n⚡ **Quick Wins (Low Complexity, High Impact):**`);
+        const quickWins = notImplementedByPriority['High'].filter(rule => {
+            const text = rule.title.toLowerCase();
+            return text.includes('console.log') || text.includes('print') || 
+                   text.includes('hardcode') || text.includes('sensitive');
+        });
+        
+        quickWins.slice(0, 5).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title} - Text/Regex patterns`);
+        });
+
+        // Performance impact rules
+        console.log(`\n⚡ **Performance-Critical Missing Rules:**`);
+        const perfRules = notImplementedByPriority['High'].filter(rule => 
+            rule.principles?.includes('PERFORMANCE') || 
+            rule.description?.toLowerCase().includes('performance')
+        );
+        
+        perfRules.slice(0, 5).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title}`);
+        });
+
+        // Security rules
+        console.log(`\n🔒 **Security-Critical Missing Rules:**`);
+        const securityRules = notImplementedByPriority['High'].filter(rule => 
+            rule.principles?.includes('SECURITY') ||
+            rule.description?.toLowerCase().includes('security')
+        );
+        
+        securityRules.slice(0, 5).forEach((rule, i) => {
+            console.log(`   ${i+1}. ${rule.id}: ${rule.title}`);
+        });
+
+        // Recommendations
+        console.log(`\n💡 **Actionable Recommendations:**`);
+        console.log(`   1. Focus on High Priority rules first: ${notImplementedByPriority['High'].length} rules remaining`);
+        console.log(`   2. Implement Common (C) rules first - highest coverage impact`);
+        console.log(`   3. Start with Low complexity rules using text/regex patterns`);
+        console.log(`   4. Performance rules should be prioritized for production impact`);
+        console.log(`   5. Security rules are critical for safe code practices`);
+        console.log(`   6. Consider AST analysis for complex rules (Medium-High complexity)`);
+        
+        console.log(`\n📈 **ROI Analysis:**`);
+        const commonMissing = notImplementedByPriority['High'].filter(rule => rule.id.startsWith('C')).length;
+        console.log(`   • Common rules impact: All languages (${commonMissing} High-priority missing)`);
+        console.log(`   • Language-specific rules: Limited scope but deep impact`);
+        console.log(`   • Implementation effort: Low complexity rules = 1-2 days, High = 1-2 weeks`);
+        
+        return {
+            total: activatedRules.length,
+            implemented: totalImplemented,
+            missing: activatedRules.length - totalImplemented,
+            highPriorityMissing: notImplementedByPriority['High'].length,
+            quickWins: quickWins.length,
+            recommendations: notImplementedByPriority
+        };
+    }
+}
+
+// Run analysis
+if (require.main === module) {
+    const analyzer = new SunLintInsightGenerator();
+    analyzer.generateInsights();
+}
+
+module.exports = SunLintInsightGenerator;

package/scripts/merge-reports.js

@@ -1,424 +0,0 @@
-#!/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/test-scripts/README.md

@@ -1,22 +0,0 @@
-# Test Scripts
-
-This directory contains various test scripts for SunLint development and validation.
-
-## Files
-
-- `test-eslint-rules.js` - Tests ESLint rule implementations
-- `test-rules-on-real-projects.js` - Tests rules on real project samples
-- `test-real-world.js` - Real-world testing scenarios
-- `test-c041-eslint.js` - Specific tests for C041 ESLint rule
-- `test-c041-comparison.js` - Comparison tests between Heuristic and ESLint for C041
-
-## Usage
-
-Run any test script from the project root:
-
-```bash
-node scripts/test-scripts/test-eslint-rules.js
-node scripts/test-scripts/test-rules-on-real-projects.js
-```
-
-These scripts are used for development, validation, and debugging of SunLint rules.