From 1d648c520ed35ebc1581e7e0c0311c0b4f144076 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Thu, 22 Oct 2026 03:31:21 +0100 Subject: [PATCH] feat(app): expand a recorded chat activity line in place The summary line now carries the host's own disclosure control and, when expanded, the recorded lifecycle, input, output, error, duration and edit diff. Each absent field keeps an exact sentence; no value is inferred from answer text. --- .../chat/conversation/chat_thread_view.dart | 170 +++++++++++++-- .../chat/domain/chat_activity_detail.dart | 194 ++++++++++++++++++ .../conversation/chat_activity_line_test.dart | 141 ++++++++++++- 3 files changed, 475 insertions(+), 30 deletions(-) create mode 100644 app/lib/features/chat/domain/chat_activity_detail.dart diff --git a/app/lib/features/chat/conversation/chat_thread_view.dart b/app/lib/features/chat/conversation/chat_thread_view.dart index c7e61716..9e089695 100644 --- a/app/lib/features/chat/conversation/chat_thread_view.dart +++ b/app/lib/features/chat/conversation/chat_thread_view.dart @@ -4,6 +4,7 @@ import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import '../../../core/api_gateway.dart'; +import '../domain/chat_activity_detail.dart'; import '../domain/chat_transcript.dart'; import '../ui/sessions/chat_adaptive.dart'; import '../ui/transcript/chat_markdown_view.dart'; @@ -313,27 +314,48 @@ class _ChatThreadViewState extends State { /// One recorded activity line for a turn. /// -/// The line is a summary, not a control: expansion belongs to the later overlay -/// slice. Its wording and state come from the recorded row, and the icon only -/// repeats that state with theme roles, so an unknown kind or state is still -/// readable without colour. -class _ChatActivityLine extends StatelessWidget { +/// The line is a summary of the recorded sequence. Its wording and state come +/// from the recorded row, and the icon only repeats that state with theme roles, +/// so an unknown kind or state is still readable without colour. The trailing +/// control expands the same line into the recorded lifecycle and any recorded +/// input, output, error, duration and edit diff; collapsing restores the single +/// line without touching the turn. +class _ChatActivityLine extends StatefulWidget { const _ChatActivityLine({required this.row}); final JsonMap row; + @override + State<_ChatActivityLine> createState() => _ChatActivityLineState(); +} + +class _ChatActivityLineState extends State<_ChatActivityLine> { + bool _expanded = false; + + void _toggle() => setState(() => _expanded = !_expanded); + + /// The latest recorded update, which is also the line's label/state. With no + /// records (a caller-built row) the row itself carries the same fields. + JsonMap _record() { + final records = widget.row['records']; + if (records is List) { + for (final record in records.reversed) { + if (record is Map) return JsonMap.from(record); + } + } + return widget.row; + } + @override Widget build(BuildContext context) { final cupertino = chatControlsStyleOf(context) == ChatControlsStyle.cupertino; - final state = '${row['state'] ?? ''}'.trim().toLowerCase(); + final state = '${widget.row['state'] ?? ''}'.trim().toLowerCase(); final failed = state == 'failed' || state == 'error'; final running = state == 'running'; final completed = state == 'completed' || state == 'ended' || state == 'succeeded'; - final secondary = cupertino - ? CupertinoColors.secondaryLabel.resolveFrom(context) - : Theme.of(context).colorScheme.onSurfaceVariant; + final secondary = _secondary(context, cupertino); final color = failed ? (cupertino ? CupertinoColors.systemRed.resolveFrom(context) @@ -355,24 +377,130 @@ class _ChatActivityLine extends StatelessWidget { ? CupertinoIcons.check_mark_circled : Icons.check_circle_outline) : (cupertino ? CupertinoIcons.circle : Icons.circle_outlined); - final label = '${row['label'] ?? ''}'.trim(); - return Semantics( - container: true, - label: label, - value: state, - child: ExcludeSemantics( - child: Padding( - padding: const EdgeInsets.symmetric(vertical: 6), - child: Row( + final label = '${widget.row['label'] ?? ''}'.trim(); + return Padding( + padding: const EdgeInsets.symmetric(vertical: 6), + child: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Row( crossAxisAlignment: CrossAxisAlignment.start, children: [ - Icon(icon, color: color), - const SizedBox(width: 8), - Expanded(child: Text(label, style: style)), + Expanded( + child: Semantics( + container: true, + label: label, + value: state, + child: ExcludeSemantics( + child: Row( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Icon(icon, color: color), + const SizedBox(width: 8), + Expanded(child: Text(label, style: style)), + ], + ), + ), + ), + ), + _toggleControl(cupertino), ], ), + if (_expanded) _detail(context, cupertino, secondary), + ], + ), + ); + } + + /// The host's own disclosure control, with an action label that states what a + /// tap does. Cupertino's button has no built-in label, so the wrapping node + /// carries it and the button keeps the pointer handling. + Widget _toggleControl(bool cupertino) { + const key = ValueKey('chat-activity-toggle'); + final label = _expanded ? 'Collapse activity' : 'Expand activity'; + final icon = Icon( + _expanded + ? (cupertino ? CupertinoIcons.chevron_up : Icons.expand_less) + : (cupertino ? CupertinoIcons.chevron_down : Icons.expand_more), + ); + if (!cupertino) { + return IconButton( + key: key, + tooltip: label, + onPressed: _toggle, + icon: icon, + ); + } + return Semantics( + container: true, + button: true, + label: label, + onTap: _toggle, + child: ExcludeSemantics( + child: CupertinoButton( + key: key, + padding: EdgeInsets.zero, + onPressed: _toggle, + child: icon, ), ), ); } + + /// The expanded section: every recorded field, with the exact absence sentence + /// for one the record did not carry. Only [ChatActivityDetail] reads the + /// record, so the line and its details cannot disagree about a field. + Widget _detail(BuildContext context, bool cupertino, Color secondary) { + final detail = chatActivityDetail(_record()); + final baseStyle = cupertino + ? CupertinoTheme.of(context).textTheme.textStyle + : Theme.of(context).textTheme.bodyMedium; + final labelStyle = TextStyle(color: secondary, fontWeight: FontWeight.w600); + Widget field(String label, String value) { + final absent = + value == chatActivityLifecycleAbsent || + value == chatActivityInputAbsent || + value == chatActivityOutputAbsent || + value == chatActivityErrorAbsent || + value == chatActivityDurationAbsent || + value == chatActivityDiffAbsent; + return Padding( + padding: const EdgeInsetsDirectional.only(top: 8), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(label, style: labelStyle), + DefaultTextStyle.merge( + style: absent ? TextStyle(color: secondary) : const TextStyle(), + child: SelectableText(value), + ), + ], + ), + ); + } + + return DefaultTextStyle.merge( + style: baseStyle, + child: Padding( + key: const ValueKey('chat-activity-details'), + padding: const EdgeInsetsDirectional.only(bottom: 2), + child: Column( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + field('Lifecycle', detail.lifecycle), + field('Input', detail.input), + field('Output', detail.output), + field('Error', detail.error), + field('Duration', detail.duration), + field('Edit diff', detail.diff), + ], + ), + ), + ); + } + + Color _secondary(BuildContext context, bool cupertino) => cupertino + ? CupertinoColors.secondaryLabel.resolveFrom(context) + : Theme.of(context).colorScheme.onSurfaceVariant; } diff --git a/app/lib/features/chat/domain/chat_activity_detail.dart b/app/lib/features/chat/domain/chat_activity_detail.dart new file mode 100644 index 00000000..746aca4d --- /dev/null +++ b/app/lib/features/chat/domain/chat_activity_detail.dart @@ -0,0 +1,194 @@ +import 'dart:convert'; + +import '../../../core/api_gateway.dart'; +import 'chat_transcript.dart'; + +/// The exact sentence for a recorded activity field the server did not send. +/// Input and Output reuse the run detail's own wording, so the same absent fact +/// never reads differently in this app. +const String chatActivityLifecycleAbsent = 'No lifecycle recorded.'; +const String chatActivityInputAbsent = 'No input recorded.'; +const String chatActivityOutputAbsent = 'No output recorded.'; +const String chatActivityErrorAbsent = 'No error recorded.'; +const String chatActivityDurationAbsent = 'No duration recorded.'; +const String chatActivityDiffAbsent = 'No edit diff recorded.'; + +/// The recorded detail behind one activity line. +/// +/// Every field is the value the server recorded on the line's latest record, or +/// the exact absence sentence above. Nothing is inferred from answer text and an +/// empty string/map/list is absent rather than a blank block. +class ChatActivityDetail { + const ChatActivityDetail({ + required this.lifecycle, + required this.input, + required this.output, + required this.error, + required this.duration, + required this.diff, + }); + + final String lifecycle; + final String input; + final String output; + final String error; + final String duration; + final String diff; +} + +/// The expanded detail of [record], reading only the fields the parsed activity +/// record already carries. +/// +/// Tool-style records keep their payload in `state` (input, content, error and +/// the invocation's timing envelope), while an activity record may carry the same +/// names at the top level; the top-level value wins when both are present. +ChatActivityDetail chatActivityDetail(JsonMap record) { + final state = record['state'] is Map + ? JsonMap.from(record['state'] as Map) + : const {}; + return ChatActivityDetail( + lifecycle: _lifecycle(record, state) ?? chatActivityLifecycleAbsent, + input: _input(record, state) ?? chatActivityInputAbsent, + output: _output(record, state) ?? chatActivityOutputAbsent, + error: _error(record, state) ?? chatActivityErrorAbsent, + duration: _duration(record, state) ?? chatActivityDurationAbsent, + diff: _diff(record, state) ?? chatActivityDiffAbsent, + ); +} + +/// The lifecycle state, including a tool-style `state` map's `status`. +String? _lifecycle(JsonMap record, JsonMap state) { + if (record['state'] is! Map) { + final recorded = chatActivityState(record); + if (recorded.isNotEmpty) return recorded; + } + for (final key in const ['status', 'lifecycle']) { + final text = _scalar(record[key]); + if (text != null) return text; + } + for (final key in const ['status', 'state', 'lifecycle']) { + final text = _scalar(state[key]); + if (text != null) return text; + } + return null; +} + +String? _input(JsonMap record, JsonMap state) => + _display(_field(record, state, 'input')); + +/// The textual output, either an `output` field or a tool-style `content` list +/// of text parts. A content entry that is not text is not answer output. +String? _output(JsonMap record, JsonMap state) { + final direct = _display(_field(record, state, 'output')); + if (direct != null) return direct; + final content = _field(record, state, 'content'); + if (content is! List) return null; + final text = content + .whereType() + .where((item) => item['type'] == 'text') + .map((item) => '${item['text'] ?? ''}') + .where((item) => item.trim().isNotEmpty) + .join('\n'); + return text.isEmpty ? null : text; +} + +/// A structured error's message (or type when it has no message), else the +/// recorded error text. +String? _error(JsonMap record, JsonMap state) { + final value = _field(record, state, 'error'); + if (value is Map) { + return _display(value['message']) ?? + _display(value['type']) ?? + _display(value); + } + return _display(value); +} + +/// A recorded duration, else one derived from the record's own timing envelope. +String? _duration(JsonMap record, JsonMap state) { + final direct = record['duration'] ?? state['duration']; + if (direct is String && direct.trim().isNotEmpty) return direct; + if (direct is num) return _formatMillis(direct.round()); + final millis = record['duration_ms'] ?? state['duration_ms']; + if (millis is num) return _formatMillis(millis.round()); + final time = record['time'] ?? state['time']; + if (time is! Map) return null; + final start = _millis(time['ran']) ?? _millis(time['created']); + final completed = _millis(time['completed']); + if (start == null || completed == null || completed < start) return null; + return _formatMillis(completed - start); +} + +/// A recorded edit diff, either its text or its line list. A line list keeps the +/// recorded `+`/`-` gutter; no diff is synthesised from an edit call's strings. +String? _diff(JsonMap record, JsonMap state) { + final value = _field(record, state, 'diff'); + if (value is String) return value.trim().isEmpty ? null : value; + if (value is! Map) return _display(value); + final lines = value['lines']; + if (lines is List && lines.isNotEmpty) { + final rendered = []; + final file = _display(value['file']); + if (file != null) rendered.add(file); + final added = _int(value['added']); + final removed = _int(value['removed']); + if (added != null || removed != null) { + rendered.add('+${added ?? 0} -${removed ?? 0}'); + } + for (final line in lines) { + if (line is Map) { + final text = '${line['text'] ?? ''}'; + switch ('${line['kind'] ?? ''}'.toLowerCase()) { + case 'add': + rendered.add('+ $text'); + case 'remove': + rendered.add('- $text'); + default: + rendered.add(' $text'); + } + } else { + rendered.add('$line'); + } + } + return rendered.join('\n'); + } + return _display(value['text'] ?? value['patch']) ?? _display(value); +} + +Object? _field(JsonMap record, JsonMap state, String key) { + final value = record[key]; + if (!_absent(value)) return value; + final nested = state[key]; + return _absent(nested) ? null : nested; +} + +bool _absent(Object? value) => + value == null || + (value is String && value.trim().isEmpty) || + (value is Map && value.isEmpty) || + (value is List && value.isEmpty); + +/// A scalar's exact text or a map/list as formatted, selectable JSON. +String? _display(Object? value) { + if (_absent(value)) return null; + if (value is String) return value; + if (value is Map || value is List) { + return const JsonEncoder.withIndent(' ').convert(value); + } + return '$value'; +} + +/// A scalar's text; a structured value is not a lifecycle state. +String? _scalar(Object? value) => + value is Map || value is List ? null : _display(value); + +int? _millis(Object? value) => value is num ? value.toInt() : null; + +int? _int(Object? value) => value is num ? value.toInt() : null; + +/// The compact duration wording shared with the web's `formatToolDuration`. +String _formatMillis(int millis) { + if (millis < 1000) return '${millis}ms'; + if (millis < 60000) return '${(millis / 1000).toStringAsFixed(1)}s'; + return '${millis ~/ 60000}m ${(millis % 60000) ~/ 1000}s'; +} diff --git a/app/test/features/chat/conversation/chat_activity_line_test.dart b/app/test/features/chat/conversation/chat_activity_line_test.dart index b724f9c9..d21782a6 100644 --- a/app/test/features/chat/conversation/chat_activity_line_test.dart +++ b/app/test/features/chat/conversation/chat_activity_line_test.dart @@ -174,6 +174,7 @@ void main() { Future pumpThread( WidgetTester tester, { required bool cupertino, + List? activityParts, }) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); @@ -188,15 +189,17 @@ void main() { chatMessage( 'a1', 'assistant', - parts: [ - { - 'type': 'activity', - 'id': 'e1', - 'kind': 'compaction', - 'state': 'running', - }, - {'type': 'text', 'id': 't1', 'text': 'Answer'}, - ], + parts: + activityParts ?? + [ + { + 'type': 'activity', + 'id': 'e1', + 'kind': 'compaction', + 'state': 'running', + }, + {'type': 'text', 'id': 't1', 'text': 'Answer'}, + ], ), ]); final view = ChatThreadView( @@ -236,5 +239,125 @@ void main() { expect(find.text('Answer'), findsOneWidget); expect(find.textContaining('Unrecognised part'), findsNothing); }); + + group('expanded detail', () { + final recorded = [ + { + 'type': 'activity', + 'id': 'e1', + 'kind': 'tool', + 'state': 'completed', + 'label': 'Ran a tool', + 'input': {'command': 'ls'}, + 'output': 'two files', + 'error': 'exit 1', + 'duration': 1200, + 'diff': { + 'file': 'lib/main.dart', + 'added': 1, + 'removed': 1, + 'lines': [ + {'kind': 'remove', 'text': 'old'}, + {'kind': 'add', 'text': 'new'}, + ], + }, + }, + {'type': 'text', 'id': 't1', 'text': 'Answer'}, + ]; + final sparse = [ + { + 'type': 'activity', + 'id': 'e1', + 'kind': 'compaction', + 'state': 'running', + }, + {'type': 'text', 'id': 't1', 'text': 'Answer'}, + ]; + + Future toggle(WidgetTester tester) async { + final control = find.byKey( + const ValueKey('chat-activity-toggle'), + ); + await tester.ensureVisible(control); + await tester.tap(control); + await tester.pumpAndSettle(); + } + + for (final cupertino in [false, true]) { + final host = cupertino ? 'Cupertino' : 'Material'; + + testWidgets('$host shows only the recorded detail values', ( + tester, + ) async { + await pumpThread( + tester, + cupertino: cupertino, + activityParts: recorded, + ); + await toggle(tester); + + expect( + find.byKey(const ValueKey('chat-activity-details')), + findsOneWidget, + ); + expect(find.text('Lifecycle'), findsOneWidget); + expect(find.text('completed'), findsOneWidget); + expect(find.textContaining('"command": "ls"'), findsOneWidget); + expect(find.text('two files'), findsOneWidget); + expect(find.text('exit 1'), findsOneWidget); + expect(find.text('1.2s'), findsOneWidget); + expect( + find.text('lib/main.dart\n+1 -1\n- old\n+ new'), + findsOneWidget, + ); + for (final absent in const [ + 'No lifecycle recorded.', + 'No input recorded.', + 'No output recorded.', + 'No error recorded.', + 'No duration recorded.', + 'No edit diff recorded.', + ]) { + expect(find.text(absent), findsNothing, reason: absent); + } + }); + + testWidgets('$host words every absent field exactly', (tester) async { + await pumpThread(tester, cupertino: cupertino, activityParts: sparse); + await toggle(tester); + + expect(find.text('running'), findsOneWidget); + expect(find.text('No input recorded.'), findsOneWidget); + expect(find.text('No output recorded.'), findsOneWidget); + expect(find.text('No error recorded.'), findsOneWidget); + expect(find.text('No duration recorded.'), findsOneWidget); + expect(find.text('No edit diff recorded.'), findsOneWidget); + expect(find.text('No lifecycle recorded.'), findsNothing); + }); + + testWidgets('$host collapses back to the single line', (tester) async { + await pumpThread( + tester, + cupertino: cupertino, + activityParts: recorded, + ); + await toggle(tester); + expect( + find.byKey(const ValueKey('chat-activity-details')), + findsOneWidget, + ); + + await toggle(tester); + + expect( + find.byKey(const ValueKey('chat-activity-details')), + findsNothing, + ); + expect(find.text('Input'), findsNothing); + expect(find.text('Ran a tool'), findsOneWidget); + expect(find.text('Answer'), findsOneWidget); + }); + } + }); }); }