@sun-asterisk/sunlint 1.0.6 → 1.1.3

package/core/typescript-engine.js

@@ -1,313 +0,0 @@
-/**
- * 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/RULE-RESPONSIBILITY-MATRIX.md

@@ -1,204 +0,0 @@
-# Rule Responsibility Matrix
-
-## Overview
-This document defines clear responsibilities between ESLint and SunLint to avoid duplication and maximize efficiency.
-
-## Current Rule Distribution
-
-### ESLint Custom Rules (29 rules)
-**Primary Responsibilities:**
-- ✅ Syntactic/structural checks
-- ✅ IDE integration & fast feedback
-- ✅ Standard coding conventions
-- ✅ TypeScript-specific features
-
-| Rule ID | Name | Type | Rationale |
-|---------|------|------|-----------|
-| C002 | no-duplicate-code | Structural | AST-based duplicate detection |
-| C003 | no-vague-abbreviations | Naming | Simple naming convention |
-| C006 | function-name-verb-noun | Naming | **ACTIVE** - Simple naming check |
-| C008 | declare-variables-near-usage | Structural | Scope analysis |
-| C010 | limit-block-nesting | Structural | Nesting depth check |
-| C013 | no-dead-code | Structural | Dead code detection |
-| C014 | abstract-dependency-preferred | Structural | DI pattern detection |
-| C017 | limit-constructor-logic | Structural | Constructor complexity |
-| C018 | no-generic-throw | Structural | Error handling pattern |
-| C023 | no-duplicate-variable-name | Structural | Variable naming |
-| C024 | no-hardcode-constants | Structural | Constant extraction |
-| C027 | limit-function-nesting | Structural | Function nesting |
-| C028 | no-silent-catch | Structural | **DEPRECATED** - Use SunLint C029 |
-| C030 | use-custom-error-classes | Structural | Error class pattern |
-| C034 | no-implicit-return | Structural | Return statement check |
-| C035 | no-empty-catch | Structural | Empty catch detection |
-| C037 | error-handler-log-input | Structural | Error logging pattern |
-| C041 | no-config-inline | Structural | Configuration separation |
-| C042 | boolean-name-prefix | Naming | Boolean naming convention |
-| C043 | no-console-or-print | Structural | Console usage detection |
-| C047 | no-duplicate-retry-logic | Structural | Retry pattern detection |
-| C048 | no-var-declaration | Structural | Variable declaration |
-| C076 | one-assert-per-test | Test | Test assertion pattern |
-| T002 | interface-prefix-i | TypeScript | Interface naming |
-| T003 | ts-ignore-reason | TypeScript | TypeScript ignore usage |
-| T004 | interface-public-only | TypeScript | Interface structure |
-| T007 | no-fn-in-constructor | TypeScript | Constructor pattern |
-| T011 | no-real-time-dependency | Test | Test isolation |
-| T019 | no-empty-type | TypeScript | Type definition |
-| T025 | no-nested-union-tuple | TypeScript | Type complexity |
-| T026 | limit-nested-generics | TypeScript | Generic complexity |
-
-### SunLint Rules (4 rules)
-**Primary Responsibilities:**
-- ✅ Complex semantic analysis
-- ✅ Cross-file/project analysis  
-- ✅ Performance-critical batch processing
-- ✅ Business rule logic
-
-| Rule ID | Name | Type | Rationale |
-|---------|------|------|-----------|
-| C006 | function_naming | Naming | **DISABLED** - Use ESLint version |
-| C019 | log_level_usage | Semantic | **ACTIVE** - Complex log context analysis |
-| C029 | catch_block_logging | Semantic | **ACTIVE** - Enhanced error context analysis |
-| C031 | validation_separation | Architectural | **ACTIVE** - Cross-function validation pattern |
-
-## Rule Overlap Resolution
-
-### ✅ Resolved Overlaps
-
-#### C006 - Function Naming
-- **Decision**: Use ESLint version
-- **Rationale**: Simple naming check, better IDE integration
-- **Action**: SunLint C006 disabled in config
-
-#### C028/C029 - Catch Block Logging  
-- **Decision**: Use SunLint C029
-- **Rationale**: More sophisticated error context analysis
-- **Action**: ESLint C028 should be deprecated in favor of SunLint C029
-
-### 🔄 Planned Enhancements
-
-#### C029 - Enhanced Catch Block Logging
-Current SunLint C029 should be enhanced to fully replace ESLint C028:
-
-**ESLint C028 capabilities:**
-- Detects silent catch blocks
-- Basic error logging requirements
-
-**SunLint C029 enhancements needed:**
-- All C028 functionality
-- Context-aware error logging
-- Stack trace preservation analysis
-- Error correlation tracking
-
-## Integration Strategy
-
-### Phase 1: Current State (Implemented)
-```json
-// .eslintrc.cjs - ESLint handles most rules
-{
-  "rules": {
-    "custom/c006": "warn",  // Active in ESLint
-    "custom/c029": "warn",  // Will be deprecated
-    // ... other ESLint rules
-  }
-}
-
-// .sunlint.json - SunLint handles specialized rules
-{
-  "rules": {
-    "C006": "off",      // Disabled - use ESLint
-    "C019": true,       // Active - unique to SunLint
-    "C029": "error",    // Active - enhanced version
-    "C031": true        // Active - unique to SunLint
-  }
-}
-```
-
-### Phase 2: ESLint Adapter (Planned)
-```json
-// .sunlint.json - Unified configuration
-{
-  "rules": {
-    "C019": true,
-    "C029": true, 
-    "C031": true,
-    // ESLint rules via adapter
-    "eslint:custom/c003": true,
-    "eslint:custom/c006": true,
-    "eslint:custom/c042": true
-  },
-  "eslintAdapter": {
-    "configPath": ".eslintrc.cjs",
-    "rules": ["custom/c003", "custom/c006", "custom/c042"]
-  }
-}
-```
-
-## Migration Guidelines
-
-### Rules to Keep in ESLint
-**Criteria:**
-- Simple syntactic checks
-- IDE integration critical
-- TypeScript-specific features
-- Standard conventions
-
-**Examples:**
-- C003 (Variable naming)
-- C042 (Boolean naming)  
-- T002 (Interface prefix)
-- T003 (TypeScript ignore)
-
-### Rules to Migrate to SunLint
-**Criteria:**
-- Complex semantic analysis
-- Cross-file analysis needed
-- Performance-critical
-- Business rule logic
-
-**Candidates:**
-- C014 (Dependency Injection) - Cross-file analysis
-- C034 (Data fetching separation) - Service layer analysis
-- C040 (File execution order) - Project-level analysis
-
-### Rules to Enhance in SunLint
-**Current:**
-- C029 (Catch block logging) - Enhance to replace C028
-- C031 (Validation separation) - Add cross-file validation
-
-## Testing Strategy
-
-### Rule Compatibility Testing
-1. **Overlap Testing**: Ensure no conflicting reports
-2. **Performance Testing**: Compare combined vs individual execution
-3. **Accuracy Testing**: Validate rule logic equivalence
-
-### Integration Testing
-1. **CI/CD Pipeline**: Test unified reporting
-2. **IDE Integration**: Verify ESLint feedback still works
-3. **Configuration**: Test rule enable/disable scenarios
-
-## Monitoring & Maintenance
-
-### Performance Metrics
-- Combined analysis time
-- Memory usage comparison
-- CI/CD pipeline impact
-
-### Quality Metrics
-- Rule coverage completeness
-- False positive rates
-- Developer satisfaction
-
-### Process Metrics
-- Configuration complexity
-- Maintenance overhead
-- Team adoption rate
-
-## Decision Log
-
-| Date | Decision | Rationale |
-|------|----------|-----------|
-| 2024-01-XX | Disable SunLint C006 | ESLint version sufficient, better IDE integration |
-| 2024-01-XX | Keep SunLint C019 | Unique semantic analysis capability |
-| 2024-01-XX | Enhance SunLint C029 | Replace ESLint C028 with better analysis |
-| 2024-01-XX | Keep SunLint C031 | Unique architectural analysis |

package/eslint-integration/cli.js

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SunLint CLI Entry Point
- * Main CLI entry point with modular architecture
- * Following Rule C005: Single responsibility - only handle CLI bootstrapping
- * Following Rule C014: Dependency injection for services
- */
-
-const chalk = require('chalk');
-const { createCliProgram } = require('./core/cli-program');
-const CliActionHandler = require('./core/cli-action-handler');
-
-// Create CLI program
-const program = createCliProgram();
-
-// Set up main action handler
-program.action(async (options) => {
-  const actionHandler = new CliActionHandler(options);
-  await actionHandler.execute();
-});
-
-// Global 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);
-});
-
-// Parse CLI arguments
-program.parse();

package/eslint-integration/eslint-plugin-custom/c013-no-dead-code.js

@@ -1,43 +0,0 @@
-/**
- * Custom ESLint rule for: C013 – Do not leave dead code commented out
- * Rule ID: custom/c013
- * Purpose: Prevent commented-out code from being left in the codebase to maintain cleanliness
- */
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Do not leave dead code commented out",
-      recommended: false
-    },
-    schema: [],
-    messages: {
-      deadCode: "Do not leave dead code commented out. Remove it or use version control to track changes."
-    }
-  },
-  create(context) {
-    return {
-      BlockStatement(node) {
-        let unreachable = false;
-        for (const stmt of node.body) {
-          if (unreachable) {
-            context.report({
-              node: stmt,
-              messageId: "deadCode"
-            });
-          }
-
-          if (
-            stmt.type === "ReturnStatement" ||
-            stmt.type === "ThrowStatement" ||
-            stmt.type === "ContinueStatement" ||
-            stmt.type === "BreakStatement"
-          ) {
-            unreachable = true;
-          }
-        }
-      }
-    };
-  }
-};

package/eslint-integration/eslint-plugin-custom/c017-limit-constructor-logic.js

@@ -1,39 +0,0 @@
-/**
- * Custom ESLint rule for: C017 – Limit constructor logic
- * Rule ID: custom/c017
- * Purpose: Enforce minimal logic in constructors to maintain clean initialization
- */
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Limit constructor logic",
-      recommended: false
-    },
-    schema: [],
-    messages: {
-      constructorLogic: "Constructor should only initialize properties, avoid complex logic"
-    }
-  },
-  create(context) {
-    return {
-      MethodDefinition(node) {
-        if (
-          node.kind === "constructor" &&
-          node.value &&
-          node.value.body &&
-          node.value.body.body.length > 5 // threshold for logic lines in constructor
-        ) {
-          context.report({
-            node,
-            messageId: "constructorLogic",
-            data: {
-              count: node.value.body.body.length
-            }
-          });
-        }
-      }
-    };
-  }
-};

package/eslint-integration/eslint-plugin-custom/c027-limit-function-nesting.js

@@ -1,50 +0,0 @@
-/**
- * Custom ESLint rule for: C027 – Avoid deeply nested functions (maximum 2 levels)
- * Rule ID: custom/c027
- * Goal: Limit function nesting to maximum 2 levels to improve readability and maintainability
- */
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Avoid deeply nested functions (maximum 2 levels)",
-      recommended: false
-    },
-    schema: [],
-    messages: {
-      tooDeep: "Function is nested too deeply (level {{depth}}). Should be maximum 2 levels."
-    }
-  },
-  create(context) {
-    let functionStack = [];
-
-    function enterFunction(node) {
-      functionStack.push(node);
-      const depth = functionStack.length;
-
-      if (depth > 2) {
-        context.report({
-          node,
-          messageId: "tooDeep",
-          data: {
-            depth
-          }
-        });
-      }
-    }
-
-    function exitFunction() {
-      functionStack.pop();
-    }
-
-    return {
-      FunctionDeclaration: enterFunction,
-      FunctionExpression: enterFunction,
-      ArrowFunctionExpression: enterFunction,
-      'FunctionDeclaration:exit': exitFunction,
-      'FunctionExpression:exit': exitFunction,
-      'ArrowFunctionExpression:exit': exitFunction
-    };
-  }
-};