@sun-asterisk/sunlint 1.0.6 → 1.0.7

package/cli-legacy.js

@@ -1,355 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * LEGACY CLI - DO NOT USE
- * This is the old monolithic CLI implementation kept for reference only.
- * Use cli.js instead - it has the new modular architecture with ESLint integration.
- */
-
-const { Command } = require('commander');
-const chalk = require('chalk');
-const path = require('path');
-const fs = require('fs');
-const MultiRuleRunner = require('./core/multi-rule-runner');
-const ConfigManager = require('./core/config-manager');
-const ReportGenerator = require('./core/report-generator');
-const { version } = require('./package.json');
-
-const program = new Command();
-
-program
-  .name('sunlint')
-  .description('☀️ Sun Lint - Coding Standards Checker | Multi-rule Quality & Security Analysis')
-  .version(version);
-
-// Rule selection
-program
-  .option('-r, --rule <rule>', 'Run single rule (e.g., C019)')
-  .option('-R, --rules <rules>', 'Run multiple rules (e.g., C019,C006,C021)')
-  .option('-a, --all', 'Run all available rules')
-  .option('-c, --category <category>', 'Run rules by category (quality,security,logging,naming)')
-  .option('--quality', 'Run all code quality rules')
-  .option('--security', 'Run all secure coding rules')
-  .option('--preset <preset>', 'Use predefined rule preset (recommended,strict,beginner)')
-  
-  // Input/Output
-  .option('-i, --input <path>', 'Input file or directory to analyze', 'src')
-  .option('-f, --format <format>', 'Output format (eslint,json,summary,table)', 'eslint')
-  .option('-o, --output <file>', 'Output file path')
-  .option('--config <file>', 'Configuration file path', '.sunlint.json')
-  
-  // CI/CD and Git integration
-  .option('--changed-files', 'Only analyze files changed in current branch (git diff)')
-  .option('--staged-files', 'Only analyze staged files (git diff --cached)')
-  .option('--diff-base <ref>', 'Compare against specific git reference (e.g., origin/main)')
-  .option('--since <commit>', 'Only analyze files changed since specific commit')
-  .option('--pr-mode', 'Enable PR mode (changed files + baseline comparison)')
-  .option('--baseline <file>', 'Load baseline results to compare against')
-  .option('--save-baseline <file>', 'Save current results as baseline')
-  .option('--fail-on-new-violations', 'Exit with error only on new violations (not existing)')
-  
-  // Rule control
-  .option('--exclude-rules <rules>', 'Exclude specific rules (e.g., C019,C006)')
-  .option('--include-rules <rules>', 'Include only specific rules (e.g., C019,C006)')  
-  .option('--disable-rule <rule>', 'Disable specific rule')
-  .option('--enable-rule <rule>', 'Enable specific rule')
-  .option('--severity <level>', 'Minimum severity level (error,warning,info)', 'info')
-  .option('--languages <langs>', 'Target languages (typescript,dart,kotlin)')
-  
-  // Advanced options
-  .option('--ai', 'Enable AI-powered analysis')
-  .option('--no-ai', 'Force disable AI analysis (use heuristic only)')
-  .option('--no-cache', 'Disable result caching')
-  .option('--max-concurrent <n>', 'Maximum concurrent rule execution', '5')
-  .option('--timeout <ms>', 'Timeout for rule execution (ms)', '30000')
-  .option('--fix', 'Auto-fix issues when possible')
-  .option('--dry-run', 'Show what would be analyzed without running')
-  .option('--verbose', 'Enable verbose logging')
-  .option('--quiet', 'Suppress non-error output')
-  .option('--debug', 'Enable debug mode');
-
-program.action(async (options) => {
-  try {
-    // Sun Lint banner
-    console.log(chalk.yellow.bold('☀️  Sun Lint - Coding Standards Checker'));
-    console.log(chalk.gray(`Version: ${version} | Sun* Engineering`));
-    
-    if (options.debug) {
-      console.log(chalk.yellow('Debug mode enabled'));
-      console.log('Options:', options);
-    }
-
-    // Handle quality/security shortcuts
-    if (options.quality) {
-      options.category = 'quality';
-    }
-    if (options.security) {
-      options.category = 'security';
-    }
-
-    // Load configuration
-    const configManager = new ConfigManager();
-    const config = await configManager.loadConfig(options.config, options);
-    
-    if (options.verbose) {
-      console.log(chalk.gray('Configuration loaded:'), config);
-    }
-
-    // Validate input
-    if (!fs.existsSync(options.input)) {
-      console.error(chalk.red(`❌ Input path not found: ${options.input}`));
-      process.exit(1);
-    }
-
-    // Show dry run info
-    if (options.dryRun) {
-      console.log(chalk.yellow('🔍 Dry run mode - Analysis preview:'));
-      await showDryRunPreview(config, options);
-      return;
-    }
-
-    // Initialize multi-rule runner
-    const runner = new MultiRuleRunner(config, options);
-    
-    // Get rules to run
-    const rulesToRun = await getRulesToRun(config, options);
-    
-    if (rulesToRun.length === 0) {
-      console.log(chalk.yellow('⚠️  No rules to run'));
-      return;
-    }
-
-    if (!options.quiet) {
-      const rulesByCategory = categorizeRules(rulesToRun);
-      console.log(chalk.green(`🚀 Running ${rulesToRun.length} rules on: ${options.input}`));
-      
-      if (rulesByCategory.quality.length > 0) {
-        console.log(chalk.blue(`  📋 Quality rules: ${rulesByCategory.quality.map(r => r.id).join(', ')}`));
-      }
-      if (rulesByCategory.security.length > 0) {
-        console.log(chalk.red(`  🔒 Security rules: ${rulesByCategory.security.map(r => r.id).join(', ')}`));
-      }
-      if (rulesByCategory.other.length > 0) {
-        console.log(chalk.gray(`  ⚙️  Other rules: ${rulesByCategory.other.map(r => r.id).join(', ')}`));
-      }
-    }
-
-    // Run analysis
-    const startTime = Date.now();
-    const results = await runner.runRules(rulesToRun, options.input, options);
-    const duration = Date.now() - startTime;
-
-    // Generate report
-    const reportGenerator = new ReportGenerator(config, options);
-    const report = await reportGenerator.generateReport(results, {
-      duration,
-      rulesRun: rulesToRun.length,
-      filesAnalyzed: results.filesAnalyzed || 0
-    });
-
-    // Output results
-    await outputResults(report, options);
-
-    // Exit with appropriate code
-    const allResults = results.results || [];
-    const hasErrors = allResults.some(r => 
-      r.violations && r.violations.some(v => v.severity === 'error')
-    );
-    process.exit(hasErrors ? 1 : 0);
-
-  } catch (error) {
-    console.error(chalk.red('❌ Sun Lint Error:'), error.message);
-    if (options.debug) {
-      console.error(error.stack);
-    }
-    process.exit(1);
-  }
-});
-
-async function getRulesToRun(config, options) {
-  const allRules = config.rules || {};
-  const rulesRegistry = require('./config/rules-registry.json');
-  
-  let selectedRules = [];
-
-  if (options.rule) {
-    // Single rule
-    selectedRules = [options.rule];
-  } else if (options.rules) {
-    // Multiple rules
-    selectedRules = options.rules.split(',').map(r => r.trim());
-  } else if (options.all) {
-    // All rules
-    selectedRules = Object.keys(rulesRegistry.rules);
-  } else if (options.category) {
-    // Rules by category
-    const category = rulesRegistry.categories[options.category];
-    if (category && category.rules) {
-      selectedRules = category.rules;
-    }
-  } else if (options.preset) {
-    // Load preset using ConfigManager
-    try {
-      const ConfigManager = require('./core/config-manager');
-      const configManager = new ConfigManager();
-      
-      const presetName = options.preset.startsWith('@sun/sunlint/') 
-        ? options.preset 
-        : `@sun/sunlint/${options.preset}`;
-      const presetConfig = await configManager.loadPreset(presetName);
-      if (presetConfig && presetConfig.rules) {
-        selectedRules = Object.keys(presetConfig.rules).filter(ruleId => 
-          presetConfig.rules[ruleId] !== 'off' && presetConfig.rules[ruleId] !== false
-        );
-        console.log(chalk.blue(`🎯 Using preset: ${presetName}`));
-      }
-    } catch (error) {
-      console.error(chalk.red(`❌ Failed to load preset '${options.preset}':`), error.message);
-      process.exit(1);
-    }
-  } else {
-    // Default: use config rules
-    selectedRules = Object.keys(allRules).filter(ruleId => 
-      allRules[ruleId] !== 'off' && allRules[ruleId] !== false
-    );
-  }
-
-  // Filter out excluded rules
-  if (options.excludeRules) {
-    const excludedRules = options.excludeRules.split(',').map(r => r.trim());
-    selectedRules = selectedRules.filter(rule => !excludedRules.includes(rule));
-  }
-
-  // Filter by severity
-  if (options.severity) {
-    const minSeverity = options.severity;
-    const severityLevels = { info: 0, warning: 1, error: 2 };
-    const minLevel = severityLevels[minSeverity] || 0;
-    
-    selectedRules = selectedRules.filter(ruleId => {
-      const rule = rulesRegistry.rules[ruleId];
-      if (!rule) return false;
-      const ruleLevel = severityLevels[rule.severity] || 0;
-      return ruleLevel >= minLevel;
-    });
-  }
-
-  // Filter by languages
-  if (options.languages) {
-    const targetLanguages = options.languages.split(',').map(l => l.trim());
-    selectedRules = selectedRules.filter(ruleId => {
-      const rule = rulesRegistry.rules[ruleId];
-      if (!rule) return false;
-      return rule.languages.some(lang => targetLanguages.includes(lang));
-    });
-  }
-
-  // Convert to rule objects
-  return selectedRules.map(ruleId => ({
-    id: ruleId,
-    ...rulesRegistry.rules[ruleId]
-  })).filter(rule => rule.name); // Filter out invalid rules
-}
-
-function categorizeRules(rules) {
-  const categories = {
-    quality: [],
-    security: [],
-    other: []
-  };
-
-  rules.forEach(rule => {
-    if (rule.category === 'security' || rule.id.startsWith('S')) {
-      categories.security.push(rule);
-    } else if (['logging', 'naming', 'validation', 'design'].includes(rule.category)) {
-      categories.quality.push(rule);
-    } else {
-      categories.other.push(rule);
-    }
-  });
-
-  return categories;
-}
-
-async function showDryRunPreview(config, options) {
-  const rulesToRun = await getRulesToRun(config, options);
-  const rulesByCategory = categorizeRules(rulesToRun);
-  
-  console.log(chalk.blue('📋 Sun Lint Analysis Preview:'));
-  console.log(chalk.gray(`Input: ${options.input}`));
-  console.log(chalk.gray(`Format: ${options.format}`));
-  console.log(chalk.gray(`Rules to run: ${rulesToRun.length}`));
-  
-  if (rulesByCategory.quality.length > 0) {
-    console.log(chalk.blue('📋 Quality Rules:'));
-    rulesByCategory.quality.forEach(rule => {
-      console.log(`  ${chalk.cyan(rule.id)}: ${rule.name} (${rule.severity})`);
-    });
-  }
-  
-  if (rulesByCategory.security.length > 0) {
-    console.log(chalk.red('🔒 Security Rules:'));
-    rulesByCategory.security.forEach(rule => {
-      console.log(`  ${chalk.cyan(rule.id)}: ${rule.name} (${rule.severity})`);
-    });
-  }
-  
-  if (rulesByCategory.other.length > 0) {
-    console.log(chalk.white('⚙️  Other Rules:'));
-    rulesByCategory.other.forEach(rule => {
-      console.log(`  ${chalk.cyan(rule.id)}: ${rule.name} (${rule.severity})`);
-    });
-  }
-}
-
-async function outputResults(report, options) {
-  // Console output
-  if (!options.quiet) {
-    console.log(report.formatted);
-  }
-
-  // File output
-  if (options.output) {
-    fs.writeFileSync(options.output, JSON.stringify(report.raw, null, 2));
-    console.log(chalk.green(`📄 Report saved to: ${options.output}`));
-  }
-
-  // Summary
-  if (report.summary && !options.quiet) {
-    console.log(chalk.blue('\n📊 Sun Lint Summary:'));
-    console.log(report.summary);
-  }
-}
-
-// Error handling
-process.on('unhandledRejection', (reason, promise) => {
-  console.error(chalk.red('Sun Lint - Unhandled Rejection:'), promise, chalk.red('reason:'), reason);
-  process.exit(1);
-});
-
-process.on('uncaughtException', (error) => {
-  console.error(chalk.red('Sun Lint - Uncaught Exception:'), error);
-  process.exit(1);
-});
-
-// Help examples
-program.addHelpText('after', `
-Examples:
-  $ sunlint --rule=C019 --input=src
-  $ sunlint --rules=C019,C006 --input=src --format=json
-  $ sunlint --all --input=src --format=summary
-  $ sunlint --quality --input=src
-  $ sunlint --security --input=src  
-  $ sunlint --category=logging --input=src
-  $ sunlint --preset=recommended --input=src
-  $ sunlint --config=.sunlint.json --input=src
-  $ sunlint --rule=C019 --input=src --output=report.json
-  $ sunlint --all --input=src --exclude-rules=C006,C031
-  $ sunlint --rule=C019 --input=src --ai
-  $ sunlint --rule=C019 --input=src --no-ai
-  $ sunlint --all --input=src --severity=error --ai
-
-Sun* Engineering - Coding Standards Made Simple ☀️
-`);
-
-program.parse();

package/docs/AI.md

@@ -1,163 +0,0 @@
-# 🤖 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

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