@sun-asterisk/sunlint 1.0.5

package/cli-legacy.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+
+/**
+ * LEGACY CLI - DO NOT USE
+ * This is the old monolithic CLI implementation kept for reference only.
+ * Use cli.js instead - it has the new modular architecture with ESLint integration.
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const MultiRuleRunner = require('./core/multi-rule-runner');
+const ConfigManager = require('./core/config-manager');
+const ReportGenerator = require('./core/report-generator');
+const { version } = require('./package.json');
+
+const program = new Command();
+
+program
+  .name('sunlint')
+  .description('☀️ Sun Lint - Coding Standards Checker | Multi-rule Quality & Security Analysis')
+  .version(version);
+
+// Rule selection
+program
+  .option('-r, --rule <rule>', 'Run single rule (e.g., C019)')
+  .option('-R, --rules <rules>', 'Run multiple rules (e.g., C019,C006,C021)')
+  .option('-a, --all', 'Run all available rules')
+  .option('-c, --category <category>', 'Run rules by category (quality,security,logging,naming)')
+  .option('--quality', 'Run all code quality rules')
+  .option('--security', 'Run all secure coding rules')
+  .option('--preset <preset>', 'Use predefined rule preset (recommended,strict,beginner)')
+  
+  // Input/Output
+  .option('-i, --input <path>', 'Input file or directory to analyze', 'src')
+  .option('-f, --format <format>', 'Output format (eslint,json,summary,table)', 'eslint')
+  .option('-o, --output <file>', 'Output file path')
+  .option('--config <file>', 'Configuration file path', '.sunlint.json')
+  
+  // CI/CD and Git integration
+  .option('--changed-files', 'Only analyze files changed in current branch (git diff)')
+  .option('--staged-files', 'Only analyze staged files (git diff --cached)')
+  .option('--diff-base <ref>', 'Compare against specific git reference (e.g., origin/main)')
+  .option('--since <commit>', 'Only analyze files changed since specific commit')
+  .option('--pr-mode', 'Enable PR mode (changed files + baseline comparison)')
+  .option('--baseline <file>', 'Load baseline results to compare against')
+  .option('--save-baseline <file>', 'Save current results as baseline')
+  .option('--fail-on-new-violations', 'Exit with error only on new violations (not existing)')
+  
+  // Rule control
+  .option('--exclude-rules <rules>', 'Exclude specific rules (e.g., C019,C006)')
+  .option('--include-rules <rules>', 'Include only specific rules (e.g., C019,C006)')  
+  .option('--disable-rule <rule>', 'Disable specific rule')
+  .option('--enable-rule <rule>', 'Enable specific rule')
+  .option('--severity <level>', 'Minimum severity level (error,warning,info)', 'info')
+  .option('--languages <langs>', 'Target languages (typescript,dart,kotlin)')
+  
+  // Advanced options
+  .option('--ai', 'Enable AI-powered analysis')
+  .option('--no-ai', 'Force disable AI analysis (use heuristic only)')
+  .option('--no-cache', 'Disable result caching')
+  .option('--max-concurrent <n>', 'Maximum concurrent rule execution', '5')
+  .option('--timeout <ms>', 'Timeout for rule execution (ms)', '30000')
+  .option('--fix', 'Auto-fix issues when possible')
+  .option('--dry-run', 'Show what would be analyzed without running')
+  .option('--verbose', 'Enable verbose logging')
+  .option('--quiet', 'Suppress non-error output')
+  .option('--debug', 'Enable debug mode');
+
+program.action(async (options) => {
+  try {
+    // Sun Lint banner
+    console.log(chalk.yellow.bold('☀️  Sun Lint - Coding Standards Checker'));
+    console.log(chalk.gray(`Version: ${version} | Sun* Engineering`));
+    
+    if (options.debug) {
+      console.log(chalk.yellow('Debug mode enabled'));
+      console.log('Options:', options);
+    }
+
+    // Handle quality/security shortcuts
+    if (options.quality) {
+      options.category = 'quality';
+    }
+    if (options.security) {
+      options.category = 'security';
+    }
+
+    // Load configuration
+    const configManager = new ConfigManager();
+    const config = await configManager.loadConfig(options.config, options);
+    
+    if (options.verbose) {
+      console.log(chalk.gray('Configuration loaded:'), config);
+    }
+
+    // Validate input
+    if (!fs.existsSync(options.input)) {
+      console.error(chalk.red(`❌ Input path not found: ${options.input}`));
+      process.exit(1);
+    }
+
+    // Show dry run info
+    if (options.dryRun) {
+      console.log(chalk.yellow('🔍 Dry run mode - Analysis preview:'));
+      await showDryRunPreview(config, options);
+      return;
+    }
+
+    // Initialize multi-rule runner
+    const runner = new MultiRuleRunner(config, options);
+    
+    // Get rules to run
+    const rulesToRun = await getRulesToRun(config, options);
+    
+    if (rulesToRun.length === 0) {
+      console.log(chalk.yellow('⚠️  No rules to run'));
+      return;
+    }
+
+    if (!options.quiet) {
+      const rulesByCategory = categorizeRules(rulesToRun);
+      console.log(chalk.green(`🚀 Running ${rulesToRun.length} rules on: ${options.input}`));
+      
+      if (rulesByCategory.quality.length > 0) {
+        console.log(chalk.blue(`  📋 Quality rules: ${rulesByCategory.quality.map(r => r.id).join(', ')}`));
+      }
+      if (rulesByCategory.security.length > 0) {
+        console.log(chalk.red(`  🔒 Security rules: ${rulesByCategory.security.map(r => r.id).join(', ')}`));
+      }
+      if (rulesByCategory.other.length > 0) {
+        console.log(chalk.gray(`  ⚙️  Other rules: ${rulesByCategory.other.map(r => r.id).join(', ')}`));
+      }
+    }
+
+    // Run analysis
+    const startTime = Date.now();
+    const results = await runner.runRules(rulesToRun, options.input, options);
+    const duration = Date.now() - startTime;
+
+    // Generate report
+    const reportGenerator = new ReportGenerator(config, options);
+    const report = await reportGenerator.generateReport(results, {
+      duration,
+      rulesRun: rulesToRun.length,
+      filesAnalyzed: results.filesAnalyzed || 0
+    });
+
+    // Output results
+    await outputResults(report, options);
+
+    // Exit with appropriate code
+    const allResults = results.results || [];
+    const hasErrors = allResults.some(r => 
+      r.violations && r.violations.some(v => v.severity === 'error')
+    );
+    process.exit(hasErrors ? 1 : 0);
+
+  } catch (error) {
+    console.error(chalk.red('❌ Sun Lint Error:'), error.message);
+    if (options.debug) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+});
+
+async function getRulesToRun(config, options) {
+  const allRules = config.rules || {};
+  const rulesRegistry = require('./config/rules-registry.json');
+  
+  let selectedRules = [];
+
+  if (options.rule) {
+    // Single rule
+    selectedRules = [options.rule];
+  } else if (options.rules) {
+    // Multiple rules
+    selectedRules = options.rules.split(',').map(r => r.trim());
+  } else if (options.all) {
+    // All rules
+    selectedRules = Object.keys(rulesRegistry.rules);
+  } else if (options.category) {
+    // Rules by category
+    const category = rulesRegistry.categories[options.category];
+    if (category && category.rules) {
+      selectedRules = category.rules;
+    }
+  } else if (options.preset) {
+    // Load preset using ConfigManager
+    try {
+      const ConfigManager = require('./core/config-manager');
+      const configManager = new ConfigManager();
+      
+      const presetName = options.preset.startsWith('@sun/sunlint/') 
+        ? options.preset 
+        : `@sun/sunlint/${options.preset}`;
+      const presetConfig = await configManager.loadPreset(presetName);
+      if (presetConfig && presetConfig.rules) {
+        selectedRules = Object.keys(presetConfig.rules).filter(ruleId => 
+          presetConfig.rules[ruleId] !== 'off' && presetConfig.rules[ruleId] !== false
+        );
+        console.log(chalk.blue(`🎯 Using preset: ${presetName}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to load preset '${options.preset}':`), error.message);
+      process.exit(1);
+    }
+  } else {
+    // Default: use config rules
+    selectedRules = Object.keys(allRules).filter(ruleId => 
+      allRules[ruleId] !== 'off' && allRules[ruleId] !== false
+    );
+  }
+
+  // Filter out excluded rules
+  if (options.excludeRules) {
+    const excludedRules = options.excludeRules.split(',').map(r => r.trim());
+    selectedRules = selectedRules.filter(rule => !excludedRules.includes(rule));
+  }
+
+  // Filter by severity
+  if (options.severity) {
+    const minSeverity = options.severity;
+    const severityLevels = { info: 0, warning: 1, error: 2 };
+    const minLevel = severityLevels[minSeverity] || 0;
+    
+    selectedRules = selectedRules.filter(ruleId => {
+      const rule = rulesRegistry.rules[ruleId];
+      if (!rule) return false;
+      const ruleLevel = severityLevels[rule.severity] || 0;
+      return ruleLevel >= minLevel;
+    });
+  }
+
+  // Filter by languages
+  if (options.languages) {
+    const targetLanguages = options.languages.split(',').map(l => l.trim());
+    selectedRules = selectedRules.filter(ruleId => {
+      const rule = rulesRegistry.rules[ruleId];
+      if (!rule) return false;
+      return rule.languages.some(lang => targetLanguages.includes(lang));
+    });
+  }
+
+  // Convert to rule objects
+  return selectedRules.map(ruleId => ({
+    id: ruleId,
+    ...rulesRegistry.rules[ruleId]
+  })).filter(rule => rule.name); // Filter out invalid rules
+}
+
+function categorizeRules(rules) {
+  const categories = {
+    quality: [],
+    security: [],
+    other: []
+  };
+
+  rules.forEach(rule => {
+    if (rule.category === 'security' || rule.id.startsWith('S')) {
+      categories.security.push(rule);
+    } else if (['logging', 'naming', 'validation', 'design'].includes(rule.category)) {
+      categories.quality.push(rule);
+    } else {
+      categories.other.push(rule);
+    }
+  });
+
+  return categories;
+}
+
+async function showDryRunPreview(config, options) {
+  const rulesToRun = await getRulesToRun(config, options);
+  const rulesByCategory = categorizeRules(rulesToRun);
+  
+  console.log(chalk.blue('📋 Sun Lint Analysis Preview:'));
+  console.log(chalk.gray(`Input: ${options.input}`));
+  console.log(chalk.gray(`Format: ${options.format}`));
+  console.log(chalk.gray(`Rules to run: ${rulesToRun.length}`));
+  
+  if (rulesByCategory.quality.length > 0) {
+    console.log(chalk.blue('📋 Quality Rules:'));
+    rulesByCategory.quality.forEach(rule => {
+      console.log(`  ${chalk.cyan(rule.id)}: ${rule.name} (${rule.severity})`);
+    });
+  }
+  
+  if (rulesByCategory.security.length > 0) {
+    console.log(chalk.red('🔒 Security Rules:'));
+    rulesByCategory.security.forEach(rule => {
+      console.log(`  ${chalk.cyan(rule.id)}: ${rule.name} (${rule.severity})`);
+    });
+  }
+  
+  if (rulesByCategory.other.length > 0) {
+    console.log(chalk.white('⚙️  Other Rules:'));
+    rulesByCategory.other.forEach(rule => {
+      console.log(`  ${chalk.cyan(rule.id)}: ${rule.name} (${rule.severity})`);
+    });
+  }
+}
+
+async function outputResults(report, options) {
+  // Console output
+  if (!options.quiet) {
+    console.log(report.formatted);
+  }
+
+  // File output
+  if (options.output) {
+    fs.writeFileSync(options.output, JSON.stringify(report.raw, null, 2));
+    console.log(chalk.green(`📄 Report saved to: ${options.output}`));
+  }
+
+  // Summary
+  if (report.summary && !options.quiet) {
+    console.log(chalk.blue('\n📊 Sun Lint Summary:'));
+    console.log(report.summary);
+  }
+}
+
+// Error handling
+process.on('unhandledRejection', (reason, promise) => {
+  console.error(chalk.red('Sun Lint - Unhandled Rejection:'), promise, chalk.red('reason:'), reason);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (error) => {
+  console.error(chalk.red('Sun Lint - Uncaught Exception:'), error);
+  process.exit(1);
+});
+
+// Help examples
+program.addHelpText('after', `
+Examples:
+  $ sunlint --rule=C019 --input=src
+  $ sunlint --rules=C019,C006 --input=src --format=json
+  $ sunlint --all --input=src --format=summary
+  $ sunlint --quality --input=src
+  $ sunlint --security --input=src  
+  $ sunlint --category=logging --input=src
+  $ sunlint --preset=recommended --input=src
+  $ sunlint --config=.sunlint.json --input=src
+  $ sunlint --rule=C019 --input=src --output=report.json
+  $ sunlint --all --input=src --exclude-rules=C006,C031
+  $ sunlint --rule=C019 --input=src --ai
+  $ sunlint --rule=C019 --input=src --no-ai
+  $ sunlint --all --input=src --severity=error --ai
+
+Sun* Engineering - Coding Standards Made Simple ☀️
+`);
+
+program.parse();

package/cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+/**
+ * SunLint CLI Entry Point
+ * Main CLI entry point with modular architecture
+ * Following Rule C005: Single responsibility - only handle CLI bootstrapping
+ * Following Rule C014: Dependency injection for services
+ */
+
+const chalk = require('chalk');
+const { createCliProgram } = require('./core/cli-program');
+const CliActionHandler = require('./core/cli-action-handler');
+
+// Create CLI program
+const program = createCliProgram();
+
+// Set up main action handler
+program.action(async (options) => {
+  const actionHandler = new CliActionHandler(options);
+  await actionHandler.execute();
+});
+
+// Global error handling
+process.on('unhandledRejection', (reason, promise) => {
+  console.error(chalk.red('Sun Lint - Unhandled Rejection:'), promise, chalk.red('reason:'), reason);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (error) => {
+  console.error(chalk.red('Sun Lint - Uncaught Exception:'), error);
+  process.exit(1);
+});
+
+// Parse CLI arguments
+program.parse();

package/config/default.json

@@ -0,0 +1,22 @@
+{
+  "rules": {
+    "C006": true,
+    "C019": true,
+    "C032": true,
+    "C045": true
+  },
+  "categories": ["quality", "security"],
+  "integration": {
+    "eslint": {
+      "enabled": true,
+      "legacySupport": false,
+      "autoDetect": true,
+      "fallbackToStandalone": true
+    }
+  },
+  "compatibility": {
+    "eslintV8": false,
+    "eslintV9": true,
+    "strictConfigValidation": false
+  }
+}

package/config/presets/beginner.json

@@ -0,0 +1,36 @@
+{
+  "name": "@sun/sunlint/beginner",
+  "description": "Beginner-friendly configuration with warnings only",
+  "rules": {
+    "C019": "warning", 
+    "C029": "warning",
+    "C006": "info"
+  },
+  "categories": {
+    "quality": "warning",
+    "security": "warning", 
+    "logging": "warning",
+    "naming": "info",
+    "validation": "warning"
+  },
+  "languages": ["typescript"],
+  "ignorePatterns": [
+    "**/node_modules/**",
+    "**/build/**",
+    "**/dist/**",
+    "**/*.generated.*",
+    "**/*.min.*",
+    "**/test/**",
+    "**/tests/**"
+  ],
+  "ai": {
+    "enabled": false,
+    "fallbackToPattern": true
+  },
+  "reporting": {
+    "exitOnError": false,
+    "showProgress": true,
+    "includeContext": true,
+    "showFixSuggestions": true
+  }
+}

package/config/presets/ci.json

@@ -0,0 +1,46 @@
+{
+  "name": "@sun/sunlint/ci",
+  "description": "Configuration optimized for CI/CD pipelines",
+  "rules": {
+    "C019": "error",
+    "C029": "error",
+    "C006": "off"
+  },
+  "categories": {
+    "quality": "error",
+    "security": "error", 
+    "logging": "error",
+    "naming": "off",
+    "validation": "error"
+  },
+  "languages": ["typescript", "dart", "javascript"],
+  "ignorePatterns": [
+    "**/node_modules/**",
+    "**/build/**",
+    "**/dist/**",
+    "**/*.generated.*",
+    "**/*.min.*",
+    "coverage/**"
+  ],
+  "ai": {
+    "enabled": false,
+    "fallbackToPattern": true
+  },
+  "output": {
+    "format": "github",
+    "console": false,
+    "summary": true,
+    "file": "sunlint-report.json"
+  },
+  "performance": {
+    "maxConcurrentRules": 10,
+    "timeoutMs": 60000,
+    "cacheEnabled": true
+  },
+  "reporting": {
+    "exitOnError": true,
+    "showProgress": false,
+    "includeContext": false,
+    "showFixSuggestions": false
+  }
+}

package/config/presets/recommended.json

@@ -0,0 +1,24 @@
+{
+  "name": "@sun/sunlint/recommended",
+  "description": "Sun* Engineering recommended configuration",
+  "rules": {
+    "C019": "warning",
+    "C029": "error",
+    "C006": "off"
+  },
+  "categories": {
+    "quality": "warning",
+    "security": "error", 
+    "logging": "warning",
+    "naming": "off",
+    "validation": "error"
+  },
+  "languages": ["typescript", "dart"],
+  "ignorePatterns": [
+    "**/node_modules/**",
+    "**/build/**",
+    "**/dist/**",
+    "**/*.generated.*",
+    "**/*.min.*"
+  ]
+}

package/config/presets/strict.json

@@ -0,0 +1,32 @@
+{
+  "name": "@sun/sunlint/strict",
+  "description": "Strict configuration for production projects",
+  "rules": {
+    "C019": "error",
+    "C029": "error",
+    "C006": "warning"
+  },
+  "categories": {
+    "quality": "error",
+    "security": "error", 
+    "logging": "error",
+    "naming": "warning",
+    "validation": "error"
+  },
+  "languages": ["typescript", "dart", "javascript"],
+  "ignorePatterns": [
+    "**/node_modules/**",
+    "**/build/**",
+    "**/dist/**",
+    "**/*.generated.*",
+    "**/*.min.*"
+  ],
+  "ai": {
+    "enabled": true,
+    "fallbackToPattern": false
+  },
+  "reporting": {
+    "exitOnError": true,
+    "showProgress": true
+  }
+}