@sun-asterisk/sunlint 1.1.6 → 1.1.7

package/CHANGELOG.md

@@ -1,3 +1,76 @@
+# 🎉 SunLint v1.1.7 Release Notes
+
+**Release Date**: July 24, 2025  
+**Type**: Minor Release (ESLint Engine Enhancement & Smart Installation Guidance)
+
+---
+
+## 🚀 **Key Improvements**
+
+### 🧠 **ESLint Engine Enhancement**
+- **Enhanced**: ESLint v9+ flat config support with automatic legacy config conversion
+- **Improved**: Dynamic plugin loading with availability detection (React, TypeScript, React Hooks)
+- **Robust**: Better error handling and parsing error filtering for TypeScript files
+- **Smart**: Temporary flat config generation for legacy compatibility
+
+### 🎯 **Smart Installation Guidance**
+- **Intelligent**: Project type detection (NestJS, React, Next.js, Node.js)
+- **Targeted**: Package manager detection (npm, yarn, pnpm) from package.json
+- **Conditional**: Smart `--legacy-peer-deps` suggestion only when dependency conflicts detected
+- **Clear**: Descriptive project-specific installation instructions
+
+### 🔧 **Project Type Detection**
+- **NestJS Projects**: `pnpm install --save-dev @typescript-eslint/parser @typescript-eslint/eslint-plugin`
+- **React Projects**: `npm install --save-dev @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-react eslint-plugin-react-hooks`
+- **Conflict Detection**: Automatic detection of date-fns, React version conflicts, ESLint v8 issues
+
+### 📦 **Dependency Management**
+- **Aggregated Warnings**: Consolidated messages for missing plugins instead of spam
+- **Graceful Fallback**: Analysis continues even with missing plugins, filtering parsing errors
+- **Cleanup**: Automatic temporary config file cleanup after analysis
+
+---
+
+## 🛠 **Technical Details**
+
+### **ESLint Integration**
+- **Config Detection**: Automatic detection of flat config vs legacy config
+- **Plugin Availability**: Runtime detection of React, TypeScript, React Hooks plugins
+- **Parser Support**: Conditional TypeScript parser loading based on availability
+- **Rule Filtering**: Skip rules for unavailable plugins with clear messaging
+
+### **Smart Guidance Logic**
+- **Package Manager**: Detects preferred package manager from scripts and preinstall hooks
+- **Conflict Detection**: Analyzes package.json for known dependency conflicts
+- **Project Classification**: Distinguishes between frontend (React/Next.js) and backend (NestJS/Node.js) projects
+
+---
+
+## 📋 **Usage Examples**
+
+### **Minimal Installation (Works for basic analysis)**
+```bash
+npm install --save-dev @sun-asterisk/sunlint
+```
+
+### **TypeScript Projects (Recommended)**
+```bash
+npm install --save-dev @sun-asterisk/sunlint typescript
+```
+
+### **Full Installation (All project types)**
+```bash
+npm install --save-dev @sun-asterisk/sunlint eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin eslint-plugin-react eslint-plugin-react-hooks typescript
+```
+
+---
+
+## 🎉 **What's Next**
+
+SunLint v1.1.7 makes ESLint integration more robust and user-friendly with intelligent project detection and clear installation guidance. No more guessing what dependencies to install! 🚀
+
+---
+
 # 🎉 SunLint v1.1.0 Release Notes
 
 **Release Date**: July 23, 2025  

package/engines/eslint-engine.js

@@ -186,25 +186,24 @@ class ESLintEngine extends AnalysisEngineInterface {
         // Use flat config (ESLint v9+ preferred)
         eslintOptions = {
           overrideConfigFile: null,     // Let ESLint find flat config automatically
-          overrideConfig: this.createBaseConfig(),
           fix: this.config?.fix || false,
           cache: this.config?.cache || false,
           cwd: projectPath
         };
         console.log(`✅ [ESLintEngine] Using flat config (modern ESLint v9+)`);
       } else if (configDetection.hasLegacyConfig || configDetection.hasPackageConfig) {
-        // Use legacy config for compatibility - but ESLint v9+ only supports flat config
-        // We'll convert legacy to flat config on-the-fly
+        // ESLint v9+ requires flat config - convert legacy config to flat config format
+        const flatConfig = await this.convertLegacyToFlatConfig(projectPath, configDetection);
         eslintOptions = {
-          overrideConfigFile: null,     // Force flat config mode
-          overrideConfig: this.createBaseConfig(),
+          overrideConfigFile: null,  // Use our generated flat config
+          overrideConfig: flatConfig,
           fix: this.config?.fix || false,
           cache: this.config?.cache || false,
           cwd: projectPath
         };
-        console.log(`✅ [ESLintEngine] Legacy config detected, but using flat config mode (ESLint v9+ requirement)`);
+        console.log(`✅ [ESLintEngine] Legacy config converted to flat config for ESLint v9+ compatibility`);
       } else {
-        // No config found - use SunLint's base config only, create empty config file
+        // No config found - use SunLint's base config only
         eslintOptions = {
           overrideConfig: this.createBaseConfig(),
           fix: this.config?.fix || false,
@@ -228,6 +227,310 @@ class ESLintEngine extends AnalysisEngineInterface {
     }
   }
 
+  /**
+   * Extract rules array from eslint config
+   * @param {Object} eslintConfig - ESLint config object
+   * @returns {Array} Rules array for plugin detection
+   */
+  extractRulesFromConfig(eslintConfig) {
+    // Convert rules object keys back to rule objects for plugin detection
+    const rules = [];
+    for (const ruleKey of Object.keys(eslintConfig.rules || {})) {
+      if (ruleKey.startsWith('custom/typescript_s')) {
+        rules.push({ id: ruleKey.replace('custom/typescript_', '').toUpperCase() });
+      } else if (ruleKey.startsWith('custom/')) {
+        rules.push({ id: ruleKey.replace('custom/', '').toUpperCase() });
+      } else if (ruleKey.startsWith('react/')) {
+        rules.push({ id: 'R001' }); // Mock React rule for detection
+      } else if (ruleKey.includes('@typescript-eslint/')) {
+        rules.push({ id: 'T001' }); // Mock TypeScript rule for detection
+      }
+    }
+    return rules;
+  }
+
+  /**
+   * Create temporary flat config file for legacy compatibility
+   * Following Rule C006: Verb-noun naming
+   * @param {string} projectPath - Path to the project
+   * @param {Object} configDetection - Config detection results
+   * @param {Object} eslintConfig - Analysis config to merge
+   * @returns {Promise<string>} Path to temporary flat config file
+   */
+  async createTemporaryFlatConfig(projectPath, configDetection, eslintConfig) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      let baseConfig;
+      
+      if (configDetection.hasFlatConfig) {
+        // Load existing flat config
+        const existingConfigPath = path.join(projectPath, 'eslint.config.js');
+        if (fs.existsSync(existingConfigPath)) {
+          try {
+            // Read and parse existing flat config
+            const configContent = fs.readFileSync(existingConfigPath, 'utf8');
+            // For now, use a simple base config - parsing dynamic imports is complex
+            baseConfig = {
+              files: ['**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx'],
+              languageOptions: {
+                ecmaVersion: 'latest',
+                sourceType: 'module',
+                parserOptions: {
+                  ecmaFeatures: {
+                    jsx: true
+                  }
+                }
+              },
+              rules: {}
+            };
+          } catch (error) {
+            console.warn(`⚠️ [ESLintEngine] Failed to parse existing flat config: ${error.message}`);
+            baseConfig = this.createBaseConfig();
+          }
+        } else {
+          baseConfig = this.createBaseConfig();
+        }
+      } else {
+        // Convert legacy config
+        baseConfig = await this.convertLegacyToFlatConfig(projectPath, configDetection);
+      }
+      
+      // Build plugin imports based on what's needed AND what's available
+      const rules = this.extractRulesFromConfig(eslintConfig);
+      const needsReact = this.needsReactPlugins(rules);
+      const needsTypeScript = this.needsTypeScriptPlugins(rules);
+      
+      // Check plugin availability in target project
+      const hasReact = needsReact && this.isReactPluginAvailable(projectPath);
+      const hasReactHooks = needsReact && this.isReactHooksPluginAvailable(projectPath);
+      const hasTypeScript = needsTypeScript && this.isTypeScriptPluginAvailable(projectPath);
+      const hasTypeScriptParser = this.isTypeScriptParserAvailable(projectPath);
+      
+      let pluginImports = '';
+      let pluginDefs = '{ "custom": customPlugin';
+      
+      if (hasReact) {
+        pluginImports += `\nimport reactPlugin from 'eslint-plugin-react';`;
+        pluginDefs += ', "react": reactPlugin';
+      }
+      
+      if (hasReactHooks) {
+        pluginImports += `\nimport reactHooksPlugin from 'eslint-plugin-react-hooks';`;
+        pluginDefs += ', "react-hooks": reactHooksPlugin';
+      }
+      
+      if (hasTypeScript) {
+        pluginImports += `\nimport typescriptPlugin from '@typescript-eslint/eslint-plugin';`;
+        pluginDefs += ', "@typescript-eslint": typescriptPlugin';
+      }
+      
+      pluginDefs += ' }';
+      
+      // Filter rules to only include those for available plugins
+      const filteredRules = {};
+      const skippedRules = { react: [], reactHooks: [], typescript: [] };
+      
+      for (const [ruleKey, ruleConfig] of Object.entries(eslintConfig.rules || {})) {
+        if (ruleKey.startsWith('react/') && !hasReact) {
+          skippedRules.react.push(ruleKey);
+          continue;
+        }
+        if (ruleKey.startsWith('react-hooks/') && !hasReactHooks) {
+          skippedRules.reactHooks.push(ruleKey);
+          continue;
+        }
+        if (ruleKey.startsWith('@typescript-eslint/') && !hasTypeScript) {
+          skippedRules.typescript.push(ruleKey);
+          continue;
+        }
+        filteredRules[ruleKey] = ruleConfig;
+      }
+      
+      // Summary of skipped rules instead of individual warnings
+      if (skippedRules.react.length > 0) {
+        console.warn(`⚠️ [ESLintEngine] Skipped ${skippedRules.react.length} React rules - plugin not available`);
+      }
+      if (skippedRules.reactHooks.length > 0) {
+        console.warn(`⚠️ [ESLintEngine] Skipped ${skippedRules.reactHooks.length} React Hooks rules - plugin not available`);
+      }
+      if (skippedRules.typescript.length > 0) {
+        console.warn(`⚠️ [ESLintEngine] Skipped ${skippedRules.typescript.length} TypeScript ESLint rules - plugin not available`);
+      }
+      
+      // Merge with analysis config using filtered rules
+      const mergedConfig = {
+        ...baseConfig,
+        ...eslintConfig,
+        rules: {
+          ...baseConfig.rules,
+          ...filteredRules
+        }
+      };
+      
+      // Create temporary config file in project directory
+      const tempConfigPath = path.join(projectPath, '.sunlint-eslint.config.js');
+      
+      // Create simple config compatible with flat config format
+      const configForExport = {
+        files: ['**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx'],
+        languageOptions: {
+          ecmaVersion: 'latest',
+          sourceType: 'module',
+          parserOptions: {
+            ecmaFeatures: {
+              jsx: true
+            }
+          }
+        },
+        rules: {
+          ...baseConfig.rules,
+          ...filteredRules
+        }
+      };
+      
+      const configContent = `// Temporary flat config generated by SunLint
+import customPlugin from '${path.resolve(__dirname, '../integrations/eslint/plugin/index.js')}';${pluginImports}
+
+export default [
+  ${JSON.stringify(configForExport, null, 2).replace('"rules":', `"plugins": ${pluginDefs},\n    "rules":`)},
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    plugins: ${pluginDefs},
+    languageOptions: {${hasTypeScriptParser ? `
+      parser: (await import('@typescript-eslint/parser')).default,` : ''}
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        }
+      }
+    },
+    rules: ${JSON.stringify({...baseConfig.rules, ...filteredRules}, null, 2)}
+  }
+];
+`;
+      
+      fs.writeFileSync(tempConfigPath, configContent);
+      console.log(`🔧 [ESLintEngine] Created temporary flat config: ${tempConfigPath}`);
+      
+      // Schedule cleanup
+      this.tempConfigPaths = this.tempConfigPaths || [];
+      this.tempConfigPaths.push(tempConfigPath);
+      
+      return tempConfigPath;
+    } catch (error) {
+      console.warn(`⚠️ [ESLintEngine] Failed to create temporary flat config: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Convert legacy ESLint config to flat config format
+   * Following Rule C006: Verb-noun naming
+   * @param {string} projectPath - Path to the project
+   * @param {Object} configDetection - Config detection results
+   * @returns {Promise<Object>} Flat config object
+   */
+  async convertLegacyToFlatConfig(projectPath, configDetection) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    let legacyConfig = {};
+    
+    try {
+      // Load legacy config from .eslintrc.json
+      if (configDetection.foundFiles.includes('.eslintrc.json')) {
+        const configPath = path.join(projectPath, '.eslintrc.json');
+        const configContent = fs.readFileSync(configPath, 'utf8');
+        legacyConfig = JSON.parse(configContent);
+      }
+      
+      // Convert to flat config format
+      const flatConfig = {
+        files: ['**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx'],
+        languageOptions: {
+          ecmaVersion: legacyConfig.env?.es2022 ? 2022 : 
+                      legacyConfig.env?.es2021 ? 2021 : 
+                      legacyConfig.env?.es6 ? 6 : 'latest',
+          sourceType: legacyConfig.parserOptions?.sourceType || 'module',
+          globals: {}
+        },
+        plugins: {},
+        rules: legacyConfig.rules || {}
+      };
+      
+      // Convert env to globals
+      if (legacyConfig.env) {
+        if (legacyConfig.env.browser) {
+          Object.assign(flatConfig.languageOptions.globals, {
+            window: 'readonly',
+            document: 'readonly',
+            navigator: 'readonly',
+            console: 'readonly'
+          });
+        }
+        if (legacyConfig.env.node) {
+          Object.assign(flatConfig.languageOptions.globals, {
+            process: 'readonly',
+            Buffer: 'readonly',
+            __dirname: 'readonly',
+            __filename: 'readonly',
+            module: 'readonly',
+            require: 'readonly',
+            exports: 'readonly',
+            global: 'readonly'
+          });
+        }
+        if (legacyConfig.env.es6) {
+          Object.assign(flatConfig.languageOptions.globals, {
+            Promise: 'readonly',
+            Set: 'readonly',
+            Map: 'readonly'
+          });
+        }
+      }
+      
+      // Set parser if specified
+      if (legacyConfig.parser) {
+        if (legacyConfig.parser === '@typescript-eslint/parser') {
+          flatConfig.languageOptions.parser = this.loadTypeScriptParser();
+        }
+      }
+      
+      // Convert parser options
+      if (legacyConfig.parserOptions) {
+        flatConfig.languageOptions.parserOptions = legacyConfig.parserOptions;
+      }
+      
+      // Handle extends - merge base rules
+      if (legacyConfig.extends) {
+        const extendsList = Array.isArray(legacyConfig.extends) ? legacyConfig.extends : [legacyConfig.extends];
+        
+        for (const extend of extendsList) {
+          if (extend === 'eslint:recommended') {
+            // Add some basic recommended rules
+            Object.assign(flatConfig.rules, {
+              'no-unused-vars': 'warn',
+              'no-undef': 'error',
+              'no-console': 'warn'
+            });
+          }
+        }
+      }
+      
+      console.log(`🔄 [ESLintEngine] Converted legacy config to flat config`);
+      return flatConfig;
+      
+    } catch (error) {
+      console.warn(`⚠️ [ESLintEngine] Failed to convert legacy config: ${error.message}`);
+      // Fallback to base config
+      return this.createBaseConfig();
+    }
+  }
+
   /**
    * Create base ESLint configuration
    * Following Rule C006: Verb-noun naming
@@ -303,6 +606,298 @@ class ESLintEngine extends AnalysisEngineInterface {
     console.warn('⚠️ Using default ESLint rule mapping');
   }
 
+  /**
+   * Detect project type from package.json and file patterns
+   * @param {string} projectPath - Project path
+   * @param {string[]} files - Files being analyzed
+   * @returns {Object} Project type information
+   */
+  detectProjectType(projectPath, files) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    const result = {
+      isReactProject: false,
+      isNextProject: false,
+      isNestProject: false,
+      isNodeProject: false,
+      hasReactFiles: false,
+      hasNestFiles: false,
+      packageManager: 'npm'
+    };
+    
+    try {
+      // Check package.json for project type indicators
+      const packageJsonPath = path.join(projectPath, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        
+        // Check dependencies for project type
+        const allDeps = {
+          ...packageJson.dependencies,
+          ...packageJson.devDependencies,
+          ...packageJson.peerDependencies
+        };
+        
+        if (allDeps.react || allDeps['@types/react']) {
+          result.isReactProject = true;
+        }
+        
+        if (allDeps.next || allDeps['@types/next']) {
+          result.isNextProject = true;
+        }
+        
+        if (allDeps['@nestjs/core'] || allDeps['@nestjs/common']) {
+          result.isNestProject = true;
+        }
+        
+        // Check package manager from scripts
+        if (packageJson.scripts && Object.values(packageJson.scripts).some(script => script.includes('pnpm'))) {
+          result.packageManager = 'pnpm';
+        } else if (packageJson.scripts && Object.values(packageJson.scripts).some(script => script.includes('yarn'))) {
+          result.packageManager = 'yarn';
+        }
+        
+        // Check for preinstall script indicating package manager preference
+        if (packageJson.scripts?.preinstall?.includes('pnpm')) {
+          result.packageManager = 'pnpm';
+        } else if (packageJson.scripts?.preinstall?.includes('yarn')) {
+          result.packageManager = 'yarn';
+        }
+      }
+      
+      // Check file patterns
+      const hasJsxTsx = files.some(file => {
+        const ext = path.extname(file).toLowerCase();
+        return ['.jsx', '.tsx'].includes(ext);
+      });
+      
+      const hasNestFiles = files.some(file => {
+        return file.includes('controller.ts') || 
+               file.includes('service.ts') || 
+               file.includes('module.ts') ||
+               file.includes('main.ts');
+      });
+      
+      result.hasReactFiles = hasJsxTsx && !result.isNestProject;
+      result.hasNestFiles = hasNestFiles;
+      result.isNodeProject = !result.isReactProject && !result.isNextProject;
+      
+    } catch (error) {
+      console.warn(`⚠️ [ESLintEngine] Failed to detect project type: ${error.message}`);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Check if project has dependency conflicts that require --legacy-peer-deps
+   * @param {string} projectPath - Project path
+   * @returns {boolean} True if project has known dependency conflicts
+   */
+  hasKnownDependencyConflicts(projectPath) {
+    const fs = require('fs');
+    const path = require('path');
+    
+    try {
+      const packageJsonPath = path.join(projectPath, 'package.json');
+      if (!fs.existsSync(packageJsonPath)) {
+        return false;
+      }
+      
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const allDeps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+        ...packageJson.peerDependencies
+      };
+      
+      // Check for known problematic combinations
+      const conflicts = [
+        // date-fns version conflicts
+        () => {
+          const dateFns = allDeps['date-fns'];
+          const dateFnsTz = allDeps['date-fns-tz'];
+          if (dateFns && dateFnsTz) {
+            // If date-fns is v2.x and date-fns-tz is v3.x, there's likely a conflict
+            if (dateFns.includes('2.') && dateFnsTz.includes('3.')) {
+              return true;
+            }
+          }
+          return false;
+        },
+        
+        // React version conflicts
+        () => {
+          const react = allDeps['react'];
+          const reactDom = allDeps['react-dom'];
+          if (react && reactDom) {
+            // Check for major version mismatches
+            const reactMajor = react.match(/(\d+)\./)?.[1];
+            const reactDomMajor = reactDom.match(/(\d+)\./)?.[1];
+            if (reactMajor && reactDomMajor && reactMajor !== reactDomMajor) {
+              return true;
+            }
+          }
+          return false;
+        },
+        
+        // ESLint version conflicts (common with older projects)
+        () => {
+          const eslint = allDeps['eslint'];
+          if (eslint && eslint.includes('8.')) {
+            // ESLint v8 with newer plugins often has peer dependency issues
+            return true;
+          }
+          return false;
+        }
+      ];
+      
+      return conflicts.some(check => check());
+      
+    } catch (error) {
+      // If we can't read package.json, assume no conflicts
+      return false;
+    }
+  }
+
+  /**
+   * Provide appropriate installation guidance based on project type
+   * @param {Object} projectType - Project type information
+   * @param {number} tsFileCount - Number of TypeScript files
+   * @param {number} reactFileCount - Number of React files
+   * @param {boolean} hasTypeScriptParser - TypeScript parser availability
+   * @param {boolean} hasReactPlugin - React plugin availability
+   * @param {boolean} hasReactHooksPlugin - React Hooks plugin availability
+   * @param {string} projectPath - Project path for conflict detection
+   */
+  provideInstallationGuidance(projectType, tsFileCount, reactFileCount, hasTypeScriptParser, hasReactPlugin, hasReactHooksPlugin, projectPath) {
+    const missingDeps = [];
+    const projectDescription = this.getProjectDescription(projectType, tsFileCount, reactFileCount);
+    
+    // TypeScript dependencies (needed for most projects with .ts files)
+    if (tsFileCount > 0 && !hasTypeScriptParser) {
+      missingDeps.push('@typescript-eslint/parser', '@typescript-eslint/eslint-plugin');
+    }
+    
+    // React dependencies (only for actual React projects, not NestJS)
+    if (projectType.hasReactFiles && !projectType.isNestProject) {
+      if (!hasReactPlugin) missingDeps.push('eslint-plugin-react');
+      if (!hasReactHooksPlugin) missingDeps.push('eslint-plugin-react-hooks');
+    }
+    
+    if (missingDeps.length > 0) {
+      console.log(`\n📦 [SunLint] To enable full analysis of your ${projectDescription}, install:`);
+      
+      // Use appropriate package manager and flags
+      const packageManager = projectType.packageManager;
+      const installFlag = packageManager === 'npm' ? '--save-dev' : packageManager === 'yarn' ? '--dev' : '--save-dev';
+      
+      // Only suggest --legacy-peer-deps if the project has known dependency conflicts
+      let legacyFlag = '';
+      if (packageManager === 'npm' && this.hasKnownDependencyConflicts(projectPath)) {
+        legacyFlag = ' --legacy-peer-deps';
+        console.log(`   ⚠️  Detected dependency conflicts in your project.`);
+      }
+      
+      console.log(`   ${packageManager} install ${installFlag} ${missingDeps.join(' ')}${legacyFlag}`);
+      console.log(`   Then SunLint will analyze all files with full ${this.getToolDescription(missingDeps)} support.\n`);
+    }
+  }
+
+  /**
+   * Get project description for user guidance
+   * @param {Object} projectType - Project type information
+   * @param {number} tsFileCount - Number of TypeScript files
+   * @param {number} reactFileCount - Number of React files
+   * @returns {string} Project description
+   */
+  getProjectDescription(projectType, tsFileCount, reactFileCount) {
+    if (projectType.isNestProject) {
+      return `${tsFileCount} TypeScript files (NestJS backend)`;
+    } else if (projectType.isNextProject) {
+      return `${tsFileCount} TypeScript and ${reactFileCount} React files (Next.js project)`;
+    } else if (projectType.isReactProject) {
+      return `${tsFileCount} TypeScript and ${reactFileCount} React files (React project)`;
+    } else if (tsFileCount > 0) {
+      return `${tsFileCount} TypeScript files (Node.js project)`;
+    } else {
+      return 'JavaScript files';
+    }
+  }
+
+  /**
+   * Get tool description for user guidance
+   * @param {string[]} missingDeps - Missing dependencies
+   * @returns {string} Tool description
+   */
+  getToolDescription(missingDeps) {
+    const tools = [];
+    if (missingDeps.some(dep => dep.includes('typescript-eslint'))) {
+      tools.push('TypeScript');
+    }
+    if (missingDeps.some(dep => dep.includes('react'))) {
+      tools.push('React');
+    }
+    return tools.join(' and ');
+  }
+
+  /**
+   * Check if React plugin is available in project
+   * @param {string} projectPath - Project path to check
+   * @returns {boolean} True if React plugin is available
+   */
+  isReactPluginAvailable(projectPath) {
+    try {
+      require.resolve('eslint-plugin-react', { paths: [projectPath] });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check if React Hooks plugin is available in project
+   * @param {string} projectPath - Project path to check
+   * @returns {boolean} True if React Hooks plugin is available
+   */
+  isReactHooksPluginAvailable(projectPath) {
+    try {
+      require.resolve('eslint-plugin-react-hooks', { paths: [projectPath] });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check if TypeScript plugin is available in project
+   * @param {string} projectPath - Project path to check
+   * @returns {boolean} True if TypeScript plugin is available
+   */
+  isTypeScriptPluginAvailable(projectPath) {
+    try {
+      require.resolve('@typescript-eslint/eslint-plugin', { paths: [projectPath] });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check if TypeScript parser is available in project
+   * @param {string} projectPath - Project path to check
+   * @returns {boolean} True if TypeScript parser is available
+   */
+  isTypeScriptParserAvailable(projectPath) {
+    try {
+      require.resolve('@typescript-eslint/parser', { paths: [projectPath] });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
   /**
    * Load React ESLint plugin
    * Following Rule C006: Verb-noun naming
@@ -433,7 +1028,7 @@ class ESLintEngine extends AnalysisEngineInterface {
 
     try {
       // Filter files for JS/TS only
-      const jstsFiles = files.filter(file => this.isJavaScriptTypeScriptFile(file));
+      let jstsFiles = files.filter(file => this.isJavaScriptTypeScriptFile(file));
       
       if (jstsFiles.length === 0) {
         console.warn('⚠️ No JavaScript/TypeScript files found for ESLint analysis');
@@ -448,44 +1043,109 @@ class ESLintEngine extends AnalysisEngineInterface {
         return results;
       }
 
-      // Reconfigure ESLint with analysis-specific rules and detect project config
+      // Find project root from input path (usually the project's working directory)
       const path = require('path');
-      const projectPath = path.dirname(jstsFiles[0]) || process.cwd();
+      let projectPath;
       
-      const eslintInstance = await this.createESLintInstance(projectPath);
+      if (options.input) {
+        // If input is specified, find project root from it
+        const inputPath = path.resolve(options.input);
+        // Always go up to find project root, not use input directory directly
+        projectPath = this.findProjectRoot([inputPath]);
+      } else if (jstsFiles.length > 0) {
+        // Find project root from all files
+        projectPath = this.findProjectRoot(jstsFiles);
+      } else {
+        projectPath = process.cwd();
+      }
       
-      // Override config for analysis-specific rules
-      const analysisConfig = {
-        ...this.createBaseConfig(),
-        ...eslintConfig
-      };
+      console.log(`🔍 [ESLintEngine] Using project path: ${projectPath}`);
       
-      // Re-create instance with analysis config
-      const { ESLint } = await this.loadESLint();
+      // Get config detection for reuse
       const configDetection = this.detectESLintConfig(projectPath);
+
+      // Check for missing dependencies and provide installation guidance
+      const hasTypeScriptParser = this.isTypeScriptParserAvailable(projectPath);
+      const hasReactPlugin = this.isReactPluginAvailable(projectPath);
+      const hasReactHooksPlugin = this.isReactHooksPluginAvailable(projectPath);
+      const hasTypeScriptPlugin = this.isTypeScriptPluginAvailable(projectPath);
       
+      // Detect project type from package.json and file patterns
+      const projectType = this.detectProjectType(projectPath, jstsFiles);
+      
+      // Count TypeScript files to determine if we need to recommend TypeScript tools
+      const tsFileCount = jstsFiles.filter(file => {
+        const ext = path.extname(file).toLowerCase();
+        return ['.ts', '.tsx'].includes(ext);
+      }).length;
+      
+      // Count React-like files to determine if we need React tools
+      const reactFileCount = jstsFiles.filter(file => {
+        const ext = path.extname(file).toLowerCase();
+        return ['.jsx', '.tsx'].includes(ext);
+      }).length;
+      
+      // Provide helpful installation guidance based on project type
+      this.provideInstallationGuidance(projectType, tsFileCount, reactFileCount, hasTypeScriptParser, hasReactPlugin, hasReactHooksPlugin, projectPath);
+
+      // Create ESLint instance with proper config
+      const { ESLint } = await this.loadESLint();
       let finalESLintOptions;
+      
+      // Configure ESLint to handle files appropriately
       if (configDetection.hasFlatConfig) {
+        // For flat config, always create temporary config to ensure plugin compatibility
+        const tempFlatConfigPath = await this.createTemporaryFlatConfig(projectPath, configDetection, eslintConfig);
         finalESLintOptions = {
-          overrideConfigFile: null,
-          overrideConfig: analysisConfig,
+          overrideConfigFile: tempFlatConfigPath,
           cwd: projectPath
         };
+        console.log(`✅ [ESLintEngine] Created temporary flat config for plugin compatibility`);
+      } else if (configDetection.hasLegacyConfig || configDetection.hasPackageConfig) {
+        // For legacy config, create a temporary flat config file
+        const tempFlatConfigPath = await this.createTemporaryFlatConfig(projectPath, configDetection, eslintConfig);
+        finalESLintOptions = {
+          overrideConfigFile: tempFlatConfigPath,
+          cwd: projectPath
+        };
+        console.log(`✅ [ESLintEngine] Created temporary flat config for legacy compatibility`);
       } else {
-        // For legacy config or no config, omit overrideConfigFile to use default behavior
+        // No config found - use analysis config only
         finalESLintOptions = {
-          overrideConfig: analysisConfig,
+          overrideConfig: eslintConfig,
           cwd: projectPath
         };
+        console.log(`⚠️ [ESLintEngine] Using analysis config only`);
       }
       
       const finalESLintInstance = new ESLint(finalESLintOptions);
 
-      // Run ESLint analysis
+      // Run ESLint analysis - let ESLint handle parsing errors gracefully
+      console.log(`🔍 [ESLintEngine] Analyzing ${jstsFiles.length} JavaScript/TypeScript files...`);
       const eslintResults = await finalESLintInstance.lintFiles(jstsFiles);
       
+      // Filter out parsing errors when TypeScript parser is not available
+      let processedResults = eslintResults;
+      if (!hasTypeScriptParser) {
+        let parsingErrorCount = 0;
+        processedResults = eslintResults.map(result => {
+          const filteredMessages = result.messages.filter(message => {
+            if (message.ruleId === null && message.message.includes('Parsing error')) {
+              parsingErrorCount++;
+              return false; // Skip parsing errors
+            }
+            return true; // Keep all other messages
+          });
+          return { ...result, messages: filteredMessages };
+        });
+        
+        if (parsingErrorCount > 0) {
+          console.log(`ℹ️ [ESLintEngine] Filtered ${parsingErrorCount} TypeScript parsing errors (install @typescript-eslint/parser for full TypeScript support)`);
+        }
+      }
+      
       // Convert ESLint results to SunLint format
-      results.results = this.convertESLintResults(eslintResults, rules);
+      results.results = this.convertESLintResults(processedResults, rules);
       results.filesAnalyzed = jstsFiles.length;
       results.metadata.rulesAnalyzed = rules.map(r => r.id);
       results.metadata.eslintRulesUsed = Object.keys(eslintConfig.rules);
@@ -498,6 +1158,76 @@ class ESLintEngine extends AnalysisEngineInterface {
     return results;
   }
 
+  /**
+   * Find project root from a list of files or a directory
+   * Following Rule C006: Verb-noun naming
+   * @param {string[]} paths - List of file paths or directories
+   * @returns {string} Project root path
+   */
+  findProjectRoot(paths) {
+    const path = require('path');
+    
+    if (paths.length === 0) {
+      return process.cwd();
+    }
+    
+    // Start from the first path (could be directory or file)
+    let startPath = paths[0];
+    
+    // If it's a file, get its directory
+    if (fs.existsSync(startPath) && fs.statSync(startPath).isFile()) {
+      startPath = path.dirname(startPath);
+    }
+    
+    // Look for project indicators going up the tree from start path
+    let currentPath = path.resolve(startPath);
+    while (currentPath !== path.dirname(currentPath)) { // Stop at root
+      const packageJsonPath = path.join(currentPath, 'package.json');
+      const eslintConfigPath = path.join(currentPath, 'eslint.config.js');
+      const eslintrcPath = path.join(currentPath, '.eslintrc.json');
+      const tsConfigPath = path.join(currentPath, 'tsconfig.json');
+      
+      // Found project root indicators
+      if (fs.existsSync(packageJsonPath) || fs.existsSync(eslintConfigPath) || 
+          fs.existsSync(eslintrcPath) || fs.existsSync(tsConfigPath)) {
+        return currentPath;
+      }
+      
+      // Go up one level
+      currentPath = path.dirname(currentPath);
+    }
+    
+    // If nothing found, return the original start path
+    return path.resolve(startPath);
+  }
+
+  /**
+   * Find common path between two paths
+   * Following Rule C006: Verb-noun naming
+   * @param {string} path1 - First path
+   * @param {string} path2 - Second path  
+   * @returns {string} Common path
+   */
+  findCommonPath(path1, path2) {
+    const path = require('path');
+    
+    const parts1 = path1.split(path.sep);
+    const parts2 = path2.split(path.sep);
+    
+    const commonParts = [];
+    const minLength = Math.min(parts1.length, parts2.length);
+    
+    for (let i = 0; i < minLength; i++) {
+      if (parts1[i] === parts2[i]) {
+        commonParts.push(parts1[i]);
+      } else {
+        break;
+      }
+    }
+    
+    return commonParts.join(path.sep) || path.sep;
+  }
+
   /**
    * Check if file is JavaScript or TypeScript
    * Following Rule C006: Verb-noun naming
@@ -595,6 +1325,37 @@ class ESLintEngine extends AnalysisEngineInterface {
 
     // Map SunLint rules to ESLint rules
     for (const rule of rules) {
+      // For Security rules, always use custom plugin (ignore mapping file)
+      if (rule.id.startsWith('S')) {
+        const customRuleName = `custom/typescript_${rule.id.toLowerCase()}`;
+        const ruleConfig = this.mapSeverity(rule.severity || 'warning');
+        config.rules[customRuleName] = ruleConfig;
+        continue;
+      }
+      
+      // For Common rules (C series), use rule ID directly in custom plugin
+      if (rule.id.startsWith('C')) {
+        const customRuleName = `custom/${rule.id.toLowerCase()}`;
+        const ruleConfig = this.mapSeverity(rule.severity || 'warning');
+        
+        // Add rule configuration for specific rules
+        if (rule.id === 'C010') {
+          config.rules[customRuleName] = [ruleConfig, { maxDepth: 3 }];
+        } else {
+          config.rules[customRuleName] = ruleConfig;
+        }
+        continue;
+      }
+      
+      // For TypeScript rules (T series), use rule ID directly in custom plugin
+      if (rule.id.startsWith('T')) {
+        const customRuleName = `custom/${rule.id.toLowerCase()}`;
+        const ruleConfig = this.mapSeverity(rule.severity || 'warning');
+        config.rules[customRuleName] = ruleConfig;
+        continue;
+      }
+      
+      // For other rules, check mapping file
       const eslintRules = this.ruleMapping.get(rule.id);
       
       if (eslintRules && Array.isArray(eslintRules)) {
@@ -604,16 +1365,10 @@ class ESLintEngine extends AnalysisEngineInterface {
           config.rules[eslintRule] = severity;
         }
       } else {
-        // Check if it's a custom rule (C010, etc.)
+        // Fallback - try as custom rule
         const customRuleName = `custom/${rule.id.toLowerCase()}`;
         const ruleConfig = this.mapSeverity(rule.severity || 'warning');
-        
-        // Add rule configuration for specific rules
-        if (rule.id === 'C010') {
-          config.rules[customRuleName] = [ruleConfig, { maxDepth: 3 }];
-        } else {
-          config.rules[customRuleName] = ruleConfig;
-        }
+        config.rules[customRuleName] = ruleConfig;
       }
     }
 
@@ -732,6 +1487,22 @@ class ESLintEngine extends AnalysisEngineInterface {
    * Following Rule C006: Verb-noun naming
    */
   async cleanup() {
+    // Clean up temporary config files
+    if (this.tempConfigPaths && this.tempConfigPaths.length > 0) {
+      const fs = require('fs');
+      for (const tempPath of this.tempConfigPaths) {
+        try {
+          if (fs.existsSync(tempPath)) {
+            fs.unlinkSync(tempPath);
+            console.log(`🧹 [ESLintEngine] Cleaned up temporary config: ${tempPath}`);
+          }
+        } catch (error) {
+          console.warn(`⚠️ [ESLintEngine] Failed to cleanup temp config ${tempPath}: ${error.message}`);
+        }
+      }
+      this.tempConfigPaths = [];
+    }
+    
     this.eslint = null;
     this.configFiles.clear();
     this.ruleMapping.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {