@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/rules/common/C073_validate_required_config_on_startup/config.json

@@ -5,33 +5,103 @@
   "description": "C073 - Validate mandatory configuration at startup and fail fast on invalid/missing values.",
   "severity": "error",
   "enabled": true,
-  "semantic": { "enabled": true, "priority": "high", "fallback": "heuristic" },
+  "semantic": {
+    "enabled": true,
+    "priority": "high",
+    "fallback": "heuristic"
+  },
   "patterns": {
-    "include": ["**/*.ts","**/*.tsx","**/*.js","**/*.jsx","**/*.java","**/*.go"],
-    "exclude": ["**/*.test.*","**/*.spec.*","**/__tests__/**","**/fixtures/**","**/examples/**"]
+    "include": [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.java",
+      "**/*.go"
+    ],
+    "exclude": [
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/__tests__/**",
+      "**/fixtures/**",
+      "**/examples/**"
+    ]
   },
   "options": {
     "configModules": {
-      "typescript": ["src/config/**","**/config/**","**/bootstrap/**","**/main.ts"],
-      "java": ["**/config/**","**/Configuration/**","**/Application.java","**/*Application.java"],
-      "go": ["cmd/**","**/config/**","**/main.go"]
+      "typescript": [
+        "src/config/**",
+        "**/config/**",
+        "**/bootstrap/**",
+        "**/main.ts"
+      ],
+      "java": [
+        "**/config/**",
+        "**/Configuration/**",
+        "**/Application.java",
+        "**/*Application.java"
+      ],
+      "go": [
+        "cmd/**",
+        "**/config/**",
+        "**/main.go"
+      ]
     },
     "envAccessors": {
-      "typescript": ["process.env.*"],
-      "java": ["System.getenv(*)","System.getProperty(*)"],
-      "go": ["os.Getenv(*)"]
+      "typescript": [
+        "process.env.*"
+      ],
+      "java": [
+        "System.getenv(*)",
+        "System.getProperty(*)"
+      ],
+      "go": [
+        "os.Getenv(*)"
+      ]
     },
     "schemaDetectors": {
-      "typescript": ["zod","joi","yup","envalid","dotenv-safe","class-validator"],
-      "java": ["@ConfigurationProperties","@Validated","jakarta.validation","hibernate.validator"],
-      "go": ["github.com/kelseyhightower/envconfig","github.com/spf13/viper"]
+      "typescript": [
+        "zod",
+        "joi",
+        "yup",
+        "envalid",
+        "dotenv-safe",
+        "class-validator"
+      ],
+      "java": [
+        "@ConfigurationProperties",
+        "@Validated",
+        "jakarta.validation",
+        "hibernate.validator"
+      ],
+      "go": [
+        "github.com/kelseyhightower/envconfig",
+        "github.com/spf13/viper"
+      ]
     },
     "failFastSignals": {
-      "typescript": ["throw new Error(*)","process.exit(1)"],
-      "java": ["throw new RuntimeException(*)","SpringApplication.exit(*)","System.exit(1)"],
-      "go": ["log.Fatal(*)","panic(*)","os.Exit(1)"]
+      "typescript": [
+        "throw new Error(*)",
+        "process.exit(1)"
+      ],
+      "java": [
+        "throw new RuntimeException(*)",
+        "SpringApplication.exit(*)",
+        "System.exit(1)"
+      ],
+      "go": [
+        "log.Fatal(*)",
+        "panic(*)",
+        "os.Exit(1)"
+      ]
     },
-    "dangerousDefaults": ["|| ''","|| 0","|| 'http://localhost'","?: ''","?: 0"],
+    "dangerousDefaults": [
+      "|| ''",
+      "|| 0",
+      "|| 'http://localhost'",
+      "?: ''",
+      "?: 0"
+    ],
     "thresholds": {
       "maxEnvReadsOutsideConfig": 3
     },
@@ -42,5 +112,10 @@
       "flagDangerousDefaults": true,
       "requireStartupConnectivityChecks": true
     }
-  }
-}
+  },
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ]
+}

package/rules/common/C073_validate_required_config_on_startup/dart/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C073 Dart Analyzer - Validate Required Config On Startup
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C073_validate_required_config_on_startup.dart
+ */
+
+class DartC073Analyzer {
+  constructor() {
+    this.ruleId = 'C073';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C073',
+      name: 'Validate Required Config On Startup',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Validate required configuration on application startup'
+    };
+  }
+
+  getConfig() {
+    return {
+      severity: 'warning'
+    };
+  }
+
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC073Analyzer;

package/rules/common/C073_validate_required_config_on_startup/index.js

@@ -0,0 +1,83 @@
+/**
+ * C073 Rule Router - Validate Required Config On Startup
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C073Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C073';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C073Router();

package/rules/common/C073_validate_required_config_on_startup/{analyzer.js → typescript/analyzer.js}

@@ -28,7 +28,6 @@ class C073ConfigValidationAnalyzer {
       this.thresholds = this.options.thresholds || {};
       this.policy = this.options.policy || {};
     } catch (error) {
-      console.warn(`[C073] Could not load config: ${error.message}`);
       this.options = {};
       this.configModules = {};
       this.envAccessors = {};

package/rules/common/C075_explicit_return_types/config.json

@@ -0,0 +1,28 @@
+{
+  "ruleId": "C075",
+  "name": "Explicit Return Types",
+  "description": "Functions should have explicit return type annotations",
+  "category": "typescript",
+  "severity": "info",
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ],
+  "version": "1.0.0",
+  "status": "stable",
+  "tags": [
+    "typescript",
+    "types",
+    "explicit"
+  ],
+  "config": {},
+  "examples": {
+    "violations": [],
+    "valid": []
+  },
+  "fixes": {
+    "autoFixable": false,
+    "suggestions": []
+  }
+}

package/rules/common/C075_explicit_return_types/dart/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C075 Dart Analyzer - Explicit Return Types
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C075_explicit_return_types.dart
+ */
+
+class DartC075Analyzer {
+  constructor() {
+    this.ruleId = 'C075';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C075',
+      name: 'Explicit Return Types',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Functions should have explicit return type annotations'
+    };
+  }
+
+  getConfig() {
+    return {
+      severity: 'warning'
+    };
+  }
+
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC075Analyzer;

package/rules/common/C075_explicit_return_types/index.js

@@ -0,0 +1,83 @@
+/**
+ * C075 Rule Router - Explicit Return Types
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C075Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C075';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C075Router();

package/rules/common/C076_explicit_function_types/config.json

@@ -4,12 +4,26 @@
   "description": "All public functions must declare explicit types for arguments",
   "severity": "warning",
   "category": "type-safety",
-  "languages": ["typescript", "javascript"],
-  "disallow": ["any", "Object", "object", "{}", "unknown"],
+  "languages": [
+    "typescript",
+    "javascript",
+    "dart"
+  ],
+  "disallow": [
+    "any",
+    "Object",
+    "object",
+    "{}",
+    "unknown"
+  ],
   "requireGenericConstraints": false,
   "checkCollections": true,
-  "ignorePatterns": ["**/*.spec.ts", "**/__tests__/**", "**/*.test.ts"],
+  "ignorePatterns": [
+    "**/*.spec.ts",
+    "**/__tests__/**",
+    "**/*.test.ts"
+  ],
   "exemptPrivateFunctions": true,
   "allowDefaultParameters": false,
   "strictGenericTypes": true
-}
+}

package/rules/common/C076_explicit_function_types/dart/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C076 Dart Analyzer - Explicit Function Types
+ *
+ * This is a JS wrapper that delegates to DartAnalyzer binary.
+ * Actual implementation: dart_analyzer/lib/rules/C076_explicit_function_types.dart
+ */
+
+class DartC076Analyzer {
+  constructor() {
+    this.ruleId = 'C076';
+    this.language = 'dart';
+  }
+
+  getMetadata() {
+    return {
+      ruleId: 'C076',
+      name: 'Explicit Function Types',
+      language: 'dart',
+      delegateTo: 'dart_analyzer',
+      description: 'Function parameters should have explicit type annotations'
+    };
+  }
+
+  getConfig() {
+    return {
+      severity: 'warning'
+    };
+  }
+
+  async analyze(files, language, options) {
+    // Delegated to DartAnalyzer binary via heuristic-engine.js
+    return [];
+  }
+
+  supportsLanguage(language) {
+    return language === 'dart';
+  }
+}
+
+module.exports = DartC076Analyzer;

package/rules/common/C076_explicit_function_types/index.js

@@ -0,0 +1,83 @@
+/**
+ * C076 Rule Router - Explicit Function Types
+ *
+ * Routes analysis to the appropriate language-specific analyzer.
+ * Supports: TypeScript, JavaScript
+ */
+
+const path = require('path');
+
+class C076Router {
+  constructor() {
+    this.analyzers = new Map();
+    this.ruleId = 'C076';
+  }
+
+  getAnalyzer(language) {
+    const normalizedLang = this.normalizeLanguage(language);
+
+    if (!this.analyzers.has(normalizedLang)) {
+      try {
+        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
+        const AnalyzerClass = require(analyzerPath);
+        this.analyzers.set(normalizedLang, new AnalyzerClass());
+      } catch (error) {
+        return null;
+      }
+    }
+
+    return this.analyzers.get(normalizedLang);
+  }
+
+  normalizeLanguage(language) {
+    if (typeof language !== 'string') {
+      return 'typescript';
+    }
+    const languageMap = {
+      'typescript': 'typescript',
+      'javascript': 'typescript',
+      'ts': 'typescript',
+      'js': 'typescript'
+    };
+    return languageMap[language.toLowerCase()] || 'typescript';
+  }
+
+  supportsLanguage(language) {
+    if (typeof language !== 'string') return false;
+    const supported = ['typescript', 'javascript', 'ts', 'js'];
+    return supported.includes(language.toLowerCase());
+  }
+
+  getSupportedLanguages() {
+    return ['typescript', 'javascript'];
+  }
+
+  async analyze(files, language, options = {}) {
+    const analyzer = this.getAnalyzer(language);
+    if (!analyzer) return [];
+    if (typeof analyzer.analyze === 'function') {
+      return analyzer.analyze(files, language, options);
+    }
+    return [];
+  }
+
+  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
+    let engine = semanticEngine;
+    let lang = null;
+
+    if (typeof semanticEngineOrLanguage === 'string') {
+      lang = semanticEngineOrLanguage;
+    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
+      engine = semanticEngineOrLanguage;
+    }
+
+    if (lang) {
+      const analyzer = this.getAnalyzer(lang);
+      if (analyzer && typeof analyzer.initialize === 'function') {
+        await analyzer.initialize(engine);
+      }
+    }
+  }
+}
+
+module.exports = new C076Router();

package/rules/index.js

@@ -1,14 +1,15 @@
 /**
  * SunLint Heuristic Rules Registry
- * Central reconst securityRules = {
-  S015: require('./security/S015_insecure_tls_certificate/analyzer'),
-  S023: require('./security/S023_no_json_injection/analyzer'),stry for all heuristic rules organized by category
+ * Central registry for all heuristic rules organized by category
  */
 
 const path = require('path');
+const fs = require('fs');
 
 /**
  * Load rule analyzer from category folder
+ * Supports both old structure (analyzer.js) and new multi-language structure (index.js router)
+ *
  * @param {string} category - Rule category (common, security, typescript)
  * @param {string} ruleId - Rule ID (e.g., C006_function_naming)
  * @returns {Object} Rule analyzer module
@@ -21,7 +22,18 @@ function loadRule(category, ruleId) {
             console.log(`🔬 Loading C047 semantic analyzer: ${semanticPath}`);
             return require(semanticPath);
         }
-        
+
+        // Try new multi-language structure first (index.js router)
+        const routerPath = path.join(__dirname, category, ruleId, 'index.js');
+        try {
+            if (fs.existsSync(routerPath)) {
+                return require(routerPath);
+            }
+        } catch (routerError) {
+            // Fall through to old structure
+        }
+
+        // Fallback to old structure (analyzer.js)
         const rulePath = path.join(__dirname, category, ruleId, 'analyzer.js');
         return require(rulePath);
     } catch (error) {
@@ -48,13 +60,17 @@ function loadRuleConfig(category, ruleId) {
 
 // 🔹 Common Rules (C-series) - General coding standards
 const commonRules = {
+    // Multi-language rules (TypeScript + Dart)
     C002: loadRule('common', 'C002_no_duplicate_code'),
+    C003: loadRule('common', 'C003_no_vague_abbreviations'),
+
+    // TypeScript-only rules (existing)
     C006: loadRule('common', 'C006_function_naming'),
     C012: loadRule('common', 'C012_command_query_separation'),
     C013: loadRule('common', 'C013_no_dead_code'),
     C014: loadRule('common', 'C014_dependency_injection'),
     C018: loadRule('common', 'C018_no_throw_generic_error'),
-    C019: loadRule('common', 'C019_log_level_usage'), 
+    C019: loadRule('common', 'C019_log_level_usage'),
     C030: loadRule('common', 'C030_use_custom_error_classes'),
     C023: loadRule('common', 'C023_no_duplicate_variable'),
     C024: loadRule('common', 'C024_no_scatter_hardcoded_constants'),
@@ -72,6 +88,11 @@ const commonRules = {
 
 // 🔒 Security Rules (S-series) - Ready for migration
 const securityRules = {
+    // Multi-language rules (TypeScript + Dart)
+    S003: loadRule('security', 'S003_open_redirect_protection'),
+    S004: loadRule('security', 'S004_sensitive_data_logging'),
+
+    // TypeScript-only rules (existing)
     S006: loadRule('security', 'S006_no_plaintext_recovery_codes'),
     S010: loadRule('security', 'S010_no_insecure_encryption'),
     S015: loadRule('security', 'S015_insecure_tls_certificate'),
@@ -80,7 +101,6 @@ const securityRules = {
     S027: loadRule('security', 'S027_no_hardcoded_secrets'),
     S029: loadRule('security', 'S029_csrf_protection'),
     // S001: loadRule('security', 'S001_fail_securely'),
-    // S003: loadRule('security', 'S003_no_unvalidated_redirect'),
     // S012: loadRule('security', 'S012_hardcode_secret'),
     // ... 46 more security rules ready for migration
 };