@sun-asterisk/sunlint 1.1.3 → 1.1.4

package/.sunlint.json

@@ -1,5 +1,5 @@
 {
-  "extends": ["recommended"],
+  "extends": ["@sun/sunlint/recommended"],
   "rules": {
     "C019": "warn",
     "C006": "warn", 

package/README.md

@@ -8,29 +8,30 @@ Sun Lint is a universal coding standards checker providing comprehensive code qu
 
 ### **✨ Key Features**
 - ✅ **97+ Coding Rules**: Quality (30), Security (47), TypeScript-specific
-- ✅ **AST-Enhanced Analysis**: Superior accuracy with Babel/ESLint parsers
+- ✅ **Built-in AST Analysis**: JavaScript/TypeScript parsing out of the box
 - ✅ **Multi-Engine Architecture**: Heuristic + ESLint + OpenAI integration  
 - ✅ **Git Integration**: `--changed-files`, `--staged-files`, `--pr-mode`
 - ✅ **TypeScript Support**: Native TypeScript 5.8+ analysis
+- ✅ **Zero Config**: Works immediately after `npm install`
 - ✅ **CI/CD Ready**: Baseline comparison, fail-on-new-violations
 - ✅ **Advanced File Targeting**: Include/exclude patterns, language filtering
 
 ### **🚀 Quick Start**
 ```bash
-# Install globally
+# Install
 npm install -g @sun-asterisk/sunlint
 
-# Basic usage (uses config file or default patterns)
+# Basic usage - works immediately!
 sunlint --all
 sunlint --rules=C019,C006
 
-# Explicit input specification  
+# With input specification  
 sunlint --all --input=src
 sunlint --rules=C019,C006 --input=src
 sunlint --quality --input=src
 sunlint --security --input=src
 
-# ESLint integration (multi-engine analysis)
+# ESLint integration (requires eslint dependency)
 sunlint --rules=C010,C006 --eslint-integration --input=src
 
 # Git integration  
@@ -48,12 +49,66 @@ sunlint --version
 ### **Project Installation**
 ```bash
 npm install --save-dev @sun-asterisk/sunlint
+```
+
+**✅ Works immediately** with JavaScript analysis using built-in AST parsers (`@babel/parser`, `espree`)
+
+### **Enhanced TypeScript Support**
+For advanced TypeScript analysis with ESLint integration:
+
+```bash
+npm install --save-dev @sun-asterisk/sunlint eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin typescript
+```
+
+### **What's Included by Default**
+- ✅ **JavaScript Analysis**: High-accuracy AST analysis out of the box
+- ✅ **Basic TypeScript**: Works with built-in Babel parser  
+- ✅ **97+ Rules**: All quality and security rules available
+- ✅ **Heuristic Engine**: Pattern-based analysis for all languages
+
+### **Optional Dependencies (Install as needed)**
+```bash
+# For ESLint engine integration
+npm install eslint --save-dev
+
+# For enhanced TypeScript analysis  
+npm install @typescript-eslint/parser @typescript-eslint/eslint-plugin --save-dev
+
+# For TypeScript compiler integration
+npm install typescript --save-dev
+```
+
+**Quick setup for TypeScript projects:**
+```bash
+npm install --save-dev @sun-asterisk/sunlint eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin typescript
+```
+
+> 💡 **Note**: SunLint gracefully handles missing dependencies. Install only what your project needs. See [docs/DEPENDENCIES.md](docs/DEPENDENCIES.md) for detailed guidance.
 
 # Package.json scripts
+```json
 {
   "scripts": {
     "lint": "sunlint --all --input=src",
-    "lint:changed": "sunlint --all --changed-files"
+    "lint:changed": "sunlint --all --changed-files",
+    "lint:typescript": "sunlint --all --input=src",
+    "lint:eslint-integration": "sunlint --all --eslint-integration --input=src"
+  },
+  "devDependencies": {
+    "@sun-asterisk/sunlint": "^1.2.0"
+  }
+}
+```
+
+**For TypeScript projects, add:**
+```json
+{
+  "devDependencies": {
+    "@sun-asterisk/sunlint": "^1.2.0",
+    "eslint": "^8.50.0",
+    "@typescript-eslint/parser": "^7.2.0",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "typescript": "^5.0.0"
   }
 }
 ```
@@ -209,16 +264,28 @@ Complete reference with all available options:
 
 ### **Development**
 ```bash
-# Run all rules
-sunlint --all --input=src
+# Quick start - works immediately
+npm install --save-dev @sun-asterisk/sunlint
+npx sunlint --all --input=src
 
 # Check specific rules
 sunlint --rules=C019,S005 --input=src
 
-# ESLint + Git integration
+# ESLint integration (requires eslint dependency)
+npm install --save-dev eslint
 sunlint --all --eslint-integration --changed-files
 ```
 
+### **TypeScript Projects**
+```bash
+# Enhanced TypeScript setup
+npm install --save-dev @sun-asterisk/sunlint eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin typescript
+
+# Full TypeScript analysis
+sunlint --all --input=src
+sunlint --all --eslint-integration --input=src
+```
+
 ### **CI/CD**
 ```bash
 # Full project scan
@@ -227,7 +294,7 @@ sunlint --all --input=. --format=json --output=report.json
 # PR validation
 sunlint --all --changed-files --fail-on-new-violations
 
-# Pre-commit hook
+# Pre-commit hook  
 sunlint --all --staged-files --format=summary
 ```
 

package/config/eslint-rule-mapping.json

@@ -104,7 +104,7 @@
     "R001": ["react/no-this-in-sfc", "no-param-reassign", "react/function-component-definition", "react/forbid-component-props"],
     "R002": ["react-hooks/rules-of-hooks", "react-hooks/exhaustive-deps", "react/no-did-mount-set-state", "react/no-did-update-set-state"],
     "R003": ["react/no-direct-mutation-state", "react/jsx-no-constructed-context-values", "react/forbid-dom-props"],
-    "R004": ["@typescript-eslint/prefer-readonly", "react/forbid-foreign-prop-types"],
+    "R004": ["no-param-reassign", "react/forbid-foreign-prop-types"],
     "R005": ["react/jsx-no-bind"],
     "R006": ["react/jsx-pascal-case", "react/jsx-uses-react", "react/jsx-uses-vars"],
     "R007": ["react-hooks/rules-of-hooks"],

package/config/rules/rules-registry.json

@@ -651,13 +651,13 @@
     "quality": {
       "name": "Code Quality",
       "description": "Rules for code quality improvement",
-      "rules": ["C002", "C003", "C006", "C010", "C013", "C014", "C017", "C018", "C019", "C023", "C027", "C029", "C030", "C031", "C034", "C035", "C041", "C042", "C043", "C047", "C048", "C076", "T002", "T003", "T004", "T007", "T011", "T019", "T025", "T026"],
+      "rules": ["C002", "C003", "C006", "C010", "C013", "C014", "C017", "C018", "C023", "C029", "C030", "C035", "C041", "C042", "C043", "C047", "C072", "C075", "C076", "T002", "T003", "T004", "T007", "T010", "T019", "T020", "T021", "R001", "R002", "R003", "R004", "R005", "R006"],
       "severity": "warning"
     },
     "security": {
       "name": "Security",
       "description": "Rules for security best practices",
-      "rules": ["S003", "S005", "S006", "S008", "S009", "S010", "S011", "S012", "S014", "S015", "S016", "S017", "S018", "S019", "S020", "S022", "S023", "S025", "S026", "S027", "S029", "S030", "S033", "S034", "S035", "S036", "S037", "S038", "S039", "S041", "S042", "S043", "S044", "S045", "S046", "S047", "S048", "S050", "S052", "S054", "S055", "S057", "S058"],
+      "rules": ["S001", "S002", "S003", "S005", "S006", "S007", "S008", "S009", "S010", "S011", "S012", "S013", "S014", "S015", "S016", "S017", "S018", "S019", "S020", "S022", "S023", "S025", "S026", "S027", "S029", "S030", "S033", "S034", "S035", "S036", "S037", "S038", "S039", "S041", "S042", "S043", "S044", "S045", "S046", "S047", "S048", "S050", "S052", "S054", "S055", "S057", "S058"],
       "severity": "error"
     },
     "logging": {
@@ -745,11 +745,11 @@
     }
   },
   "metadata": {
-    "version": "1.0.4",
-    "lastUpdated": "2025-07-08",
+    "version": "1.1.4",
+    "lastUpdated": "2025-07-24",
     "totalRules": 44,
-    "qualityRules": 4,
-    "securityRules": 40,
+    "qualityRules": 33,
+    "securityRules": 47,
     "stableRules": 43,
     "experimentalRules": 1,
     "supportedLanguages": 4,
@@ -757,7 +757,8 @@
       "Security rules integration",
       "Category-based rule filtering",
       "Dynamic rule configuration",
-      "ESLint integration enhancement"
+      "ESLint integration enhancement",
+      "React rules integration"
     ]
   }
 }

package/core/ast-modules/parsers/eslint-js-parser.js

@@ -1,25 +1,31 @@
 /**
  * ESLint-based JavaScript Parser
  * Uses the same AST infrastructure as ESLint for reliable parsing
+ * Gracefully handles missing peer dependencies
  */
 
 class ESLintJavaScriptParser {
   constructor() {
     this.parser = null;
+    this.parserType = null;
     this.initParser();
   }
 
   initParser() {
-    try {
-      // Try to use @babel/parser (what ESLint uses internally)
-      this.parser = require('@babel/parser');
-    } catch (e1) {
+    // Try to dynamically load available parsers
+    const parsers = [
+      { name: '@babel/parser', type: 'babel' },
+      { name: 'espree', type: 'espree' }
+    ];
+
+    for (const { name, type } of parsers) {
       try {
-        // Fallback to espree (ESLint's default parser)
-        this.parser = require('espree');
-      } catch (e2) {
-        // If no parser available, this will be null
-        this.parser = null;
+        this.parser = require(name);
+        this.parserType = type;
+        break;
+      } catch (error) {
+        // Continue to next parser
+        continue;
       }
     }
   }
@@ -28,11 +34,9 @@ class ESLintJavaScriptParser {
     if (!this.parser) return null;
 
     try {
-      if (this.parser.parse) {
-        // @babel/parser or espree
+      if (this.parserType === 'babel') {
         return this.parser.parse(code, {
-          ecmaVersion: 'latest',
-          sourceType: 'module',
+          sourceType: 'unambiguous',
           allowImportExportEverywhere: true,
           allowReturnOutsideFunction: true,
           plugins: [
@@ -43,14 +47,16 @@ class ESLintJavaScriptParser {
             'objectRestSpread',
             'optionalChaining',
             'nullishCoalescingOperator'
-          ].filter(plugin => {
-            // Only include plugins that are supported
-            try {
-              return true;
-            } catch {
-              return false;
-            }
-          })
+          ]
+        });
+      } else if (this.parserType === 'espree') {
+        return this.parser.parse(code, {
+          ecmaVersion: 'latest',
+          sourceType: 'module',
+          ecmaFeatures: {
+            jsx: true,
+            globalReturn: true
+          }
         });
       }
     } catch (error) {

package/core/ast-modules/parsers/eslint-ts-parser.js

@@ -1,26 +1,31 @@
 /**
  * ESLint-based TypeScript Parser
  * Uses @typescript-eslint/parser for TypeScript AST analysis
+ * Gracefully handles missing peer dependencies
  */
 
 class ESLintTypeScriptParser {
   constructor() {
     this.parser = null;
+    this.parserType = null;
     this.initParser();
   }
 
   initParser() {
-    try {
-      // Try to use @typescript-eslint/parser
-      this.parser = require('@typescript-eslint/parser');
-    } catch (e1) {
+    // Try to dynamically load available TypeScript parsers
+    const parsers = [
+      { name: '@typescript-eslint/parser', type: 'typescript-eslint' },
+      { name: '@babel/parser', type: 'babel' }
+    ];
+
+    for (const { name, type } of parsers) {
       try {
-        // Fallback to @babel/parser with TypeScript plugin
-        this.parser = require('@babel/parser');
-        this.parserType = 'babel';
-      } catch (e2) {
-        // If no parser available, this will be null
-        this.parser = null;
+        this.parser = require(name);
+        this.parserType = type;
+        break;
+      } catch (error) {
+        // Continue to next parser
+        continue;
       }
     }
   }
@@ -29,45 +34,32 @@ class ESLintTypeScriptParser {
     if (!this.parser) return null;
 
     try {
-      // Try Babel parser first for better TypeScript 5.x support
       if (this.parserType === 'babel') {
         return this.parser.parse(code, {
-          sourceType: 'module',
+          sourceType: 'unambiguous',
           allowImportExportEverywhere: true,
           plugins: ['typescript', 'jsx', 'decorators-legacy']
         });
-      } else {
-        // Use Babel parser as primary for TypeScript files
+      } else if (this.parserType === 'typescript-eslint') {
+        // First try @babel/parser for better compatibility
         try {
           const babel = require('@babel/parser');
           return babel.parse(code, {
-            sourceType: 'module',
+            sourceType: 'unambiguous',
             allowImportExportEverywhere: true,
             plugins: ['typescript', 'jsx', 'decorators-legacy', 'classProperties']
           });
         } catch (babelError) {
-          // Fallback to @typescript-eslint/parser (with warnings suppressed)
+          // Fallback to @typescript-eslint/parser if available
           if (this.parser.parseForESLint) {
-            const originalWarn = console.warn;
-            const originalError = console.error;
-            console.warn = () => {}; // Suppress warnings temporarily
-            console.error = () => {}; // Suppress errors temporarily
-            
-            try {
-              const result = this.parser.parseForESLint(code, {
-                ecmaVersion: 'latest',
-                sourceType: 'module',
-                ecmaFeatures: {
-                  jsx: true
-                },
-                errorOnUnknownASTType: false // Don't error on unknown AST types
-              });
-              return result.ast;
-            } finally {
-              // Always restore console methods
-              console.warn = originalWarn;
-              console.error = originalError;
-            }
+            const result = this.parser.parseForESLint(code, {
+              ecmaVersion: 'latest',
+              sourceType: 'module',
+              ecmaFeatures: {
+                jsx: true
+              }
+            });
+            return result.ast;
           }
         }
       }

package/core/dependency-checker.js

@@ -0,0 +1,125 @@
+/**
+ * Dependency Checker
+ * Checks for optional peer dependencies and provides helpful messages
+ */
+
+class DependencyChecker {
+  constructor() {
+    this.checkedDependencies = new Set();
+  }
+
+  /**
+   * Check if a dependency is available
+   */
+  isDependencyAvailable(packageName) {
+    try {
+      require.resolve(packageName);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Check for ESLint engine dependencies
+   */
+  checkESLintDependencies() {
+    const dependencies = {
+      'eslint': { required: false, description: 'ESLint engine support' },
+      '@typescript-eslint/eslint-plugin': { required: false, description: 'TypeScript ESLint rules' },
+      '@typescript-eslint/parser': { required: false, description: 'TypeScript ESLint parsing' },
+      'typescript': { required: false, description: 'TypeScript compiler' }
+    };
+
+    const missing = [];
+    const available = [];
+
+    for (const [pkg, info] of Object.entries(dependencies)) {
+      if (this.isDependencyAvailable(pkg)) {
+        available.push(pkg);
+      } else {
+        missing.push({ pkg, ...info });
+      }
+    }
+
+    return { available, missing };
+  }
+
+  /**
+   * Check for AST parsing dependencies
+   */
+  checkASTDependencies() {
+    const dependencies = {
+      '@babel/parser': { required: false, description: 'JavaScript AST parsing' },
+      'espree': { required: false, description: 'ECMAScript AST parsing' }
+    };
+
+    const missing = [];
+    const available = [];
+
+    for (const [pkg, info] of Object.entries(dependencies)) {
+      if (this.isDependencyAvailable(pkg)) {
+        available.push(pkg);
+      } else {
+        missing.push({ pkg, ...info });
+      }
+    }
+
+    return { available, missing };
+  }
+
+  /**
+   * Show installation instructions for missing dependencies
+   */
+  showInstallationInstructions(missing, context = 'general') {
+    if (missing.length === 0) return;
+
+    console.log('\n📦 Optional dependencies not found:');
+    
+    for (const { pkg, description } of missing) {
+      console.log(`   • ${pkg} - ${description}`);
+    }
+
+    const packages = missing.map(m => m.pkg).join(' ');
+    
+    if (context === 'eslint') {
+      console.log('\n💡 To enable ESLint engine features, install:');
+      console.log(`   npm install ${packages}`);
+      console.log('\n   Or add to your project dependencies if you already have them.');
+    } else if (context === 'ast') {
+      console.log('\n💡 To enable AST analysis features, install:');
+      console.log(`   npm install ${packages}`);
+    } else {
+      console.log('\n💡 To enable full functionality, install:');
+      console.log(`   npm install ${packages}`);
+    }
+
+    console.log('\n   SunLint will continue using heuristic analysis.\n');
+  }
+
+  /**
+   * Check and notify about missing dependencies (only once per session)
+   */
+  checkAndNotify(type = 'all') {
+    const key = `checked_${type}`;
+    if (this.checkedDependencies.has(key)) return;
+    
+    this.checkedDependencies.add(key);
+
+    if (type === 'eslint' || type === 'all') {
+      const { missing } = this.checkESLintDependencies();
+      if (missing.length > 0) {
+        this.showInstallationInstructions(missing, 'eslint');
+      }
+    }
+
+    if (type === 'ast' || type === 'all') {
+      const { missing } = this.checkASTDependencies();
+      if (missing.length > 0) {
+        this.showInstallationInstructions(missing, 'ast');
+      }
+    }
+  }
+}
+
+module.exports = new DependencyChecker();

package/core/smart-installer.js

@@ -0,0 +1,164 @@
+/**
+ * Smart Dependency Auto-Installer
+ * Automatically installs missing peer dependencies when SunLint runs
+ * Future: Will support package flavor recommendations
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+class SmartInstaller {
+  constructor() {
+    this.installedInSession = new Set();
+    this.packageFlavors = {
+      'typescript': '@sun-asterisk/sunlint-typescript',
+      'dart': '@sun-asterisk/sunlint-dart', 
+      'python': '@sun-asterisk/sunlint-python',
+      'go': '@sun-asterisk/sunlint-go',
+      'full': '@sun-asterisk/sunlint-full'
+    };
+  }
+
+  /**
+   * Detect project type and recommend appropriate packages
+   */
+  detectProjectType(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) return ['basic'];
+
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const types = [];
+
+    // Check for TypeScript
+    if (packageJson.devDependencies?.typescript || 
+        packageJson.dependencies?.typescript ||
+        fs.existsSync(path.join(projectRoot, 'tsconfig.json'))) {
+      types.push('typescript');
+    }
+
+    // Check for other languages (future)
+    if (fs.existsSync(path.join(projectRoot, 'pubspec.yaml'))) {
+      types.push('dart');
+    }
+
+    if (fs.existsSync(path.join(projectRoot, 'requirements.txt')) ||
+        fs.existsSync(path.join(projectRoot, 'pyproject.toml'))) {
+      types.push('python');
+    }
+
+    if (fs.existsSync(path.join(projectRoot, 'go.mod'))) {
+      types.push('go');
+    }
+
+    return types.length > 0 ? types : ['basic'];
+  }
+
+  /**
+   * Recommend optimal package flavors instead of individual dependencies
+   */
+  recommendPackageFlavors(missingDeps, projectTypes) {
+    const recommendations = [];
+
+    // If missing TypeScript deps and it's a TS project
+    if (missingDeps.some(d => d.pkg.includes('@typescript-eslint')) && 
+        projectTypes.includes('typescript')) {
+      recommendations.push({
+        package: '@sun-asterisk/sunlint-typescript',
+        reason: 'Complete TypeScript analysis support',
+        replaces: missingDeps.filter(d => d.pkg.includes('typescript')).map(d => d.pkg)
+      });
+    }
+
+    // If missing many ESLint deps, suggest full package
+    if (missingDeps.length >= 3 && missingDeps.some(d => d.pkg === 'eslint')) {
+      recommendations.push({
+        package: '@sun-asterisk/sunlint-full', 
+        reason: 'Complete ESLint integration with all features',
+        replaces: missingDeps.map(d => d.pkg)
+      });
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Check if we're in a project that can install dependencies
+   */
+  canAutoInstall() {
+    // Check if package.json exists in current or parent directories
+    let currentDir = process.cwd();
+    const root = path.parse(currentDir).root;
+    
+    while (currentDir !== root) {
+      if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+        return currentDir;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+    return null;
+  }
+
+  /**
+   * Auto-install missing dependencies with user confirmation
+   */
+  async autoInstallMissing(missingDeps, context = 'analysis') {
+    const projectRoot = this.canAutoInstall();
+    if (!projectRoot) {
+      this.showManualInstallInstructions(missingDeps);
+      return false;
+    }
+
+    console.log(`\n🔍 SunLint needs these dependencies for enhanced ${context}:`);
+    missingDeps.forEach(dep => console.log(`   • ${dep.pkg} - ${dep.description}`));
+    
+    const packages = missingDeps.map(d => d.pkg).join(' ');
+    
+    console.log(`\n💡 Install command:`);
+    console.log(`   npm install ${packages} --save-dev`);
+    
+    // In CI environments, don't auto-install but show clear message
+    if (process.env.CI || process.env.NODE_ENV === 'test') {
+      console.log('\n⚠️  CI Environment: Add dependencies to package.json for consistent builds');
+      console.log('   SunLint will continue with available features\n');
+      return false;
+    }
+
+    // Interactive prompt for auto-install
+    const shouldAutoInstall = process.env.SUNLINT_AUTO_INSTALL === 'true';
+    
+    if (shouldAutoInstall) {
+      try {
+        console.log('\n📦 Auto-installing dependencies...');
+        execSync(`npm install ${packages} --save-dev`, { 
+          cwd: projectRoot, 
+          stdio: 'pipe'  // Less noisy
+        });
+        console.log('✅ Dependencies installed successfully!');
+        console.log('🔄 Re-running analysis with full features...\n');
+        return true;
+      } catch (error) {
+        console.log('❌ Auto-install failed, continuing with available features');
+        return false;
+      }
+    } else {
+      console.log('\n🔄 Continuing with available features...');
+      console.log('💡 Set SUNLINT_AUTO_INSTALL=true to enable automatic installation\n');
+    }
+
+    return false;
+  }
+
+  /**
+   * Show manual installation instructions
+   */
+  showManualInstallInstructions(missingDeps) {
+    console.log('\n📦 To enable full functionality, install:');
+    const packages = missingDeps.map(d => d.pkg).join(' ');
+    console.log(`   npm install ${packages} --save-dev`);
+    console.log('\n💡 Or set SUNLINT_AUTO_INSTALL=true for automatic installation');
+    console.log('   SunLint will continue with heuristic analysis.\n');
+  }
+}
+
+module.exports = new SmartInstaller();

package/docs/DEPENDENCIES.md

@@ -0,0 +1,90 @@
+# Installing SunLint Dependencies
+
+SunLint is designed to work immediately after installation with built-in JavaScript/TypeScript analysis capabilities. Additional dependencies are only needed for enhanced features.
+
+## Core Installation
+
+```bash
+npm install @sun-asterisk/sunlint --save-dev
+```
+
+**✅ What you get immediately:**
+- High-accuracy JavaScript analysis (AST-based)
+- Basic TypeScript analysis (Babel parser)
+- All 97+ quality and security rules
+- Heuristic analysis for all supported languages
+
+## Enhanced Features
+
+### For ESLint Integration
+
+If you want to combine SunLint with ESLint rules and ecosystem:
+
+```bash
+npm install eslint --save-dev
+```
+
+### For Advanced TypeScript Analysis
+
+For enhanced TypeScript parsing and ESLint TypeScript rules:
+
+```bash
+npm install @typescript-eslint/eslint-plugin @typescript-eslint/parser --save-dev
+```
+
+### For TypeScript Projects (Complete Setup)
+
+For full TypeScript development support:
+
+```bash
+npm install eslint typescript @typescript-eslint/eslint-plugin @typescript-eslint/parser --save-dev
+```
+
+## Installation Examples
+
+### Minimal Setup (JavaScript projects)
+```bash
+npm install @sun-asterisk/sunlint --save-dev
+npx sunlint --all --input=src  # ✅ Works immediately
+```
+
+### TypeScript Projects
+```bash
+npm install @sun-asterisk/sunlint eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin typescript --save-dev
+npx sunlint --all --input=src  # ✅ Full TypeScript support
+```
+
+### ESLint Integration
+```bash
+npm install @sun-asterisk/sunlint eslint --save-dev
+npx sunlint --all --eslint-integration --input=src  # ✅ Combined analysis
+```
+
+## What happens without optional dependencies?
+
+- **Without ESLint**: SunLint uses heuristic engine only (still very capable)
+- **Without TypeScript parsers**: Falls back to Babel parser (good coverage)
+- **Without TypeScript compiler**: Basic type checking only
+
+**SunLint always provides analysis results** - dependencies only enhance capabilities.
+
+## Built-in vs Optional Parsers
+
+### ✅ Built-in (Always Available)
+- **@babel/parser**: JavaScript + basic TypeScript support
+- **espree**: ECMAScript parsing for compatibility
+
+### 🔄 Optional (Install as needed)  
+- **@typescript-eslint/parser**: Advanced TypeScript features
+- **@typescript-eslint/eslint-plugin**: TypeScript-specific rules
+- **eslint**: ESLint engine integration
+- **typescript**: TypeScript compiler integration
+
+## Dependency Check
+
+Run any SunLint command to see recommendations for your project:
+
+```bash
+npx sunlint --help
+# Automatically detects project type and suggests relevant dependencies
+```

package/docs/FUTURE_PACKAGES.md

@@ -0,0 +1,83 @@
+# Future SunLint Package Strategy
+
+## Core Packages
+
+### @sun-asterisk/sunlint (Core)
+- Size: ~235KB
+- Features: Basic JS/TS heuristic analysis
+- Dependencies: @babel/parser, espree
+- Target: Minimal setup, basic quality checks
+
+### @sun-asterisk/sunlint-typescript 
+- Size: ~2MB
+- Features: Full TypeScript analysis with AST
+- Dependencies: Core + @typescript-eslint/parser, typescript
+- Target: TypeScript projects
+
+### @sun-asterisk/sunlint-full
+- Size: ~10MB  
+- Features: Complete ESLint integration, all parsers
+- Dependencies: Core + all ESLint ecosystem
+- Target: Full-featured analysis
+
+## Language Extensions
+
+### @sun-asterisk/sunlint-dart
+- Dart-specific rules and analysis
+- Dependencies: dart_analyzer, dart tools
+
+### @sun-asterisk/sunlint-python
+- Python-specific rules
+- Dependencies: pylint, autopep8, mypy
+
+### @sun-asterisk/sunlint-go
+- Go-specific analysis
+- Dependencies: staticcheck, golint
+
+## Feature Extensions
+
+### @sun-asterisk/sunlint-ai
+- AI-powered code analysis
+- Dependencies: OpenAI API, Claude API
+
+### @sun-asterisk/sunlint-security
+- Advanced security scanning
+- Dependencies: semgrep, snyk, security plugins
+
+## Installation Examples
+
+```bash
+# Basic usage
+npm install @sun-asterisk/sunlint --save-dev
+
+# TypeScript project
+npm install @sun-asterisk/sunlint-typescript --save-dev
+
+# Multi-language project
+npm install @sun-asterisk/sunlint @sun-asterisk/sunlint-dart @sun-asterisk/sunlint-python --save-dev
+
+# Enterprise setup with all features
+npm install @sun-asterisk/sunlint-full @sun-asterisk/sunlint-ai @sun-asterisk/sunlint-security --save-dev
+```
+
+## Configuration
+
+### Package-based auto-detection
+```json
+// .sunlint.json
+{
+  "extends": ["auto-detect-packages"],  // Automatically use installed packages
+  "rules": {
+    "C010": "error"
+  }
+}
+```
+
+### Smart recommendations
+```bash
+# When SunLint detects TypeScript files but no TS package
+npx sunlint --all
+# Output: 
+# 💡 TypeScript files detected. For better analysis:
+# npm install @sun-asterisk/sunlint-typescript --save-dev
+```

package/docs/PRODUCTION_DEPLOYMENT_ANALYSIS.md

@@ -0,0 +1,112 @@
+# Production Deployment Analysis - SunLint Size Impact
+
+## 🔍 **Câu hỏi từ Developer:**
+*"Công việc trên có phải là phổ biến không, tức là khi deploy thông thường có làm các công việc đó không?"*
+
+## 📊 **Thực tế Deployment Phổ Biến**
+
+### ✅ **THỰC TẾ 1: DevDependencies tự động bị loại trừ**
+
+**Hầu hết deployment platforms tự động loại trừ devDependencies:**
+
+| Platform | Auto-exclude devDependencies | Command |
+|----------|------------------------------|---------|
+| **Heroku** | ✅ | `npm install --production` |
+| **Vercel** | ✅ | `npm ci --production` |
+| **Netlify** | ✅ | `npm install --production` |
+| **Docker** | ✅ | `RUN npm ci --only=production` |
+| **AWS Lambda** | ✅ | `npm install --production` |
+| **Google Cloud** | ✅ | `npm ci --production` |
+
+### ✅ **THỰC TẾ 2: Build process tự nhiên**
+
+**Typical CI/CD pipeline:**
+```bash
+# Development
+npm install              # Cài tất cả (bao gồm SunLint)
+npm run lint            # SunLint chạy để check code
+npm run test            # Tests chạy
+npm run build           # Build production bundle
+
+# Production deployment
+npm ci --production     # CHỈ cài runtime dependencies
+# SunLint tự động bị loại trừ!
+```
+
+### ✅ **THỰC TẾ 3: Docker multistage builds**
+
+**Phổ biến nhất - Docker multistage:**
+```dockerfile
+# Build stage
+FROM node:18 AS builder
+COPY package*.json ./
+RUN npm install        # Cài tất cả, kể cả SunLint
+COPY . .
+RUN npm run build      # SunLint chạy trong quá trình build
+
+# Production stage  
+FROM node:18-alpine AS production
+COPY package*.json ./
+RUN npm ci --production --silent  # CHỈ runtime deps
+COPY --from=builder /app/dist ./dist
+# SunLint không có trong production image!
+```
+
+## 🎯 **Kết luận về SunLint**
+
+### **TẠI SAO SUNLINT AN TOÀN 100%:**
+
+1. **DevDependency by design** - SunLint được thiết kế như linting tool
+2. **Industry standard** - Tất cả linting tools đều hoạt động như vậy
+3. **Automatic exclusion** - Deployment platforms tự động loại trừ
+4. **Zero production footprint** - Không code SunLint nào trong runtime
+
+### **SO SÁNH VỚI CÔNG CỤ KHÁC:**
+
+| Tool | Size | Production Impact | Usage Pattern |
+|------|------|-------------------|---------------|
+| **ESLint** | ~500KB | ❌ (nếu sai cách) | DevDependency ✅ |
+| **SunLint** | **241KB** | ✅ **KHÔNG** | DevDependency ✅ |
+| **Prettier** | ~300KB | ❌ (nếu sai cách) | DevDependency ✅ |
+| **TypeScript** | ~60MB | ❌ (nếu sai cách) | DevDependency ✅ |
+
+## 📈 **Best Practices Verification**
+
+### **✅ ĐÚNG CÁCH (99% cases):**
+```json
+{
+  "devDependencies": {
+    "@sun-asterisk/sunlint": "^1.1.4",
+    "eslint": "^8.57.1",
+    "prettier": "^3.0.0"
+  },
+  "dependencies": {
+    "express": "^4.18.0"  // Chỉ runtime deps
+  }
+}
+```
+
+### **❌ SAI CÁCH (hiếm, chỉ newbie):**
+```json
+{
+  "dependencies": {
+    "@sun-asterisk/sunlint": "^1.1.4",  // ❌ Sai!
+    "express": "^4.18.0"
+  }
+}
+```
+
+## 🚀 **Tóm tắt**
+
+**CÂU TRẢ LỜI:** Các công việc này **HOÀN TOÀN PHỔ BIẾN** và **TỰ ĐỘNG** trong production deployment:
+
+1. ✅ **DevDependencies tự động bị loại trừ** - Industry standard
+2. ✅ **Build tools chỉ chạy development time** - Normal practice  
+3. ✅ **Production chỉ có runtime code** - Security best practice
+4. ✅ **SunLint = 0KB trong production** - Guaranteed
+
+**Developer không cần lo lắng về size impact của SunLint!**
+
+---
+*Generated on: 2025-07-24*
+*SunLint Version: 1.1.4*

package/docs/PRODUCTION_SIZE_IMPACT.md

@@ -0,0 +1,183 @@
+# 📦 SunLint Production Size Impact Analysis
+
+## Tóm tắt cho Leadership
+
+**KẾT LUẬN: SunLint KHÔNG làm tăng size production khi sử dụng đúng cách.**
+
+## Chi tiết phân tích
+
+### 1. Package Size của SunLint
+
+```bash
+SunLint package size: 241.6 kB
+SunLint unpacked size: 1.1 MB
+Total files: 214
+```
+
+### 2. Test Production Impact
+
+Chúng tôi đã tạo một project test để kiểm tra impact thực tế:
+
+| Giai đoạn | Size | Ghi chú |
+|-----------|------|---------|
+| Project ban đầu | 8.0K | Chỉ có package.json và .gitignore |
+| Sau khi cài SunLint (devDependency) | 88M | Bao gồm tất cả devDependencies |
+| Production bundle (dist/) | 4.0K | Code production thực tế |
+| Sau npm prune --production | 156K | Đã xóa tất cả devDependencies |
+
+### 3. Khuyến nghị sử dụng trong Production
+
+#### ✅ ĐÚNG CÁCH (Production-friendly):
+
+```json
+{
+  "devDependencies": {
+    "@sun-asterisk/sunlint": "^1.1.4"
+  }
+}
+```
+
+**Lợi ích:**
+- ✅ Không ảnh hưởng size production bundle
+- ✅ Chỉ cài khi development (`npm install`)
+- ✅ Tự động loại trừ khỏi production (`npm prune --production`)
+- ✅ CI/CD có thể dùng để check code quality
+
+#### ❌ SAI CÁCH (Không khuyến nghị):
+
+```json
+{
+  "dependencies": {
+    "@sun-asterisk/sunlint": "^1.1.4"
+  }
+}
+```
+
+**Vấn đề:**
+- ❌ Tăng 1.1MB cho production bundle
+- ❌ Không cần thiết cho runtime
+- ❌ Làm chậm deployment
+
+### 4. Deployment Strategies
+
+#### Option 1: Development Only (Khuyến nghị)
+```bash
+# Development
+npm install
+
+# Production build
+npm run build
+npm prune --production
+# → SunLint sẽ bị xóa hoàn toàn
+```
+
+#### Option 2: CI/CD Pipeline
+```yaml
+# .github/workflows/ci.yml
+- name: Install deps
+  run: npm ci
+- name: Run SunLint
+  run: npx sunlint --quality --input=src
+- name: Build production
+  run: npm run build
+- name: Remove dev deps
+  run: npm prune --production
+```
+
+#### Option 3: Docker Multi-stage
+```dockerfile
+# Development stage với SunLint
+FROM node:18 as dev
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npx sunlint --all --input=src
+
+# Production stage KHÔNG có SunLint
+FROM node:18-alpine as prod
+COPY package*.json ./
+RUN npm ci --only=production
+COPY dist/ ./dist/
+```
+
+### 5. So sánh với các tools khác
+
+| Tool | Package Size | Production Impact | Use Case |
+|------|-------------|-------------------|-----------|
+| ESLint | ~500KB | ❌ Nếu để dependencies | Development only |
+| Prettier | ~200KB | ❌ Nếu để dependencies | Development only |
+| **SunLint** | **241KB** | **✅ KHÔNG (devDep)** | **Development + CI/CD** |
+| TypeScript | ~60MB | ❌ Nếu để dependencies | Development only |
+
+### 6. Best Practices cho Teams
+
+#### Developers:
+```bash
+# Local development
+npm install          # Cài tất cả deps (bao gồm SunLint)
+npx sunlint --quality --input=src
+
+# Pre-commit hook
+npx sunlint --changed-files
+```
+
+#### CI/CD:
+```bash
+# Build pipeline
+npm ci                       # Cài tất cả deps
+npx sunlint --all --input=src  # Quality check
+npm run build                # Build production
+npm prune --production       # Xóa devDeps
+```
+
+#### Production:
+```bash
+# Server deployment
+npm ci --only=production     # Chỉ cài production deps
+# → SunLint sẽ KHÔNG được cài
+```
+
+### 7. Monitoring & Verification
+
+#### Verify production size:
+```bash
+# Trước deploy
+du -sh node_modules
+du -sh dist/
+
+# Kiểm tra không có SunLint
+ls node_modules | grep sunlint  # Không có kết quả = OK
+```
+
+#### Bundle size monitoring:
+```bash
+# Add to package.json
+{
+  "scripts": {
+    "analyze-bundle": "du -sh dist/ && echo 'Production bundle size'",
+    "verify-prod": "npm ls --production --depth=0"
+  }
+}
+```
+
+## Kết luận
+
+### ✅ AN TOÀN cho Production:
+- SunLint được thiết kế như devDependency
+- Không ảnh hưởng size production bundle khi sử dụng đúng
+- Có thể tích hợp vào CI/CD mà không ảnh hưởng deployment
+
+### 📊 Số liệu cụ thể:
+- **Development**: +88MB (chỉ khi dev)
+- **Production**: +0KB (khi dùng đúng cách)
+- **CI/CD**: Impact chỉ ở build time, không ở runtime
+
+### 🚀 Khuyến nghị:
+1. **Luôn cài như devDependency**
+2. **Sử dụng trong CI/CD pipeline**
+3. **npm prune --production trước deploy**
+4. **Monitor bundle size định kỳ**
+
+---
+
+*Tài liệu này được cập nhật cho SunLint v1.1.4 - July 2025*

package/engines/eslint-engine.js

@@ -6,6 +6,7 @@
  */
 
 const AnalysisEngineInterface = require('../core/interfaces/analysis-engine.interface');
+const dependencyChecker = require('../core/dependency-checker');
 const fs = require('fs');
 const path = require('path');
 
@@ -62,6 +63,9 @@ class ESLintEngine extends AnalysisEngineInterface {
       // Store verbosity setting for use in other methods
       this.verbose = config?.verbose || false;
       
+      // Check for ESLint dependencies first
+      dependencyChecker.checkAndNotify('eslint');
+      
       // Dynamically import ESLint
       const { ESLint } = await this.loadESLint();
       
@@ -94,6 +98,11 @@ class ESLintEngine extends AnalysisEngineInterface {
    * @returns {Promise<Object>} ESLint module
    */
   async loadESLint() {
+    // Check if ESLint is available first
+    if (!dependencyChecker.isDependencyAvailable('eslint')) {
+      throw new Error('ESLint not available. Install with: npm install eslint');
+    }
+
     try {
       // Try to load ESLint from node_modules
       return await import('eslint');

package/engines/heuristic-engine.js

@@ -7,6 +7,7 @@
 
 const AnalysisEngineInterface = require('../core/interfaces/analysis-engine.interface');
 const ASTModuleRegistry = require('../core/ast-modules/index');
+const dependencyChecker = require('../core/dependency-checker');
 const fs = require('fs');
 const path = require('path');
 
@@ -30,6 +31,9 @@ class HeuristicEngine extends AnalysisEngineInterface {
       // Store verbosity setting
       this.verbose = config?.verbose || false;
       
+      // Check for optional AST dependencies
+      dependencyChecker.checkAndNotify('ast');
+      
       // Load rules registry
       await this.loadRulesRegistry(config);
       

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.1.3",
-  "description": "☀️ Sun Lint - Universal Coding Standards | Multi-rule Quality & Security Analysis with ESLint Integration",
+  "version": "1.1.4",
+  "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {
     "sunlint": "./cli.js"
@@ -87,22 +87,49 @@
   },
   "dependencies": {
     "@babel/parser": "^7.23.0",
-    "@typescript-eslint/parser": "^8.38.0",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
+    "eslint": "^8.57.1",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
     "espree": "^9.6.0",
-    "glob": "^11.0.0",
     "minimatch": "^10.0.3",
     "node-fetch": "^3.3.2",
-    "table": "^6.8.2",
-    "typescript": "^5.7.2"
+    "table": "^6.8.2"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    },
+    "@typescript-eslint/eslint-plugin": {
+      "optional": true
+    },
+    "@typescript-eslint/parser": {
+      "optional": true
+    },
+    "eslint-plugin-react": {
+      "optional": true
+    },
+    "eslint-plugin-react-hooks": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/node": "^22.10.1",
     "@typescript-eslint/eslint-plugin": "^8.38.0",
     "@typescript-eslint/parser": "^8.38.0",
     "eslint": "^9.31.0",
-    "jest": "^29.7.0"
+    "glob": "^11.0.3",
+    "jest": "^29.7.0",
+    "typescript": "^5.7.2"
   },
   "bugs": {
     "url": "https://github.com/sun-asterisk/engineer-excellence/issues"

package/integrations/eslint/test-c041-rule.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-
-const rule = require('./plugin/rules/common/c041-no-config-inline.js');
-
-// Simple test cases
-const testCases = [
-  // Should NOT flag (false positives to avoid)
-  { code: 'const inputType = "password";', shouldError: false, desc: 'InputType definition' },
-  { code: 'const fieldType = "password";', shouldError: false, desc: 'Field type' },
-  { code: 'const usePassword = "password_validation";', shouldError: false, desc: 'Hook usage' },
-  { code: 'const testPassword = "test123";', shouldError: false, desc: 'Test data' },
-  { code: 'const mockSecret = "mock_secret_key";', shouldError: false, desc: 'Mock data' },
-  { code: 'const route = "/reset_password";', shouldError: false, desc: 'Route path' },
-  
-  // SHOULD flag (real sensitive data)
-  { code: 'const dbPassword = "MySecretP@ssw0rd123";', shouldError: true, desc: 'Real hardcoded password' },
-  { code: 'const apiKey = "sk-1234567890abcdef1234567890abcdef";', shouldError: true, desc: 'Real API key' },
-  { code: 'const authToken = "bearer_token_12345678901234567";', shouldError: true, desc: 'Real auth token' }
-];
-
-console.log('🧪 Testing ESLint C041 rule manually...\n');
-
-let passed = 0;
-let failed = 0;
-
-// Mock context for testing
-function createMockContext(code) {
-  return {
-    getSourceCode: () => ({
-      lines: code.split('\n')
-    }),
-    report: ({ node, messageId }) => {
-      return { reported: true, messageId };
-    }
-  };
-}
-
-testCases.forEach((testCase, index) => {
-  try {
-    let reported = false;
-    
-    // Parse the code to extract literal nodes (simplified)
-    const literalMatch = testCase.code.match(/"([^"]+)"/);
-    if (literalMatch) {
-      const mockNode = {
-        value: literalMatch[1],
-        loc: { start: { line: 1 } }
-      };
-      
-      const mockContext = {
-        getSourceCode: () => ({
-          lines: [testCase.code]
-        }),
-        report: ({ node, messageId }) => {
-          reported = true;
-        }
-      };
-      
-      const ruleImplementation = rule.create(mockContext);
-      ruleImplementation.Literal(mockNode);
-    }
-    
-    const testPassed = reported === testCase.shouldError;
-    
-    if (testPassed) {
-      console.log(`✅ Test ${index + 1}: ${testCase.desc}`);
-      passed++;
-    } else {
-      console.log(`❌ Test ${index + 1}: ${testCase.desc}`);
-      console.log(`   Expected: ${testCase.shouldError ? 'Should flag' : 'Should NOT flag'}`);
-      console.log(`   Actual: ${reported ? 'Flagged' : 'Not flagged'}`);
-      failed++;
-    }
-  } catch (error) {
-    console.log(`💥 Test ${index + 1}: ${testCase.desc} - Error: ${error.message}`);
-    failed++;
-  }
-});
-
-console.log(`\n📊 Test Results: ${passed} passed, ${failed} failed`);
-console.log(`Success rate: ${Math.round((passed / (passed + failed)) * 100)}%`);
-
-if (failed === 0) {
-  console.log('\n🎉 All ESLint rule tests passed!');
-} else {
-  console.log('\n⚠️  Some tests failed. Review the rule logic.');
-}