@sun-asterisk/sunlint 1.1.3 → 1.1.5

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,19 +745,21 @@
     }
   },
   "metadata": {
-    "version": "1.0.4",
-    "lastUpdated": "2025-07-08",
+    "version": "1.1.5",
+    "lastUpdated": "2025-07-24",
     "totalRules": 44,
-    "qualityRules": 4,
-    "securityRules": 40,
+    "qualityRules": 33,
+    "securityRules": 47,
     "stableRules": 43,
     "experimentalRules": 1,
     "supportedLanguages": 4,
     "features": [
       "Security rules integration",
-      "Category-based rule filtering",
+      "Category-based rule filtering", 
       "Dynamic rule configuration",
-      "ESLint integration enhancement"
+      "ESLint 9.x integration",
+      "React rules integration",
+      "Memory leak fixes"
     ]
   }
 }

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();