@sun-asterisk/sunlint 1.0.5

package/core/eslint-instance-manager.js

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,363 @@
+/**
+ * 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/git-utils.js

@@ -0,0 +1,170 @@
+/**
+ * Git Utils - Handle git operations for file filtering
+ * Following Rule C005: Single responsibility - only handle git operations
+ * Following Rule C014: Dependency injection for git operations
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+class GitUtils {
+  /**
+   * Check if current directory is a git repository
+   */
+  static isGitRepository(cwd = process.cwd()) {
+    try {
+      execSync('git rev-parse --git-dir', { cwd, stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get list of changed files compared to base reference
+   * @param {string} baseRef - Base git reference (e.g., 'origin/main')
+   * @param {string} cwd - Working directory
+   * @returns {string[]} Array of changed file paths
+   */
+  static getChangedFiles(baseRef = 'HEAD', cwd = process.cwd()) {
+    if (!this.isGitRepository(cwd)) {
+      throw new Error('Not a git repository');
+    }
+
+    try {
+      // Get git root directory
+      const gitRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf8' }).trim();
+      
+      const command = `git diff --name-only ${baseRef}`;
+      const output = execSync(command, { cwd: gitRoot, encoding: 'utf8' });
+      
+      return output
+        .split('\n')
+        .filter(file => file.trim() !== '')
+        .map(file => path.resolve(gitRoot, file))
+        .filter(file => fs.existsSync(file)); // Only existing files
+    } catch (error) {
+      throw new Error(`Failed to get changed files: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get list of staged files
+   * @param {string} cwd - Working directory
+   * @returns {string[]} Array of staged file paths
+   */
+  static getStagedFiles(cwd = process.cwd()) {
+    if (!this.isGitRepository(cwd)) {
+      throw new Error('Not a git repository');
+    }
+
+    try {
+      // Get git root directory
+      const gitRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf8' }).trim();
+      
+      const command = 'git diff --cached --name-only';
+      const output = execSync(command, { cwd: gitRoot, encoding: 'utf8' });
+      
+      return output
+        .split('\n')
+        .filter(file => file.trim() !== '')
+        .map(file => path.resolve(gitRoot, file))
+        .filter(file => fs.existsSync(file));
+    } catch (error) {
+      throw new Error(`Failed to get staged files: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get files changed since specific commit
+   * @param {string} commit - Commit hash or reference
+   * @param {string} cwd - Working directory
+   * @returns {string[]} Array of changed file paths
+   */
+  static getFilesSince(commit, cwd = process.cwd()) {
+    if (!this.isGitRepository(cwd)) {
+      throw new Error('Not a git repository');
+    }
+
+    try {
+      // Get git root directory
+      const gitRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf8' }).trim();
+      
+      const command = `git diff --name-only ${commit}..HEAD`;
+      const output = execSync(command, { cwd: gitRoot, encoding: 'utf8' });
+      
+      return output
+        .split('\n')
+        .filter(file => file.trim() !== '')
+        .map(file => path.resolve(gitRoot, file))
+        .filter(file => fs.existsSync(file));
+    } catch (error) {
+      throw new Error(`Failed to get files since ${commit}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get current branch name
+   * @param {string} cwd - Working directory
+   * @returns {string} Current branch name
+   */
+  static getCurrentBranch(cwd = process.cwd()) {
+    if (!this.isGitRepository(cwd)) {
+      throw new Error('Not a git repository');
+    }
+
+    try {
+      const command = 'git rev-parse --abbrev-ref HEAD';
+      const output = execSync(command, { cwd, encoding: 'utf8' });
+      return output.trim();
+    } catch (error) {
+      throw new Error(`Failed to get current branch: ${error.message}`);
+    }
+  }
+
+  /**
+   * Filter TypeScript/JavaScript files from file list
+   * @param {string[]} files - Array of file paths
+   * @returns {string[]} Filtered TypeScript/JavaScript files
+   */
+  static filterSourceFiles(files) {
+    const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+    return files.filter(file => {
+      const ext = path.extname(file);
+      return extensions.includes(ext);
+    });
+  }
+
+  /**
+   * Get git diff base reference for PR mode
+   * @param {string} targetBranch - Target branch (e.g., 'main', 'develop')
+   * @param {string} cwd - Working directory
+   * @returns {string} Git reference for comparison
+   */
+  static getPRDiffBase(targetBranch = 'main', cwd = process.cwd()) {
+    if (!this.isGitRepository(cwd)) {
+      throw new Error('Not a git repository');
+    }
+
+    // Try common remote references
+    const candidates = [
+      `origin/${targetBranch}`,
+      `upstream/${targetBranch}`,
+      targetBranch
+    ];
+
+    for (const candidate of candidates) {
+      try {
+        execSync(`git rev-parse --verify ${candidate}`, { cwd, stdio: 'ignore' });
+        return candidate;
+      } catch (error) {
+        // Continue to next candidate
+      }
+    }
+
+    throw new Error(`No valid git reference found for target branch: ${targetBranch}`);
+  }
+}
+
+module.exports = GitUtils;