@sun-asterisk/sunlint 1.3.48 → 1.3.49

package/engines/arch-detect/rules/presentation/pr006-router-layer.js

@@ -50,6 +50,7 @@ const rule = (0, base_rule_1.createRule)('PR006', 'Router/Wireframe Layer', 'Xá
     folderPatterns: ['routers', 'wireframes', 'navigation', 'routing', 'Routers', 'coordinators'],
     filePatterns: ['*Router.*', '*Wireframe.*', '*Coordinator.*', '*Navigator.*'],
     codePatterns: [
+        // Swift
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.PATTERN, pattern: /protocol\s+\w+Router/ },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Router/ },
         {
@@ -59,12 +60,31 @@ const rule = (0, base_rule_1.createRule)('PR006', 'Router/Wireframe Layer', 'Xá
         },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.METHOD, pattern: /func\s+navigate/ },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.METHOD, pattern: /func\s+present/ },
+        // Kotlin
         {
             language: enums_1.Language.KOTLIN,
             type: enums_1.CodePatternType.PATTERN,
             pattern: /interface\s+\w+Router/,
         },
         { language: enums_1.Language.KOTLIN, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Router/ },
+        // Java
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Router/ },
+        // PHP
+        {
+            language: enums_1.Language.PHP,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /Route::(get|post|put|delete|group)\s*\(/,
+        },
+        // Python
+        { language: enums_1.Language.PYTHON, type: enums_1.CodePatternType.PATTERN, pattern: /urlpatterns\s*=/ },
+        {
+            language: enums_1.Language.PYTHON,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /router\s*=\s*APIRouter\s*\(/,
+        },
+        // Go
+        { language: enums_1.Language.GO, type: enums_1.CodePatternType.PATTERN, pattern: /func\s+\w+Router\b/ },
+        { language: enums_1.Language.GO, type: enums_1.CodePatternType.PATTERN, pattern: /r\.Group\s*\(/ },
     ],
 }, {
     isKeyIndicator: true,
@@ -110,10 +130,10 @@ let PR006RouterLayer = (() => {
                 }
             }
             // Check for router files - match any file containing Router/Wireframe/WireFrame/Coordinator
-            const routerFiles = context.files.filter((f) => /Router\.(swift|kt|java|ts|js)$/i.test(f.fileName) ||
+            const routerFiles = context.files.filter((f) => /Router\.(swift|kt|java|ts|js|php|py|go|rb|cs)$/i.test(f.fileName) ||
                 /WireFrame\.(swift|kt|java)$/i.test(f.fileName) ||
                 /Wireframe\.(swift|kt|java)$/i.test(f.fileName) ||
-                /Coordinator\.(swift|kt|java|ts)$/i.test(f.fileName));
+                /Coordinator\.(swift|kt|java|ts|php|py|go)$/i.test(f.fileName));
             if (routerFiles.length > 0) {
                 for (const file of routerFiles.slice(0, 5)) {
                     matches.push({
@@ -129,12 +149,17 @@ let PR006RouterLayer = (() => {
                 .filter((f) => !f.isTest && !f.isConfig && f.language)
                 .slice(0, 50);
             const codePatterns = [
-                /protocol\s+\w+Router/,
-                /class\s+\w+Router/,
-                /class\s+\w+Coordinator/,
-                /func\s+navigateTo/,
-                /func\s+presentModule/,
-                /interface\s+\w+Router/,
+                /protocol\s+\w+Router/, // Swift
+                /class\s+\w+Router/, // Swift/Kotlin/Java
+                /class\s+\w+Coordinator/, // Swift
+                /func\s+navigateTo/, // Swift/Kotlin
+                /func\s+presentModule/, // Swift
+                /interface\s+\w+Router/, // Kotlin/Java
+                /Route::(get|post|put|delete|group)\s*\(/, // PHP Laravel
+                /urlpatterns\s*=/, // Python Django
+                /router\s*=\s*APIRouter\s*\(/, // Python FastAPI
+                /func\s+\w+Router\b/, // Go
+                /r\.Group\s*\(/, // Go Gin
             ];
             for (const file of sourceFiles) {
                 try {

package/engines/arch-detect/rules/presentation/pr007-interactor-layer.js

@@ -50,12 +50,14 @@ const rule = (0, base_rule_1.createRule)('PR007', 'Interactor Layer', 'Xác nh
     folderPatterns: ['interactors', 'usecases', 'Interactors', 'UseCases'],
     filePatterns: ['*Interactor.*', '*UseCase.*', '*BusinessLogic.*'],
     codePatterns: [
+        // Swift
         {
             language: enums_1.Language.SWIFT,
             type: enums_1.CodePatternType.PATTERN,
             pattern: /protocol\s+\w+Interactor/,
         },
         { language: enums_1.Language.SWIFT, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Interactor/ },
+        // Kotlin
         {
             language: enums_1.Language.KOTLIN,
             type: enums_1.CodePatternType.PATTERN,
@@ -67,6 +69,31 @@ const rule = (0, base_rule_1.createRule)('PR007', 'Interactor Layer', 'Xác nh
             pattern: /class\s+\w+Interactor/,
         },
         { language: enums_1.Language.KOTLIN, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        // Java
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Interactor/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        // TypeScript
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /class\s+\w+UseCase/,
+        },
+        // PHP
+        { language: enums_1.Language.PHP, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        { language: enums_1.Language.PHP, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+Interactor/ },
+        // Python
+        { language: enums_1.Language.PYTHON, type: enums_1.CodePatternType.PATTERN, pattern: /class\s+\w+UseCase/ },
+        // Go
+        {
+            language: enums_1.Language.GO,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /type\s+\w+UseCase\s+struct/,
+        },
+        {
+            language: enums_1.Language.GO,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /type\s+\w+Interactor\s+struct/,
+        },
     ],
 }, {
     isKeyIndicator: true,
@@ -110,8 +137,8 @@ let PR007InteractorLayer = (() => {
                 }
             }
             // Check for interactor files
-            const interactorFiles = context.files.filter((f) => /Interactor\.(swift|kt|java|ts|js)$/i.test(f.fileName) ||
-                /UseCase\.(swift|kt|java|ts|js)$/i.test(f.fileName));
+            const interactorFiles = context.files.filter((f) => /Interactor\.(swift|kt|java|ts|js|php|py|go|rb|cs)$/i.test(f.fileName) ||
+                /UseCase\.(swift|kt|java|ts|js|php|py|go|rb|cs)$/i.test(f.fileName));
             if (interactorFiles.length > 0) {
                 for (const file of interactorFiles.slice(0, 5)) {
                     matches.push({
@@ -127,10 +154,12 @@ let PR007InteractorLayer = (() => {
                 .filter((f) => !f.isTest && !f.isConfig && f.language)
                 .slice(0, 50);
             const codePatterns = [
-                /protocol\s+\w+Interactor/,
-                /class\s+\w+Interactor/,
-                /interface\s+\w+Interactor/,
-                /class\s+\w+UseCase/,
+                /protocol\s+\w+Interactor/, // Swift
+                /class\s+\w+Interactor/, // Swift/Kotlin/Java/PHP
+                /interface\s+\w+Interactor/, // Kotlin/Java
+                /class\s+\w+UseCase/, // Kotlin/Java/TS/PHP/Python
+                /type\s+\w+UseCase\s+struct/, // Go
+                /type\s+\w+Interactor\s+struct/, // Go
             ];
             for (const file of sourceFiles) {
                 try {

package/engines/arch-detect/rules/project-scanner/ps003-framework-detection.js

@@ -86,9 +86,20 @@ const FRAMEWORK_DETECTORS = [
         dependencies: [
             { file: 'pom.xml', packages: ['spring-boot-starter'] },
             { file: 'build.gradle', packages: ['spring-boot'] },
+            { file: 'build.gradle.kts', packages: ['spring-boot'] },
         ],
         codePatterns: [/@SpringBootApplication/],
     },
+    // Ktor
+    {
+        framework: enums_1.Framework.KTOR,
+        configFiles: [],
+        dependencies: [
+            { file: 'build.gradle.kts', packages: ['io.ktor'] },
+            { file: 'build.gradle', packages: ['io.ktor'] },
+        ],
+        codePatterns: [/routing\s*\{/, /embeddedServer\s*\(/],
+    },
     // Angular
     {
         framework: enums_1.Framework.ANGULAR,
@@ -133,15 +144,26 @@ const FRAMEWORK_DETECTORS = [
     // Laravel
     {
         framework: enums_1.Framework.LARAVEL,
-        configFiles: ['artisan'],
+        configFiles: ['artisan', 'config/app.php'],
         dependencies: [{ file: 'composer.json', packages: ['laravel/framework'] }],
-        codePatterns: [/extends\s+Controller/],
+        codePatterns: [/extends\s+Controller/, /use\s+Illuminate\\/],
+    },
+    // Symfony
+    {
+        framework: enums_1.Framework.SYMFONY,
+        configFiles: ['config/bundles.php', 'symfony.lock'],
+        dependencies: [{ file: 'composer.json', packages: ['symfony/framework-bundle'] }],
+        codePatterns: [/#\[Route\s*\(/, /extends\s+AbstractController/],
     },
     // Django
     {
         framework: enums_1.Framework.DJANGO,
         configFiles: ['manage.py'],
-        dependencies: [{ file: 'requirements.txt', packages: ['django', 'Django'] }],
+        dependencies: [
+            { file: 'requirements.txt', packages: ['django', 'Django'] },
+            { file: 'pyproject.toml', packages: ['django', 'Django'] },
+            { file: 'Pipfile', packages: ['django', 'Django'] },
+        ],
         codePatterns: [/from\s+django/, /INSTALLED_APPS/],
     },
     // Rails
@@ -186,15 +208,23 @@ const FRAMEWORK_DETECTORS = [
     {
         framework: enums_1.Framework.FASTAPI,
         configFiles: [],
-        dependencies: [{ file: 'requirements.txt', packages: ['fastapi'] }],
+        dependencies: [
+            { file: 'requirements.txt', packages: ['fastapi'] },
+            { file: 'pyproject.toml', packages: ['fastapi'] },
+            { file: 'Pipfile', packages: ['fastapi'] },
+        ],
         codePatterns: [/from\s+fastapi/, /@app\.(get|post|put|delete)\s*\(/],
     },
     // Flask
     {
         framework: enums_1.Framework.FLASK,
         configFiles: [],
-        dependencies: [{ file: 'requirements.txt', packages: ['flask', 'Flask'] }],
-        codePatterns: [/from\s+flask/, /Flask\s*\(__name__\)/],
+        dependencies: [
+            { file: 'requirements.txt', packages: ['flask', 'Flask'] },
+            { file: 'pyproject.toml', packages: ['flask', 'Flask'] },
+            { file: 'Pipfile', packages: ['flask', 'Flask'] },
+        ],
+        codePatterns: [/from\s+flask/, /Flask\s*\(\s*__name__\s*\)/],
     },
     // Gin (Go)
     {
@@ -247,7 +277,7 @@ let PS003FrameworkDetection = (() => {
                 // Check dependencies
                 if (detector.dependencies) {
                     for (const dep of detector.dependencies) {
-                        const depDetected = await this.checkDependency(projectRoot, dep.file, dep.packages);
+                        const depDetected = await this.checkDependency(projectRoot, dep.file, dep.packages, context.files);
                         if (depDetected) {
                             matches.push({
                                 type: enums_1.MatchType.CONFIG,
@@ -289,10 +319,26 @@ let PS003FrameworkDetection = (() => {
                 score,
             };
         }
-        async checkDependency(projectRoot, depFile, packages) {
-            // Handle glob patterns
+        async checkDependency(projectRoot, depFile, packages, files) {
+            // Handle glob patterns by searching matching files
             if (depFile.includes('*')) {
-                // Skip glob for now, check exact files
+                if (!files)
+                    return false;
+                const globRegex = new RegExp(`${depFile.replace(/\./g, '\\.').replace(/\*/g, '.*')}$`, 'i');
+                const matchingFiles = files.filter((f) => globRegex.test(f.fileName));
+                for (const file of matchingFiles) {
+                    try {
+                        const content = await file_scanner_1.FileScanner.readFileContent(file.absolutePath);
+                        for (const pkg of packages) {
+                            if (content.includes(pkg)) {
+                                return true;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip unreadable files
+                    }
+                }
                 return false;
             }
             const filePath = `${projectRoot}/${depFile}`;

package/package.json

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

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)