@sun-asterisk/sunlint 1.3.37 → 1.3.39

package/engines/heuristic-engine.js

@@ -20,13 +20,18 @@ const fs = require('fs');
 const path = require('path');
 
 /**
- * Check if a rule supports Dart by detecting dart/ folder in rule structure
- * @param {string} ruleId - Rule ID (e.g., 'C002', 'S003')
- * @returns {boolean} True if rule has dart/ subfolder
+ * Check if a rule supports Dart by detecting dart/ folder in rule structure or Dart-only rules
+ * @param {string} ruleId - Rule ID (e.g., 'C002', 'S003', 'D001')
+ * @returns {boolean} True if rule has dart/ subfolder or is a Dart-only rule (Dxxx)
  */
 function detectDartSupport(ruleId) {
+  // Dart-only rules (Dxxx) are always Dart-supported
+  if (ruleId.startsWith('D')) {
+    return true;
+  }
+
   const rulesBasePath = path.join(__dirname, '../rules');
-  const categories = ['common', 'security', 'typescript'];
+  const categories = ['common', 'security', 'typescript', 'dart'];
 
   for (const category of categories) {
     const categoryPath = path.join(rulesBasePath, category);
@@ -395,6 +400,14 @@ class HeuristicEngine extends AnalysisEngineInterface {
    * @param {Object} options - Loading options
    */
   async lazyLoadRule(ruleId, options = {}) {
+    // Special handling for C047 - always use semantic analyzer
+    if (ruleId === 'C047') {
+      if (!this.semanticRules.has('C047') && !this.ruleAnalyzers.has('C047')) {
+        await this.manuallyLoadC047();
+        return;
+      }
+    }
+    
     try {
       const ruleDefinition = this.unifiedRegistry.getRuleDefinition(ruleId);
       
@@ -435,7 +448,7 @@ class HeuristicEngine extends AnalysisEngineInterface {
         console.log(`[DEBUG] 🔬 Manually loading C047 semantic rule...`);
       }
       
-      const c047Path = path.resolve(__dirname, '../rules/common/C047_no_duplicate_retry_logic/c047-semantic-rule.js');
+      const c047Path = path.resolve(__dirname, '../rules/common/C047_no_duplicate_retry_logic/typescript/c047-semantic-rule.js');
       
       if (fs.existsSync(c047Path)) {
         const C047SemanticRule = require(c047Path);
@@ -791,25 +804,25 @@ class HeuristicEngine extends AnalysisEngineInterface {
       return parseInt(options.maxFiles);
     }
     
-    // User explicitly disabled limit
-    if (options.maxFiles === -1 || options.maxFiles === '-1') {
+    // User explicitly disabled limit (0 or -1 = unlimited)
+    if (options.maxFiles === 0 || options.maxFiles === -1 || options.maxFiles === '0' || options.maxFiles === '-1') {
       return Infinity;
     }
     
     // Performance config limit
-    if (this.performanceConfig?.maxFiles) {
+    if (this.performanceConfig?.maxFiles && this.performanceConfig.maxFiles > 0) {
       return this.performanceConfig.maxFiles;
     }
     
     // Default based on performance mode
-    const mode = options.performance || 'auto';
+    const mode = options.performance;
     const defaults = {
       fast: 500,
       auto: 1000,
       careful: 1500
     };
     
-    return defaults[mode] || 1000;
+    return mode ? defaults[mode] : Infinity;
   }
 
   /**

package/origin-rules/dart-en.md

@@ -2,12 +2,12 @@
 
 ---
 
-### 📘 Rule D001 – Keep parameter names consistent when overriding methods
+### 📘 Rule D001 – Recommended Lint Rules Should Be Enabled
 
-- **Objective**: Maintain consistency between inherited classes
-- **Details**: Do not change parameter names when overriding to maintain consistency in meaning and documentation of parameters if available.
+- **Objective**: Ensure code quality through standard lint configurations
+- **Details**: The `analysis_options.yaml` file should include recommended lint packages (flutter_lints, very_good_analysis, or lints) and critical lint rules should not be disabled. This ensures consistent code quality standards across the project.
 - **Applies to**: Flutter/Dart
-- **Tools**: `dart lint` (`avoid_renaming_method_parameters`)
+- **Tools**: `dart lint` (flutter_lints, very_good_analysis, lints)
 - **Principles**: CODE_QUALITY
 - **Version**: 1.0
 - **Status**: activated

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.37",
+  "version": "1.3.39",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {

package/rules/dart/D001_recommended_lint_rules/config.json

@@ -0,0 +1,134 @@
+{
+  "id": "D001",
+  "name": "Recommended Lint Rules Should Be Enabled",
+  "description": "Ensure recommended lint rules from flutter_lints or very_good_analysis are enabled in analysis_options.yaml with appropriate severity",
+  "severity": "warning",
+  "category": "dart",
+  "languages": ["dart"],
+  "tags": ["lint", "best-practices", "flutter", "code-quality"],
+  "analysisMethod": "dart-only",
+  "dartAnalyzer": {
+    "class": "D001RecommendedLintRulesAnalyzer",
+    "file": "D001_recommended_lint_rules.dart"
+  },
+  "detection": {
+    "targetFiles": ["analysis_options.yaml", "analysis_options.yml"],
+    "requiredPackages": [
+      "flutter_lints",
+      "very_good_analysis",
+      "lints"
+    ],
+    "recommendedRules": {
+      "errors": [
+        "avoid_empty_else",
+        "avoid_print",
+        "avoid_relative_lib_imports",
+        "avoid_returning_null_for_future",
+        "avoid_slow_async_io",
+        "avoid_type_to_string",
+        "avoid_types_as_parameter_names",
+        "avoid_web_libraries_in_flutter",
+        "cancel_subscriptions",
+        "close_sinks",
+        "empty_statements",
+        "hash_and_equals",
+        "no_adjacent_strings_in_list",
+        "no_duplicate_case_values",
+        "prefer_void_to_null",
+        "throw_in_finally",
+        "unnecessary_statements",
+        "unrelated_type_equality_checks",
+        "valid_regexps"
+      ],
+      "warnings": [
+        "always_declare_return_types",
+        "always_require_non_null_named_parameters",
+        "annotate_overrides",
+        "avoid_init_to_null",
+        "avoid_null_checks_in_equality_operators",
+        "avoid_renaming_method_parameters",
+        "avoid_return_types_on_setters",
+        "avoid_shadowing_type_parameters",
+        "avoid_single_cascade_in_expression_statements",
+        "await_only_futures",
+        "camel_case_extensions",
+        "camel_case_types",
+        "constant_identifier_names",
+        "curly_braces_in_flow_control_structures",
+        "empty_catches",
+        "empty_constructor_bodies",
+        "exhaustive_cases",
+        "file_names",
+        "implementation_imports",
+        "library_names",
+        "library_prefixes",
+        "no_leading_underscores_for_library_prefixes",
+        "no_leading_underscores_for_local_identifiers",
+        "null_check_on_nullable_type_parameter",
+        "null_closures",
+        "overridden_fields",
+        "prefer_adjacent_string_concatenation",
+        "prefer_collection_literals",
+        "prefer_conditional_assignment",
+        "prefer_contains",
+        "prefer_final_fields",
+        "prefer_for_elements_to_map_fromIterable",
+        "prefer_function_declarations_over_variables",
+        "prefer_generic_function_type_aliases",
+        "prefer_if_null_operators",
+        "prefer_initializing_formals",
+        "prefer_inlined_adds",
+        "prefer_interpolation_to_compose_strings",
+        "prefer_is_empty",
+        "prefer_is_not_empty",
+        "prefer_is_not_operator",
+        "prefer_iterable_whereType",
+        "prefer_null_aware_operators",
+        "prefer_spread_collections",
+        "prefer_typing_uninitialized_variables",
+        "provide_deprecation_message",
+        "recursive_getters",
+        "slash_for_doc_comments",
+        "type_init_formals",
+        "unnecessary_brace_in_string_interps",
+        "unnecessary_const",
+        "unnecessary_constructor_name",
+        "unnecessary_getters_setters",
+        "unnecessary_late",
+        "unnecessary_new",
+        "unnecessary_null_aware_assignments",
+        "unnecessary_null_in_if_null_operators",
+        "unnecessary_nullable_for_final_variable_declarations",
+        "unnecessary_overrides",
+        "unnecessary_string_escapes",
+        "unnecessary_string_interpolations",
+        "unnecessary_this",
+        "use_function_type_syntax_for_parameters",
+        "use_rethrow_when_possible"
+      ]
+    },
+    "minimumSeverity": "warning"
+  },
+  "examples": {
+    "violations": [
+      {
+        "description": "analysis_options.yaml without recommended lint package",
+        "code": "# analysis_options.yaml\nanalyzer:\n  strong-mode:\n    implicit-casts: false"
+      },
+      {
+        "description": "Lint rules disabled without justification",
+        "code": "# analysis_options.yaml\nlinter:\n  rules:\n    avoid_print: false\n    cancel_subscriptions: false"
+      }
+    ],
+    "clean": [
+      {
+        "description": "Using flutter_lints with proper configuration",
+        "code": "# analysis_options.yaml\ninclude: package:flutter_lints/flutter.yaml\n\nlinter:\n  rules:\n    avoid_print: error"
+      },
+      {
+        "description": "Using very_good_analysis",
+        "code": "# analysis_options.yaml\ninclude: package:very_good_analysis/analysis_options.yaml"
+      }
+    ]
+  }
+}

package/rules/index.js

@@ -18,9 +18,11 @@ function loadRule(category, ruleId) {
     try {
         // Special case for C047: Use semantic analyzer by default
         if (ruleId === 'C047_no_duplicate_retry_logic') {
-            const semanticPath = path.join(__dirname, category, ruleId, 'c047-semantic-rule.js');
-            console.log(`🔬 Loading C047 semantic analyzer: ${semanticPath}`);
-            return require(semanticPath);
+            const semanticPath = path.join(__dirname, category, ruleId, 'typescript', 'c047-semantic-rule.js');
+            if (fs.existsSync(semanticPath)) {
+                console.log(`🔬 Loading C047 semantic analyzer: ${semanticPath}`);
+                return require(semanticPath);
+            }
         }
 
         // Try new multi-language structure first (index.js router)
@@ -79,7 +81,7 @@ const commonRules = {
     C033: loadRule('common', 'C033_separate_service_repository'),
     C041: loadRule('common', 'C041_no_sensitive_hardcode'),
     C042: loadRule('common', 'C042_boolean_name_prefix'),
-    // C047: loadRule('common', 'C047_no_duplicate_retry_logic'),
+    C047: loadRule('common', 'C047_no_duplicate_retry_logic'),
     C048: loadRule('common', 'C048_no_bypass_architectural_layers'),
     C052: loadRule('common', 'C052_parsing_or_data_transformation'),
     C060: loadRule('common', 'C060_no_override_superclass'),