@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/README.md

@@ -0,0 +1,226 @@
+# SunLint Dart Analyzer
+
+Dart language analyzer for SunLint. Provides AST-based code analysis and rule checking via JSON-RPC communication.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  SunLint (Node.js)                                               │
+│  └── DartAnalyzer adapter                                        │
+└────────┬───────────────────────────────────────────────────────┘
+         │ JSON-RPC over STDIO
+         ▼
+┌─────────────────────────────────────────────────────────────────┐
+│  SunLint Dart Analyzer (This package)                            │
+│  ├── JsonRpcServer      - Handles communication                  │
+│  ├── AnalyzerService    - Orchestrates analysis                  │
+│  ├── SymbolTableExtractor - Extracts symbols from AST            │
+│  └── Analyzers/         - Rule implementations                   │
+│      ├── C001 - Code Complexity                                  │
+│      ├── C008 - Deep Nesting                                     │
+│      ├── N001 - Naming Conventions                               │
+│      ├── E001 - Error Handling                                   │
+│      └── S003 - Security (Sensitive Data)                        │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Development
+
+### Prerequisites
+
+- Dart SDK >= 3.0.0
+
+### Setup
+
+```bash
+cd dart_analyzer
+dart pub get
+```
+
+### Run in standalone mode (for testing)
+
+```bash
+# Analyze a single file
+dart run bin/sunlint_dart_analyzer.dart --standalone --file test/fixtures/sample.dart
+
+# Analyze with specific rules
+dart run bin/sunlint_dart_analyzer.dart --standalone --file lib/main.dart --rules C001,N001
+```
+
+### Run as JSON-RPC server
+
+```bash
+dart run bin/sunlint_dart_analyzer.dart
+```
+
+### Build executable
+
+```bash
+# Compile to native executable
+dart compile exe bin/sunlint_dart_analyzer.dart -o bin/sunlint-dart-macos
+
+# For different platforms (requires cross-compilation):
+# Linux: dart compile exe bin/sunlint_dart_analyzer.dart -o bin/sunlint-dart-linux
+# Windows: dart compile exe bin/sunlint_dart_analyzer.dart -o bin/sunlint-dart-windows.exe
+```
+
+## JSON-RPC Protocol
+
+### Methods
+
+#### `initialize`
+
+Initialize the analyzer with a project.
+
+**Request:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "initialize",
+  "params": {
+    "projectPath": "/path/to/project",
+    "targetFiles": ["lib/main.dart"]
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "success": true,
+    "version": "1.0.0",
+    "capabilities": {
+      "analyze": true,
+      "getSymbolTable": true,
+      "rules": ["C001", "C008", "N001", "E001", "S003"]
+    }
+  }
+}
+```
+
+#### `analyze`
+
+Analyze a file with specified rules.
+
+**Request:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 2,
+  "method": "analyze",
+  "params": {
+    "filePath": "lib/main.dart",
+    "rules": [
+      {"id": "C001", "config": {"threshold": 10}},
+      {"id": "N001"}
+    ]
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 2,
+  "result": {
+    "violations": [
+      {
+        "ruleId": "C001",
+        "filePath": "/path/to/lib/main.dart",
+        "line": 15,
+        "column": 3,
+        "message": "Method \"processData\" has cyclomatic complexity of 12 (threshold: 10)",
+        "severity": "warning",
+        "analysisMethod": "ast"
+      }
+    ],
+    "fileAnalyzed": "lib/main.dart"
+  }
+}
+```
+
+#### `getSymbolTable`
+
+Get symbol table for a file.
+
+**Request:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 3,
+  "method": "getSymbolTable",
+  "params": {
+    "filePath": "lib/main.dart"
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 3,
+  "result": {
+    "filePath": "/path/to/lib/main.dart",
+    "fileName": "main.dart",
+    "imports": [...],
+    "classes": [...],
+    "functions": [...],
+    "variables": [...]
+  }
+}
+```
+
+#### `shutdown`
+
+Gracefully shut down the analyzer.
+
+**Request:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 4,
+  "method": "shutdown",
+  "params": {}
+}
+```
+
+#### `ping`
+
+Health check.
+
+**Request:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 5,
+  "method": "ping",
+  "params": {}
+}
+```
+
+## Supported Rules
+
+| Rule ID | Name | Description |
+|---------|------|-------------|
+| C001 | Code Complexity | Detects functions with high cyclomatic complexity |
+| C008 | Deep Nesting | Detects code with excessive nesting depth |
+| N001 | Naming Conventions | Enforces Dart naming conventions |
+| E001 | Error Handling | Detects empty catch blocks and ignored exceptions |
+| S003 | Security | Detects logging of sensitive data |
+
+## Testing
+
+```bash
+dart test
+```
+
+## License
+
+MIT

package/dart_analyzer/analysis_options.yaml

@@ -0,0 +1,66 @@
+include: package:lints/recommended.yaml
+
+analyzer:
+  exclude:
+    - build/**
+    - .dart_tool/**
+
+linter:
+  rules:
+    - always_declare_return_types
+    - annotate_overrides
+    - avoid_empty_else
+    - avoid_print
+    - avoid_relative_lib_imports
+    - avoid_returning_null_for_void
+    - avoid_types_as_parameter_names
+    - await_only_futures
+    - camel_case_extensions
+    - camel_case_types
+    - cancel_subscriptions
+    - close_sinks
+    - constant_identifier_names
+    - control_flow_in_finally
+    - curly_braces_in_flow_control_structures
+    - empty_catches
+    - empty_constructor_bodies
+    - empty_statements
+    - hash_and_equals
+    - implementation_imports
+    - library_names
+    - library_prefixes
+    - no_duplicate_case_values
+    - non_constant_identifier_names
+    - null_closures
+    - overridden_fields
+    - package_names
+    - package_prefixed_library_names
+    - prefer_adjacent_string_concatenation
+    - prefer_collection_literals
+    - prefer_conditional_assignment
+    - prefer_contains
+    - prefer_final_fields
+    - prefer_for_elements_to_map_fromIterable
+    - prefer_generic_function_type_aliases
+    - prefer_if_null_operators
+    - prefer_is_empty
+    - prefer_is_not_empty
+    - prefer_iterable_whereType
+    - prefer_single_quotes
+    - prefer_spread_collections
+    - prefer_typing_uninitialized_variables
+    - recursive_getters
+    - slash_for_doc_comments
+    - type_init_formals
+    - unawaited_futures
+    - unnecessary_brace_in_string_interps
+    - unnecessary_const
+    - unnecessary_getters_setters
+    - unnecessary_new
+    - unnecessary_null_in_if_null_operators
+    - unnecessary_statements
+    - unnecessary_this
+    - unrelated_type_equality_checks
+    - use_function_type_syntax_for_parameters
+    - use_rethrow_when_possible
+    - valid_regexps

package/dart_analyzer/bin/sunlint_dart_analyzer.dart

@@ -0,0 +1,124 @@
+import 'dart:io';
+
+import 'package:sunlint_dart_analyzer/json_rpc_server.dart';
+import 'package:sunlint_dart_analyzer/analyzer_service.dart';
+
+/// Entry point for SunLint Dart Analyzer
+/// This is the executable that communicates with SunLint's Node.js process
+/// via JSON-RPC over STDIO
+void main(List<String> arguments) async {
+  // Parse arguments
+  if (arguments.contains('--help') || arguments.contains('-h')) {
+    _printHelp();
+    return;
+  }
+
+  if (arguments.contains('--version') || arguments.contains('-v')) {
+    print('SunLint Dart Analyzer v1.0.0');
+    return;
+  }
+
+  // Check for standalone mode (for testing)
+  if (arguments.contains('--standalone')) {
+    await _runStandalone(arguments);
+    return;
+  }
+
+  // Normal mode: JSON-RPC server
+  final server = JsonRpcServer();
+  await server.start();
+
+  // Keep the process running until interrupted
+  await ProcessSignal.sigint.watch().first;
+  await server.stop();
+}
+
+/// Print help message
+void _printHelp() {
+  print('''
+SunLint Dart Analyzer
+
+Usage:
+  sunlint_dart_analyzer [options]
+
+Options:
+  --help, -h      Show this help message
+  --version, -v   Show version
+  --standalone    Run in standalone mode (for testing)
+
+Standalone mode options:
+  --file <path>   Analyze a single file
+  --rules <ids>   Comma-separated rule IDs (default: all)
+
+Examples:
+  # Normal mode (JSON-RPC server)
+  sunlint_dart_analyzer
+
+  # Standalone mode (for testing)
+  sunlint_dart_analyzer --standalone --file lib/main.dart
+  sunlint_dart_analyzer --standalone --file lib/main.dart --rules C001,N001
+''');
+}
+
+/// Run in standalone mode for testing
+Future<void> _runStandalone(List<String> arguments) async {
+  stderr.writeln('Running in standalone mode...');
+
+  // Parse arguments
+  String? filePath;
+  List<String>? ruleIds;
+
+  for (var i = 0; i < arguments.length; i++) {
+    if (arguments[i] == '--file' && i + 1 < arguments.length) {
+      filePath = arguments[i + 1];
+      i++;
+    } else if (arguments[i] == '--rules' && i + 1 < arguments.length) {
+      ruleIds = arguments[i + 1].split(',');
+      i++;
+    }
+  }
+
+  if (filePath == null) {
+    stderr.writeln('Error: --file is required in standalone mode');
+    exit(1);
+  }
+
+  // Create analyzer service
+  final analyzerService = AnalyzerService();
+
+  // Initialize with project path
+  final projectPath = Directory.current.path;
+  await analyzerService.initialize(
+    projectPath: projectPath,
+    targetFiles: [filePath],
+  );
+
+  stderr.writeln('Analyzing: $filePath');
+  stderr.writeln('Rules: ${ruleIds?.join(', ') ?? 'all'}');
+
+  // Analyze file
+  final violations = await analyzerService.analyzeFile(
+    filePath: filePath,
+    rulesData: ruleIds?.map((id) => {'id': id}).toList(),
+  );
+
+  // Print results
+  if (violations.isEmpty) {
+    print('No violations found!');
+  } else {
+    print('Found ${violations.length} violation(s):');
+    for (final v in violations) {
+      print('  ${v.ruleId} at line ${v.line}: ${v.message}');
+    }
+  }
+
+  // Get symbol table
+  stderr.writeln('\nSymbol Table:');
+  final symbolTable = await analyzerService.getSymbolTable(filePath);
+  if (symbolTable != null) {
+    stderr.writeln('  Imports: ${symbolTable.imports.length}');
+    stderr.writeln('  Classes: ${symbolTable.classes.length}');
+    stderr.writeln('  Functions: ${symbolTable.functions.length}');
+    stderr.writeln('  Variables: ${symbolTable.variables.length}');
+  }
+}