@sun-asterisk/sunlint 1.0.5

package/core/rule-selection-service.js

@@ -0,0 +1,121 @@
+/**
+ * Rule Selection Service
+ * Following Rule C005: Single responsibility - only handle rule selection
+ */
+
+const chalk = require('chalk');
+const RuleMappingService = require('./rule-mapping-service');
+
+class RuleSelectionService {
+  constructor() {
+    this.rulesRegistry = null;
+    this.ruleMappingService = new RuleMappingService();
+  }
+
+  async selectRules(config, options) {
+    // Load rules registry
+    try {
+      this.rulesRegistry = require('../config/rules-registry.json');
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  Rules registry not found, using minimal rule set'));
+      this.rulesRegistry = this.getMinimalRuleSet();
+    }
+    
+    const allRules = config.rules || {};
+    let selectedRules = [];
+
+    // Determine rule selection strategy
+    if (options.rule) {
+      selectedRules = [options.rule];
+    } else if (options.rules) {
+      selectedRules = options.rules.split(',').map(r => r.trim());
+    } else if (options.all) {
+      // For --all, use all supported rules from both registry and ESLint integration
+      const registryRules = Object.keys(this.rulesRegistry.rules || {});
+      const eslintSupportedRules = this.ruleMappingService.getSupportedSunLintRules();
+      
+      // Combine and deduplicate
+      selectedRules = [...new Set([...registryRules, ...eslintSupportedRules])];
+      
+      if (options.verbose) {
+        console.log(chalk.blue(`📋 Found ${selectedRules.length} total rules (${registryRules.length} registry + ${eslintSupportedRules.length} ESLint)`));
+      }
+    } else if (options.category) {
+      const categoryRules = this.getRulesByCategory(options.category);
+      selectedRules = categoryRules;
+    } else {
+      // Default: use config rules or minimal set
+      selectedRules = Object.keys(allRules).filter(ruleId => 
+        allRules[ruleId] !== 'off' && allRules[ruleId] !== false
+      );
+      
+      if (selectedRules.length === 0) {
+        selectedRules = ['C006', 'C019']; // Default minimal set
+      }
+    }
+
+    // Convert to rule objects
+    return selectedRules.map(ruleId => ({
+      id: ruleId,
+      name: this.getRuleName(ruleId),
+      severity: 'warning',
+      ...((this.rulesRegistry.rules && this.rulesRegistry.rules[ruleId]) || {})
+    })).filter(rule => rule.id);
+  }
+
+  getMinimalRuleSet() {
+    return {
+      rules: {
+        'C006': {
+          name: 'Function Naming Convention',
+          description: 'Function names should follow verb-noun pattern',
+          category: 'naming',
+          severity: 'warning'
+        },
+        'C019': {
+          name: 'Log Level Usage',
+          description: 'Use appropriate log levels',
+          category: 'logging',
+          severity: 'warning'
+        }
+      }
+    };
+  }
+
+  getRulesByCategory(category) {
+    // Get rules from registry if available
+    if (this.rulesRegistry && this.rulesRegistry.categories && this.rulesRegistry.categories[category]) {
+      return this.rulesRegistry.categories[category].rules;
+    }
+    
+    // Fallback to hardcoded mapping
+    const categoryMap = {
+      'quality': [
+        'C002', 'C003', 'C006', 'C010', 'C013', 'C014', 'C017', 'C018', 'C019', 
+        'C023', 'C027', 'C029', 'C030', 'C031', 'C034', 'C035', 'C041', 'C042', 
+        'C043', 'C047', 'C048', 'C076', 'T002', 'T003', 'T004', 'T007', 'T011', 
+        'T019', 'T025', 'T026'
+      ],
+      'security': ['S003', 'S005', 'S006', 'S008', 'S009', 'S010', 'S011', 'S012', 'S014', 'S015', 'S016', 'S017', 'S018', 'S019', 'S020', 'S022', 'S023', 'S025', 'S026', 'S027', 'S029', 'S030', 'S033', 'S034', 'S035', 'S036', 'S037', 'S038', 'S039', 'S041', 'S042', 'S043', 'S044', 'S045', 'S046', 'S047', 'S048', 'S050', 'S052', 'S054', 'S055', 'S057', 'S058'],
+      'naming': ['C006'],
+      'logging': ['C019', 'S057'],
+      'validation': ['C031', 'S018', 'S025', 'S026']
+    };
+    
+    return categoryMap[category] || [];
+  }
+
+  getRuleName(ruleId) {
+    const ruleNames = {
+      'C006': 'Function Naming Convention',
+      'C019': 'Log Level Usage',
+      'C002': 'No Duplicate Code',
+      'C003': 'No Vague Abbreviations',
+      'C029': 'Catch Block Logging'
+    };
+    
+    return ruleNames[ruleId] || `Rule ${ruleId}`;
+  }
+}
+
+module.exports = RuleSelectionService;

package/core/sunlint-engine-service.js

@@ -0,0 +1,23 @@
+/**
+ * SunLint Engine Service
+ * Handles native SunLint analysis
+ * Following Rule C005: Single responsibility - only handle SunLint execution
+ */
+
+const MultiRuleRunner = require('./multi-rule-runner');
+
+class SunLintEngineService {
+  constructor() {
+    this.multiRuleRunner = new MultiRuleRunner();
+  }
+
+  /**
+   * Command: Run SunLint analysis
+   */
+  async runAnalysis(rulesToRun, options) {
+    // Use existing multi-rule runner
+    return await this.multiRuleRunner.runRules(rulesToRun, options.input, options);
+  }
+}
+
+module.exports = SunLintEngineService;

package/core/typescript-analyzer.js

@@ -0,0 +1,262 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Handles TypeScript file analysis using ESLint
+ * Rule C005: Single responsibility - only file analysis
+ * Rule C015: Domain language - TypescriptAnalyzer
+ * Rule C033: Separates analysis logic from data queries
+ */
+class TypescriptAnalyzer {
+  constructor(eslintInstanceManager) {
+    // Rule C014: Dependency injection
+    this.eslintInstanceManager = eslintInstanceManager;
+  }
+
+  /**
+   * Rule C006: analyzeTypeScriptFiles - verb-noun naming
+   * Rule C012: Command method - performs analysis
+   * Rule C033: Analysis logic separated from data queries
+   */
+  async analyzeTypeScriptFiles(filePaths, options = {}) {
+    // Expand directories to actual files
+    const expandedFiles = this.expandDirectories(filePaths);
+    
+    if (expandedFiles.length === 0) {
+      console.warn(chalk.yellow('⚠️  No TypeScript/JavaScript files found'));
+      return this.formatAnalysisResults([], options);
+    }
+    
+    if (options.verbose) {
+      console.log(chalk.blue(`📁 Found ${expandedFiles.length} files to analyze`));
+    }
+    
+    const eslint = this.eslintInstanceManager.getEslintInstance();
+    const results = [];
+    
+    for (const filePath of expandedFiles) {
+      try {
+        const analysisResult = await this.analyzeFile(eslint, filePath, options);
+        if (analysisResult) {
+          results.push(analysisResult);
+        }
+      } catch (error) {
+        console.error(chalk.red(`❌ Error analyzing ${filePath}:`), error.message);
+        
+        // Add error result
+        results.push({
+          filePath: filePath,
+          messages: [{
+            ruleId: null,
+            severity: 2,
+            message: `Analysis failed: ${error.message}`,
+            line: 1,
+            column: 1
+          }],
+          errorCount: 1,
+          warningCount: 0,
+          fixableErrorCount: 0,
+          fixableWarningCount: 0
+        });
+      }
+    }
+
+    return this.formatAnalysisResults(results, options);
+  }
+
+  /**
+   * Rule C006: analyzeFile - verb-noun naming
+   * Rule C005: Single responsibility - analyze one file
+   */
+  async analyzeFile(eslint, filePath, options) {
+    if (!this.validateFilePath(filePath)) {
+      return null;
+    }
+
+    if (options.verbose) {
+      console.log(chalk.gray(`🔍 Analyzing: ${filePath}`));
+    }
+
+    try {
+      const results = await eslint.lintFiles([filePath]);
+      const result = results[0]; // ESLint returns array, we need first result
+      
+      // Ensure filePath is preserved in result
+      if (result && !result.filePath) {
+        result.filePath = filePath;
+      }
+      
+      return result;
+    } catch (error) {
+      throw new Error(`ESLint analysis failed for ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Rule C006: validateFilePath - verb-noun naming
+   * Rule C031: Validation logic separated
+   */
+  validateFilePath(filePath) {
+    if (!fs.existsSync(filePath)) {
+      console.warn(chalk.yellow(`⚠️  File not found: ${filePath}`));
+      return false;
+    }
+
+    // Check if it's a directory
+    const stats = fs.statSync(filePath);
+    if (stats.isDirectory()) {
+      return true; // Directories are valid, will be expanded later
+    }
+
+    // Check file extension for files
+    const ext = path.extname(filePath);
+    const supportedExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+    
+    if (!supportedExtensions.includes(ext)) {
+      console.warn(chalk.yellow(`⚠️  Unsupported file type: ${filePath}`));
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Rule C006: formatAnalysisResults - verb-noun naming
+   * Rule C005: Single responsibility - format results
+   */
+  formatAnalysisResults(results, options) {
+    const totalFiles = results.length;
+    const totalErrors = results.reduce((sum, result) => sum + (result.errorCount || 0), 0);
+    const totalWarnings = results.reduce((sum, result) => sum + (result.warningCount || 0), 0);
+
+    const summary = {
+      totalFiles,
+      totalErrors,
+      totalWarnings,
+      results: results.filter(result => result.messages && result.messages.length > 0)
+    };
+
+    if (options.verbose) {
+      console.log(chalk.blue(`📊 Analysis Summary: ${totalFiles} files, ${totalErrors} errors, ${totalWarnings} warnings`));
+    }
+
+    return summary;
+  }
+
+  /**
+   * Rule C006: extractProblemsFromResults - verb-noun naming
+   * Rule C012: Query method - extracts data without side effects
+   */
+  extractProblemsFromResults(results) {
+    const problems = [];
+    
+    for (const result of results.results || []) {
+      for (const message of result.messages || []) {
+        problems.push({
+          filePath: result.filePath,
+          ruleId: message.ruleId,
+          severity: message.severity,
+          message: message.message,
+          line: message.line,
+          column: message.column,
+          endLine: message.endLine,
+          endColumn: message.endColumn
+        });
+      }
+    }
+
+    return problems;
+  }
+
+  /**
+   * Rule C006: filterResultsByRules - verb-noun naming
+   * Rule C012: Query method - filters without modifying original
+   */
+  filterResultsByRules(results, ruleIds) {
+    if (!ruleIds || ruleIds.length === 0) {
+      return results;
+    }
+
+    const filteredResults = {
+      ...results,
+      results: results.results.map(result => ({
+        ...result,
+        messages: result.messages.filter(message => 
+          ruleIds.includes(message.ruleId)
+        )
+      })).filter(result => result.messages.length > 0)
+    };
+
+    // Recalculate counts
+    filteredResults.totalErrors = filteredResults.results.reduce(
+      (sum, result) => sum + result.messages.filter(m => m.severity === 2).length, 
+      0
+    );
+    filteredResults.totalWarnings = filteredResults.results.reduce(
+      (sum, result) => sum + result.messages.filter(m => m.severity === 1).length, 
+      0
+    );
+
+    return filteredResults;
+  }
+
+  /**
+   * Rule C006: expandDirectories - verb-noun naming
+   * Rule C005: Single responsibility - expand directories to files
+   */
+  expandDirectories(filePaths) {
+    const expandedFiles = [];
+    const supportedExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+    
+    for (const filePath of filePaths) {
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+      
+      const stats = fs.statSync(filePath);
+      if (stats.isDirectory()) {
+        // Recursively find TypeScript/JavaScript files
+        const files = this.findFilesRecursively(filePath, supportedExtensions);
+        expandedFiles.push(...files);
+      } else if (stats.isFile() && supportedExtensions.includes(path.extname(filePath))) {
+        expandedFiles.push(filePath);
+      }
+    }
+    
+    return expandedFiles;
+  }
+
+  /**
+   * Rule C006: findFilesRecursively - verb-noun naming
+   * Rule C005: Single responsibility - recursive file finding
+   */
+  findFilesRecursively(dir, extensions) {
+    const files = [];
+    
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        // Skip node_modules and other common ignore patterns
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.')) {
+          continue;
+        }
+        
+        if (entry.isDirectory()) {
+          files.push(...this.findFilesRecursively(fullPath, extensions));
+        } else if (entry.isFile() && extensions.includes(path.extname(entry.name))) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠️  Cannot read directory: ${dir}`));
+    }
+    
+    return files;
+  }
+}
+
+module.exports = TypescriptAnalyzer;