@sun-asterisk/sunlint 1.0.5

package/core/typescript-engine.js

@@ -0,0 +1,313 @@
+/**
+ * TypeScript Engine - Main coordinator for TypeScript analysis
+ * Rule C005: Single responsibility - orchestrates TypeScript analysis
+ * Rule C012: Command Query Separation - separate analysis and result processing
+ * Rule C014: Dependency Injection - inject required services
+ * Rule C015: Domain language - TypeScriptEngine
+ */
+
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+
+// Rule C014: Dependency injection
+const EslintInstanceManager = require('./eslint-instance-manager');
+const DependencyManager = require('./dependency-manager');
+const TypescriptAnalyzer = require('./typescript-analyzer');
+const RuleMappingService = require('./rule-mapping-service');
+
+class TypeScriptEngine {
+  constructor(eslintModulePath = null) {
+    // Rule C014: Dependency injection instead of direct instantiation
+    this.eslintInstanceManager = new EslintInstanceManager();
+    this.dependencyManager = new DependencyManager();
+    this.typescriptAnalyzer = new TypescriptAnalyzer(this.eslintInstanceManager);
+    this.ruleMappingService = new RuleMappingService();
+    
+    this.eslintModulePath = eslintModulePath;
+    this.isInitialized = false;
+  }
+
+  /**
+   * Rule C006: initializeEngine - verb-noun naming
+   * Rule C032: No external API calls in constructor - initialization method
+   */
+  async initializeEngine() {
+    if (this.isInitialized) {
+      return;
+    }
+
+    // Check dependencies first
+    const dependenciesAvailable = await this.dependencyManager.checkDependenciesAvailable();
+    if (!dependenciesAvailable.allAvailable) {
+      console.log(chalk.yellow('⚠️  Missing TypeScript dependencies. Attempting to install...'));
+      const installed = await this.dependencyManager.installMissingDependencies();
+      if (!installed) {
+        throw new Error('Required TypeScript dependencies are not available');
+      }
+    }
+
+    // Initialize ESLint instance
+    await this.eslintInstanceManager.initializeEslintInstance(this.eslintModulePath);
+    
+    this.isInitialized = true;
+    console.log(chalk.green('✅ TypeScript engine initialized successfully'));
+  }
+
+  /**
+   * Rule C006: runAnalysis - verb-noun naming
+   * Rule C005: Single responsibility - coordinates analysis
+   * Rule C012: Command method - performs analysis operation
+   */
+  async runAnalysis(filePaths, options = {}) {
+    if (!this.isInitialized) {
+      await this.initializeEngine();
+    }
+
+    // Validate input
+    if (!filePaths || filePaths.length === 0) {
+      throw new Error('No files provided for analysis');
+    }
+
+    const filePathsArray = Array.isArray(filePaths) ? filePaths : [filePaths];
+    
+    if (options.verbose) {
+      console.log(chalk.blue(`🔄 Running TypeScript analysis on ${filePathsArray.length} files...`));
+    }
+
+    try {
+      const results = await this.typescriptAnalyzer.analyzeTypeScriptFiles(filePathsArray, options);
+      
+      if (options.verbose) {
+        this.logAnalysisResults(results);
+      }
+
+      return results;
+    } catch (error) {
+      // Rule C035: Log full error information
+      console.error(chalk.red('❌ TypeScript analysis failed:'), {
+        message: error.message,
+        files: filePathsArray.length,
+        configPath: this.eslintInstanceManager.getConfigPath()
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Rule C006: configureRules - verb-noun naming  
+   * Rule C005: Single responsibility - rule configuration
+   */
+  async configureRules(selectedRules = [], options = {}) {
+    if (!this.isInitialized) {
+      await this.initializeEngine();
+    }
+
+    try {
+      const configPath = this.eslintInstanceManager.getConfigPath();
+      const configFilePath = path.join(configPath, 'eslint.config.js');
+      
+      if (options.verbose) {
+        console.log(chalk.blue(`   Config path: ${configFilePath}`));
+      }
+      
+      // Clear require cache to ensure fresh config
+      delete require.cache[require.resolve(configFilePath)];
+      
+      // Read current config
+      const currentConfig = require(configFilePath);
+      
+      // Convert SunLint rule IDs to ESLint rule names
+      const eslintRuleNames = selectedRules.map(sunlintRuleId => {
+        const eslintRule = this.ruleMappingService.sunlintToEslintMapping[sunlintRuleId];
+        return eslintRule || sunlintRuleId;
+      }).filter(rule => rule);
+      
+      // Update rules based on selection
+      const updatedConfig = this.updateRulesConfiguration(currentConfig, eslintRuleNames, options);
+      
+      if (options.verbose) {
+        console.log(chalk.blue(`🔧 Configured ${selectedRules.length} rules for analysis`));
+        console.log(chalk.gray(`   SunLint rules: ${selectedRules.join(', ')}`));
+        console.log(chalk.gray(`   ESLint rules: ${eslintRuleNames.join(', ')}`));
+      }
+
+      return updatedConfig;
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to configure rules:'), error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Rule C006: updateRulesConfiguration - verb-noun naming
+   * Rule C005: Single responsibility - update config
+   * Rule C012: Pure function - no side effects
+   */
+  updateRulesConfiguration(currentConfig, selectedRules, options) {
+    if (!Array.isArray(currentConfig)) {
+      throw new Error('Expected flat config array format');
+    }
+
+    // Create new config with selected rules
+    const updatedConfig = currentConfig.map(config => {
+      if (config.rules) {
+        if (options.verbose) {
+          const ruleKeys = Object.keys(config.rules);
+          console.log(chalk.blue(`   Config has ${ruleKeys.length} rules`));
+          const s003Rules = ruleKeys.filter(r => r.includes('s003'));
+          console.log(chalk.blue(`   S003-related rules: ${s003Rules.join(', ') || 'none'}`));
+        }
+        
+        // Keep all existing rules and enable selected ones
+        const updatedRules = { ...config.rules };
+        
+        // Enable only selected rules
+        for (const ruleId of selectedRules) {
+          if (options.verbose) {
+            console.log(chalk.blue(`   Checking rule: ${ruleId}`));
+            console.log(chalk.blue(`   Available in config: ${ruleId in config.rules}`));
+          }
+          
+          if (config.rules[ruleId] !== undefined) {
+            updatedRules[ruleId] = 'error'; // Enable the rule as error
+            if (options.verbose) {
+              console.log(chalk.gray(`   Enabling rule: ${ruleId} as error`));
+            }
+          } else {
+            if (options.verbose) {
+              console.log(chalk.red(`   Rule not found in config: ${ruleId}`));
+            }
+          }
+        }
+
+        return {
+          ...config,
+          rules: updatedRules
+        };
+      }
+      return config;
+    });
+
+    return updatedConfig;
+  }
+
+  /**
+   * Rule C006: logAnalysisResults - verb-noun naming
+   * Rule C005: Single responsibility - logging
+   */
+  logAnalysisResults(results) {
+    const { totalFiles, totalErrors, totalWarnings } = results;
+    
+    console.log(chalk.blue('📊 TypeScript Analysis Results:'));
+    console.log(chalk.gray(`   Files analyzed: ${totalFiles}`));
+    console.log(chalk.gray(`   Errors found: ${totalErrors}`));
+    console.log(chalk.gray(`   Warnings found: ${totalWarnings}`));
+    
+    if (totalErrors === 0 && totalWarnings === 0) {
+      console.log(chalk.green('   ✅ All checks passed!'));
+    }
+  }
+
+  /**
+   * Rule C006: getEngineStatus - verb-noun naming
+   * Rule C012: Query method - returns status without side effects
+   */
+  getEngineStatus() {
+    return {
+      initialized: this.isInitialized,
+      configPath: this.eslintInstanceManager.getConfigPath(),
+      eslintReady: this.eslintInstanceManager.checkInstanceReady()
+    };
+  }
+
+  /**
+   * Rule C006: checkDependencies - verb-noun naming
+   * Rule C014: Delegate to dependency manager
+   */
+  async checkDependencies() {
+    return this.dependencyManager.checkDependenciesAvailable();
+  }
+
+  /**
+   * Rule C006: installDependencies - verb-noun naming
+   * Rule C014: Delegate to dependency manager
+   */
+  async installDependencies() {
+    return this.dependencyManager.installMissingDependencies();
+  }
+
+  /**
+   * Rule C006: convertToSunLintFormat - verb-noun naming
+   * Rule C012: Pure function - converts ESLint results to SunLint format
+   */
+  convertToSunLintFormat(eslintResults, ruleMapping = {}, options = {}) {
+    const chalk = require('chalk');
+    // Handle both direct results and wrapped results
+    const resultsArray = eslintResults.results || [eslintResults];
+    const problems = [];
+    const convertedResults = [];
+    
+    for (const result of resultsArray) {
+      // Skip if no messages
+      if (!result || !result.messages) continue;
+      
+      const violations = [];
+      
+      for (const message of result.messages) {
+        // Map ESLint rule ID to SunLint rule ID if mapping provided
+        const sunlintRuleId = ruleMapping[message.ruleId] || message.ruleId;
+        
+        // Debug logging
+        if (options && options.verbose) {
+          console.log(chalk.gray(`   ESLint message: ${message.ruleId} -> ${sunlintRuleId} (${message.message})`));
+        }
+        
+        // Ensure we have a valid file path
+        const filePath = result.filePath || result.file || 'unknown';
+        
+        const violation = {
+          ruleId: sunlintRuleId,
+          severity: message.severity === 2 ? 'error' : 'warning',
+          message: message.message,
+          file: filePath,
+          line: message.line,
+          column: message.column,
+          endLine: message.endLine,
+          endColumn: message.endColumn
+        };
+        
+        violations.push(violation);
+        problems.push(violation);
+      }
+      
+      if (violations.length > 0) {
+        convertedResults.push({
+          filePath: result.filePath || result.file || 'unknown',
+          violations: violations
+        });
+      }
+    }
+
+    return {
+      problems,
+      results: convertedResults,
+      errorCount: problems.filter(p => p.severity === 'error').length,
+      warningCount: problems.filter(p => p.severity === 'warning').length,
+      fileCount: eslintResults.totalFiles || resultsArray.length,
+      totalViolations: problems.length
+    };
+  }
+
+  // Legacy method names for backward compatibility
+  async initializeEslint() {
+    return this.initializeEngine();
+  }
+
+  // Rule C006: getEslintInstance - kept for backward compatibility
+  getEslintInstance() {
+    return this.eslintInstanceManager.getEslintInstance();
+  }
+}
+
+module.exports = TypeScriptEngine;

package/docs/AI.md

@@ -0,0 +1,163 @@
+# 🤖 AI-Powered Analysis
+
+Sunlint supports AI-powered code analysis alongside traditional pattern-based analysis for more intelligent and context-aware rule checking.
+
+## Overview
+
+- **🎯 Smart Analysis**: Uses AI to understand code context and intent
+- **🔄 Fallback Strategy**: Automatically falls back to pattern analysis if AI fails
+- **⚡ Performance**: AI analysis runs per-file with caching support
+- **🔧 Configurable**: Multiple AI providers and models supported
+
+## Configuration
+
+### In `.sunlint.json`:
+
+```json
+{
+  "ai": {
+    "enabled": true,
+    "provider": "openai",
+    "model": "gpt-4o-mini",
+    "apiKey": "${OPENAI_API_KEY}",
+    "fallbackToPattern": true
+  }
+}
+```
+
+### Environment Variables:
+
+```bash
+export OPENAI_API_KEY="your-openai-api-key"
+```
+
+## Supported Providers
+
+### OpenAI
+- **Models**: `gpt-4`, `gpt-4o-mini`, `gpt-3.5-turbo`
+- **API Key**: Required via `OPENAI_API_KEY` environment variable
+- **Cost**: Pay-per-use based on OpenAI pricing
+
+### GitHub Copilot (Planned)
+- **Integration**: VS Code extension integration
+- **Models**: GitHub Copilot models
+- **Authentication**: VS Code Copilot session
+
+## AI-Enhanced Rules
+
+### C019 - Log Level Usage
+✅ **AI-Enabled**: Understands code context to determine appropriate log levels
+
+**AI Analysis Features:**
+- **Context Understanding**: Analyzes surrounding code to determine error criticality
+- **Intent Recognition**: Understands whether errors are expected or exceptional
+- **Semantic Analysis**: Goes beyond pattern matching to understand meaning
+
+**Example:**
+```typescript
+// AI understands this is a validation error, suggests warn level
+if (!user.email) {
+  console.error('Missing email'); // AI: Should use console.warn()
+}
+
+// AI understands this is a critical system error, keeps error level
+try {
+  await database.connect();
+} catch (error) {
+  console.error('Database connection failed:', error); // AI: Appropriate error level
+}
+```
+
+## Usage
+
+### CLI Commands
+
+**Enable AI for specific rule:**
+```bash
+sunlint --rule=C019 --input=src --ai
+```
+
+**Enable AI for all rules:**
+```bash
+sunlint --quality --input=src --ai
+```
+
+**Debug AI analysis:**
+```bash
+sunlint --rule=C019 --input=src --ai --verbose
+```
+
+### VS Code Integration
+
+1. **Debug Configuration**: Use "Debug Sunlint - AI Analysis"
+2. **Task**: Run "Sunlint: AI Analysis Test"
+3. **Set API Key**: Configure `OPENAI_API_KEY` in environment
+
+## Output Differences
+
+### Pattern Analysis Output:
+```
+WARNING: Error log level used for non-critical issue - should use warn/info level
+  at src/user.ts:15:5 (C019)
+```
+
+### AI Analysis Output:
+```
+WARNING: Email validation error should use console.warn() - this is user input validation, not a system error
+  at src/user.ts:15:5 (C019)
+  Suggestion: Change to console.warn('User email validation failed:', email)
+```
+
+## Performance Considerations
+
+- **Caching**: AI responses are cached per file content hash
+- **Concurrency**: AI calls are made concurrently with rate limiting
+- **Timeout**: 30-second timeout per AI request
+- **Cost**: Monitor API usage in OpenAI dashboard
+
+## Troubleshooting
+
+### Common Issues
+
+**API Key Not Found:**
+```bash
+⚠️  AI API key not found, falling back to pattern analysis
+```
+Solution: Set `OPENAI_API_KEY` environment variable
+
+**API Rate Limit:**
+```bash
+AI Analysis failed: OpenAI API error: 429 Too Many Requests
+```
+Solution: Reduce `maxConcurrentRules` in config or wait
+
+**Network Issues:**
+```bash
+AI Analysis failed: OpenAI API error: Network timeout
+```
+Solution: Check internet connection, increase `timeoutMs`
+
+### Debug AI Issues
+
+1. **Enable verbose mode**: `--verbose`
+2. **Check API key**: `echo $OPENAI_API_KEY`
+3. **Test connection**: Use debug configuration
+4. **Check API quota**: Visit OpenAI dashboard
+
+## Future Enhancements
+
+- **🔄 GitHub Copilot Integration**: Direct integration with VS Code Copilot
+- **📊 Custom Models**: Support for fine-tuned models
+- **🎯 Rule-Specific Prompts**: Specialized prompts per rule type
+- **💾 Smart Caching**: Semantic caching across similar code patterns
+- **📈 Analytics**: AI vs Pattern analysis effectiveness metrics
+
+## Cost Estimation
+
+**OpenAI API Costs** (approximate):
+- **gpt-4o-mini**: ~$0.001 per 1K tokens
+- **gpt-4**: ~$0.03 per 1K tokens
+- **Average file**: ~500 tokens
+- **1000 files with gpt-4o-mini**: ~$0.50
+
+**Recommendation**: Start with `gpt-4o-mini` for cost-effectiveness.

package/docs/ARCHITECTURE.md

@@ -0,0 +1,78 @@
+# SunLint Modular Architecture
+
+## Phase 1: TypeScript Focus với Kiến trúc Modular
+
+### Cấu trúc mới:
+
+```
+cli.js                    # CLI entry point (simplified)
+core/
+├── cli-program.js        # CLI options definition (Rule C005)
+├── cli-action-handler.js # Main execution flow (Rule C005)
+├── rule-selection-service.js # Rule selection logic (Rule C005)
+├── analysis-orchestrator.js  # Analysis coordination (Rule C005)
+├── output-service.js     # Output formatting (Rule C005)
+├── eslint-engine-service.js   # ESLint integration (future)
+└── sunlint-engine-service.js  # Native SunLint engine
+```
+
+### Nguyên tắc thiết kế:
+
+1. **Rule C005**: Mỗi class/file chỉ làm một việc
+2. **Rule C014**: Dependency injection thay vì new trực tiếp
+3. **Rule C012**: Tách rõ Command và Query
+4. **Modular**: Dễ mở rộng cho Phase 2
+
+### Luồng hoạt động:
+
+1. `cli.js` → `CliActionHandler`
+2. `CliActionHandler` → Load config, validate input
+3. `RuleSelectionService` → Select rules based on options
+4. `AnalysisOrchestrator` → Run analysis (SunLint or ESLint)
+5. `OutputService` → Format and display results
+
+### Các tính năng hiện tại:
+
+- ✅ Modular CLI với dependency injection
+- ✅ Rule selection (single, multiple, all, category)
+- ✅ Dry run mode
+- ✅ TypeScript-specific options (chuẩn bị cho Phase 1)
+- ✅ Graceful fallback khi không tìm thấy dependencies
+- ✅ Clean error handling và logging
+
+### Phase 1 roadmap:
+
+1. **✅ Done**: Modular CLI architecture
+2. **✅ Done**: ESLint integration cho TypeScript
+3. **Next**: TypeScript custom rules thông qua ESLint
+4. **✅ Done**: Hybrid engine (ESLint + SunLint)
+
+### Phase 2 roadmap:
+
+1. Native SunLint engine cho tất cả ngôn ngữ
+2. Mở rộng Dart, Kotlin rules
+3. AI-powered analysis
+4. VS Code extension integration
+
+### Usage Examples:
+
+```bash
+# Basic usage
+sunlint --rule=C006 --input=src
+
+# Category-based
+sunlint --quality --input=src
+
+# TypeScript-specific (Phase 1)
+sunlint --typescript --input=src
+sunlint --typescript-engine=eslint --input=src
+
+# Dry run
+sunlint --dry-run --all --input=src
+```
+
+### Dependencies:
+
+- Minimal core dependencies
+- ESLint integration sẽ được thêm trong Phase 1
+- Graceful fallback khi dependencies không có sẵn