feat(ground-suite): add replay observability console

ground-suite/lib/features/diagnostics/presentation/diagnostics_page.dart

@@ -0,0 +1,273 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../../../core/observations/observed_event.dart';
+import '../../../shared/widgets/severity_badge.dart';
+import '../../observability/presentation/observability_controller.dart';
+
+enum _DiagnosticFilter { all, logs, errors, shutdowns }
+
+class DiagnosticsPage extends ConsumerStatefulWidget {
+  const DiagnosticsPage({super.key});
+
+  @override
+  ConsumerState<DiagnosticsPage> createState() => _DiagnosticsPageState();
+}
+
+class _DiagnosticsPageState extends ConsumerState<DiagnosticsPage> {
+  _DiagnosticFilter _filter = _DiagnosticFilter.all;
+  String _query = '';
+
+  @override
+  Widget build(BuildContext context) {
+    final state = ref.watch(observabilityControllerProvider);
+    final events = state.events.where(_matches).toList(growable: false);
+
+    return ListView(
+      padding: const EdgeInsets.all(24),
+      children: [
+        Text('Diagnostics', style: Theme.of(context).textTheme.headlineMedium),
+        const SizedBox(height: 8),
+        const Text(
+          'Messages remain distinct by protocol class. A configuration result '
+          'will remain authoritative when configuration support is added.',
+        ),
+        const SizedBox(height: 16),
+        Wrap(
+          spacing: 8,
+          runSpacing: 8,
+          children: _DiagnosticFilter.values
+              .map(
+                (filter) => ChoiceChip(
+                  label: Text(_labelFor(filter)),
+                  selected: _filter == filter,
+                  onSelected: (_) => setState(() => _filter = filter),
+                ),
+              )
+              .toList(growable: false),
+        ),
+        const SizedBox(height: 12),
+        TextField(
+          decoration: const InputDecoration(
+            border: OutlineInputBorder(),
+            labelText: 'Filter diagnostics',
+            prefixIcon: Icon(Icons.search),
+          ),
+          onChanged: (value) {
+            setState(() => _query = value.trim().toLowerCase());
+          },
+        ),
+        const SizedBox(height: 16),
+        if (events.isEmpty)
+          const Card(
+            child: Padding(
+              padding: EdgeInsets.all(20),
+              child: Text('No diagnostic observations match this filter.'),
+            ),
+          )
+        else
+          ...events.map((event) => _DiagnosticCard(event: event)),
+      ],
+    );
+  }
+
+  bool _matches(ObservedEvent event) {
+    final typeMatches = switch (_filter) {
+      _DiagnosticFilter.all =>
+        event is LogEvent || event is ErrorEvent || event is ShutdownEvent,
+      _DiagnosticFilter.logs => event is LogEvent,
+      _DiagnosticFilter.errors => event is ErrorEvent,
+      _DiagnosticFilter.shutdowns => event is ShutdownEvent,
+    };
+    if (!typeMatches) {
+      return false;
+    }
+    if (_query.isEmpty) {
+      return true;
+    }
+    return _searchableText(event).toLowerCase().contains(_query);
+  }
+}
+
+class _DiagnosticCard extends StatelessWidget {
+  const _DiagnosticCard({required this.event});
+
+  final ObservedEvent event;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final content = switch (event) {
+      LogEvent(:final level, :final message, :final flags) => _LogContent(
+        level: level,
+        message: message,
+        flags: flags,
+      ),
+      ErrorEvent(:final path, :final additionalInformation, :final flags) =>
+        _ErrorContent(
+          path: path,
+          additionalInformation: additionalInformation,
+          flags: flags,
+        ),
+      ShutdownEvent(:final reason) => _ShutdownContent(reason: reason),
+      _ => null,
+    };
+    if (content == null) {
+      return const SizedBox.shrink();
+    }
+
+    return Semantics(
+      container: true,
+      label: content.semanticLabel,
+      child: Card(
+        margin: const EdgeInsets.only(bottom: 12),
+        child: Padding(
+          padding: const EdgeInsets.all(16),
+          child: Row(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              content.leading,
+              const SizedBox(width: 12),
+              Expanded(
+                child: SelectionArea(
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      Text(content.title, style: theme.textTheme.titleMedium),
+                      const SizedBox(height: 4),
+                      Text(content.detail),
+                      if (content.additionalDetail case final detail?) ...[
+                        const SizedBox(height: 8),
+                        Text(detail),
+                      ],
+                      const SizedBox(height: 8),
+                      Text(
+                        event.receivedAt.toIso8601String(),
+                        style: theme.textTheme.bodySmall,
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+class _DiagnosticContent {
+  const _DiagnosticContent({
+    required this.leading,
+    required this.title,
+    required this.detail,
+    required this.semanticLabel,
+    this.additionalDetail,
+  });
+
+  final Widget leading;
+  final String title;
+  final String detail;
+  final String? additionalDetail;
+  final String semanticLabel;
+}
+
+class _LogContent extends _DiagnosticContent {
+  _LogContent({
+    required MavSeverity level,
+    required String message,
+    required int flags,
+  }) : super(
+         leading: SeverityBadge(level: level),
+         title: 'Log — ${level.label}',
+         detail: message,
+         additionalDetail: _formatLogFlags(flags),
+         semanticLabel: _semanticLogLabel(level, message, flags),
+       );
+}
+
+class _ErrorContent extends _DiagnosticContent {
+  _ErrorContent({
+    required String path,
+    required String additionalInformation,
+    required int flags,
+  }) : super(
+         leading: const SeverityBadge(level: MavSeverity.error),
+         title: 'Error',
+         detail: path,
+         additionalDetail: _formatErrorDetail(additionalInformation, flags),
+         semanticLabel: _semanticErrorLabel(path, additionalInformation, flags),
+       );
+}
+
+class _ShutdownContent extends _DiagnosticContent {
+  _ShutdownContent({required KaptanShutdownReason reason})
+    : super(
+        leading: const Icon(Icons.power_settings_new_outlined),
+        title: 'Orderly shutdown observed',
+        detail: 'Reason: ${reason.label}',
+        semanticLabel: 'Orderly shutdown observed: ${reason.label}',
+      );
+}
+
+String _labelFor(_DiagnosticFilter filter) => switch (filter) {
+  _DiagnosticFilter.all => 'All',
+  _DiagnosticFilter.logs => 'Logs',
+  _DiagnosticFilter.errors => 'Errors',
+  _DiagnosticFilter.shutdowns => 'Shutdowns',
+};
+
+String _searchableText(ObservedEvent event) => switch (event) {
+  LogEvent(:final level, :final message) => '${level.label} $message',
+  ErrorEvent(:final path, :final additionalInformation) =>
+    '$path $additionalInformation',
+  ShutdownEvent(:final reason) => reason.label,
+  _ => '',
+};
+
+String? _formatLogFlags(int flags) {
+  final labels = <String>[
+    if (flags & LogEvent.traceFlag != 0) 'Trace',
+    if (flags & LogEvent.truncatedFlag != 0) 'Truncated',
+    if (flags & LogEvent.coalescedFlag != 0) 'Coalesced',
+    if (flags & ~LogEvent.knownFlags != 0)
+      'Unknown bits 0x${(flags & ~LogEvent.knownFlags).toRadixString(16)}',
+  ];
+  return labels.isEmpty ? null : 'Flags: ${labels.join(', ')}';
+}
+
+String? _formatErrorDetail(String additionalInformation, int flags) {
+  final flagDetail = _formatErrorFlags(flags);
+  final details = <String>[
+    if (additionalInformation.isNotEmpty) additionalInformation,
+    ?flagDetail,
+  ];
+  return details.isEmpty ? null : details.join('\n');
+}
+
+String? _formatErrorFlags(int flags) {
+  final labels = <String>[
+    if (flags & ErrorEvent.truncatedFlag != 0) 'Truncated',
+    if (flags & ErrorEvent.coalescedFlag != 0) 'Coalesced',
+    if (flags & ~ErrorEvent.knownFlags != 0)
+      'Unknown bits 0x${(flags & ~ErrorEvent.knownFlags).toRadixString(16)}',
+  ];
+  return labels.isEmpty ? null : 'Flags: ${labels.join(', ')}';
+}
+
+String _semanticLogLabel(MavSeverity level, String message, int flags) {
+  final flagDetail = _formatLogFlags(flags);
+  return flagDetail == null
+      ? '${level.label} log: $message'
+      : '${level.label} log: $message. $flagDetail';
+}
+
+String _semanticErrorLabel(
+  String path,
+  String additionalInformation,
+  int flags,
+) {
+  final detail = _formatErrorDetail(additionalInformation, flags);
+  return detail == null ? 'Error: $path' : 'Error: $path. $detail';
+}