@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/json_rpc_server.dart

@@ -0,0 +1,275 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'analyzer_service.dart';
+
+/// JSON-RPC 2.0 Server for SunLint Dart Analyzer
+/// Communicates via STDIO with the Node.js parent process
+class JsonRpcServer {
+  final AnalyzerService _analyzerService;
+  bool _running = false;
+  StreamSubscription? _subscription;
+
+  JsonRpcServer() : _analyzerService = AnalyzerService();
+
+  /// Start the JSON-RPC server
+  /// Listens on stdin for requests, writes responses to stdout
+  Future<void> start() async {
+    if (_running) {
+      _logError('Server already running');
+      return;
+    }
+
+    _running = true;
+    _log('SunLint Dart Analyzer started');
+    _log('Listening for JSON-RPC requests on stdin...');
+
+    // Listen on stdin for newline-delimited JSON
+    _subscription = stdin
+        .transform(utf8.decoder)
+        .transform(const LineSplitter())
+        .listen(
+          _handleLine,
+          onError: _handleError,
+          onDone: _handleDone,
+        );
+  }
+
+  /// Stop the server
+  Future<void> stop() async {
+    _running = false;
+    await _subscription?.cancel();
+    _subscription = null;
+    _log('Server stopped');
+  }
+
+  /// Handle a single line of input (one JSON-RPC request)
+  Future<void> _handleLine(String line) async {
+    if (line.trim().isEmpty) return;
+
+    try {
+      final request = jsonDecode(line) as Map<String, dynamic>;
+      final response = await _processRequest(request);
+      _sendResponse(response);
+    } catch (e, stackTrace) {
+      _logError('Failed to process request: $e');
+      _logError('Stack trace: $stackTrace');
+      _sendResponse(_createErrorResponse(
+        null,
+        -32700,
+        'Parse error: $e',
+      ));
+    }
+  }
+
+  /// Process a JSON-RPC request and return a response
+  Future<Map<String, dynamic>> _processRequest(
+      Map<String, dynamic> request) async {
+    // Validate JSON-RPC 2.0 format
+    final jsonrpc = request['jsonrpc'];
+    if (jsonrpc != '2.0') {
+      return _createErrorResponse(
+        request['id'],
+        -32600,
+        'Invalid Request: jsonrpc must be "2.0"',
+      );
+    }
+
+    final method = request['method'] as String?;
+    if (method == null) {
+      return _createErrorResponse(
+        request['id'],
+        -32600,
+        'Invalid Request: method is required',
+      );
+    }
+
+    final id = request['id'];
+    final params = request['params'] as Map<String, dynamic>? ?? {};
+
+    try {
+      final result = await _invokeMethod(method, params);
+      return _createSuccessResponse(id, result);
+    } on MethodNotFoundException catch (e) {
+      return _createErrorResponse(id, -32601, e.message);
+    } on InvalidParamsException catch (e) {
+      return _createErrorResponse(id, -32602, e.message);
+    } catch (e, stackTrace) {
+      _logError('Error in method $method: $e');
+      _logError('Stack trace: $stackTrace');
+      return _createErrorResponse(id, -32603, 'Internal error: $e');
+    }
+  }
+
+  /// Invoke the requested method
+  Future<dynamic> _invokeMethod(
+      String method, Map<String, dynamic> params) async {
+    switch (method) {
+      case 'initialize':
+        return await _handleInitialize(params);
+      case 'analyze':
+        return await _handleAnalyze(params);
+      case 'getSymbolTable':
+        return await _handleGetSymbolTable(params);
+      case 'shutdown':
+        return await _handleShutdown(params);
+      case 'ping':
+        return _handlePing(params);
+      default:
+        throw MethodNotFoundException('Method not found: $method');
+    }
+  }
+
+  /// Handle initialize request
+  Future<Map<String, dynamic>> _handleInitialize(
+      Map<String, dynamic> params) async {
+    final projectPath = params['projectPath'] as String?;
+    if (projectPath == null) {
+      throw InvalidParamsException('projectPath is required');
+    }
+
+    final targetFiles = (params['targetFiles'] as List<dynamic>?)
+        ?.map((e) => e as String)
+        .toList();
+
+    final sdkPath = params['sdkPath'] as String?;
+
+    await _analyzerService.initialize(
+      projectPath: projectPath,
+      targetFiles: targetFiles,
+      sdkPath: sdkPath,
+    );
+
+    return {
+      'success': true,
+      'version': '1.0.0',
+      'capabilities': {
+        'analyze': true,
+        'getSymbolTable': true,
+        'rules': _analyzerService.supportedRules,
+      },
+    };
+  }
+
+  /// Handle analyze request
+  Future<Map<String, dynamic>> _handleAnalyze(
+      Map<String, dynamic> params) async {
+    final filePath = params['filePath'] as String?;
+    if (filePath == null) {
+      throw InvalidParamsException('filePath is required');
+    }
+
+    final rulesData = params['rules'] as List<dynamic>?;
+
+    final violations = await _analyzerService.analyzeFile(
+      filePath: filePath,
+      rulesData: rulesData,
+    );
+
+    return {
+      'violations': violations.map((v) => v.toJson()).toList(),
+      'fileAnalyzed': filePath,
+    };
+  }
+
+  /// Handle getSymbolTable request
+  Future<Map<String, dynamic>> _handleGetSymbolTable(
+      Map<String, dynamic> params) async {
+    final filePath = params['filePath'] as String?;
+    if (filePath == null) {
+      throw InvalidParamsException('filePath is required');
+    }
+
+    final symbolTable = await _analyzerService.getSymbolTable(filePath);
+
+    if (symbolTable == null) {
+      return {'error': 'Failed to parse file', 'filePath': filePath};
+    }
+
+    return symbolTable.toJson();
+  }
+
+  /// Handle shutdown request
+  Future<Map<String, dynamic>> _handleShutdown(
+      Map<String, dynamic> params) async {
+    _log('Shutdown requested');
+
+    // Schedule shutdown after response is sent
+    Future.delayed(const Duration(milliseconds: 100), () {
+      stop();
+      exit(0);
+    });
+
+    return {'success': true};
+  }
+
+  /// Handle ping request (for health checks)
+  Map<String, dynamic> _handlePing(Map<String, dynamic> params) {
+    return {
+      'pong': true,
+      'timestamp': DateTime.now().toIso8601String(),
+    };
+  }
+
+  /// Create a success response
+  Map<String, dynamic> _createSuccessResponse(dynamic id, dynamic result) {
+    return {
+      'jsonrpc': '2.0',
+      'id': id,
+      'result': result,
+    };
+  }
+
+  /// Create an error response
+  Map<String, dynamic> _createErrorResponse(
+      dynamic id, int code, String message) {
+    return {
+      'jsonrpc': '2.0',
+      'id': id,
+      'error': {
+        'code': code,
+        'message': message,
+      },
+    };
+  }
+
+  /// Send a response to stdout
+  void _sendResponse(Map<String, dynamic> response) {
+    final json = jsonEncode(response);
+    stdout.writeln(json);
+  }
+
+  /// Handle stream errors
+  void _handleError(dynamic error) {
+    _logError('Stream error: $error');
+  }
+
+  /// Handle stream done
+  void _handleDone() {
+    _log('Input stream closed');
+    _running = false;
+  }
+
+  /// Log to stderr (debug output)
+  void _log(String message) {
+    stderr.writeln('[SunLint Dart] $message');
+  }
+
+  /// Log error to stderr
+  void _logError(String message) {
+    stderr.writeln('[SunLint Dart ERROR] $message');
+  }
+}
+
+/// Exception for method not found errors
+class MethodNotFoundException implements Exception {
+  final String message;
+  MethodNotFoundException(this.message);
+}
+
+/// Exception for invalid params errors
+class InvalidParamsException implements Exception {
+  final String message;
+  InvalidParamsException(this.message);
+}

package/dart_analyzer/lib/models/rule.dart

@@ -0,0 +1,67 @@
+/// Represents a lint rule configuration
+class Rule {
+  /// Rule ID (e.g., 'C001', 'N001', 'S003')
+  final String id;
+
+  /// Rule name
+  final String name;
+
+  /// Rule description
+  final String description;
+
+  /// Severity level
+  final String severity;
+
+  /// Rule category
+  final String category;
+
+  /// Whether the rule is enabled
+  final bool enabled;
+
+  /// Rule-specific configuration
+  final Map<String, dynamic> config;
+
+  Rule({
+    required this.id,
+    this.name = '',
+    this.description = '',
+    this.severity = 'warning',
+    this.category = 'common',
+    this.enabled = true,
+    this.config = const {},
+  });
+
+  /// Get a config value with default
+  T getConfig<T>(String key, T defaultValue) {
+    final value = config[key];
+    if (value == null) return defaultValue;
+    if (value is T) return value;
+    return defaultValue;
+  }
+
+  /// Get threshold value (common for complexity rules)
+  int get threshold => getConfig('threshold', 10);
+
+  /// Get max depth (common for nesting rules)
+  int get maxDepth => getConfig('maxDepth', 4);
+
+  factory Rule.fromJson(Map<String, dynamic> json) => Rule(
+        id: json['id'] as String,
+        name: json['name'] as String? ?? '',
+        description: json['description'] as String? ?? '',
+        severity: json['severity'] as String? ?? 'warning',
+        category: json['category'] as String? ?? 'common',
+        enabled: json['enabled'] as bool? ?? true,
+        config: json['config'] as Map<String, dynamic>? ?? {},
+      );
+
+  Map<String, dynamic> toJson() => {
+        'id': id,
+        'name': name,
+        'description': description,
+        'severity': severity,
+        'category': category,
+        'enabled': enabled,
+        if (config.isNotEmpty) 'config': config,
+      };
+}