@sun-asterisk/sunlint 1.0.7 → 1.1.4

package/core/eslint-instance-manager.js

@@ -1,104 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const chalk = require('chalk');
-
-/**
- * Handles ESLint instance initialization and configuration detection
- * Rule C005: Single responsibility - only ESLint initialization
- * Rule C015: Domain language - EslintInstanceManager
- */
-class EslintInstanceManager {
-  constructor() {
-    this.eslintInstance = null;
-    this.isInitialized = false;
-    this.eslintModulePath = null;
-  }
-
-  /**
-   * Rule C006: initializeEslintInstance - verb-noun naming
-   * Rule C032: No external API calls in constructor - initialization method
-   */
-  async initializeEslintInstance(eslintModulePath = null) {
-    if (this.isInitialized) {
-      return this.eslintInstance;
-    }
-
-    try {
-      // Rule C014: Dependency injection from main package
-      const { ESLint } = require('eslint');
-      
-      const configPath = this.resolveConfigPath(eslintModulePath);
-      
-      this.eslintInstance = new ESLint({
-        overrideConfigFile: path.join(configPath, 'eslint.config.js'),
-        cache: false,
-        fix: false,
-        overrideConfig: {
-          linterOptions: {
-            reportUnusedDisableDirectives: 'error'
-          }
-        }
-      });
-
-      this.isInitialized = true;
-      this.eslintModulePath = configPath;
-      
-      return this.eslintInstance;
-    } catch (error) {
-      throw new Error(`Failed to initialize ESLint: ${error.message}`);
-    }
-  }
-
-  /**
-   * Rule C006: resolveConfigPath - verb-noun naming
-   * Rule C005: Single responsibility - config path resolution
-   */
-  resolveConfigPath(eslintModulePath) {
-    if (eslintModulePath) {
-      return eslintModulePath;
-    }
-
-    // Try primary config path, fallback to eslint-integration
-    const primaryPath = path.join(__dirname, '..', 'config', 'typescript');
-    const fallbackPath = path.join(__dirname, '..', 'eslint-integration');
-    const configFile = 'eslint.config.js';
-    
-    // Check if primary config exists
-    if (fs.existsSync(path.join(primaryPath, configFile))) {
-      return primaryPath;
-    } else {
-      // Fallback to eslint-integration
-      console.log(chalk.yellow('⚠️  Using fallback ESLint config from eslint-integration'));
-      return fallbackPath;
-    }
-  }
-
-  /**
-   * Rule C006: getEslintInstance - verb-noun naming
-   * Rule C012: Query method - returns instance without side effects
-   */
-  getEslintInstance() {
-    if (!this.isInitialized) {
-      throw new Error('ESLint instance not initialized. Call initializeEslintInstance() first.');
-    }
-    return this.eslintInstance;
-  }
-
-  /**
-   * Rule C006: getConfigPath - verb-noun naming
-   * Rule C012: Query method
-   */
-  getConfigPath() {
-    return this.eslintModulePath;
-  }
-
-  /**
-   * Rule C006: checkInstanceReady - verb-noun naming
-   * Rule C012: Query method
-   */
-  checkInstanceReady() {
-    return this.isInitialized && this.eslintInstance !== null;
-  }
-}
-
-module.exports = EslintInstanceManager;

package/core/eslint-integration-service.js

@@ -1,363 +0,0 @@
-/**
- * ESLint Integration Service
- * Following Rule C005: Single responsibility - handle ESLint integration
- * Following Rule C014: Dependency injection for ESLint engine
- */
-
-const fs = require('fs');
-const path = require('path');
-const chalk = require('chalk');
-const { ESLint } = require('eslint');
-
-class ESLintIntegrationService {
-  constructor() {
-    this.eslintInstance = null;
-    this.userESLintConfig = null;
-  }
-
-  /**
-   * Check if project has existing ESLint configuration
-   * @param {string} projectRoot - Project root directory
-   * @returns {boolean} Whether ESLint config exists
-   */
-  hasExistingESLintConfig(projectRoot) {
-    const configFiles = [
-      '.eslintrc.js',
-      '.eslintrc.json', 
-      '.eslintrc.yaml',
-      '.eslintrc.yml',
-      'eslint.config.js',
-      'eslint.config.mjs'
-    ];
-
-    return configFiles.some(file => {
-      const configPath = path.join(projectRoot, file);
-      return fs.existsSync(configPath);
-    }) || this.hasPackageJsonESLintConfig(projectRoot);
-  }
-
-  /**
-   * Check if package.json has ESLint config
-   */
-  hasPackageJsonESLintConfig(projectRoot) {
-    const packagePath = path.join(projectRoot, 'package.json');
-    if (fs.existsSync(packagePath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-        return !!(pkg.eslintConfig || pkg.eslint);
-      } catch (error) {
-        return false;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Load existing ESLint configuration
-   * @param {string} projectRoot - Project root directory
-   * @param {Object} sunlintConfig - SunLint configuration for legacy support check
-   * @returns {Object} ESLint configuration object
-   */
-  async loadExistingESLintConfig(projectRoot, sunlintConfig = {}) {
-    try {
-      console.log('Debug: Project root:', projectRoot);
-      console.log('Debug: Config files check:', {
-        flatConfig: fs.existsSync(path.join(projectRoot, 'eslint.config.mjs')),
-        eslintrc: fs.existsSync(path.join(projectRoot, '.eslintrc.json')),
-        eslintrcJs: fs.existsSync(path.join(projectRoot, '.eslintrc.js')),
-        packageJson: fs.existsSync(path.join(projectRoot, 'package.json'))
-      });
-      
-      // For ESLint v9, prioritize flat config files
-      const flatConfigPath = path.join(projectRoot, 'eslint.config.mjs');
-      if (fs.existsSync(flatConfigPath)) {
-        console.log('Debug: Found flat config eslint.config.mjs');
-        // For flat config, we don't need to load it directly
-        // ESLint v9 will auto-discover it
-        this.userESLintConfig = { flatConfig: true };
-        return { flatConfig: true };
-      }
-      
-      // Fallback to legacy .eslintrc format
-      const eslintrcPath = path.join(projectRoot, '.eslintrc.json');
-      if (fs.existsSync(eslintrcPath)) {
-        const configContent = JSON.parse(fs.readFileSync(eslintrcPath, 'utf8'));
-        console.log('Debug: Loaded .eslintrc.json successfully');
-        this.userESLintConfig = configContent;
-        return configContent;
-      }
-      
-      // Check for .eslintrc.js
-      const eslintrcJsPath = path.join(projectRoot, '.eslintrc.js');
-      if (fs.existsSync(eslintrcJsPath)) {
-        console.log('Debug: Found .eslintrc.js, using legacy format');
-        // We can't require() the .eslintrc.js directly due to potential conflicts,
-        // but we signal that a legacy config exists
-        this.userESLintConfig = { legacyConfig: true, configFile: eslintrcJsPath };
-        return { legacyConfig: true, configFile: eslintrcJsPath };
-      }
-      
-      // Last resort - try ESLint API
-      const eslint = new ESLint({
-        cwd: path.resolve(projectRoot)
-      });
-
-      const sampleFile = path.join(projectRoot, 'src/violations.ts');
-      console.log('Debug: Sample file:', sampleFile, 'exists:', fs.existsSync(sampleFile));
-      const config = await eslint.calculateConfigForFile(sampleFile);
-      
-      this.userESLintConfig = config;
-      return config;
-    } catch (error) {
-      console.warn(chalk.yellow(`⚠️  Could not load ESLint config: ${error.message}`));
-      return null;
-    }
-  }
-
-  /**
-   * Create merged ESLint configuration (SunLint + User ESLint)
-   * @param {Object} sunlintESLintConfig - SunLint's ESLint configuration
-   * @param {Object} userESLintConfig - User's existing ESLint configuration  
-   * @returns {Object} Merged configuration
-   */
-  createMergedConfig(sunlintESLintConfig, userESLintConfig) {
-    if (!userESLintConfig) {
-      return sunlintESLintConfig;
-    }
-
-    // Ensure configs are safe objects
-    const safeUserConfig = typeof userESLintConfig === 'object' ? userESLintConfig : {};
-    const safeSunlintConfig = typeof sunlintESLintConfig === 'object' ? sunlintESLintConfig : {};
-
-    const merged = {
-      ...safeSunlintConfig,
-      // Merge extends arrays safely
-      extends: [
-        ...(Array.isArray(safeSunlintConfig.extends) ? safeSunlintConfig.extends : []),
-        ...(Array.isArray(safeUserConfig.extends) ? safeUserConfig.extends : [])
-      ],
-      // Merge plugins arrays safely
-      plugins: [
-        ...(Array.isArray(safeSunlintConfig.plugins) ? safeSunlintConfig.plugins : []),
-        ...(Array.isArray(safeUserConfig.plugins) ? safeUserConfig.plugins : [])
-      ],
-      // Merge rules (user rules override SunLint in case of conflict)
-      rules: {
-        ...(safeSunlintConfig.rules || {}),
-        ...(safeUserConfig.rules || {})
-      },
-      // Merge parser options
-      parserOptions: {
-        ...(safeSunlintConfig.parserOptions || {}),
-        ...(safeUserConfig.parserOptions || {})
-      },
-      // Merge env
-      env: {
-        ...(safeSunlintConfig.env || {}),
-        ...(safeUserConfig.env || {})
-      },
-      // Merge settings
-      settings: {
-        ...(safeSunlintConfig.settings || {}),
-        ...(safeUserConfig.settings || {})
-      }
-    };
-
-    return merged;
-  }
-
-  /**
-   * Run integrated ESLint analysis (SunLint + User rules)
-   * @param {string[]} filePaths - Files to analyze
-   * @param {Object} sunlintConfig - SunLint configuration
-   * @param {Object} options - Analysis options
-   * @returns {Object} Combined ESLint results
-   */
-  async runIntegratedAnalysis(filePaths, sunlintConfig, options = {}) {
-    try {
-      // Resolve first file path to determine project root
-      const firstFilePath = path.resolve(filePaths[0]);
-      const projectRoot = this.findProjectRoot(firstFilePath);
-      
-      // Load existing ESLint config
-      const userESLintConfig = await this.loadExistingESLintConfig(projectRoot, sunlintConfig);
-      
-      // Create ESLint instance based on config type
-      let eslintOptions = {
-        cwd: path.resolve(projectRoot),
-        fix: options.fix || false,
-        ignore: false
-      };
-      
-      // If we found a legacy config file, specify it explicitly
-      if (userESLintConfig && userESLintConfig.legacyConfig) {
-        eslintOptions.overrideConfigFile = userESLintConfig.configFile;
-      }
-      
-      this.eslintInstance = new ESLint(eslintOptions);
-
-      // Run analysis with resolved file paths
-      const resolvedFilePaths = [];
-      
-      for (const fp of filePaths) {
-        const resolved = path.isAbsolute(fp) ? fp : path.resolve(process.cwd(), fp);
-        
-        // If it's a directory, find all JS/TS files in it
-        if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
-          const glob = require('glob');
-          const files = glob.sync(`${resolved}/**/*.{js,jsx,ts,tsx}`, { 
-            ignore: ['**/node_modules/**', '**/.next/**'] 
-          });
-          resolvedFilePaths.push(...files);
-        } else {
-          resolvedFilePaths.push(resolved);
-        }
-      }
-      
-      const results = await this.eslintInstance.lintFiles(resolvedFilePaths);
-      
-      // Categorize results by rule source
-      const categorizedResults = this.categorizeResults(results);
-
-      if (!options.quiet) {
-        this.logIntegrationSummary(categorizedResults, userESLintConfig !== null);
-      }
-
-      return {
-        results,
-        categorized: categorizedResults,
-        totalRules: results.length,
-        sunlintRules: 0, // Will be counted in analysis orchestrator
-        userRules: results.length
-      };
-
-    } catch (error) {
-      throw new Error(`ESLint integration failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Get SunLint's ESLint configuration
-   */
-  getSunLintESLintConfig(sunlintConfig) {
-    // This would be the ESLint config that SunLint normally uses
-    return {
-      extends: ['@sun/sunlint/eslint-recommended'],
-      plugins: ['@sun/sunlint'],
-      rules: {
-        // Map SunLint rules to ESLint format
-        'custom/typescript_s003': 'warn',
-        'custom/typescript_s047': 'warn', 
-        'custom/typescript_s055': 'warn',
-        // ... other SunLint rules
-      },
-      parserOptions: {
-        ecmaVersion: 2022,
-        sourceType: 'module',
-        project: './tsconfig.json'
-      }
-    };
-  }
-
-  /**
-   * Categorize ESLint results by rule source (SunLint vs User)
-   */
-  categorizeResults(results) {
-    const categorized = {
-      sunlint: [],
-      user: [],
-      combined: []
-    };
-
-    results.forEach(fileResult => {
-      fileResult.messages.forEach(message => {
-        const ruleId = message.ruleId;
-        if (this.isSunLintRule(ruleId)) {
-          categorized.sunlint.push({ ...message, filePath: fileResult.filePath });
-        } else {
-          categorized.user.push({ ...message, filePath: fileResult.filePath });
-        }
-        categorized.combined.push({ ...message, filePath: fileResult.filePath });
-      });
-    });
-
-    return categorized;
-  }
-
-  /**
-   * Check if rule belongs to SunLint
-   */
-  isSunLintRule(ruleId) {
-    return ruleId && (
-      ruleId.startsWith('custom/typescript_') ||
-      ruleId.startsWith('@sun/sunlint/') ||
-      ruleId.startsWith('S') ||
-      ruleId.startsWith('C')
-    );
-  }
-
-  /**
-   * Count total active rules in configuration
-   */
-  countTotalRules(config) {
-    return Object.keys(config.rules || {}).length;
-  }
-
-  countSunLintRules(config) {
-    return Object.keys(config.rules || {})
-      .filter(ruleId => this.isSunLintRule(ruleId))
-      .length;
-  }
-
-  countUserRules(config, userConfig) {
-    if (!userConfig) return 0;
-    return Object.keys(config.rules || {})
-      .filter(ruleId => !this.isSunLintRule(ruleId))
-      .length;
-  }
-
-  /**
-   * Log integration summary
-   */
-  logIntegrationSummary(categorized, hasUserConfig) {
-    console.log(chalk.blue('🔗 ESLint Integration Summary:'));
-    console.log(chalk.green(`  📋 SunLint violations: ${categorized.sunlint.length}`));
-    
-    if (hasUserConfig) {
-      console.log(chalk.cyan(`  🔧 User ESLint violations: ${categorized.user.length}`));
-      console.log(chalk.yellow(`  📊 Total combined violations: ${categorized.combined.length}`));
-    } else {
-      console.log(chalk.gray('  🔧 No existing ESLint config found'));
-    }
-  }
-
-  /**
-   * Find project root directory
-   */
-  findProjectRoot(startPath) {
-    let currentPath = path.dirname(startPath);
-    while (currentPath !== path.dirname(currentPath)) {
-      const packagePath = path.join(currentPath, 'package.json');
-      if (fs.existsSync(packagePath)) {
-        return currentPath;
-      }
-      currentPath = path.dirname(currentPath);
-    }
-    return path.dirname(startPath);
-  }
-
-  /**
-   * Check if legacy ESLint support is enabled in SunLint config
-   * @param {Object} sunlintConfig - SunLint configuration
-   * @returns {boolean} Whether legacy ESLint support is enabled
-   */
-  isLegacySupportEnabled(sunlintConfig) {
-    // Default to true for backward compatibility
-    const legacySupport = sunlintConfig?.integration?.eslint?.legacySupport !== false;
-    const eslintV8Support = sunlintConfig?.compatibility?.eslintV8 !== false;
-    
-    return legacySupport && eslintV8Support;
-  }
-}
-
-module.exports = ESLintIntegrationService;

package/core/sunlint-engine-service.js

@@ -1,23 +0,0 @@
-/**
- * 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;