@sun-asterisk/sunlint 1.0.5

package/core/config-manager.js

@@ -0,0 +1,396 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const os = require('os');
+
+// Rule C014: Dependency injection instead of direct instantiation
+const ConfigSourceLoader = require('./config-source-loader');
+const ConfigPresetResolver = require('./config-preset-resolver');
+const ConfigMerger = require('./config-merger');
+const ConfigValidator = require('./config-validator');
+const ConfigOverrideProcessor = require('./config-override-processor');
+
+/**
+ * Main configuration manager - orchestrates config loading process
+ * Rule C005: Single responsibility - orchestrates other config services
+ * Rule C015: Domain language - ConfigManager as main coordinator
+ * Rule C014: Uses dependency injection for all services
+ */
+class ConfigManager {
+  constructor() {
+    // Rule C014: Dependency injection
+    this.sourceLoader = new ConfigSourceLoader();
+    this.presetResolver = new ConfigPresetResolver();
+    this.merger = new ConfigMerger();
+    this.validator = new ConfigValidator();
+    this.overrideProcessor = new ConfigOverrideProcessor();
+    
+    this.defaultConfig = {
+      rules: {},
+      categories: {},
+      languages: ['typescript', 'dart'],
+      include: ['**/*.ts', '**/*.tsx', '**/*.dart', '**/*.js', '**/*.jsx'],
+      exclude: ['**/node_modules/**', '**/build/**', '**/dist/**'],
+      ignorePatterns: [],
+      overrides: [],
+      env: {},
+      parserOptions: {},
+      // ESLint Integration Configuration
+      eslintIntegration: {
+        enabled: false,
+        mergeRules: true,
+        preserveUserConfig: true,
+        runAfterSunLint: false
+      },
+      output: {
+        format: 'eslint',
+        console: true,
+        summary: true
+      },
+      ai: {
+        enabled: false,
+        fallbackToPattern: true,
+        provider: 'openai',
+        model: 'gpt-4o-mini'
+      },
+      performance: {
+        maxConcurrentRules: 5,
+        timeoutMs: 30000,
+        cacheEnabled: true,
+        cacheLocation: '.sunlint-cache/'
+      },
+      reporting: {
+        includeContext: true,
+        showFixSuggestions: true,
+        groupByFile: true,
+        sortBy: 'severity',
+        showProgress: true,
+        exitOnError: false
+      }
+    };
+  }
+
+  /**
+   * Rule C006: loadConfiguration - verb-noun naming
+   * Rule C005: Single responsibility - orchestrates config loading
+   * Rule C012: Command method - loads and returns config
+   */
+  async loadConfiguration(configPath, cliOptions = {}) {
+    // 1. Start with built-in defaults
+    let config = { ...this.defaultConfig };
+
+    // 2. Environment variables
+    config = this.merger.applyEnvironmentVariables(config);
+
+    // 3. Global config (~/.sunlint.json)
+    const globalConfig = this.sourceLoader.loadGlobalConfiguration(os.homedir(), cliOptions.verbose);
+    if (globalConfig) {
+      config = this.merger.mergeConfigurations(config, globalConfig.config);
+    }
+
+    // 4. Auto-discover project config if not explicitly provided
+    let resolvedConfigPath = configPath;
+    if (!configPath || configPath === '.sunlint.json') {
+      const discoveredConfig = this.findConfigFile(cliOptions.input || process.cwd());
+      if (discoveredConfig) {
+        resolvedConfigPath = discoveredConfig;
+        if (cliOptions.verbose) {
+          console.log(chalk.gray(`🔍 Auto-discovered config: ${discoveredConfig}`));
+        }
+      }
+    }
+
+    // 5. Load project config (explicit or discovered)
+    let projectConfig = null;
+    if (resolvedConfigPath && fs.existsSync(resolvedConfigPath)) {
+      if (resolvedConfigPath.endsWith('package.json')) {
+        // Load from package.json sunlint field
+        const pkg = JSON.parse(fs.readFileSync(resolvedConfigPath, 'utf8'));
+        if (pkg.sunlint) {
+          projectConfig = { 
+            config: pkg.sunlint, 
+            path: resolvedConfigPath,
+            dir: path.dirname(resolvedConfigPath)
+          };
+        }
+      } else {
+        // Load from dedicated config file
+        projectConfig = this.sourceLoader.loadConfiguration(resolvedConfigPath, cliOptions.verbose);
+      }
+      
+      if (projectConfig) {
+        config = this.merger.mergeConfigurations(config, projectConfig.config);
+        if (cliOptions.verbose) {
+          console.log(chalk.gray(`📄 Loaded project config: ${projectConfig.path}`));
+        }
+      }
+    }
+
+    // 6. Load ignore patterns (.sunlintignore)
+    const ignorePatterns = this.sourceLoader.loadIgnorePatterns(
+      projectConfig?.dir || process.cwd(), 
+      cliOptions.verbose
+    );
+    config.ignorePatterns = [...(config.ignorePatterns || []), ...ignorePatterns];
+    config = this.merger.processIgnorePatterns(config);
+
+    // 7. Apply CLI overrides (highest priority)
+    config = this.merger.applyCLIOverrides(config, cliOptions);
+
+    // 8. Resolve extends
+    config = await this.resolveExtends(config);
+
+    // 9. Validate config
+    this.validator.validateConfiguration(config);
+
+    return config;
+  }
+
+  mergeConfigs(base, override) {
+    const merged = { ...base };
+
+    for (const [key, value] of Object.entries(override)) {
+      if (key === 'rules' && typeof value === 'object') {
+        merged.rules = { ...merged.rules, ...value };
+      } else if (key === 'categories' && typeof value === 'object') {
+        merged.categories = { ...merged.categories, ...value };
+      } else if (typeof value === 'object' && !Array.isArray(value)) {
+        merged[key] = { ...merged[key], ...value };
+      } else {
+        merged[key] = value;
+      }
+    }
+
+    return merged;
+  }
+
+  applyCLIOverrides(config, options) {
+    const overrides = { ...config };
+
+    // Languages override
+    if (options.languages) {
+      overrides.languages = options.languages.split(',').map(l => l.trim());
+    }
+
+    // Output format override
+    if (options.format) {
+      overrides.output = { ...overrides.output, format: options.format };
+    }
+
+    // AI override
+    if (options.ai === true) {
+      overrides.ai = { ...overrides.ai, enabled: true };
+    }
+    if (options.ai === false) {
+      overrides.ai = { ...overrides.ai, enabled: false };
+    }
+
+    // Performance overrides
+    if (options.maxConcurrent) {
+      overrides.performance = { 
+        ...overrides.performance, 
+        maxConcurrentRules: parseInt(options.maxConcurrent) 
+      };
+    }
+
+    if (options.timeout) {
+      overrides.performance = { 
+        ...overrides.performance, 
+        timeoutMs: parseInt(options.timeout) 
+      };
+    }
+
+    // Cache override
+    if (options.cache === false) {
+      overrides.performance = { 
+        ...overrides.performance, 
+        cacheEnabled: false 
+      };
+    }
+
+    return overrides;
+  }
+
+  /**
+   * Rule C006: resolveExtends - verb-noun naming
+   * Rule C005: Single responsibility - only handles extends resolution
+   */
+  async resolveExtends(config) {
+    if (!config.extends) {
+      return config;
+    }
+
+    const extends_ = Array.isArray(config.extends) ? config.extends : [config.extends];
+    let resolvedConfig = { ...config };
+
+    for (const extendPath of extends_) {
+      try {
+        // Check if it's a preset
+        if (extendPath.startsWith('@sun/sunlint/')) {
+          const presetConfig = await this.presetResolver.loadPresetConfiguration(extendPath);
+          resolvedConfig = this.merger.mergeConfigurations(presetConfig, resolvedConfig);
+        } else {
+          const extendedConfig = await this.loadExtendedConfig(extendPath);
+          resolvedConfig = this.merger.mergeConfigurations(extendedConfig, resolvedConfig);
+        }
+      } catch (error) {
+        console.error(chalk.yellow(`⚠️  Failed to extend config '${extendPath}':`), error.message);
+      }
+    }
+
+    // Remove extends to avoid circular references
+    delete resolvedConfig.extends;
+
+    return resolvedConfig;
+  }
+
+  /**
+   * Rule C006: loadExtendedConfig - verb-noun naming
+   */
+  async loadExtendedConfig(extendPath) {
+    if (extendPath.startsWith('@sun/sunlint/')) {
+      // Load preset from rules registry
+      const presetName = extendPath.replace('@sun/sunlint/', '');
+      const rulesRegistry = require('../config/rules-registry.json');
+      return this.presetResolver.resolvePresetFromRegistry(presetName, rulesRegistry);
+    } else {
+      // Load from file path
+      const configPath = path.resolve(extendPath);
+      if (fs.existsSync(configPath)) {
+        return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      } else {
+        throw new Error(`Config file not found: ${configPath}`);
+      }
+    }
+  }
+
+  /**
+   * Rule C006: applyFileOverrides - verb-noun naming
+   * Rule C014: Delegate to override processor
+   */
+  applyFileOverrides(config, filePath) {
+    return this.overrideProcessor.applyFileOverrides(config, filePath);
+  }
+
+  /**
+   * Rule C006: getEffectiveRuleConfiguration - verb-noun naming
+   * Rule C014: Delegate to validator
+   */
+  getEffectiveRuleConfiguration(ruleId, config) {
+    const rulesRegistry = require('../config/rules-registry.json');
+    return this.validator.getEffectiveRuleConfiguration(ruleId, config, rulesRegistry);
+  }
+
+  /**
+   * Rule C006: normalizeRuleValue - verb-noun naming
+   * Rule C014: Delegate to validator
+   */
+  normalizeRuleValue(value) {
+    return this.validator.normalizeRuleValue(value);
+  }
+
+  /**
+   * Find configuration file using discovery hierarchy
+   * Following Rule C005: Single responsibility - only handle config discovery
+   * @param {string} startPath - Starting directory for config search
+   * @returns {string|null} Path to config file or null if not found
+   */
+  findConfigFile(startPath = process.cwd()) {
+    const configNames = [
+      '.sunlint.json',
+      '.sunlint.js', 
+      'sunlint.config.js',
+      'sunlint.config.json'
+    ];
+    
+    let currentPath = path.resolve(startPath);
+    
+    // Traverse up directory tree
+    while (currentPath !== path.dirname(currentPath)) {
+      for (const configName of configNames) {
+        const configPath = path.join(currentPath, configName);
+        if (fs.existsSync(configPath)) {
+          return configPath;
+        }
+      }
+      currentPath = path.dirname(currentPath);
+    }
+    
+    // Check for package.json with sunlint field
+    const packageConfigPath = this.findPackageConfig(startPath);
+    if (packageConfigPath) {
+      return packageConfigPath;
+    }
+    
+    return null;
+  }
+
+  /**
+   * Find package.json with sunlint configuration
+   * @param {string} startPath - Starting directory
+   * @returns {string|null} Path to package.json or null
+   */
+  findPackageConfig(startPath = process.cwd()) {
+    let currentPath = path.resolve(startPath);
+    
+    while (currentPath !== path.dirname(currentPath)) {
+      const packagePath = path.join(currentPath, 'package.json');
+      if (fs.existsSync(packagePath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+          if (pkg.sunlint) {
+            return packagePath;
+          }
+        } catch (error) {
+          // Continue searching if package.json is invalid
+        }
+      }
+      currentPath = path.dirname(currentPath);
+    }
+    
+    return null;
+  }
+
+  /**
+   * Find project root directory (where package.json exists)
+   * @param {string} startPath - Starting directory
+   * @returns {string} Project root path or startPath if not found
+   */
+  findProjectRoot(startPath = process.cwd()) {
+    let currentPath = path.resolve(startPath);
+    
+    while (currentPath !== path.dirname(currentPath)) {
+      const packagePath = path.join(currentPath, 'package.json');
+      if (fs.existsSync(packagePath)) {
+        return currentPath;
+      }
+      currentPath = path.dirname(currentPath);
+    }
+    
+    return startPath;
+  }
+
+  // Legacy method names for backward compatibility
+  // Rule C006: Maintaining existing API while delegating to new services
+  async loadConfig(configPath, cliOptions) {
+    return this.loadConfiguration(configPath, cliOptions);
+  }
+
+  mergeConfigs(base, override) {
+    return this.merger.mergeConfigurations(base, override);
+  }
+
+  applyCLIOverrides(config, options) {
+    return this.merger.applyCLIOverrides(config, options);
+  }
+
+  applyOverrides(config, filePath) {
+    return this.overrideProcessor.applyFileOverrides(config, filePath);
+  }
+
+  validateConfig(config) {
+    return this.validator.validateConfiguration(config);
+  }
+}
+
+module.exports = ConfigManager;

package/core/config-merger.js

@@ -0,0 +1,136 @@
+/**
+ * Handles configuration merging and CLI overrides
+ * Rule C005: Single responsibility - chỉ merge và override config
+ * Rule C015: Domain language - ConfigMerger
+ */
+class ConfigMerger {
+  
+  /**
+   * Rule C006: mergeConfigurations - verb-noun naming
+   * Rule C012: Pure function - no side effects, clear input/output
+   */
+  mergeConfigurations(base, override) {
+    const merged = { ...base };
+
+    for (const [key, value] of Object.entries(override)) {
+      if (key === 'rules' && typeof value === 'object') {
+        merged.rules = { ...merged.rules, ...value };
+      } else if (key === 'categories' && typeof value === 'object') {
+        merged.categories = { ...merged.categories, ...value };
+      } else if (typeof value === 'object' && !Array.isArray(value)) {
+        merged[key] = { ...merged[key], ...value };
+      } else {
+        merged[key] = value;
+      }
+    }
+
+    return merged;
+  }
+
+  /**
+   * Rule C006: applyCLIOverrides - verb-noun naming
+   * Rule C012: Pure function - no side effects
+   */
+  applyCLIOverrides(config, options) {
+    const overrides = { ...config };
+
+    // Languages override
+    if (options.languages) {
+      overrides.languages = options.languages.split(',').map(l => l.trim());
+    }
+
+    // Output format override
+    if (options.format) {
+      overrides.output = { ...overrides.output, format: options.format };
+    }
+
+    // AI overrides
+    overrides.ai = this.applyAIOverrides(overrides.ai, options);
+
+    // Performance overrides
+    overrides.performance = this.applyPerformanceOverrides(overrides.performance, options);
+
+    return overrides;
+  }
+
+  /**
+   * Rule C006: applyAIOverrides - verb-noun naming
+   * Rule C005: Extracted for single responsibility
+   */
+  applyAIOverrides(aiConfig, options) {
+    const ai = { ...aiConfig };
+
+    if (options.ai === true) {
+      ai.enabled = true;
+    }
+    if (options.ai === false) {
+      ai.enabled = false;
+    }
+
+    return ai;
+  }
+
+  /**
+   * Rule C006: applyPerformanceOverrides - verb-noun naming
+   * Rule C005: Extracted for single responsibility
+   */
+  applyPerformanceOverrides(performanceConfig, options) {
+    const performance = { ...performanceConfig };
+
+    if (options.maxConcurrent) {
+      performance.maxConcurrentRules = parseInt(options.maxConcurrent);
+    }
+
+    if (options.timeout) {
+      performance.timeoutMs = parseInt(options.timeout);
+    }
+
+    if (options.cache === false) {
+      performance.cacheEnabled = false;
+    }
+
+    return performance;
+  }
+
+  /**
+   * Rule C006: applyEnvironmentVariables - verb-noun naming
+   */
+  applyEnvironmentVariables(config) {
+    const updatedConfig = { ...config };
+
+    // SUNLINT_RULES environment variable
+    if (process.env.SUNLINT_RULES) {
+      const envRules = {};
+      process.env.SUNLINT_RULES.split(',').forEach(rule => {
+        const [ruleId, severity] = rule.trim().split(':');
+        envRules[ruleId] = severity || 'error';
+      });
+      updatedConfig.rules = { ...updatedConfig.rules, ...envRules };
+    }
+
+    // SUNLINT_AI_ENABLED environment variable
+    if (process.env.SUNLINT_AI_ENABLED) {
+      updatedConfig.ai = updatedConfig.ai || {};
+      updatedConfig.ai.enabled = process.env.SUNLINT_AI_ENABLED === 'true';
+    }
+
+    // SUNLINT_LANGUAGES environment variable
+    if (process.env.SUNLINT_LANGUAGES) {
+      updatedConfig.languages = process.env.SUNLINT_LANGUAGES.split(',').map(l => l.trim());
+    }
+
+    return updatedConfig;
+  }
+
+  /**
+   * Rule C006: processIgnorePatterns - verb-noun naming
+   */
+  processIgnorePatterns(config) {
+    if (config.ignorePatterns && config.ignorePatterns.length > 0) {
+      config.exclude = [...new Set([...config.exclude, ...config.ignorePatterns])];
+    }
+    return config;
+  }
+}
+
+module.exports = ConfigMerger;

package/core/config-override-processor.js

@@ -0,0 +1,74 @@
+/**
+ * Handles configuration file overrides based on file patterns
+ * Rule C005: Single responsibility - chỉ xử lý overrides theo file patterns
+ * Rule C015: Domain language - ConfigOverrideProcessor
+ */
+class ConfigOverrideProcessor {
+
+  constructor() {
+    // Rule C014: Dependency injection for minimatch
+    this.minimatch = require('minimatch');
+  }
+
+  /**
+   * Rule C006: applyFileOverrides - verb-noun naming
+   * Rule C012: Pure function with clear input/output
+   */
+  applyFileOverrides(config, filePath) {
+    if (!config.overrides || config.overrides.length === 0) {
+      return config;
+    }
+
+    let fileConfig = { ...config };
+
+    for (const override of config.overrides) {
+      if (this.shouldApplyOverride(override, filePath)) {
+        fileConfig = this.applyOverride(fileConfig, override);
+      }
+    }
+
+    return fileConfig;
+  }
+
+  /**
+   * Rule C006: shouldApplyOverride - verb-noun naming
+   * Rule C005: Single responsibility check
+   * Rule C012: Pure function - query operation
+   */
+  shouldApplyOverride(override, filePath) {
+    const { files } = override;
+    
+    if (!files || !Array.isArray(files)) {
+      return false;
+    }
+
+    return files.some(pattern => this.minimatch(filePath, pattern));
+  }
+
+  /**
+   * Rule C006: applyOverride - verb-noun naming
+   * Rule C005: Single responsibility application
+   */
+  applyOverride(fileConfig, override) {
+    const { files, rules, ...otherSettings } = override;
+    const updatedConfig = { ...fileConfig };
+
+    // Apply rule overrides
+    if (rules) {
+      updatedConfig.rules = { ...updatedConfig.rules, ...rules };
+    }
+    
+    // Apply other setting overrides
+    for (const [key, value] of Object.entries(otherSettings)) {
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        updatedConfig[key] = { ...updatedConfig[key], ...value };
+      } else {
+        updatedConfig[key] = value;
+      }
+    }
+
+    return updatedConfig;
+  }
+}
+
+module.exports = ConfigOverrideProcessor;

package/core/config-preset-resolver.js

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Handles loading and resolving configuration presets
+ * Rule C005: Single responsibility - chỉ xử lý presets
+ * Rule C015: Domain language - ConfigPresetResolver
+ */
+class ConfigPresetResolver {
+  constructor() {
+    this.presetMap = {
+      '@sun/sunlint/recommended': 'config/presets/recommended.json',
+      '@sun/sunlint/strict': 'config/presets/strict.json',
+      '@sun/sunlint/beginner': 'config/presets/beginner.json',
+      '@sun/sunlint/ci': 'config/presets/ci.json'
+    };
+  }
+
+  /**
+   * Rule C006: loadPresetConfiguration - verb-noun naming
+   */
+  async loadPresetConfiguration(presetName) {
+    const presetPath = this.presetMap[presetName];
+    if (!presetPath) {
+      throw new Error(`Unknown preset: ${presetName}`);
+    }
+
+    const fullPath = path.join(__dirname, '..', presetPath);
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Preset file not found: ${fullPath}`);
+    }
+
+    try {
+      const presetConfig = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+      return presetConfig;
+    } catch (error) {
+      throw new Error(`Failed to load preset ${presetName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Rule C006: resolvePresetFromRegistry - verb-noun naming
+   */
+  resolvePresetFromRegistry(presetName, rulesRegistry) {
+    const preset = rulesRegistry.presets[presetName];
+    if (!preset) {
+      throw new Error(`Preset '${presetName}' not found`);
+    }
+
+    return {
+      rules: preset.rules,
+      output: { format: 'eslint', console: true, summary: true },
+      performance: { maxConcurrentRules: 5, timeoutMs: 30000 }
+    };
+  }
+
+  /**
+   * Rule C006: checkPresetExists - verb-noun naming
+   */
+  checkPresetExists(presetName) {
+    return this.presetMap.hasOwnProperty(presetName);
+  }
+}
+
+module.exports = ConfigPresetResolver;