@sun-asterisk/sunlint 1.0.5

package/core/cli-action-handler.js

@@ -0,0 +1,230 @@
+/**
+ * CLI Action Handler
+ * Following Rule C005: Single responsibility - handle CLI execution flow
+ */
+
+const chalk = require('chalk');
+const fs = require('fs');
+const ConfigManager = require('./config-manager');
+const RuleSelectionService = require('./rule-selection-service');
+const AnalysisOrchestrator = require('./analysis-orchestrator');
+const OutputService = require('./output-service');
+const GitUtils = require('./git-utils');
+
+class CliActionHandler {
+  constructor(options = {}) {
+    this.options = options;
+    this.configManager = null;
+    this.ruleSelectionService = new RuleSelectionService();
+    this.analysisOrchestrator = new AnalysisOrchestrator();
+    this.outputService = new OutputService(options);
+  }
+
+  async execute() {
+    try {
+      this.displayBanner();
+      this.handleShortcuts();
+      
+      // Load configuration
+      const config = await this.loadConfiguration();
+      
+      // Validate input
+      this.validateInput();
+
+      // Show dry run preview if requested
+      if (this.options.dryRun) {
+        await this.showDryRunPreview(config);
+        return;
+      }
+
+      // Select rules to run
+      const rulesToRun = await this.ruleSelectionService.selectRules(config, this.options);
+      
+      if (rulesToRun.length === 0) {
+        console.log(chalk.yellow('⚠️  No rules to run'));
+        return;
+      }
+
+      // Display analysis info
+      this.displayAnalysisInfo(rulesToRun);
+
+      // Run analysis
+      const startTime = Date.now();
+      const results = await this.analysisOrchestrator.runAnalysis(rulesToRun, this.options, config);
+      const duration = Date.now() - startTime;
+
+      // Output results
+      await this.outputService.outputResults(results, this.options, { 
+        duration,
+        rulesRun: rulesToRun.length 
+      });
+
+      // Exit with appropriate code
+      this.handleExit(results);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ Sun Lint Error:'), error.message);
+      if (this.options.debug) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  }
+
+  displayBanner() {
+    // Skip banner in quiet mode or JSON format
+    if (this.options.quiet || this.options.format === 'json') {
+      return;
+    }
+    
+    const { version } = require('../package.json');
+    console.log(chalk.yellow.bold('☀️  Sun Lint - Coding Standards Checker'));
+    console.log(chalk.gray(`Version: ${version} | Sun* Engineering`));
+    
+    if (this.options.debug) {
+      console.log(chalk.yellow('Debug mode enabled'));
+      console.log('Options:', this.options);
+    }
+  }
+
+  handleShortcuts() {
+    if (this.options.quality) {
+      this.options.category = 'quality';
+    }
+    if (this.options.security) {
+      this.options.category = 'security';
+    }
+    
+    // Handle ESLint integration options
+    if (this.options.eslintIntegration) {
+      this.options.eslintIntegration = true;
+    }
+    if (this.options.noEslintIntegration) {
+      this.options.eslintIntegration = false;
+    }
+    if (this.options.eslintMergeRules !== undefined) {
+      this.options.eslintMergeRules = this.options.eslintMergeRules;
+    }
+    if (this.options.eslintPreserveConfig !== undefined) {
+      this.options.eslintPreserveConfig = this.options.eslintPreserveConfig;
+    }
+    if (this.options.eslintRunAfter) {
+      this.options.eslintRunAfter = true;
+    }
+  }
+
+  async loadConfiguration() {
+    try {
+      if (!this.configManager) {
+        this.configManager = new ConfigManager();
+      }
+      return await this.configManager.loadConfig(this.options.config, this.options);
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  Using default configuration'));
+      return { rules: {} };
+    }
+  }
+
+  validateInput() {
+    // Handle git-based file filtering
+    if (this.options.changedFiles || this.options.stagedFiles || this.options.since || this.options.prMode) {
+      this.handleGitFileFiltering();
+      return;
+    }
+
+    // Regular input validation
+    if (!fs.existsSync(this.options.input)) {
+      console.error(chalk.red(`❌ Input path not found: ${this.options.input}`));
+      process.exit(1);
+    }
+  }
+
+  handleGitFileFiltering() {
+    try {
+      let files = [];
+
+      if (this.options.changedFiles) {
+        const diffBase = this.options.diffBase || GitUtils.getPRDiffBase('main');
+        files = GitUtils.getChangedFiles(diffBase);
+        if (!this.options.quiet) {
+          console.log(chalk.blue(`🔄 Analyzing changed files vs ${diffBase}`));
+        }
+      } else if (this.options.stagedFiles) {
+        files = GitUtils.getStagedFiles();
+        if (!this.options.quiet) {
+          console.log(chalk.blue('🔄 Analyzing staged files'));
+        }
+      } else if (this.options.since) {
+        files = GitUtils.getFilesSince(this.options.since);
+        if (!this.options.quiet) {
+          console.log(chalk.blue(`🔄 Analyzing files changed since ${this.options.since}`));
+        }
+      } else if (this.options.prMode) {
+        const diffBase = this.options.diffBase || GitUtils.getPRDiffBase('main');
+        files = GitUtils.getChangedFiles(diffBase);
+        if (!this.options.quiet) {
+          console.log(chalk.blue(`🔄 PR mode: analyzing changes vs ${diffBase}`));
+        }
+      }
+
+      // Filter for TypeScript/JavaScript files
+      const sourceFiles = GitUtils.filterSourceFiles(files);
+      
+      if (sourceFiles.length === 0) {
+        console.log(chalk.yellow('⚠️  No TypeScript/JavaScript files found in git changes'));
+        process.exit(0);
+      }
+
+      // Update input to be the filtered file list
+      this.options.input = sourceFiles;
+      this.options.isFileList = true;
+
+      if (!this.options.quiet) {
+        console.log(chalk.green(`📁 Found ${sourceFiles.length} source files to analyze`));
+        if (this.options.verbose) {
+          sourceFiles.forEach(file => console.log(`  ${chalk.gray(file)}`));
+        }
+      }
+
+    } catch (error) {
+      console.error(chalk.red(`❌ Git operation failed: ${error.message}`));
+      process.exit(1);
+    }
+  }
+
+  async showDryRunPreview(config) {
+    console.log(chalk.yellow('🔍 Dry run mode - Analysis preview:'));
+    const rulesToRun = await this.ruleSelectionService.selectRules(config, this.options);
+    
+    console.log(chalk.blue('📋 Sun Lint Analysis Preview:'));
+    console.log(chalk.gray(`Input: ${this.options.input}`));
+    console.log(chalk.gray(`Format: ${this.options.format}`));
+    console.log(chalk.gray(`Rules to run: ${rulesToRun.length}`));
+    
+    if (rulesToRun.length > 0) {
+      console.log(chalk.blue('📋 Selected Rules:'));
+      rulesToRun.forEach(rule => {
+        console.log(`  ${chalk.cyan(rule.id)}: ${rule.name} (${rule.severity})`);
+      });
+    }
+  }
+
+  displayAnalysisInfo(rulesToRun) {
+    if (this.options.quiet || this.options.format === 'json') return;
+
+    console.log(chalk.green(`🚀 Running ${rulesToRun.length} rules on: ${this.options.input}`));
+    
+    const ruleIds = rulesToRun.map(r => r.id).join(', ');
+    console.log(chalk.blue(`  📋 Rules: ${ruleIds}`));
+  }
+
+  handleExit(results) {
+    const allResults = results.results || [];
+    const hasErrors = allResults.some(r => 
+      r.violations && r.violations.some(v => v.severity === 'error')
+    );
+    process.exit(hasErrors ? 1 : 0);
+  }
+}
+
+module.exports = CliActionHandler;

package/core/cli-program.js

@@ -0,0 +1,106 @@
+/**
+ * CLI Program Definition
+ * Following Rule C005: Single responsibility - only handle CLI structure
+ */
+
+const { Command } = require('commander');
+const { version } = require('../package.json');
+
+function createCliProgram() {
+  const program = new Command();
+
+  program
+    .name('sunlint')
+    .description('☀️ Sun Lint - Coding Standards Checker | Multi-rule Quality & Security Analysis')
+    .version(version);
+
+  // Rule selection options
+  program
+    .option('-r, --rule <rule>', 'Run single rule (e.g., C019)')
+    .option('--rules <rules>', 'Run multiple rules (comma-separated, e.g., C019,C006,S005)')
+    .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');
+
+  // TypeScript specific options (Phase 1 focus)
+  program
+    .option('--typescript', 'Enable TypeScript-specific analysis')
+    .option('--typescript-engine <engine>', 'TypeScript analysis engine (eslint,sunlint,hybrid)', 'sunlint')
+    .option('--ensure-deps', 'Ensure ESLint dependencies are installed');
+
+  // Input/Output options
+  program
+    .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 options
+  program
+    .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)');
+
+  // Advanced options
+  program
+    .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')
+    .option('--ai', 'Enable AI-powered analysis')
+    .option('--no-ai', 'Force disable AI analysis (use heuristic only)');
+
+  // ESLint Integration options
+  program
+    .option('--eslint-integration', 'Enable ESLint integration (merge with existing ESLint config)')
+    .option('--no-eslint-integration', 'Disable ESLint integration')
+    .option('--eslint-merge-rules', 'Merge SunLint and user ESLint rules (default: true)')
+    .option('--eslint-preserve-config', 'Preserve user ESLint configuration (default: true)')
+    .option('--eslint-run-after', 'Run ESLint after SunLint (instead of merged execution)');
+
+  // Help examples
+  program.addHelpText('after', `
+Examples:
+  $ sunlint --rule=C019 --input=src
+  $ sunlint --rules=C019,C006,S005 --input=src
+  $ sunlint --all --input=src
+  $ sunlint --quality --input=src
+  $ sunlint --security --input=src
+  $ sunlint --category=logging --input=src
+
+TypeScript Analysis (Phase 1):
+  $ sunlint --typescript --input=src
+  $ sunlint --rule=C006 --typescript --input=src
+  $ sunlint --rules=C019,S005 --typescript --input=src
+  $ sunlint --typescript-engine=eslint --input=src
+
+CI/CD Integration:
+  $ sunlint --all --changed-files --format=summary --no-ai
+  $ sunlint --all --changed-files --diff-base=origin/main --fail-on-new-violations
+  $ sunlint --all --staged-files --format=summary
+  $ sunlint --all --pr-mode --diff-base=origin/main
+
+ESLint Integration:
+  $ sunlint --typescript --eslint-integration --input=src
+  $ sunlint --all --eslint-integration --eslint-merge-rules --input=src
+  $ sunlint --all --eslint-integration --eslint-run-after --input=src
+  $ sunlint --typescript --eslint-integration --changed-files
+
+AI-powered Analysis:
+  $ sunlint --rule=C019 --input=src --ai
+  $ sunlint --all --input=src --ai
+  $ sunlint --quality --input=src --no-ai
+
+Sun* Engineering - Coding Standards Made Simple ☀️
+`);
+
+  return program;
+}
+
+module.exports = { createCliProgram };