@sun-asterisk/sunlint 1.0.5

package/core/config-source-loader.js

@@ -0,0 +1,152 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Handles loading configuration from various sources (files, environment, etc.)
+ * Rule C005: Single responsibility - chỉ load config từ sources
+ * Rule C015: Domain language - ConfigSourceLoader
+ */
+class ConfigSourceLoader {
+  constructor() {
+    this.configNames = [
+      '.sunlint.json',
+      '.sunlint.js', 
+      'sunlint.config.json',
+      'sunlint.config.js'
+    ];
+  }
+
+  /**
+   * Rule C006: loadGlobalConfiguration - verb-noun naming
+   */
+  loadGlobalConfiguration(homePath, verbose = false) {
+    const globalConfigPath = path.join(homePath, '.sunlint.json');
+    if (!fs.existsSync(globalConfigPath)) {
+      return null;
+    }
+
+    try {
+      const globalConfig = JSON.parse(fs.readFileSync(globalConfigPath, 'utf8'));
+      if (verbose) {
+        console.log(chalk.gray(`🌍 Loaded global config: ${globalConfigPath}`));
+      }
+      return { config: globalConfig, path: globalConfigPath };
+    } catch (error) {
+      console.warn(chalk.yellow(`⚠️  Failed to load global config: ${error.message}`));
+      return null;
+    }
+  }
+
+  /**
+   * Rule C006: findProjectConfiguration - verb-noun naming
+   */
+  findProjectConfiguration(startDir) {
+    let currentDir = path.resolve(startDir);
+    const rootDir = path.parse(currentDir).root;
+
+    while (currentDir !== rootDir) {
+      // Check for SunLint config files
+      for (const configName of this.configNames) {
+        const configPath = path.join(currentDir, configName);
+        if (fs.existsSync(configPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            return { path: configPath, config, dir: currentDir };
+          } catch (error) {
+            console.warn(chalk.yellow(`⚠️  Invalid config file ${configPath}: ${error.message}`));
+          }
+        }
+      }
+
+      // Check package.json for sunlint config
+      const packageResult = this.loadPackageJsonConfig(currentDir);
+      if (packageResult) {
+        return packageResult;
+      }
+
+      currentDir = path.dirname(currentDir);
+    }
+
+    return null;
+  }
+
+  /**
+   * Rule C006: loadPackageJsonConfig - verb-noun naming
+   * Rule C005: Extracted method for single responsibility
+   */
+  loadPackageJsonConfig(directory) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      return null;
+    }
+
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (packageJson.sunlint) {
+        return { path: packageJsonPath, config: packageJson.sunlint, dir: directory };
+      }
+    } catch (error) {
+      // Ignore package.json parse errors
+    }
+
+    return null;
+  }
+
+  /**
+   * Rule C006: loadSpecificConfigFile - verb-noun naming
+   */
+  loadSpecificConfigFile(configPath, verbose = false) {
+    if (!configPath || !fs.existsSync(configPath)) {
+      return null;
+    }
+
+    try {
+      const fileConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (verbose) {
+        console.log(chalk.gray(`📄 Loaded config from: ${configPath}`));
+      }
+      return { config: fileConfig, path: configPath };
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to load config from ${configPath}:`), error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Rule C006: loadIgnorePatterns - verb-noun naming
+   */
+  loadIgnorePatterns(projectDir, verbose = false) {
+    const ignoreFiles = ['.sunlintignore', '.eslintignore', '.gitignore'];
+    const ignorePatterns = [];
+
+    for (const ignoreFile of ignoreFiles) {
+      const ignorePath = path.join(projectDir, ignoreFile);
+      if (fs.existsSync(ignorePath)) {
+        try {
+          const ignoreContent = fs.readFileSync(ignorePath, 'utf8');
+          const patterns = ignoreContent
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'))
+            .filter(line => !ignorePatterns.includes(line));
+          
+          ignorePatterns.push(...patterns);
+          
+          if (verbose) {
+            console.log(chalk.gray(`📋 Loaded ignore patterns from: ${ignorePath} (${patterns.length} patterns)`));
+          }
+          
+          // Only use the first ignore file found
+          break;
+        } catch (error) {
+          console.warn(chalk.yellow(`⚠️  Failed to load ignore file ${ignorePath}: ${error.message}`));
+        }
+      }
+    }
+
+    return [...new Set(ignorePatterns)]; // Remove duplicates
+  }
+}
+
+module.exports = ConfigSourceLoader;

package/core/config-validator.js

@@ -0,0 +1,126 @@
+/**
+ * Handles configuration validation and rule value normalization
+ * Rule C005: Single responsibility - chỉ validation và normalization
+ * Rule C015: Domain language - ConfigValidator
+ * Rule C031: Validation logic tách riêng
+ */
+class ConfigValidator {
+
+  constructor() {
+    this.validFormats = ['eslint', 'json', 'summary', 'table'];
+    this.validRuleValues = ['error', 'warning', 'info', 'warn', 'off', true, false, 0, 1, 2];
+    this.ruleValueMapping = {
+      0: 'off',
+      1: 'warning', 
+      2: 'error',
+      'warn': 'warning',
+      true: 'warning',
+      false: 'off'
+    };
+  }
+
+  /**
+   * Rule C006: validateConfiguration - verb-noun naming
+   * Rule C031: Main validation method
+   */
+  validateConfiguration(config) {
+    this.validateRulesSection(config.rules);
+    this.validateLanguagesSection(config.languages);
+    this.validateIncludeExcludePatterns(config.include, config.exclude);
+    this.validateOutputFormat(config.output);
+    this.validateRuleValues(config.rules);
+  }
+
+  /**
+   * Rule C006: validateRulesSection - verb-noun naming
+   * Rule C031: Specific validation logic
+   */
+  validateRulesSection(rules) {
+    if (rules && typeof rules !== 'object') {
+      throw new Error('Config error: rules must be an object');
+    }
+  }
+
+  /**
+   * Rule C006: validateLanguagesSection - verb-noun naming
+   * Rule C031: Specific validation logic
+   */
+  validateLanguagesSection(languages) {
+    if (languages && !Array.isArray(languages)) {
+      throw new Error('Config error: languages must be an array');
+    }
+  }
+
+  /**
+   * Rule C006: validateIncludeExcludePatterns - verb-noun naming
+   * Rule C031: Specific validation logic
+   */
+  validateIncludeExcludePatterns(include, exclude) {
+    if (include && !Array.isArray(include)) {
+      throw new Error('Config error: include must be an array');
+    }
+
+    if (exclude && !Array.isArray(exclude)) {
+      throw new Error('Config error: exclude must be an array');
+    }
+  }
+
+  /**
+   * Rule C006: validateOutputFormat - verb-noun naming
+   * Rule C031: Specific validation logic
+   */
+  validateOutputFormat(output) {
+    if (output && output.format && !this.validFormats.includes(output.format)) {
+      throw new Error(`Config error: invalid output format '${output.format}'. Valid formats: ${this.validFormats.join(', ')}`);
+    }
+  }
+
+  /**
+   * Rule C006: validateRuleValues - verb-noun naming
+   * Rule C031: Specific validation logic
+   */
+  validateRuleValues(rules) {
+    if (!rules) return;
+
+    for (const [ruleId, ruleValue] of Object.entries(rules)) {
+      if (!this.validRuleValues.includes(ruleValue)) {
+        throw new Error(`Config error: invalid value '${ruleValue}' for rule '${ruleId}'. Valid values: ${this.validRuleValues.join(', ')}`);
+      }
+    }
+  }
+
+  /**
+   * Rule C006: normalizeRuleValue - verb-noun naming
+   * Rule C012: Pure function - no side effects
+   */
+  normalizeRuleValue(value) {
+    return this.ruleValueMapping[value] || value;
+  }
+
+  /**
+   * Rule C006: getEffectiveRuleConfiguration - verb-noun naming
+   * Rule C014: Accept rulesRegistry as dependency injection
+   */
+  getEffectiveRuleConfiguration(ruleId, config, rulesRegistry) {
+    // Check direct rule configuration
+    if (config.rules && config.rules[ruleId] !== undefined) {
+      return this.normalizeRuleValue(config.rules[ruleId]);
+    }
+
+    // Check category configuration
+    const rule = rulesRegistry.rules[ruleId];
+    
+    if (rule && config.categories && config.categories[rule.category] !== undefined) {
+      return this.normalizeRuleValue(config.categories[rule.category]);
+    }
+
+    // Use rule default
+    if (rule) {
+      return this.normalizeRuleValue(rule.severity);
+    }
+
+    return 'off';
+  }
+}
+
+module.exports = ConfigValidator;

package/core/dependency-manager.js

@@ -0,0 +1,105 @@
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+
+/**
+ * Handles dependency validation and installation
+ * Rule C005: Single responsibility - only dependency management
+ * Rule C015: Domain language - DependencyManager
+ * Rule C032: No external API calls in constructor
+ */
+class DependencyManager {
+  constructor() {
+    this.requiredDependencies = [
+      '@typescript-eslint/parser',
+      '@typescript-eslint/eslint-plugin',
+      'eslint'
+    ];
+  }
+
+  /**
+   * Rule C006: checkDependenciesAvailable - verb-noun naming
+   * Rule C012: Query method - checks without side effects
+   */
+  async checkDependenciesAvailable() {
+    const missingDeps = [];
+    
+    for (const dep of this.requiredDependencies) {
+      try {
+        require.resolve(dep);
+      } catch (error) {
+        missingDeps.push(dep);
+      }
+    }
+
+    return {
+      allAvailable: missingDeps.length === 0,
+      missing: missingDeps
+    };
+  }
+
+  /**
+   * Rule C006: installMissingDependencies - verb-noun naming
+   * Rule C012: Command method - performs installation
+   */
+  async installMissingDependencies() {
+    const { allAvailable, missing } = await this.checkDependenciesAvailable();
+    
+    if (allAvailable) {
+      console.log(chalk.green('✅ All TypeScript dependencies are available'));
+      return true;
+    }
+
+    console.log(chalk.yellow(`⚠️  Missing dependencies: ${missing.join(', ')}`));
+    console.log(chalk.blue('📦 Installing missing dependencies...'));
+    
+    try {
+      const installCommand = `npm install ${missing.join(' ')}`;
+      execSync(installCommand, { stdio: 'inherit', cwd: process.cwd() });
+      
+      console.log(chalk.green('✅ Dependencies installed successfully'));
+      return true;
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to install dependencies:'), error.message);
+      console.log(chalk.yellow('💡 Please install manually:'));
+      console.log(chalk.gray(`   npm install ${missing.join(' ')}`));
+      return false;
+    }
+  }
+
+  /**
+   * Rule C006: validateDependencyVersions - verb-noun naming
+   * Rule C012: Query method
+   */
+  validateDependencyVersions() {
+    const versions = {};
+    
+    for (const dep of this.requiredDependencies) {
+      try {
+        const packagePath = require.resolve(`${dep}/package.json`);
+        const packageInfo = require(packagePath);
+        versions[dep] = packageInfo.version;
+      } catch (error) {
+        versions[dep] = 'not found';
+      }
+    }
+
+    return versions;
+  }
+
+  /**
+   * Rule C006: logDependencyStatus - verb-noun naming
+   */
+  logDependencyStatus() {
+    const versions = this.validateDependencyVersions();
+    
+    console.log(chalk.blue('📦 TypeScript Dependencies:'));
+    for (const [dep, version] of Object.entries(versions)) {
+      const status = version === 'not found' 
+        ? chalk.red('❌ Not found')
+        : chalk.green(`✅ v${version}`);
+      console.log(`   ${dep}: ${status}`);
+    }
+  }
+}
+
+module.exports = DependencyManager;

package/core/eslint-engine-service.js

@@ -0,0 +1,312 @@
+/**
+ * ESLint Engine Service
+ * Handles ESLint integration for TypeScript analysis
+ * Following Rule C005: Single responsibility - only handle ESLint execution
+ * Following Rule C014: Dependency injection for configuration
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+
+class ESLintEngineService {
+  constructor() {
+    this.eslintConfigPath = path.join(__dirname, '../config/typescript/eslint.config.js');
+    this.eslintPackagePath = path.join(__dirname, '../config/typescript');
+  }
+
+  /**
+   * Query: Check if ESLint is available
+   */
+  isAvailable() {
+    try {
+      // Check if config exists
+      if (!fs.existsSync(this.eslintConfigPath)) {
+        return false;
+      }
+
+      // Check if ESLint is available
+      execSync('npx eslint --version', { 
+        stdio: 'ignore',
+        cwd: this.eslintPackagePath
+      });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Command: Ensure ESLint dependencies are installed
+   */
+  async ensureDependencies() {
+    try {
+      console.log(chalk.blue('🔧 Ensuring ESLint dependencies...'));
+      
+      const packageJsonPath = path.join(this.eslintPackagePath, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        execSync('npm install', { 
+          cwd: this.eslintPackagePath,
+          stdio: 'inherit'
+        });
+      }
+      
+      console.log(chalk.green('✅ ESLint dependencies ready'));
+    } catch (error) {
+      throw new Error(`Failed to ensure ESLint dependencies: ${error.message}`);
+    }
+  }
+
+  /**
+   * Command: Run ESLint analysis
+   */
+  async runAnalysis(rulesToRun, options) {
+    try {
+      // Map SunLint rules to ESLint rules
+      const eslintRules = this.mapSunLintRulesToESLint(rulesToRun);
+      
+      // Build ESLint command
+      const command = this.buildESLintCommand(eslintRules, options);
+      
+      if (options.debug) {
+        console.log(chalk.yellow('ESLint command:'), command);
+      }
+
+      // Execute ESLint
+      const output = execSync(command, { 
+        cwd: this.eslintPackagePath,
+        encoding: 'utf-8'
+      });
+
+      // Parse results
+      return this.parseESLintOutput(output, options);
+
+    } catch (error) {
+      // ESLint might exit with non-zero code when violations are found
+      if (error.stdout) {
+        return this.parseESLintOutput(error.stdout, options);
+      }
+      throw new Error(`ESLint execution failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Query: Map SunLint rule IDs to ESLint rule IDs
+   */
+  mapSunLintRulesToESLint(rules) {
+    const ruleMapping = {
+      // Quality rules (C-rules)
+      'C002': 'custom/c002',
+      'C003': 'custom/c003',
+      'C006': 'custom/c006',
+      'C010': 'custom/c010',
+      'C013': 'custom/c013',
+      'C014': 'custom/c014',
+      'C017': 'custom/c017',
+      'C018': 'custom/c018',
+      'C023': 'custom/c023',
+      'C027': 'custom/c027',
+      'C029': 'custom/c029',
+      'C030': 'custom/c030',
+      'C034': 'custom/c034',
+      'C035': 'custom/c035',
+      'C041': 'custom/c041',
+      'C042': 'custom/c042',
+      'C043': 'custom/c043',
+      'C047': 'custom/c047',
+      'C048': 'custom/c048',
+      
+      // Security rules (S-rules)
+      'S005': 'custom/typescript_s005',
+      'S006': 'custom/typescript_s006',
+      'S008': 'custom/typescript_s008',
+      'S009': 'custom/typescript_s009',
+      'S010': 'custom/typescript_s010',
+      'S011': 'custom/typescript_s011',
+      'S012': 'custom/typescript_s012',
+      'S014': 'custom/typescript_s014',
+      'S015': 'custom/typescript_s015',
+      'S016': 'custom/typescript_s016',
+      'S017': 'custom/typescript_s017',
+      'S018': 'custom/typescript_s018',
+      'S019': 'custom/typescript_s019',
+      'S020': 'custom/typescript_s020',
+      'S022': 'custom/typescript_s022',
+      'S023': 'custom/typescript_s023',
+      'S025': 'custom/typescript_s025',
+      'S026': 'custom/typescript_s026',
+      'S027': 'custom/typescript_s027',
+      'S029': 'custom/typescript_s029',
+      'S030': 'custom/typescript_s030',
+      'S033': 'custom/typescript_s033',
+      'S034': 'custom/typescript_s034',
+      'S035': 'custom/typescript_s035',
+      'S036': 'custom/typescript_s036',
+      'S037': 'custom/typescript_s037',
+      'S038': 'custom/typescript_s038',
+      'S039': 'custom/typescript_s039',
+      'S041': 'custom/typescript_s041',
+      'S042': 'custom/typescript_s042',
+      'S043': 'custom/typescript_s043',
+      'S044': 'custom/typescript_s044',
+      'S045': 'custom/typescript_s045',
+      'S046': 'custom/typescript_s046',
+      'S048': 'custom/typescript_s048',
+      'S050': 'custom/typescript_s050',
+      'S052': 'custom/typescript_s052',
+      'S054': 'custom/typescript_s054',
+      'S057': 'custom/typescript_s057',
+      'S058': 'custom/typescript_s058'
+    };
+
+    return rules
+      .filter(rule => ruleMapping[rule.id])
+      .map(rule => ruleMapping[rule.id]);
+  }
+
+  /**
+   * Command: Build ESLint command
+   */
+  buildESLintCommand(eslintRules, options) {
+    const parts = [
+      'npx eslint',
+      `--config ${this.eslintConfigPath}`,
+      '--format json',
+      `"${options.input}"`
+    ];
+
+    // Add specific rules if provided
+    if (eslintRules.length > 0) {
+      const rulesFlag = eslintRules.map(rule => `${rule}:error`).join(' ');
+      parts.push(`--rule "${rulesFlag}"`);
+    }
+
+    // Add file extensions
+    parts.push('--ext .ts,.tsx,.js,.jsx');
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Query: Parse ESLint JSON output to SunLint format
+   */
+  parseESLintOutput(output, options) {
+    try {
+      const eslintResults = JSON.parse(output);
+      
+      const results = {
+        results: [],
+        filesAnalyzed: eslintResults.length,
+        engine: 'eslint'
+      };
+
+      eslintResults.forEach(file => {
+        if (file.messages.length > 0) {
+          const violations = file.messages.map(msg => ({
+            ruleId: this.mapESLintRuleToSunLint(msg.ruleId),
+            severity: this.mapESLintSeverity(msg.severity),
+            message: msg.message,
+            line: msg.line,
+            column: msg.column,
+            file: file.filePath
+          }));
+
+          results.results.push({
+            file: file.filePath,
+            violations: violations
+          });
+        }
+      });
+
+      return results;
+    } catch (error) {
+      throw new Error(`Failed to parse ESLint output: ${error.message}`);
+    }
+  }
+
+  /**
+   * Query: Map ESLint rule ID back to SunLint rule ID
+   */
+  mapESLintRuleToSunLint(eslintRuleId) {
+    const reverseMapping = {
+      // Quality rules (C-rules)
+      'custom/c002': 'C002',
+      'custom/c003': 'C003',
+      'custom/c006': 'C006',
+      'custom/c010': 'C010',
+      'custom/c013': 'C013',
+      'custom/c014': 'C014',
+      'custom/c017': 'C017',
+      'custom/c018': 'C018',
+      'custom/c023': 'C023',
+      'custom/c027': 'C027',
+      'custom/c029': 'C029',
+      'custom/c030': 'C030',
+      'custom/c034': 'C034',
+      'custom/c035': 'C035',
+      'custom/c041': 'C041',
+      'custom/c042': 'C042',
+      'custom/c043': 'C043',
+      'custom/c047': 'C047',
+      'custom/c048': 'C048',
+      
+      // Security rules (S-rules)
+      'custom/typescript_s005': 'S005',
+      'custom/typescript_s006': 'S006',
+      'custom/typescript_s008': 'S008',
+      'custom/typescript_s009': 'S009',
+      'custom/typescript_s010': 'S010',
+      'custom/typescript_s011': 'S011',
+      'custom/typescript_s012': 'S012',
+      'custom/typescript_s014': 'S014',
+      'custom/typescript_s015': 'S015',
+      'custom/typescript_s016': 'S016',
+      'custom/typescript_s017': 'S017',
+      'custom/typescript_s018': 'S018',
+      'custom/typescript_s019': 'S019',
+      'custom/typescript_s020': 'S020',
+      'custom/typescript_s022': 'S022',
+      'custom/typescript_s023': 'S023',
+      'custom/typescript_s025': 'S025',
+      'custom/typescript_s026': 'S026',
+      'custom/typescript_s027': 'S027',
+      'custom/typescript_s029': 'S029',
+      'custom/typescript_s030': 'S030',
+      'custom/typescript_s033': 'S033',
+      'custom/typescript_s034': 'S034',
+      'custom/typescript_s035': 'S035',
+      'custom/typescript_s036': 'S036',
+      'custom/typescript_s037': 'S037',
+      'custom/typescript_s038': 'S038',
+      'custom/typescript_s039': 'S039',
+      'custom/typescript_s041': 'S041',
+      'custom/typescript_s042': 'S042',
+      'custom/typescript_s043': 'S043',
+      'custom/typescript_s044': 'S044',
+      'custom/typescript_s045': 'S045',
+      'custom/typescript_s046': 'S046',
+      'custom/typescript_s048': 'S048',
+      'custom/typescript_s050': 'S050',
+      'custom/typescript_s052': 'S052',
+      'custom/typescript_s054': 'S054',
+      'custom/typescript_s057': 'S057',
+      'custom/typescript_s058': 'S058'
+    };
+
+    return reverseMapping[eslintRuleId] || eslintRuleId;
+  }
+
+  /**
+   * Query: Map ESLint severity to SunLint severity
+   */
+  mapESLintSeverity(eslintSeverity) {
+    switch (eslintSeverity) {
+      case 1: return 'warning';
+      case 2: return 'error';
+      default: return 'info';
+    }
+  }
+}
+
+module.exports = ESLintEngineService;