@sun-asterisk/sunlint 1.0.6 → 1.1.3

package/cli-legacy.js

@@ -1,355 +0,0 @@
-#!/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/config/sunlint-schema.json

@@ -1,166 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Sunlint Configuration",
-  "description": "Configuration file for Sun Lint - Coding Standards Checker",
-  "type": "object",
-  "properties": {
-    "extends": {
-      "description": "Extend from a base configuration",
-      "oneOf": [
-        {
-          "type": "string",
-          "enum": [
-            "@sun/sunlint/recommended",
-            "@sun/sunlint/strict",
-            "@sun/sunlint/beginner"
-          ]
-        },
-        {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        }
-      ]
-    },
-    "rules": {
-      "description": "Rule-specific configuration",
-      "type": "object",
-      "patternProperties": {
-        "^C\\d{3}$": {
-          "oneOf": [
-            {
-              "type": "string",
-              "enum": ["error", "warning", "info", "off"]
-            },
-            {
-              "type": "array",
-              "items": [
-                {
-                  "type": "string",
-                  "enum": ["error", "warning", "info", "off"]
-                },
-                {
-                  "type": "object"
-                }
-              ]
-            }
-          ]
-        }
-      },
-      "additionalProperties": false
-    },
-    "categories": {
-      "description": "Category-based rule configuration",
-      "type": "object",
-      "properties": {
-        "quality": {
-          "type": "string",
-          "enum": ["error", "warning", "info", "off"]
-        },
-        "security": {
-          "type": "string",
-          "enum": ["error", "warning", "info", "off"]
-        },
-        "logging": {
-          "type": "string",
-          "enum": ["error", "warning", "info", "off"]
-        },
-        "naming": {
-          "type": "string",
-          "enum": ["error", "warning", "info", "off"]
-        },
-        "validation": {
-          "type": "string",
-          "enum": ["error", "warning", "info", "off"]
-        }
-      },
-      "additionalProperties": false
-    },
-    "languages": {
-      "description": "Languages to analyze",
-      "type": "array",
-      "items": {
-        "type": "string",
-        "enum": ["typescript", "dart", "kotlin", "javascript"]
-      },
-      "uniqueItems": true
-    },
-    "include": {
-      "description": "File patterns to include",
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "exclude": {
-      "description": "File patterns to exclude",
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "ignorePatterns": {
-      "description": "Patterns to ignore (alias for exclude)",
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "maxConcurrent": {
-      "description": "Maximum number of concurrent rule executions",
-      "type": "integer",
-      "minimum": 1,
-      "maximum": 20,
-      "default": 5
-    },
-    "timeout": {
-      "description": "Timeout for rule execution in milliseconds",
-      "type": "integer",
-      "minimum": 1000,
-      "maximum": 60000,
-      "default": 30000
-    },
-    "reportFormat": {
-      "description": "Default output format",
-      "type": "string",
-      "enum": ["summary", "json", "eslint", "github", "table"]
-    },
-    "severity": {
-      "description": "Global severity configuration",
-      "type": "object",
-      "properties": {
-        "error": {
-          "type": "boolean",
-          "description": "Include error-level violations"
-        },
-        "warning": {
-          "type": "boolean", 
-          "description": "Include warning-level violations"
-        },
-        "info": {
-          "type": "boolean",
-          "description": "Include info-level violations"
-        }
-      }
-    }
-  },
-  "additionalProperties": false,
-  "examples": [
-    {
-      "extends": "@sun/sunlint/recommended",
-      "rules": {
-        "C019": "warning",
-        "C006": "error",
-        "C029": "error"
-      },
-      "categories": {
-        "quality": "warning",
-        "security": "error"
-      },
-      "languages": ["typescript", "dart"],
-      "include": ["src/**/*.ts", "lib/**/*.dart"],
-      "exclude": ["**/node_modules/**", "**/build/**"]
-    }
-  ]
-}

package/config/typescript/custom-rules.js

@@ -1,9 +0,0 @@
-/**
- * Custom ESLint Rules for SunLint Integration
- * Now redirects to the actual eslint-plugin-custom with all rules
- */
-
-// Import the actual plugin with all rules (quality + security)
-const eslintPluginCustom = require('../../eslint-integration/eslint-plugin-custom');
-
-module.exports = eslintPluginCustom;