@sun-asterisk/sunlint 1.3.47 → 1.3.49

package/scripts/generate-rules-registry.js

@@ -16,29 +16,45 @@ try {
   const parser = new SimpleRuleParser();
   const originRulesDir = path.join(__dirname, '..', 'origin-rules');
   const targetPath = path.join(__dirname, '..', 'config', 'rules', 'rules-registry-generated.json');
-  
+
   console.log(`Source: ${originRulesDir}`);
   console.log(`Target: ${targetPath}`);
-  
+
   // Parse all rules from origin-rules
   const allRules = parser.parseAllRules(originRulesDir);
-  
+
   if (allRules.length === 0) {
     console.error('❌ No rules found in origin-rules directory');
     process.exit(1);
   }
-  
+
   // Convert to registry format
   const registry = {
     rules: {}
   };
-  
+
   allRules.forEach(rule => {
     if (rule.id) {
+      let category = rule.category || 'Common';
+      const id = rule.id;
+
+      // Smart category detection based on prefix
+      if (id.startsWith('S')) {
+        category = 'Security';
+      } else if (id.startsWith('C')) {
+        category = 'Common';
+      } else if (['RB', 'G', 'GN', 'J', 'PY', 'P'].some(p => id.startsWith(p))) {
+        category = 'Backend';
+      } else if (['T', 'R'].some(p => id.startsWith(p))) {
+        category = 'Frontend';
+      } else if (['K', 'SW', 'D'].some(p => id.startsWith(p))) {
+        category = 'Mobile';
+      }
+
       registry.rules[rule.id] = {
         name: rule.title || `${rule.id} Rule`,
         description: rule.description || 'No description available',
-        category: rule.category || 'quality',
+        category: category,
         severity: rule.severity || 'major',
         languages: rule.language ? [rule.language] : ['All languages'],
         version: rule.version || '1.0.0',
@@ -50,37 +66,37 @@ try {
       };
     }
   });
-  
+
   // Ensure target directory exists
   const targetDir = path.dirname(targetPath);
   if (!fs.existsSync(targetDir)) {
     fs.mkdirSync(targetDir, { recursive: true });
   }
-  
+
   // Write registry file
   fs.writeFileSync(targetPath, JSON.stringify(registry, null, 2), 'utf8');
-  
+
   const rulesCount = Object.keys(registry.rules).length;
   const fileSize = (fs.statSync(targetPath).size / 1024).toFixed(1);
-  
+
   console.log(`✅ Generated registry with ${rulesCount} rules`);
   console.log(`📁 File: ${targetPath} (${fileSize} KB)`);
   console.log('');
   console.log('📊 Rules by category:');
-  
+
   // Stats by category
   const categories = {};
   Object.values(registry.rules).forEach(rule => {
     const cat = rule.category || 'unknown';
     categories[cat] = (categories[cat] || 0) + 1;
   });
-  
+
   Object.entries(categories)
-    .sort(([,a], [,b]) => b - a)
+    .sort(([, a], [, b]) => b - a)
     .forEach(([category, count]) => {
       console.log(`   ${category}: ${count} rules`);
     });
-    
+
 } catch (error) {
   console.error('❌ Error generating registry:', error.message);
   console.error(error.stack);

package/skill-assets/sunlint-code-quality/SKILL.md

@@ -9,7 +9,7 @@ metadata:
 
 # SunLint Code Quality & Security Standards
 
-Comprehensive code quality and security optimization guide for all projects, maintained by Sun* Engineering Excellence team. Contains **65 rules** across **6 priority categories**, organized by impact to guide automated code review and generation.
+Comprehensive code quality and security optimization guide for all projects, maintained by Sun* Engineering Excellence team. Contains **75 rules** across **7 priority categories**, organized by impact to guide automated code review and generation.
 
 ## When to Apply
 
@@ -31,6 +31,7 @@ Reference these guidelines when:
 | 4 | Security - Cryptography & TLS | **HIGH** | 8 | `S0xx` |
 | 5 | Security - Data Protection | **HIGH** | 10 | `S0xx` |
 | 6 | Security - Logging & Monitoring | **MEDIUM** | 6 | `S0xx` |
+| 7 | Language Specific (Go/Gin) | **CRITICAL/HIGH** | 10 | `Gxx`/`GNxx` |
 
 ---
 
@@ -173,4 +174,4 @@ For the complete guide with all rules expanded: `AGENTS.md`
 
 ---
 
-**Last Updated**: January 2026 | **Version**: 2.3 | **Maintainer**: Sun* Engineering Excellence
+**Last Updated**: February 2026 | **Version**: 2.4.1 | **Maintainer**: Sun* Engineering Excellence

package/skill-assets/sunlint-code-quality/rules/dart/C006-verb-noun-functions.md

@@ -0,0 +1,45 @@
+---
+title: Function Names Verb-Noun
+impact: LOW
+impactDescription: makes code self-documenting
+tags: naming, functions, readability, conventions, quality
+---
+
+## Function Names Verb-Noun
+
+Functions do things. Action verbs make purpose clear.
+
+**Incorrect (vague names):**
+
+```dart
+User user() { }           // Noun only
+void userData() { }       // Noun only
+void doSomething() { }    // Vague
+void handleStuff() { }    // Vague
+void manager() { }        // Noun only
+```
+
+**Correct (action verbs):**
+
+```dart
+Future<User> getUser() async { }
+void createUserAccount() { }
+bool validateEmailFormat(String email) { }
+double calculateTotalPrice(List<Item> items) { }
+Future<void> sendConfirmationEmail(String email) async { }
+String convertCurrencyToVnd(double amount) { }
+```
+
+**Verb categories:**
+
+| Category | Verbs |
+|----------|-------|
+| Retrieval | `get`, `fetch`, `find`, `load`, `query` |
+| Creation | `create`, `build`, `make`, `generate` |
+| Modification | `set`, `update`, `modify`, `change` |
+| Deletion | `delete`, `remove`, `destroy`, `clear` |
+| Validation | `validate`, `verify`, `check`, `ensure` |
+| Computation | `calculate`, `compute`, `parse`, `format` |
+| Boolean | `is`, `has`, `can`, `should`, `will` |
+
+**Tools:** PR review, dart_analyzer

package/skill-assets/sunlint-code-quality/rules/dart/C013-no-dead-code.md

@@ -0,0 +1,53 @@
+---
+title: Do Not Use Dead Code
+impact: LOW
+impactDescription: reduces codebase noise and app size
+tags: dead-code, cleanup, maintenance, quality
+---
+
+## Do Not Use Dead Code
+
+Dead code confuses readers and increases app size. Git history preserves deleted code.
+
+**Incorrect (keeping dead code):**
+
+```dart
+void processOrder(Order order) {
+  // Old implementation - keeping for reference
+  // final total = order.items.fold(0.0, (sum, item) {
+  //   return sum + item.price * item.quantity;
+  // });
+
+  final total = calculateTotal(order);
+  return total;
+}
+
+// Unused function - someone might need it later
+double legacyCalculation(List<Item> items) {
+  return items.length * 10.0;
+}
+
+import 'package:app/utils/unused_helper.dart'; // Never used
+```
+
+**Correct (clean code):**
+
+```dart
+void processOrder(Order order) {
+  final total = calculateTotal(order);
+  return total;
+}
+
+// Delete unused functions - git history preserves them
+// Delete commented code - git history preserves it
+// Remove unused imports
+```
+
+**Types of dead code:**
+- Commented-out code blocks
+- Unused functions/classes/mixins
+- Unused imports
+- Unreachable code (after `return`/`throw`)
+- Unused variables and parameters
+
+**Tools:** dart analyze, `unused_import` lint rule, Code Review

package/skill-assets/sunlint-code-quality/rules/dart/C014-dependency-injection.md

@@ -0,0 +1,92 @@
+---
+title: Use Dependency Injection
+impact: HIGH
+impactDescription: enables testability and loose coupling
+tags: dependency-injection, testing, coupling, architecture, quality
+---
+
+## Use Dependency Injection
+
+Direct instantiation creates tight coupling, making testing difficult and changes risky. DI enables mockability, replaceability, and testability.
+
+**Incorrect (hardcoded dependencies):**
+
+```dart
+class OrderService {
+  final _db = DatabaseHelper(); // Hardcoded dependency
+  final _mailer = EmailService(); // Hardcoded dependency
+
+  Future<Order> createOrder(OrderData data) async {
+    final order = await _db.insert('orders', data.toMap());
+    await _mailer.send(data.email, 'Order created');
+    return order;
+  }
+}
+```
+
+**Correct (injected dependencies):**
+
+```dart
+abstract class IDatabase {
+  Future<Map<String, dynamic>> insert(String table, Map<String, dynamic> data);
+}
+
+abstract class IMailer {
+  Future<void> send(String to, String message);
+}
+
+class OrderService {
+  OrderService({
+    required IDatabase db,
+    required IMailer mailer,
+  }) : _db = db,
+       _mailer = mailer;
+
+  final IDatabase _db;
+  final IMailer _mailer;
+
+  Future<Order> createOrder(OrderData data) async {
+    final order = await _db.insert('orders', data.toMap());
+    await _mailer.send(data.email, 'Order created');
+    return order;
+  }
+}
+
+// Usage - production
+final service = OrderService(
+  db: SqliteDatabase(path: dbPath),
+  mailer: SmtpMailer(host: smtpHost),
+);
+
+// Usage - testing
+final service = OrderService(
+  db: MockDatabase(),
+  mailer: MockMailer(),
+);
+```
+
+**With get_it or injectable:**
+
+```dart
+// Using get_it
+@injectable
+class OrderService {
+  OrderService(this._db, this._mailer);
+
+  final IDatabase _db;
+  final IMailer _mailer;
+}
+
+// Register
+GetIt.instance.registerFactory<OrderService>(
+  () => OrderService(GetIt.instance(), GetIt.instance()),
+);
+```
+
+**Benefits:**
+- Easy mocking for unit tests
+- Swappable implementations
+- Clear dependencies visible in constructor
+- Supports interface-based design
+
+**Tools:** get_it, injectable, mockito, mocktail

package/skill-assets/sunlint-code-quality/rules/dart/C017-no-constructor-logic.md

@@ -0,0 +1,62 @@
+---
+title: No Business Logic In Constructors
+impact: HIGH
+impactDescription: ensures predictable object initialization
+tags: constructor, initialization, side-effects, patterns, quality
+---
+
+## No Business Logic In Constructors
+
+Constructors should only initialize state. Side effects in constructors are unexpected and make testing difficult.
+
+**Incorrect (logic in constructor):**
+
+```dart
+class UserRepository {
+  UserRepository(String configPath) {
+    // BAD: File I/O in constructor
+    final file = File(configPath).readAsStringSync();
+    final config = jsonDecode(file) as Map<String, dynamic>;
+
+    // BAD: Network call in constructor
+    _client = HttpClient()..open('GET', config['apiUrl'] as String, 80, '/init');
+
+    // BAD: Mutation side-effects
+    _cache.clear();
+
+    // BAD: Logging with side effects
+    print('UserRepository initialized');
+  }
+}
+```
+
+**Correct (factory method for async / complex init):**
+
+```dart
+class UserRepository {
+  UserRepository({
+    required HttpClient client,
+    required AppConfig config,
+  }) : _client = client,    // Only assignments
+       _config = config;
+
+  final HttpClient _client;
+  final AppConfig _config;
+
+  // Factory method for complex initialization
+  static Future<UserRepository> create(String configPath) async {
+    final file = await File(configPath).readAsString();
+    final config = AppConfig.fromJson(jsonDecode(file) as Map<String, dynamic>);
+
+    final client = HttpClient();
+    await client.initialize(config.apiUrl);
+
+    return UserRepository(client: client, config: config);
+  }
+}
+
+// Usage
+final repo = await UserRepository.create('./config.json');
+```
+
+**Tools:** Code Review, dart_analyzer

package/skill-assets/sunlint-code-quality/rules/dart/C018-generic-errors.md

@@ -0,0 +1,57 @@
+---
+title: Do Not Throw Generic Errors
+impact: HIGH
+impactDescription: enables proper error handling and monitoring
+tags: error-handling, exceptions, custom-errors, debugging, quality
+---
+
+## Do Not Throw Generic Errors
+
+Generic errors lack context needed for debugging. They make it impossible to distinguish between error types for proper handling.
+
+**Incorrect (generic errors):**
+
+```dart
+if (user == null) {
+  throw Exception('error');
+}
+
+if (!isValid) {
+  throw Exception();
+}
+
+if (response.statusCode != 200) {
+  throw Exception('Failed');
+}
+```
+
+**Correct (specific custom exceptions):**
+
+```dart
+if (user == null) {
+  throw UserNotFoundException('User with ID $userId not found');
+}
+
+if (!isValid) {
+  throw ValidationException(
+    field: 'email',
+    message: 'Email format is invalid',
+    value: email,
+  );
+}
+
+if (response.statusCode != 200) {
+  throw ApiException(
+    statusCode: response.statusCode,
+    message: 'API request failed',
+    endpoint: '/users/$userId',
+  );
+}
+```
+
+Custom exceptions should include:
+- Descriptive message with context
+- Relevant data for debugging
+- Error code for programmatic handling
+
+**Tools:** Code Review, dart_analyzer

package/skill-assets/sunlint-code-quality/rules/dart/C019-error-log-level.md

@@ -0,0 +1,50 @@
+---
+title: Do Not Use Error Log For Non-critical
+impact: HIGH
+impactDescription: prevents alert fatigue and log noise
+tags: logging, log-levels, error, observability, quality
+---
+
+## Do Not Use Error Log For Non-critical
+
+Incorrect log levels cause alert fatigue and hide real issues. When everything is an "error", nothing is.
+
+**Incorrect (overusing error level):**
+
+```dart
+// NOT an error - expected business case
+logger.e('User entered wrong password');
+
+// NOT an error - validation failure
+logger.e('Email format invalid');
+
+// NOT an error - retry in progress
+logger.e('Retry attempt 2 of 5');
+```
+
+**Correct (appropriate log levels):**
+
+```dart
+// WARN - recoverable, may need attention
+logger.w('Payment retry attempt', error: {'attempt': 2, 'maxAttempts': 5});
+
+// INFO - normal business events  
+logger.i('Login failed - invalid password', {'userId': userId, 'attempts': 3});
+
+// DEBUG - detailed troubleshooting
+logger.d('Validation failed', error: {'field': 'email'});
+
+// ERROR - only for actual system / unrecoverable failures
+logger.e('Database connection lost', error: e, stackTrace: st);
+```
+
+**Log Level Guide (using `logger` package):**
+
+| Method | Level | Use For |
+|--------|-------|---------|
+| `logger.e()` | ERROR | System failures, crashes, unrecoverable |
+| `logger.w()` | WARN | Potential issues, degraded performance |
+| `logger.i()` | INFO | Business events, state changes |
+| `logger.d()` | DEBUG | Detailed troubleshooting |
+
+**Tools:** logger package, Code Review

package/skill-assets/sunlint-code-quality/rules/dart/C020-no-unused-imports.md

@@ -0,0 +1,46 @@
+---
+title: Do Not Import Unused Modules
+impact: LOW
+impactDescription: reduces app size and improves clarity
+tags: imports, cleanup, bundle-size, quality
+---
+
+## Do Not Import Unused Modules
+
+Unused imports add noise and may increase app size.
+
+**Incorrect (unused imports):**
+
+```dart
+import 'package:app/models/user.dart';
+import 'package:app/models/order.dart'; // Never used
+import 'package:app/utils/date_utils.dart'; // Never used
+import 'package:intl/intl.dart'; // Never used
+
+// Only User is actually used
+User getUser(String id) {
+  return userRepository.findById(id);
+}
+```
+
+**Correct (only needed imports):**
+
+```dart
+import 'package:app/models/user.dart';
+
+User getUser(String id) {
+  return userRepository.findById(id);
+}
+```
+
+**Enable via analysis_options.yaml:**
+
+```yaml
+# analysis_options.yaml
+linter:
+  rules:
+    - unused_import
+    - avoid_unused_constructor_parameters
+```
+
+**Tools:** dart analyze, IDE auto-organize imports (Cmd/Ctrl+Shift+O)

package/skill-assets/sunlint-code-quality/rules/dart/C022-no-unused-variables.md

@@ -0,0 +1,50 @@
+---
+title: Do Not Leave Unused Variables
+impact: LOW
+impactDescription: reduces code noise and potential bugs
+tags: variables, cleanup, quality
+---
+
+## Do Not Leave Unused Variables
+
+Unused variables suggest incomplete refactoring or bugs.
+
+**Incorrect (unused variables):**
+
+```dart
+void processOrder(Order order) {
+  final user = order.user;   // Never used
+  final total = order.total; // Never used
+  final items = order.items;
+
+  return items.map((i) => i.name).toList();
+}
+```
+
+**Correct (only needed variables):**
+
+```dart
+void processOrder(Order order) {
+  return order.items.map((i) => i.name).toList();
+}
+
+// If destructuring/pattern matching, prefix with _ for intentionally ignored
+void handleEvent(Map<String, dynamic> event) {
+  final type = event['type'] as String;
+  final _ = event['payload']; // Intentionally ignored
+  print('Event: $type');
+}
+```
+
+**Enable via analysis_options.yaml:**
+
+```yaml
+# analysis_options.yaml
+linter:
+  rules:
+    - unused_local_variable
+    - unused_element
+    - avoid_unused_constructor_parameters
+```
+
+**Tools:** dart analyze, `unused_local_variable` lint rule

package/skill-assets/sunlint-code-quality/rules/dart/C023-no-duplicate-names.md

@@ -0,0 +1,56 @@
+---
+title: No Duplicate Variable Names In Scope
+impact: HIGH
+impactDescription: prevents shadowing bugs
+tags: variables, shadowing, scope, quality
+---
+
+## No Duplicate Variable Names In Scope
+
+Variable shadowing causes subtle bugs where inner variables hide outer ones.
+
+**Incorrect (shadowed variables):**
+
+```dart
+final user = getCurrentUser();
+
+void processOrder(Order order) {
+  final user = order.user; // Shadows outer user!
+
+  // Which user is this?
+  print(user.name);
+}
+
+// Same name in nested scope
+for (final item in items) {
+  final item = transform(item); // Shadows loop variable!
+}
+```
+
+**Correct (unique names):**
+
+```dart
+final currentUser = getCurrentUser();
+
+void processOrder(Order order) {
+  final orderUser = order.user; // Clear distinction
+
+  print(orderUser.name);
+}
+
+// Different names in nested scope
+for (final item in items) {
+  final transformedItem = transform(item);
+}
+```
+
+**Enable via analysis_options.yaml:**
+
+```yaml
+# analysis_options.yaml
+linter:
+  rules:
+    - no_leading_underscores_for_local_identifiers
+```
+
+**Tools:** dart analyze, Code Review