diff --git a/app/lib/features/chat/conversation/chat_scroll.dart b/app/lib/features/chat/conversation/chat_scroll.dart index 20d3acc4..e1df6f6d 100644 --- a/app/lib/features/chat/conversation/chat_scroll.dart +++ b/app/lib/features/chat/conversation/chat_scroll.dart @@ -74,27 +74,35 @@ String chatJumpToLatestLabel(int newMessages) { /// Where a conversation's transcript is placed when it first shows. /// /// No saved position means the operator has none of their own: open at the -/// newest content. A saved offset is kept, clamped to the current end, so a +/// newest content. A saved offset is kept, clamped to the current extent, so a /// conversation whose content grew or shrank while it was closed still lands on -/// a real position. +/// a real position. A bottom-anchored transcript measures older rows above its +/// centre, so its offsets (and [minScrollExtent]) can be negative. double chatRestoreOffset({ required double? savedOffset, required double maxScrollExtent, + double minScrollExtent = 0, }) { if (savedOffset == null) return maxScrollExtent; - return savedOffset.clamp(0.0, maxScrollExtent).toDouble(); + return savedOffset.clamp(minScrollExtent, maxScrollExtent).toDouble(); } +/// A saved transcript position: the scroll offset and the message id of the +/// row the transcript was split at (see `chatTranscriptAnchor`), or null for a +/// top-anchored transcript whose offset counts from its first row. An offset +/// only means something measured from the same anchor. +typedef ChatScrollPosition = ({double offset, String? anchor}); + /// Per-conversation transcript positions, kept while the chat list stays /// mounted. A conversation opened again returns to the position the operator /// left; one they never moved in opens at its newest message. abstract interface class ChatScrollStore { - /// The offset the operator left this conversation at, or null when they never - /// scrolled away from its end. - double? read(String sessionId); + /// The position the operator left this conversation at, or null when they + /// never scrolled away from its end. + ChatScrollPosition? read(String sessionId); /// Records a deliberate position away from the end. - void write(String sessionId, double offset); + void write(String sessionId, ChatScrollPosition position); /// Forgets the position once the operator is following the end again. void clear(String sessionId); @@ -107,19 +115,22 @@ abstract interface class ChatScrollStore { /// client keeps no transcript position on disk and does not import the web's /// storage keys. class MemoryChatScrollStore implements ChatScrollStore { - final Map _offsets = {}; + final Map _offsets = {}; - /// A snapshot of the stored offsets, so a test can tell a cleared + /// A snapshot of the stored positions, so a test can tell a cleared /// conversation from one that was never moved. - Map get entries => Map.unmodifiable(_offsets); + Map get entries => Map.unmodifiable(_offsets); @override - double? read(String sessionId) => _offsets[sessionId]; + ChatScrollPosition? read(String sessionId) => _offsets[sessionId]; @override - void write(String sessionId, double offset) { - if (!offset.isFinite || offset < 0) return; - _offsets[sessionId] = offset; + void write(String sessionId, ChatScrollPosition position) { + // A top-anchored offset counts from the first row and is never negative; + // a bottom-anchored one is negative above its centre. + if (!position.offset.isFinite) return; + if (position.anchor == null && position.offset < 0) return; + _offsets[sessionId] = position; } @override diff --git a/app/lib/features/chat/conversation/chat_thread_view.dart b/app/lib/features/chat/conversation/chat_thread_view.dart index 4abe59c5..f03560d5 100644 --- a/app/lib/features/chat/conversation/chat_thread_view.dart +++ b/app/lib/features/chat/conversation/chat_thread_view.dart @@ -35,7 +35,9 @@ import '../../../ui/adaptive/segmented_bar_overlay.dart'; import '../../../ui/layout/app_sheet_header.dart'; import 'chat_reading_width.dart'; import 'chat_thread_header.dart'; +import 'chat_transcript_anchor.dart'; import 'chat_transcript_cache.dart'; +import 'chat_transcript_scroll_view.dart'; import 'chat_permission_card_model.dart'; import 'chat_permission_group.dart'; import 'chat_transcript_card.dart'; @@ -185,7 +187,12 @@ class _ChatThreadViewState extends State { /// The conversation's saved position, read when this view is attached and /// consumed by the first placement after the history arrives. - double? _savedOffset; + ChatScrollPosition? _savedPosition; + + /// The message id the transcript is split at (see [chatTranscriptAnchor]), + /// chosen once when the history first arrives; null keeps it top-anchored. + String? _anchor; + bool _anchorChosen = false; bool _placed = false; bool _pinScheduled = false; @@ -384,7 +391,7 @@ class _ChatThreadViewState extends State { @override void initState() { super.initState(); - _savedOffset = widget.scrollPositions?.read(widget.sessionId); + _savedPosition = widget.scrollPositions?.read(widget.sessionId); _adoptCachedTranscript(); _seedCommandNotice(); } @@ -416,7 +423,9 @@ class _ChatThreadViewState extends State { _syncGeneration++; _commandNotices.clear(); _seedCommandNotice(); - _savedOffset = widget.scrollPositions?.read(widget.sessionId); + _savedPosition = widget.scrollPositions?.read(widget.sessionId); + _anchor = null; + _anchorChosen = false; _placed = false; _following = true; _distanceFromBottom = null; @@ -489,11 +498,8 @@ class _ChatThreadViewState extends State { store.clear(id); return; } - if (_scroll.hasClients) { - store.write(id, _scroll.position.pixels); - } else { - store.write(id, _lastOffset); - } + final offset = _scroll.hasClients ? _scroll.position.pixels : _lastOffset; + store.write(id, (offset: offset, anchor: _anchor)); } /// Measured distance from the end for the current content. @@ -535,11 +541,21 @@ class _ChatThreadViewState extends State { /// the operator left one, otherwise the newest message. void _placeFromStore() { if (!_scroll.hasClients) return; + final saved = _savedPosition; + if (_anchor != null && + saved == null && + _scroll.position.minScrollExtent >= 0) { + // The rows above the centre do not fill the viewport, so a bottom-anchored + // list would leave a gap above them. A transcript this short is cheap to + // lay out whole: show it top-anchored, from its first row, as before. + setState(() => _anchor = null); + _scheduleFollow(); + return; + } _placed = true; - final saved = _savedOffset; - _savedOffset = null; + _savedPosition = null; if (saved != null) { - _restoreOffset = saved; + _restoreOffset = saved.offset; _restoring = true; _following = false; _newestAtRelease = null; @@ -564,6 +580,7 @@ class _ChatThreadViewState extends State { final target = chatRestoreOffset( savedOffset: _restoreOffset, maxScrollExtent: end, + minScrollExtent: _scroll.position.minScrollExtent, ); if (_scroll.position.pixels != target) _scroll.jumpTo(target); _lastOffset = target; @@ -680,6 +697,35 @@ class _ChatThreadViewState extends State { _restoreOffset = null; } + /// The index of the row the transcript is split at, or -1 to keep it + /// top-anchored. The anchor is chosen once, when the history first arrives: + /// a saved position keeps the anchor it was measured from. + int _splitFor(List rows) { + if (!_controller.loaded) return -1; + if (!_anchorChosen) { + _anchorChosen = true; + final saved = _savedPosition; + if (saved != null && + saved.anchor != null && + chatTranscriptAnchorIndex(rows, saved.anchor) < 0) { + // The row the position was measured from is gone: the offset no longer + // names a place in this transcript, so it opens at the newest message. + _savedPosition = null; + } + _anchor = _savedPosition == null + ? chatTranscriptAnchor(rows) + : _savedPosition!.anchor; + } + var index = chatTranscriptAnchorIndex(rows, _anchor); + if (index < 0 && _anchor != null) { + // A repair replaced the transcript without the anchor row: split the new + // one afresh (a following view is pinned to its end again after layout). + _anchor = chatTranscriptAnchor(rows); + index = chatTranscriptAnchorIndex(rows, _anchor); + } + return index; + } + @override Widget build(BuildContext context) => AnimatedBuilder( animation: Listenable.merge([ @@ -743,6 +789,7 @@ class _ChatThreadViewState extends State { // its previous messages, keeping the element (and its open disclosures) // across paging and streaming. final keys = _rowKeys.forRows(rows); + final split = _splitFor(rows); final initialLoad = !_controller.loaded && _controller.loading; final historyNotice = _noticeOf( notices, @@ -825,11 +872,16 @@ class _ChatThreadViewState extends State { children: [ // At rest the first item starts below the floating bar // and the last one ends above the floating composer. - ListView( + // Bottom-anchored at the split row, the newest rows are + // laid out first and older ones only when scrolled to. + ChatTranscriptScrollView( key: ValueKey( 'chat-thread-${widget.sessionId}', ), controller: _scroll, + splitAfter: split < 0 + ? null + : ValueKey(keys[split]), padding: EdgeInsets.fromLTRB( side, media.top + 8, diff --git a/app/lib/features/chat/conversation/chat_transcript_anchor.dart b/app/lib/features/chat/conversation/chat_transcript_anchor.dart new file mode 100644 index 00000000..7be25b3a --- /dev/null +++ b/app/lib/features/chat/conversation/chat_transcript_anchor.dart @@ -0,0 +1,69 @@ +import '../../../core/api_gateway.dart'; + +/// Where an opened transcript is split into its older and newer halves. +/// +/// Opening a long conversation at its newest message used to lay out every row +/// above it: a top-anchored list can only reach its end by measuring the rows +/// in between. The transcript is instead a two-sided scroll view whose centre +/// sits between an anchor row and the rows after it. The anchor row and every +/// older row grow upwards from the centre; the rows after it (and the queued, +/// unsent and command lines) grow downwards. Opening lays out only what shows. +/// +/// The split is fixed for as long as the conversation is open, so growth on +/// either side never moves the other: an older page loaded above, or a reply +/// streaming below, leaves the operator's reading position where it is. The +/// newest message row (and a reply that is still streaming) is never the +/// anchor or above it, because a row above the centre that grew would push the +/// rows above it up while the operator reads them. +/// +/// Returns null when the transcript has fewer than two message rows: there is +/// nothing older to keep unmeasured, and the view stays top-anchored. +String? chatTranscriptAnchor(List rows) { + var cut = -1; + for (var index = rows.length - 1; index >= 0; index--) { + if (_messageIds(rows[index]).isNotEmpty) { + cut = index; + break; + } + } + for (var index = 0; index < rows.length; index++) { + if (rows[index]['streaming'] == true && index < cut) { + cut = index; + break; + } + } + for (var index = cut - 1; index >= 0; index--) { + final ids = _messageIds(rows[index]); + if (ids.isNotEmpty) return ids.last; + } + return null; +} + +/// The index of the row that holds [anchor], or -1 when no row does (a repair +/// replaced the transcript) or there is no anchor. +int chatTranscriptAnchorIndex(List rows, String? anchor) { + if (anchor == null) return -1; + for (var index = rows.length - 1; index >= 0; index--) { + if (_messageIds(rows[index]).contains(anchor)) return index; + } + return -1; +} + +/// The stored message ids of one user or assistant row. Cards, activity lines +/// and the pending-response shell carry none and can never be an anchor. +List _messageIds(JsonMap row) { + final kind = row['kind']; + if (kind == 'assistant') { + final listed = row['messageIds']; + if (listed is! List) return const []; + return [ + for (final id in listed) + if ('$id'.trim().isNotEmpty) '$id'.trim(), + ]; + } + if (kind == 'user') { + final id = '${row['key'] ?? ''}'.trim(); + return id.isEmpty ? const [] : [id]; + } + return const []; +} diff --git a/app/lib/features/chat/conversation/chat_transcript_scroll_view.dart b/app/lib/features/chat/conversation/chat_transcript_scroll_view.dart new file mode 100644 index 00000000..0a48a0de --- /dev/null +++ b/app/lib/features/chat/conversation/chat_transcript_scroll_view.dart @@ -0,0 +1,64 @@ +import 'package:flutter/widgets.dart'; + +/// The transcript's scrollable: older rows above a centre, newer rows below. +/// +/// With [splitAfter], the children up to and including the one with that key +/// sit above the centre and the rest below it. The centre is at the viewport's +/// bottom edge at offset zero: the older children grow upwards from it and the +/// newer ones downwards, so the newest rows are laid out first and an older row +/// only when it is scrolled to. Offsets above the centre are negative. +/// +/// Without one (or when no child has that key) this is a plain top-anchored +/// list starting at its first child. A transcript that fits its viewport stays +/// top-anchored, so a short conversation still reads from the top. +/// +/// [padding] keeps the first child below the floating bar and the last child +/// above the floating composer, as a list's padding would. +class ChatTranscriptScrollView extends StatelessWidget { + const ChatTranscriptScrollView({ + super.key, + required this.controller, + required this.padding, + required this.children, + this.splitAfter, + }); + + static const _centre = ValueKey('chat-thread-newer'); + + final ScrollController controller; + final EdgeInsets padding; + final List children; + final Key? splitAfter; + + @override + Widget build(BuildContext context) { + final split = splitAfter == null + ? -1 + : children.indexWhere((child) => child.key == splitAfter); + final anchored = split >= 0; + return CustomScrollView( + controller: controller, + center: _centre, + anchor: anchored ? 1 : 0, + slivers: [ + // Before the centre, a sliver grows upwards: its first child sits at + // the centre, so the older children go in newest-first. + SliverPadding( + padding: anchored ? padding.copyWith(bottom: 0) : EdgeInsets.zero, + sliver: SliverList( + delegate: SliverChildListDelegate([ + for (var index = split; index >= 0; index--) children[index], + ]), + ), + ), + SliverPadding( + key: _centre, + padding: anchored ? padding.copyWith(top: 0) : padding, + sliver: SliverList( + delegate: SliverChildListDelegate(children.sublist(split + 1)), + ), + ), + ], + ); + } +} diff --git a/app/test/features/chat/conversation/chat_scroll_test.dart b/app/test/features/chat/conversation/chat_scroll_test.dart index ee9fb670..0ee6a071 100644 --- a/app/test/features/chat/conversation/chat_scroll_test.dart +++ b/app/test/features/chat/conversation/chat_scroll_test.dart @@ -103,27 +103,39 @@ void main() { expect(chatRestoreOffset(savedOffset: 0, maxScrollExtent: 640), 0); expect(chatRestoreOffset(savedOffset: 900, maxScrollExtent: 640), 640); }); + + test('a bottom-anchored position above the centre stays negative', () { + double restore(double saved) => chatRestoreOffset( + savedOffset: saved, + minScrollExtent: -2000, + maxScrollExtent: 300, + ); + expect(restore(-750), -750); + expect(restore(-5000), -2000); + expect(restore(900), 300); + }); }); group('store', () { test('remembers one conversation without touching another', () { final store = MemoryChatScrollStore(); - store.write('a', 120); - store.write('b', 30); - expect(store.read('a'), 120); - expect(store.read('b'), 30); + store.write('a', (offset: 120, anchor: null)); + store.write('b', (offset: -30, anchor: 'm4')); + expect(store.read('a'), (offset: 120.0, anchor: null)); + expect(store.read('b'), (offset: -30.0, anchor: 'm4')); expect(store.read('c'), isNull); store.clear('a'); expect(store.read('a'), isNull); - expect(store.entries, {'b': 30.0}); + expect(store.entries, {'b': (offset: -30.0, anchor: 'm4')}); }); test('ignores an unusable offset instead of inventing a position', () { final store = MemoryChatScrollStore(); - store.write('a', double.nan); - store.write('a', double.infinity); - store.write('a', -5); + store.write('a', (offset: double.nan, anchor: 'm1')); + store.write('a', (offset: double.infinity, anchor: null)); + // Only a bottom-anchored offset counts from a centre and can be negative. + store.write('a', (offset: -5, anchor: null)); expect(store.read('a'), isNull); }); }); diff --git a/app/test/features/chat/conversation/chat_thread_anchor_test.dart b/app/test/features/chat/conversation/chat_thread_anchor_test.dart new file mode 100644 index 00000000..7047101f --- /dev/null +++ b/app/test/features/chat/conversation/chat_thread_anchor_test.dart @@ -0,0 +1,211 @@ +import 'package:flutter/material.dart'; +import 'package:flutter/widgets.dart' as widgets; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_scroll.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_thread_view.dart'; +import 'package:pipelines_app/features/chat/ui/transcript/chat_message_view.dart'; + +import 'chat_thread_fixtures.dart'; +import 'chat_thread_scroll_test.dart' show host, transcriptScroll; + +// The transcript opens bottom-anchored: only the rows that show are built, and +// growth on either side of the split never moves the operator's place. In the +// 800x600 test viewport the first row starts below the floating header. +const _firstRowTop = 80.0; + +List messages(int count, {int from = 0, int sentences = 6}) => [ + for (var index = from; index < from + count; index++) + chatMessage( + 'm$index', + index.isEven ? 'user' : 'assistant', + parts: [ + { + 'type': 'text', + 'text': + 'Message $index. ' + '${List.filled(sentences, 'A sentence that wraps across the transcript width.').join(' ')}', + }, + ], + ), +]; + +Finder row(String id) => find.byWidgetPredicate( + (widget) => + widget is ChatMessageView && + (widget.row['key'] == id || + (widget.row['messageIds'] as List?)?.contains(id) == true), + skipOffstage: false, +); + +Finder get thread => find.byKey(const Key('chat-thread-s')); + +Future dragUntil(WidgetTester tester, Finder target) async { + for (var drag = 0; drag < 80 && !tester.any(target); drag++) { + await tester.drag(thread, const Offset(0, 500)); + await tester.pump(); + } + await tester.pumpAndSettle(); +} + +Future openThread(WidgetTester tester, FakeChatGateway gateway) async { + await tester.pumpWidget( + host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), + ); + await tester.pumpAndSettle(); +} + +void main() { + testWidgets('a long transcript opens at its newest message, building only ' + 'what shows', (tester) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => chatPage(messages(200)); + final built = {}; + widgets.debugOnRebuildDirtyWidget = (element, _) { + final widget = element.widget; + if (widget is ChatMessageView) built.add('${widget.row['key']}'); + }; + addTearDown(() => widgets.debugOnRebuildDirtyWidget = null); + + await openThread(tester, gateway); + widgets.debugOnRebuildDirtyWidget = null; + + final scroll = transcriptScroll(tester); + expect( + scroll.position.pixels, + closeTo(scroll.position.maxScrollExtent, 0.5), + ); + expect(scroll.position.minScrollExtent, lessThan(0)); + final newest = tester.getRect(row('m199')); + expect(newest.bottom, lessThanOrEqualTo(600)); + expect(newest.bottom, greaterThan(400)); + expect(built, isNot(contains('m0'))); + expect(built.length, lessThan(20)); + expect(find.byKey(const Key('chat-jump-to-latest')), findsNothing); + + // A reply streaming below the split is followed while at the end. + gateway.emitEvent(chatTextFrame('Streaming answer. ', messageId: 'live')); + await tester.pump(); + await tester.pump(); + expect( + scroll.position.pixels, + closeTo(scroll.position.maxScrollExtent, 0.5), + ); + }); + + testWidgets('scrolling up reaches the first row with no gap above it', ( + tester, + ) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => chatPage(messages(40)); + await openThread(tester, gateway); + + await dragUntil(tester, row('m0')); + await tester.fling(thread, const Offset(0, 3000), 3000); + await tester.pumpAndSettle(); + final scroll = transcriptScroll(tester); + expect( + scroll.position.pixels, + closeTo(scroll.position.minScrollExtent, 0.5), + ); + expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1)); + expect(find.byKey(const Key('chat-jump-to-latest')), findsOneWidget); + }); + + for (final tall in [false, true]) { + testWidgets('a short transcript still reads from the top ' + '(tall newest row: $tall)', (tester) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + // The rows above the newest one fit the viewport. + gateway.history = (_) async => chatPage([ + ...messages(2, sentences: 1), + ...messages(1, from: 2, sentences: tall ? 60 : 1), + ]); + await openThread(tester, gateway); + + final scroll = transcriptScroll(tester); + expect(scroll.position.minScrollExtent, 0); + expect( + scroll.position.pixels, + closeTo(scroll.position.maxScrollExtent, 0.5), + ); + if (!tall) { + expect(scroll.position.maxScrollExtent, 0); + expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1)); + return; + } + // At its end the tall newest row shows its end; scrolling back reaches + // the first row at the top padding. + expect(tester.getRect(row('m2')).bottom, lessThanOrEqualTo(600)); + await tester.fling(thread, const Offset(0, 3000), 3000); + await tester.pumpAndSettle(); + expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1)); + }); + } + + testWidgets('loading an older page keeps the rows the operator reads in ' + 'place', (tester) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => + chatPage(messages(30, from: 30), cursor: 'older', hasMore: true); + await openThread(tester, gateway); + + await dragUntil(tester, find.text('Load older')); + await tester.fling(thread, const Offset(0, 3000), 3000); + await tester.pumpAndSettle(); + final held = tester.getRect(row('m30')); + gateway.history = (_) async => chatPage(messages(30)); + await tester.tap(find.text('Load older')); + await tester.pumpAndSettle(); + + expect(find.text('Load older'), findsNothing); + expect(tester.getRect(row('m30')).top, closeTo(held.top, 0.5)); + // The older page sits above, reachable by scrolling up. + await dragUntil(tester, row('m0')); + await tester.fling(thread, const Offset(0, 3000), 3000); + await tester.pumpAndSettle(); + expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1)); + }); + + testWidgets('a reopened conversation keeps its place after messages arrived ' + 'while it was closed', (tester) async { + final gateway = FakeChatGateway(); + addTearDown(gateway.close); + gateway.history = (_) async => chatPage(messages(60)); + final positions = MemoryChatScrollStore(); + Widget view() => host( + ChatThreadView( + gateway: gateway, + sessionId: 's', + scrollPositions: positions, + onBack: () {}, + ), + ); + + await tester.pumpWidget(view()); + await tester.pumpAndSettle(); + for (var drag = 0; drag < 4; drag++) { + await tester.drag(thread, const Offset(0, 400)); + await tester.pump(); + } + await tester.pumpAndSettle(); + final shown = find.byWidgetPredicate((widget) => widget is ChatMessageView); + final top = shown.evaluate().first.widget as ChatMessageView; + final id = '${top.row['key']}'; + final held = tester.getRect(row(id)); + expect(positions.read('s')!.anchor, isNotNull); + + await tester.pumpWidget(host(const SizedBox())); + gateway.history = (_) async => chatPage(messages(64)); + await tester.pumpWidget(view()); + await tester.pumpAndSettle(); + + expect(tester.getRect(row(id)).top, closeTo(held.top, 1)); + expect(find.text('Jump to latest ยท 4 new messages'), findsNothing); + expect(find.byKey(const Key('chat-jump-to-latest')), findsOneWidget); + }); +} diff --git a/app/test/features/chat/conversation/chat_thread_scroll_test.dart b/app/test/features/chat/conversation/chat_thread_scroll_test.dart index 7364c783..780fbeea 100644 --- a/app/test/features/chat/conversation/chat_thread_scroll_test.dart +++ b/app/test/features/chat/conversation/chat_thread_scroll_test.dart @@ -35,8 +35,14 @@ JsonMap tallPage() => chatPage([ ), ]); -ScrollController transcriptScroll(WidgetTester tester) => - tester.widget(find.byKey(const Key('chat-thread-s'))).controller!; +ScrollController transcriptScroll(WidgetTester tester) => tester + .widget( + find.descendant( + of: find.byKey(const Key('chat-thread-s')), + matching: find.byType(CustomScrollView), + ), + ) + .controller!; void main() { testWidgets('a streaming transcript stays pinned to its newest end', ( @@ -181,14 +187,14 @@ void main() { ); await tester.pumpAndSettle(); final saved = scroll.position.pixels; - expect(saved, greaterThan(0)); - expect(positions.read('s'), closeTo(saved, 0.5)); + expect(saved, lessThan(scroll.position.maxScrollExtent - 300)); + expect(positions.read('s')!.offset, closeTo(saved, 0.5)); // Leaving the conversation disposes its view but not the destination's // store. await tester.pumpWidget(host(const SizedBox())); await tester.pumpAndSettle(); - expect(positions.read('s'), closeTo(saved, 0.5)); + expect(positions.read('s')!.offset, closeTo(saved, 0.5)); await tester.pumpWidget( host( diff --git a/app/test/features/chat/conversation/chat_transcript_anchor_test.dart b/app/test/features/chat/conversation/chat_transcript_anchor_test.dart new file mode 100644 index 00000000..c20e600a --- /dev/null +++ b/app/test/features/chat/conversation/chat_transcript_anchor_test.dart @@ -0,0 +1,68 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_transcript_anchor.dart'; + +JsonMap user(String id) => {'kind': 'user', 'key': id}; + +JsonMap assistant(List ids, {bool streaming = false}) => { + 'kind': 'assistant', + 'key': ids.isEmpty ? 'chat-pending-response' : ids.first, + 'messageIds': ids, + if (streaming) 'streaming': true, +}; + +void main() { + test('splits before the newest message row', () { + final rows = [ + user('u1'), + assistant(['a2', 'a3']), + user('u4'), + ]; + expect(chatTranscriptAnchor(rows), 'a3'); + expect(chatTranscriptAnchorIndex(rows, 'a3'), 1); + // Any message the folded turn holds finds it, as paging prepends into it. + expect(chatTranscriptAnchorIndex(rows, 'a2'), 1); + }); + + test('a streaming reply and the rows after it stay below the centre', () { + // A queued follow-up can be recorded after the reply still arriving. + final rows = [ + user('u1'), + assistant(['a2']), + user('u3'), + assistant(['a4'], streaming: true), + user('u5'), + ]; + expect(chatTranscriptAnchor(rows), 'u3'); + }); + + test('cards, activity lines and the pending shell are never the anchor', () { + final rows = [ + user('u1'), + {'kind': 'activity', 'key': 'chat-activity-a2'}, + assistant(['a2']), + assistant(const [], streaming: true), + {'kind': 'permission', 'key': 'chat-permission-p1'}, + ]; + // The newest message row is a2, so the anchor is the row before it. + expect(chatTranscriptAnchor(rows), 'u1'); + }); + + test('fewer than two message rows stay top-anchored', () { + expect(chatTranscriptAnchor(const []), isNull); + expect(chatTranscriptAnchor([user('u1')]), isNull); + expect( + chatTranscriptAnchor([ + user('u1'), + {'kind': 'question', 'key': 'chat-question-q1'}, + ]), + isNull, + ); + }); + + test('a missing anchor reports no split', () { + final rows = [user('u1'), user('u2')]; + expect(chatTranscriptAnchorIndex(rows, null), -1); + expect(chatTranscriptAnchorIndex(rows, 'gone'), -1); + }); +}