Search: find operator chats by title, directory and message text

A search with kind chat matches the operator-session registry's titles and
directories and the newest messages of recent transcripts through the chat
broker (bounded count, concurrency and one-second budget), answered off the
connection's read loop. The all-kind search is unchanged for older clients.

The app sends the chat search after its run search and shows a Chats group
with title, harness, directory and snippet; a chat hit opens that chat in the
Chat tab. The probe fixture answers chat searches over ?chats=N.
This commit is contained in:
2026-11-03 13:01:53 +00:00
parent d34185b56c
commit bff7115e4e
31 changed files with 1659 additions and 118 deletions
+4
View File
@@ -387,6 +387,10 @@ class _PipelinesAppState extends State<PipelinesApp>
);
route = AppRoute.run(runId);
}
case SearchChatTarget(:final sessionId):
// The Chat tab selects the routed session in its list and shows its
// thread, exactly as a chat notification opens it.
route = AppRoute.chatSession(sessionId);
}
if (route == null) return;
setState(() => _pendingRunSearch = selection);
@@ -0,0 +1,47 @@
import '../../../core/api_gateway.dart';
import 'search_row.dart';
/// The chat payload of a `chat` search hit, or null for any other hit.
JsonMap? searchChatOf(JsonMap hit) {
final chat = hit['chat'];
return hit['kind'] == 'chat' && chat is Map
? Map<String, dynamic>.from(chat)
: null;
}
/// A chat hit's row: the chat's title, its harness and directory as the
/// muted facts, and the matching message's snippet when message text matched.
/// It opens only with the server's own `chat:<session id>` target.
SearchRowView searchChatRowView(
JsonMap chat, {
required String query,
required String? target,
required String? recency,
}) {
final title = '${chat['title'] ?? ''}'.trim();
final directory = '${chat['directory'] ?? ''}'.trim();
final snippet = '${chat['snippet'] ?? ''}';
final facts = [
searchHarnessLabel('${chat['backend'] ?? ''}'),
if (directory.isNotEmpty) directory,
if (chat['closed'] == true) 'closed',
].join(' · ');
return SearchRowView(
title: title.isEmpty ? 'Untitled chat' : title,
secondary: facts,
kindLabel: 'Chat',
snippet: snippet.isEmpty ? null : snippet,
snippetSpans: snippetSpans(snippet, query),
recency: recency,
target: target,
);
}
/// The harness's display name, matching the server's own names; an unknown
/// harness shows as sent.
String searchHarnessLabel(String backend) => switch (backend) {
'claude' => 'Claude Code',
'codex' => 'Codex',
'' || 'opencode' => 'OpenCode',
_ => backend,
};
@@ -0,0 +1,83 @@
import '../../../core/api_gateway.dart';
import '../data/search_repository.dart';
import 'search_models.dart';
import 'search_query.dart';
/// Wording for a server whose search does not know the `chat` kind (it
/// predates chat search and rejects the kind by name).
const unsupportedChatSearchCopy =
'This server does not search chats. Update the Pipelines server to '
'include them.';
final _unknownKind = RegExp(r'unknown search kind', caseSensitive: false);
/// The Chats section's state: one `kind: chat` request per sent query, run
/// beside (never instead of, nor ahead of) the run/artifact search, so the
/// server's transcript readback cannot delay the other results.
class SearchChatSlice {
List<JsonMap> results = const [];
bool loading = false;
bool loaded = false;
bool truncated = false;
String? error;
void clear() {
results = const [];
loading = false;
loaded = false;
truncated = false;
error = null;
}
/// Requests chats for [query]. [current] reports whether this request is
/// still the newest edit; a stale reply is dropped without a change.
Future<void> load(
SearchRepository repository,
String query, {
required bool Function() current,
required void Function() changed,
}) async {
loading = true;
error = null;
changed();
try {
final response = await repository.search(
query: query,
kind: SearchKind.chat,
);
if (!current()) return;
if (response == null) {
results = const [];
truncated = false;
error = unsupportedChatSearchCopy;
} else {
results = response.results
.where((hit) => hit['kind'] == SearchKind.chat.wire)
.toList(growable: false);
truncated = response.truncated;
}
} catch (failure) {
if (!current()) return;
results = const [];
truncated = false;
final text = searchFailureText(failure);
error = _unknownKind.hasMatch(text) || text == unsupportedSearchCopy
? unsupportedChatSearchCopy
: text;
}
loading = false;
loaded = true;
changed();
}
/// A short honest note under the Chats section: why chats are missing, or
/// that the server's bounds left some transcripts unsearched.
String? get note {
if (error != null) return error;
if (truncated) {
return "Some chats were not searched within the server's time or "
'result limit.';
}
return null;
}
}
@@ -4,6 +4,7 @@ import 'package:flutter/foundation.dart';
import '../../../core/api_gateway.dart';
import '../data/search_repository.dart';
import 'search_chat_slice.dart';
import 'search_models.dart';
import 'search_query.dart';
import 'search_row.dart';
@@ -24,6 +25,7 @@ class OmniSearchController extends ChangeNotifier {
final SearchRepository repository;
final Duration debounce;
final SearchSequencer _sequencer = SearchSequencer();
final SearchChatSlice _chats = SearchChatSlice();
Timer? _timer;
bool _disposed = false;
@@ -51,7 +53,35 @@ class OmniSearchController extends ChangeNotifier {
int get scannedBytes => _scannedBytes;
int get cap => _cap;
int get scanBoundBytes => _scanBoundBytes;
String? get error => _error;
/// The failure the body shows: the run search's, or with the Chats kind
/// selected (no run search is sent) the chat search's.
String? get error =>
_error ?? (parsed.kind == SearchKind.chat ? _chats.error : null);
/// Chat hits for the Chats section: shown for every kind that searches
/// chats (all kinds, or Chats alone).
List<JsonMap> get shownChats =>
_searchesChats(parsed.kind) ? _chats.results : const [];
/// The Chats section's note: why chats are missing, or that the server's
/// bounds left some unsearched. With Chats selected alone a failure is the
/// body's error instead, so only the bounds note remains.
String? get chatsNote => switch (parsed.kind) {
SearchKind.all => _chats.note,
SearchKind.chat when _chats.error == null => _chats.note,
_ => null,
};
/// Whether the Chats section is drawn as its own group above the others.
bool get showsChatSection =>
parsed.kind == SearchKind.all &&
(shownChats.isNotEmpty || chatsNote != null);
static bool _searchesChats(SearchKind kind) =>
kind == SearchKind.all || kind == SearchKind.chat;
bool get _hasShown => shownResults.isNotEmpty || shownChats.isNotEmpty;
/// The results already in hand, re-narrowed to the effective kind so the list
/// always matches the control while a narrowed request loads.
@@ -64,18 +94,22 @@ class OmniSearchController extends ChangeNotifier {
}
SearchBodyKind get bodyKind {
if (_error != null) return SearchBodyKind.error;
if (shownResults.isNotEmpty) return SearchBodyKind.results;
if (_loading && _results.isEmpty) return SearchBodyKind.searching;
if (error != null) return SearchBodyKind.error;
if (_hasShown || showsChatSection) return SearchBodyKind.results;
if ((_loading && _results.isEmpty) || _chats.loading) {
return SearchBodyKind.searching;
}
if (emptyMessage != null) return SearchBodyKind.empty;
return SearchBodyKind.idle;
}
/// A thin progress report above retained results while a newer query loads.
bool get showProgress => _loading && _results.isNotEmpty;
bool get showProgress =>
(_loading && _results.isNotEmpty) ||
(_chats.loading && _chats.results.isNotEmpty);
String? get emptyMessage {
if (_error != null || _loading || shownResults.isNotEmpty) return null;
if (error != null || _loading || _chats.loading || _hasShown) return null;
final effective = parsed;
if (effective.query.trim().isEmpty) {
if (!_loaded || effective.kind == SearchKind.all) return null;
@@ -171,14 +205,39 @@ class OmniSearchController extends ChangeNotifier {
Future<void> _send(SearchEdit sent) async {
final effective = parseSearchQuery(sent.query, _selectedKind);
final query = effective.query.trim();
final chatsOnly = effective.kind == SearchKind.chat;
// The run/artifact search goes first; the chat search follows as its own
// request, so a slow transcript readback never holds the other results.
final runs = chatsOnly
? null
: repository.search(query: query, kind: effective.kind);
if (_searchesChats(effective.kind) && (query.isNotEmpty || chatsOnly)) {
unawaited(
_chats.load(
repository,
query,
current: () => _sequencer.accepts(sent.token) && !_disposed,
changed: _notify,
),
);
} else {
_chats.clear();
}
if (runs == null) {
_results = const [];
_truncated = false;
_loading = false;
_loaded = true;
_error = null;
_notify();
return;
}
_loading = true;
_error = null;
_notify();
try {
final response = await repository.search(
query: effective.query.trim(),
kind: effective.kind,
);
final response = await runs;
if (!_sequencer.accepts(sent.token) || _disposed) return;
if (response == null) {
_loading = false;
@@ -207,6 +266,7 @@ class OmniSearchController extends ChangeNotifier {
}
void _clearResults() {
_chats.clear();
_results = const [];
_truncated = false;
_scannedSteps = 0;
@@ -9,6 +9,7 @@ enum SearchKind {
step('step', 'Steps'),
field('field', 'Fields'),
artifact('artifact', 'Artifacts'),
chat('chat', 'Chats'),
version('version', 'Versions');
const SearchKind(this.wire, this.label);
@@ -1,5 +1,6 @@
import '../../../core/api_gateway.dart';
import '../../../ui/text/relative_time.dart';
import 'search_chat_row.dart';
import 'search_format.dart';
export 'search_format.dart' show humanBytes, formatSearchTimestamp;
@@ -129,6 +130,15 @@ SearchRowView searchRowView(JsonMap hit, String query) {
target: target,
);
}
final chat = searchChatOf(hit);
if (chat != null) {
return searchChatRowView(
chat,
query: query,
target: target,
recency: recency,
);
}
final kind = _nonBlank(hit['kind']);
return SearchRowView(
title: _nonBlank(hit['target']) ?? 'Unrecognised result',
@@ -191,6 +201,7 @@ String? _serverTarget(JsonMap hit) {
'step',
'field',
'artifact',
'chat',
].any((key) => _map(hit[key]) != null);
return known ? target : null;
}
@@ -1,15 +1,16 @@
import '../../../core/api_gateway.dart';
/// The kind of recorded entity a resolved target names.
enum SearchTargetKind { pipeline, version, run, step, field, artifact }
enum SearchTargetKind { pipeline, version, run, step, field, artifact, chat }
/// The exact identity behind a recorded search hit.
///
/// [wire] is the server's own stable target token
/// (`internal/protocol/search.go`): `pipeline:<id>`, `pipeline:<id>:v<version>`,
/// `run:<id>`, `run:<id>:<sequence>`, `run:<id>:<sequence>:<field>` or the
/// recorded artifact URL. It is derived from the typed payload, never copied
/// from the hit, and [SearchTarget.fromWire] accepts it back.
/// `run:<id>`, `run:<id>:<sequence>`, `run:<id>:<sequence>:<field>`, the
/// recorded artifact URL or `chat:<session id>`. It is derived from the typed
/// payload, never copied from the hit, and [SearchTarget.fromWire] accepts it
/// back.
///
/// The token is the identity: two targets that serialise to the same token are
/// the same target even when one of them also carries recorded visit facts the
@@ -63,6 +64,10 @@ sealed class SearchTarget {
// The server's artifact target is its own relative file URL
// (`/artifacts/<run>/<step>/<name>`); an absolute form is accepted only when
// it carries that same path.
if (token.startsWith('chat:')) {
final session = token.substring('chat:'.length);
return session.trim().isEmpty ? null : SearchChatTarget(session);
}
if (token.startsWith('/artifacts/')) return SearchArtifactTarget(token);
if (token.startsWith('http://') || token.startsWith('https://')) {
final uri = Uri.tryParse(token);
@@ -172,6 +177,21 @@ final class SearchArtifactTarget extends SearchTarget {
String get wire => url;
}
/// An operator chat session hit. [messageId] is the matching message when the
/// hit matched message text; the token names only the session.
final class SearchChatTarget extends SearchTarget {
const SearchChatTarget(this.sessionId, {this.messageId});
final String sessionId;
final String? messageId;
@override
SearchTargetKind get kind => SearchTargetKind.chat;
@override
String get wire => 'chat:$sessionId';
}
/// Either the exact [SearchTarget] a hit names, or the reason it names none.
sealed class SearchTargetResolution {
const SearchTargetResolution();
@@ -272,6 +292,17 @@ SearchTargetResolution _identityFor(JsonMap hit) {
return ResolvedSearchTarget(SearchFieldTarget(runId, sequence, name));
}
final chat = _payload(hit, 'chat');
if (chat != null) {
final session = _text(chat['session_id']);
if (session == null) {
return const UnresolvedSearchTarget('chat session id is missing');
}
return ResolvedSearchTarget(
SearchChatTarget(session, messageId: _text(chat['message_id'])),
);
}
final artifact = _payload(hit, 'artifact');
if (artifact != null) {
final url = _text(artifact['url']);
@@ -2,7 +2,7 @@ import 'package:flutter/cupertino.dart';
import '../../../core/api_gateway.dart';
import '../domain/search_controller.dart';
import 'search_result_row.dart';
import 'search_result_slivers.dart';
import 'search_layout.dart';
/// The Cupertino search view: an optional status header and the shared list
@@ -59,18 +59,13 @@ class CupertinoSearchBody extends StatelessWidget {
),
];
case SearchBodyKind.results:
return [
SliverList.builder(
itemCount: controller.shownResults.length,
itemBuilder: (context, index) => SearchResultRow(
hit: controller.shownResults[index],
query: query,
onOpen: onOpen,
cupertino: true,
divider: index < controller.shownResults.length - 1,
),
),
];
return searchResultSlivers(
controller: controller,
query: query,
onOpen: onOpen,
cupertino: true,
message: (text) => _CupertinoMessage(message: text),
);
case SearchBodyKind.empty:
return [
SliverToBoxAdapter(
@@ -82,7 +77,7 @@ class CupertinoSearchBody extends StatelessWidget {
SliverFillRemaining(
hasScrollBody: false,
child: _CupertinoMessage(
message: 'Search pipelines, runs and artifacts.',
message: 'Search pipelines, runs, artifacts and chats.',
),
),
];
@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
import '../../../core/api_gateway.dart';
import '../domain/search_controller.dart';
import 'search_result_row.dart';
import 'search_result_slivers.dart';
import 'search_layout.dart';
/// The Material search view: an optional status header and a flat native
@@ -50,18 +50,13 @@ class MaterialSearchBody extends StatelessWidget {
SliverFillRemaining(hasScrollBody: false, child: _Searching()),
];
case SearchBodyKind.results:
return [
SliverList.builder(
itemCount: controller.shownResults.length,
itemBuilder: (context, index) => SearchResultRow(
hit: controller.shownResults[index],
query: query,
onOpen: onOpen,
cupertino: false,
divider: index < controller.shownResults.length - 1,
),
),
];
return searchResultSlivers(
controller: controller,
query: query,
onOpen: onOpen,
cupertino: false,
message: (text) => _SearchMessage(message: text),
);
case SearchBodyKind.empty:
return [
SliverToBoxAdapter(
@@ -73,7 +68,7 @@ class MaterialSearchBody extends StatelessWidget {
SliverFillRemaining(
hasScrollBody: false,
child: _SearchMessage(
message: 'Search pipelines, runs and artifacts.',
message: 'Search pipelines, runs, artifacts and chats.',
),
),
];
@@ -12,7 +12,7 @@ const searchBarControlsKey = ValueKey<String>('search.bar');
const searchTokenHint =
'Filter with t:pipeline or type:artifact (pipeline, run, step, field, '
'artifact, version). Last type wins; choosing Kind replaces it. Quote '
'artifact, chat, version). Last type wins; choosing Kind replaces it. Quote '
'tokens to search literally.';
/// Search's controls as the top bar's main pill (in place of a title): the
@@ -57,7 +57,7 @@ class SearchBarControls extends StatelessWidget {
autofocus: autofocus,
inBar: true,
cupertino: cupertino,
placeholder: 'Search pipelines, runs and artifacts',
placeholder: 'Search pipelines, runs, artifacts and chats',
onChanged: onChanged,
onSubmitted: (_) => onSubmitted(),
onCleared: onCleared,
@@ -11,7 +11,9 @@ import 'search_result_view.dart';
/// artifact's picture), the title with its recency, and one muted line that
/// names the kind and then shows the snippet (its first query occurrence
/// emphasised by weight, never by parsing server text as markup) or, without
/// one, the kind's own facts. An artifact hit's open choices are its menu.
/// one, the kind's own facts. A chat hit with a matching message shows its
/// harness and directory, then the snippet on a second line. An artifact
/// hit's open choices are its menu.
class SearchResultRow extends StatelessWidget {
const SearchResultRow({
super.key,
@@ -46,33 +48,55 @@ class SearchResultRow extends StatelessWidget {
),
title: Text(row.title),
time: row.recency,
subtitle: Text.rich(_line(row)),
subtitle: kind == 'chat' && row.snippet != null
? Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: [
Text.rich(_facts(row)),
Text.rich(TextSpan(children: _snippet(row))),
],
)
: Text.rich(_line(row)),
compactSubtitle: kind == 'chat' && row.snippet != null
? Text.rich(TextSpan(children: _snippet(row)))
: null,
menu: searchArtifactActions(context, hit),
);
}
TextSpan _line(SearchRowView row) {
final snippet = row.snippet;
return TextSpan(
children: [
TextSpan(
text: row.kindLabel,
style: const TextStyle(fontWeight: FontWeight.w600),
),
const TextSpan(text: ' · '),
if (snippet == null)
TextSpan(text: row.secondary)
else
for (final span in row.snippetSpans)
TextSpan(
text: span.text,
style: span.matched
? const TextStyle(fontWeight: FontWeight.bold)
: null,
),
],
);
}
TextSpan _line(SearchRowView row) => row.snippet == null
? _facts(row)
: TextSpan(children: [_kind(row), ..._snippet(row)]);
/// The kind, then the kind's own facts (a chat's harness and directory).
TextSpan _facts(SearchRowView row) => TextSpan(
children: [
_kind(row),
TextSpan(text: row.secondary),
],
);
TextSpan _kind(SearchRowView row) => TextSpan(
children: [
TextSpan(
text: row.kindLabel,
style: const TextStyle(fontWeight: FontWeight.w600),
),
const TextSpan(text: ' · '),
],
);
/// The snippet with its first query occurrence emphasised by weight.
List<TextSpan> _snippet(SearchRowView row) => [
for (final span in row.snippetSpans)
TextSpan(
text: span.text,
style: span.matched
? const TextStyle(fontWeight: FontWeight.bold)
: null,
),
];
}
IconData searchMaterialIcon(String kind) => switch (kind) {
@@ -82,6 +106,7 @@ IconData searchMaterialIcon(String kind) => switch (kind) {
'step' => Icons.arrow_forward,
'field' => Icons.notes,
'artifact' => Icons.attach_file,
'chat' => Icons.chat_bubble_outline,
_ => Icons.help_outline,
};
@@ -92,5 +117,6 @@ IconData searchCupertinoIcon(String kind) => switch (kind) {
'step' => CupertinoIcons.arrow_right,
'field' => CupertinoIcons.doc_text,
'artifact' => CupertinoIcons.paperclip,
'chat' => CupertinoIcons.chat_bubble,
_ => CupertinoIcons.question_circle,
};
@@ -0,0 +1,71 @@
import 'package:flutter/widgets.dart';
import '../../../core/api_gateway.dart';
import '../../../ui/layout/section_heading.dart';
import '../domain/search_controller.dart';
import '../domain/search_models.dart';
import 'search_bounds_note.dart';
import 'search_result_row.dart';
const searchChatsSectionKey = ValueKey<String>('search.section.chats');
const searchOthersSectionKey = ValueKey<String>('search.section.others');
const searchChatsNoteKey = ValueKey<String>('search.chats.note');
/// The results body shared by both hosts. With every kind searched, chat hits
/// lead as their own "Chats" group above the pipeline/run/artifact hits; with
/// Chats selected alone they are the list. A run search with no hits still
/// says so under the Chats group.
List<Widget> searchResultSlivers({
required OmniSearchController controller,
required String query,
required ValueChanged<JsonMap> onOpen,
required bool cupertino,
required Widget Function(String message) message,
}) {
final chats = controller.shownChats;
final others = controller.shownResults;
final grouped = controller.showsChatSection;
final note = controller.chatsNote;
Widget rows(List<JsonMap> hits) => SliverList.builder(
itemCount: hits.length,
itemBuilder: (context, index) => SearchResultRow(
hit: hits[index],
query: query,
onOpen: onOpen,
cupertino: cupertino,
divider: index < hits.length - 1,
),
);
final empty = controller.emptyMessage;
return [
if (grouped)
SliverToBoxAdapter(
child: SectionHeading(
key: searchChatsSectionKey,
title: chats.isEmpty ? 'Chats' : 'Chats (${chats.length})',
header: true,
),
),
if (chats.isNotEmpty) rows(chats),
if (note != null)
SliverToBoxAdapter(
child: Padding(
padding: const EdgeInsets.symmetric(vertical: 8),
child: SearchBoundsNote(key: searchChatsNoteKey, text: note),
),
),
if (grouped && others.isNotEmpty)
const SliverToBoxAdapter(
child: SectionHeading(
key: searchOthersSectionKey,
title: 'Pipelines and runs',
header: true,
),
),
if (others.isNotEmpty) rows(others),
if (others.isEmpty &&
controller.parsed.kind != SearchKind.chat &&
empty != null)
SliverToBoxAdapter(child: message(empty)),
];
}
@@ -0,0 +1,131 @@
import 'dart:convert';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/transport/pipelines_client.dart';
import 'package:pipelines_app/features/chat/screen.dart';
import 'package:pipelines_app/features/search/search_screen.dart';
import '../core/transport/pipelines_client_test.dart' show FakeChannel;
import 'search_wiring_test.dart'
show pumpApp, reply, replyRunList, tapTab, waitForSearch;
const _session = 'ses_chatsearch1';
Map<String, dynamic> _results(String kind, List<Map<String, dynamic>> hits) => {
'type': 'search_results',
'search_results': {
'query': 'flaky',
'kind': kind,
'results': hits,
'truncated': false,
'scanned_steps': 0,
'scanned_bytes': 0,
'cap': 50,
'scan_bound_bytes': 1 << 20,
},
};
/// The whole path from the Search tab: a typed query, the run search and the
/// chat search the app sends after it, then a tap on the chat hit opens that
/// chat in the Chat tab with its session selected.
void main() {
for (final cupertino in [false, true]) {
testWidgets('${cupertino ? 'Cupertino' : 'Material'}: a chat hit opens '
'its chat in the Chat tab', (tester) async {
tester.view.physicalSize = const Size(900, 1000);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.resetPhysicalSize);
addTearDown(tester.view.resetDevicePixelRatio);
final channel = FakeChannel()..readyCompleter.complete();
final provider = PlatformRouteInformationProvider(
initialRouteInformation: RouteInformation(uri: Uri.parse('/runs')),
);
addTearDown(provider.dispose);
await pumpApp(
tester,
channel: channel,
client: PipelinesClient(channelFactory: (_) => channel),
provider: provider,
cupertino: cupertino,
);
await replyRunList(tester, channel);
await tapTab(tester, 'Search');
await tester.pump();
await tester.pump(const Duration(milliseconds: 600));
await tester.pump(const Duration(milliseconds: 100));
await tester.enterText(
find.byKey(const ValueKey('search.field')),
'flaky',
);
await tester.pump(const Duration(milliseconds: 300));
final runs = await waitForSearch(tester, channel);
channel.incoming.add(jsonEncode({'id': runs['id'], ..._results('', [])}));
await tester.pump();
await tester.pump();
final chats = await waitForSearch(tester, channel, chats: true);
expect(chats['search'], {'query': 'flaky', 'kind': 'chat', 'limit': 0});
channel.incoming.add(
jsonEncode({
'id': chats['id'],
..._results('chat', [
{
'kind': 'chat',
'target': 'chat:$_session',
'score': 1,
'matched_field': 'message',
'chat': {
'session_id': _session,
'title': 'Fix CI',
'directory': '/work/api',
'backend': 'claude',
'message_id': 'm2',
'snippet': 'the flaky retry loop',
},
},
]),
}),
);
await tester.pump();
await tester.pump();
expect(find.text('Chats (1)'), findsOneWidget);
expect(find.textContaining('the flaky retry loop'), findsOneWidget);
await tester.tap(
find.byKey(const ValueKey('search.result.chat:$_session')),
);
await tester.pump();
await tester.pump(const Duration(milliseconds: 400));
await tester.pump(const Duration(milliseconds: 400));
expect(provider.value.uri.path, '/chat/$_session');
expect(find.byType(SearchScreen), findsNothing);
final screen = tester.widget<ChatScreen>(find.byType(ChatScreen));
expect(screen.initialSessionId, _session);
await reply(
tester,
channel,
'chat_sessions',
body: {
'type': 'chat_sessions',
'chat_sessions': [
{
'id': _session,
'title': 'Fix CI',
'directory': '/work/api',
'backend': 'claude',
},
],
},
);
await tester.pump(const Duration(milliseconds: 400));
expect(find.text('Fix CI'), findsWidgets);
await tester.pumpWidget(const SizedBox.shrink());
await tester.pump();
});
}
}
+67 -10
View File
@@ -50,6 +50,63 @@ Future<Map<String, dynamic>> waitForRequest(
fail('Timed out waiting for $type #$index');
}
/// The search requests the app sent: the run/artifact searches, or with
/// [chats] the `kind: chat` searches it sends after each of them.
List<Map<String, dynamic>> searchRequestsOf(
FakeChannel channel, {
bool chats = false,
}) => requestsOf(channel, 'search')
.where(
(request) => ((request['search'] as Map?)?['kind'] == 'chat') == chats,
)
.toList();
Future<Map<String, dynamic>> waitForSearch(
WidgetTester tester,
FakeChannel channel, {
int index = 0,
bool chats = false,
}) async {
for (var attempt = 0; attempt < 80; attempt++) {
final requests = searchRequestsOf(channel, chats: chats);
if (index < requests.length) return requests[index];
await tester.pump(const Duration(milliseconds: 5));
}
fail('Timed out waiting for ${chats ? 'chat ' : ''}search #$index');
}
/// Answers the [index]th chat search (sent after each run search's reply)
/// with no chats, so the app's serialized requests continue.
Future<void> replyChatSearch(
WidgetTester tester,
FakeChannel channel, {
int index = 0,
}) async {
final request = await waitForSearch(
tester,
channel,
index: index,
chats: true,
);
channel.incoming.add(
jsonEncode({
'id': request['id'],
'type': 'search_results',
'search_results': {
'query': (request['search'] as Map)['query'],
'kind': 'chat',
'results': <JsonMap>[],
'cap': 50,
'scanned_steps': 0,
'scanned_bytes': 0,
'scan_bound_bytes': 1 << 20,
},
}),
);
await tester.pump();
await tester.pump();
}
Future<void> reply(
WidgetTester tester,
FakeChannel channel,
@@ -106,7 +163,7 @@ Future<void> searchArtifactHit(
await tester.pump(const Duration(milliseconds: 100));
await tester.enterText(find.byKey(const ValueKey('search.field')), 'report');
await tester.pump(const Duration(milliseconds: 300));
final request = await waitForRequest(tester, channel, 'search', index: index);
final request = await waitForSearch(tester, channel, index: index);
channel.incoming.add(
jsonEncode({
'id': request['id'],
@@ -125,6 +182,7 @@ Future<void> searchArtifactHit(
);
await tester.pump();
await tester.pump();
await replyChatSearch(tester, channel, index: index);
}
/// Selects the artifact hit, leaving run 7's `get_run` request unanswered.
@@ -401,7 +459,7 @@ void main() {
);
await tester.pump(const Duration(milliseconds: 300));
final request = await waitForRequest(tester, channel, 'search');
final request = await waitForSearch(tester, channel);
expect(request['search'], {'query': 'release', 'kind': '', 'limit': 0});
channel.incoming.add(
jsonEncode({
@@ -421,6 +479,7 @@ void main() {
);
await tester.pump();
await tester.pump();
await replyChatSearch(tester, channel);
expect(find.text('Run 7 · Preserved run'), findsOneWidget);
await tester.tap(find.byKey(const ValueKey('search.result.run:7')));
@@ -437,7 +496,8 @@ void main() {
expect(find.text('Run 7'), findsWidgets);
// One app socket carried the search and the run reads.
expect(sockets, 1);
expect(requestsOf(channel, 'search'), hasLength(1));
expect(searchRequestsOf(channel), hasLength(1));
expect(searchRequestsOf(channel, chats: true), hasLength(1));
await tester.pumpWidget(const SizedBox.shrink());
await tester.pump();
@@ -480,12 +540,7 @@ void main() {
await tester.pump(const Duration(milliseconds: 100));
await tester.enterText(find.byKey(const ValueKey('search.field')), query);
await tester.pump(const Duration(milliseconds: 300));
final request = await waitForRequest(
tester,
channel,
'search',
index: index,
);
final request = await waitForSearch(tester, channel, index: index);
channel.incoming.add(
jsonEncode({
'id': request['id'],
@@ -504,6 +559,7 @@ void main() {
);
await tester.pump();
await tester.pump();
await replyChatSearch(tester, channel, index: index);
}
// An artifact hit opens the run's Artifacts tab and that artifact's viewer.
@@ -592,7 +648,7 @@ void main() {
'report',
);
await tester.pump(const Duration(milliseconds: 300));
final request = await waitForRequest(tester, channel, 'search');
final request = await waitForSearch(tester, channel);
channel.incoming.add(
jsonEncode({
'id': request['id'],
@@ -611,6 +667,7 @@ void main() {
);
await tester.pump();
await tester.pump();
await replyChatSearch(tester, channel);
await tester.tap(
find.byKey(const ValueKey('search.result./artifacts/7/2/report.txt')),
@@ -0,0 +1,160 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/search/domain/search_chat_slice.dart';
import 'package:pipelines_app/features/search/domain/search_controller.dart';
import 'package:pipelines_app/features/search/domain/search_models.dart';
import 'search_test_support.dart';
const runHit = {
'kind': 'run',
'target': 'run:7',
'run': {'id': 7},
};
void main() {
test('an all-kind search sends the run search, then chats as their own '
'request, and shows runs before chats answer', () async {
final gateway = QueuedGateway(holdChats: true);
final controller = controllerFor(gateway);
addTearDown(controller.dispose);
controller.updateQuery('flaky');
await pumpEventQueue();
expect(gateway.lastSearch, {'query': 'flaky', 'kind': '', 'limit': 0});
expect(gateway.chatCalls.single['search'], {
'query': 'flaky',
'kind': 'chat',
'limit': 0,
});
gateway.succeed(0, envelope([runHit]));
await pumpEventQueue();
expect(controller.shownResults.single['target'], 'run:7');
expect(controller.bodyKind, SearchBodyKind.results);
expect(controller.shownChats, isEmpty);
expect(controller.showsChatSection, isFalse);
gateway.chatPending.single.complete(
envelope([
chatHit('ses_a', snippet: 'the flaky retry'),
// A non-chat row in a chat reply is not a chat.
runHit,
]),
);
await pumpEventQueue();
expect(controller.shownChats.single['target'], 'chat:ses_a');
expect(controller.showsChatSection, isTrue);
expect(controller.shownResults.single['target'], 'run:7');
expect(controller.chatsNote, isNull);
});
test('chat hits alone keep the body out of its empty state', () async {
final gateway = QueuedGateway(holdChats: true);
final controller = controllerFor(gateway);
addTearDown(controller.dispose);
controller.updateQuery('fix');
await pumpEventQueue();
gateway.succeed(0, envelope(const []));
await pumpEventQueue();
// Runs answered empty while chats still load: still searching.
expect(controller.bodyKind, SearchBodyKind.searching);
expect(controller.emptyMessage, isNull);
gateway.chatPending.single.complete(envelope([chatHit('ses_a')]));
await pumpEventQueue();
expect(controller.bodyKind, SearchBodyKind.results);
expect(controller.emptyMessage, isNull);
});
test(
'a narrowed kind sends no chat search; Chats alone sends only chats',
() async {
final gateway = QueuedGateway();
final controller = controllerFor(gateway);
addTearDown(controller.dispose);
controller.updateQuery('t:run flaky');
await pumpEventQueue();
expect(gateway.calls, hasLength(1));
expect(gateway.chatCalls, isEmpty);
controller.selectKind(SearchKind.chat);
await pumpEventQueue();
expect(gateway.calls, hasLength(1));
expect(gateway.chatCalls.single['search'], {
'query': 'flaky',
'kind': 'chat',
'limit': 0,
});
expect(controller.shownResults, isEmpty);
expect(controller.showsChatSection, isFalse);
},
);
test('a stale chat reply never replaces the newest query', () async {
final gateway = QueuedGateway(holdChats: true);
final controller = controllerFor(gateway);
addTearDown(controller.dispose);
controller.updateQuery('first');
await pumpEventQueue();
controller.updateQuery('second');
await pumpEventQueue();
expect(gateway.chatCalls, hasLength(2));
gateway.chatPending[0].complete(envelope([chatHit('ses_old')]));
await pumpEventQueue();
expect(controller.shownChats, isEmpty);
gateway.chatPending[1].complete(envelope([chatHit('ses_new')]));
await pumpEventQueue();
expect(controller.shownChats.single['target'], 'chat:ses_new');
});
test('a server without chat search says so beside its run results, and '
'is the error with Chats selected', () async {
final gateway = QueuedGateway(holdChats: true);
final controller = controllerFor(gateway);
addTearDown(controller.dispose);
controller.updateQuery('flaky');
await pumpEventQueue();
gateway.succeed(0, envelope([runHit]));
gateway.chatPending.single.completeError(
StateError(
'unknown search kind "chat"; use one of pipeline, version, run, '
'step, field, artifact',
),
);
await pumpEventQueue();
expect(controller.error, isNull);
expect(controller.shownResults, hasLength(1));
expect(controller.chatsNote, unsupportedChatSearchCopy);
expect(controller.showsChatSection, isTrue);
controller.selectKind(SearchKind.chat);
await pumpEventQueue();
gateway.chatPending.last.completeError(
StateError('unknown search kind "chat"'),
);
await pumpEventQueue();
expect(controller.error, unsupportedChatSearchCopy);
expect(controller.bodyKind, SearchBodyKind.error);
});
test('a truncated chat reply carries a bounds note', () async {
final gateway = QueuedGateway(holdChats: true);
final controller = controllerFor(gateway);
addTearDown(controller.dispose);
controller.updateQuery('flaky');
await pumpEventQueue();
gateway.succeed(0, envelope(const []));
gateway.chatPending.single.complete(
envelope([chatHit('ses_a')], truncated: true),
);
await pumpEventQueue();
expect(controller.chatsNote, contains('not searched'));
});
}
@@ -0,0 +1,73 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/search/domain/search_row.dart';
import 'package:pipelines_app/features/search/domain/search_target.dart';
import 'search_test_support.dart' show chatHit;
void main() {
test('a message hit shows the title, harness and directory and its '
'snippet with the match split out', () {
final row = searchRowView(
chatHit('ses_a', snippet: 'the FLAKY retry'),
'flaky',
);
expect(row.title, 'Fix CI');
expect(row.kindLabel, 'Chat');
expect(row.secondary, 'Claude Code · /work/api');
expect(row.snippet, 'the FLAKY retry');
expect(row.snippetSpans.map((span) => (span.text, span.matched)), [
('the ', false),
('FLAKY', true),
(' retry', false),
]);
expect(row.target, 'chat:ses_a');
expect(row.openable, isTrue);
});
test('a title hit has no snippet; closed and untitled chats say so', () {
final base = chatHit('ses_b', title: ' ');
final hit = {
...base,
'chat': <String, dynamic>{
...(base['chat'] as Map),
'backend': '',
'closed': true,
},
};
final row = searchRowView(hit, 'x');
expect(row.title, 'Untitled chat');
expect(row.secondary, 'OpenCode · /work/api · closed');
expect(row.snippet, isNull);
});
test('a chat hit resolves to its session, keeping the matched message', () {
final resolved = searchTargetFor(chatHit('ses_a'));
expect(resolved, isA<ResolvedSearchTarget>());
final target = (resolved as ResolvedSearchTarget).target;
expect(target, isA<SearchChatTarget>());
expect((target as SearchChatTarget).sessionId, 'ses_a');
expect(target.kind, SearchTargetKind.chat);
expect(target.wire, 'chat:ses_a');
final message = chatHit('ses_a', snippet: 'x');
(message['chat'] as Map)['message_id'] = 'm9';
final withMessage =
(searchTargetFor(message) as ResolvedSearchTarget).target
as SearchChatTarget;
expect(withMessage.messageId, 'm9');
expect(withMessage, target);
expect(SearchTarget.fromWire('chat:ses_a'), target);
expect(SearchTarget.fromWire('chat:'), isNull);
});
test('a chat hit without a session id or with a mismatched target is not '
'openable', () {
final missing = chatHit('ses_a');
(missing['chat'] as Map).remove('session_id');
expect(searchTargetFor(missing), isA<UnresolvedSearchTarget>());
final mismatched = {...chatHit('ses_a'), 'target': 'chat:ses_b'};
expect(searchTargetFor(mismatched), isA<UnresolvedSearchTarget>());
});
}
@@ -0,0 +1,124 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/search/search_screen.dart';
import 'package:pipelines_app/features/search/ui/search_result_slivers.dart';
import 'search_screen_test.dart'
show ImmediateGateway, field, response, search, useNarrowSurface;
import 'search_test_support.dart' show chatHit;
/// Run hits for every kind but chat; chat hits for the chat request.
JsonMap replies(String query, String kind) => kind == 'chat'
? response([
chatHit('ses_a', title: 'API refactor', snippet: 'the release retry'),
chatHit('ses_b', title: 'Release notes'),
])
: response([field]);
Widget host(Widget child, {required bool cupertino}) =>
cupertino ? CupertinoApp(home: child) : MaterialApp(home: child);
void main() {
for (final cupertino in [false, true]) {
final platform = cupertino ? 'Cupertino' : 'Material';
testWidgets('$platform: chat hits lead as a Chats group with title, '
'harness, directory and snippet, and open their chat', (tester) async {
useNarrowSurface(tester);
final gateway = ImmediateGateway(replies);
JsonMap? opened;
await tester.pumpWidget(
host(
SearchScreen(
gateway: gateway,
onOpen: (value) => opened = value,
cupertino: cupertino,
),
cupertino: cupertino,
),
);
await search(tester, 'release');
expect(gateway.calls.single['search'], {
'query': 'release',
'kind': '',
'limit': 0,
});
expect(gateway.chatCalls.single['search'], {
'query': 'release',
'kind': 'chat',
'limit': 0,
});
expect(find.text('Chats (2)'), findsOneWidget);
expect(find.text('Pipelines and runs'), findsOneWidget);
final chats = tester.getTopLeft(find.byKey(searchChatsSectionKey));
final others = tester.getTopLeft(find.byKey(searchOthersSectionKey));
final chatRow = find.byKey(const ValueKey('search.result.chat:ses_a'));
final runRow = find.byKey(
const ValueKey('search.result.run:11:4:output'),
);
expect(chats.dy, lessThan(tester.getTopLeft(chatRow).dy));
expect(tester.getTopLeft(chatRow).dy, lessThan(others.dy));
expect(others.dy, lessThan(tester.getTopLeft(runRow).dy));
expect(find.text('API refactor'), findsOneWidget);
expect(find.text('Release notes'), findsOneWidget);
expect(
find.textContaining('Chat · Claude Code · /work/api'),
findsNWidgets(2),
);
expect(find.textContaining('the release retry'), findsOneWidget);
expect(tester.takeException(), isNull);
await tester.tap(chatRow);
await tester.pump();
expect(opened?['target'], 'chat:ses_a');
expect((opened?['chat'] as Map)['session_id'], 'ses_a');
});
}
testWidgets('Chats selected alone lists chats without group headings', (
tester,
) async {
useNarrowSurface(tester);
final gateway = ImmediateGateway(replies);
await tester.pumpWidget(
MaterialApp(
home: SearchScreen(gateway: gateway, onOpen: (_) {}, cupertino: false),
),
);
await search(tester, 't:chat release');
expect(gateway.calls, isEmpty);
expect(gateway.chatCalls, hasLength(1));
expect(find.text('API refactor'), findsOneWidget);
expect(find.byKey(searchChatsSectionKey), findsNothing);
expect(find.byKey(searchOthersSectionKey), findsNothing);
});
testWidgets('an older server without chat search keeps its run results and '
'says chats were not searched', (tester) async {
useNarrowSurface(tester);
final gateway = ImmediateGateway((query, kind) {
if (kind == 'chat') {
throw StateError('unknown search kind "chat"; use one of pipeline');
}
return response([field]);
});
await tester.pumpWidget(
MaterialApp(
home: SearchScreen(gateway: gateway, onOpen: (_) {}, cupertino: false),
),
);
await search(tester, 'release');
expect(
find.byKey(const ValueKey('search.result.run:11:4:output')),
findsOneWidget,
);
expect(find.byKey(searchChatsNoteKey), findsOneWidget);
expect(find.textContaining('does not search chats'), findsOneWidget);
});
}
@@ -14,6 +14,7 @@ void main() {
'step',
'field',
'artifact',
'chat',
'version',
]);
expect(SearchKind.values.map((kind) => kind.label), [
@@ -23,6 +24,7 @@ void main() {
'Steps',
'Fields',
'Artifacts',
'Chats',
'Versions',
]);
expect(SearchKind.fromWire('run'), SearchKind.run);
@@ -10,10 +10,13 @@ class RecordingGateway implements ApiGateway {
final JsonMap Function(String query, String kind) reply;
final calls = <JsonMap>[];
/// The `kind: chat` searches sent beside the others.
final chatCalls = <JsonMap>[];
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
calls.add(Map.of(fields));
final search = Map<String, dynamic>.from(fields['search'] as Map);
(search['kind'] == 'chat' ? chatCalls : calls).add(Map.of(fields));
return reply(search['query'] as String, search['kind'] as String);
}
@@ -56,7 +59,7 @@ void main() {
expect(gateway.calls, isEmpty);
expect(
find.text('Search pipelines, runs and artifacts.'),
find.text('Search pipelines, runs, artifacts and chats.'),
findsOneWidget,
);
expect(find.textContaining('No matches'), findsNothing);
@@ -10,10 +10,13 @@ class ImmediateGateway implements ApiGateway {
final JsonMap Function(String query, String kind) reply;
final calls = <JsonMap>[];
/// The `kind: chat` searches sent beside the others.
final chatCalls = <JsonMap>[];
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
calls.add(Map.of(fields));
final search = Map<String, dynamic>.from(fields['search'] as Map);
(search['kind'] == 'chat' ? chatCalls : calls).add(Map.of(fields));
return reply(search['query'] as String, search['kind'] as String);
}
@@ -29,6 +32,8 @@ class FailingThenSucceedingGateway implements ApiGateway {
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
final search = fields['search'];
if (search is Map && search['kind'] == 'chat') return success;
calls++;
if (calls == 1) throw StateError('unknown command: search');
return success;
@@ -4,12 +4,28 @@ import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/search/data/search_repository.dart';
import 'package:pipelines_app/features/search/domain/search_controller.dart';
/// Queues run/artifact searches in [calls]/[pending]. A `kind: chat` search
/// (sent beside every all-kind search) is recorded in [chatCalls] and, unless
/// [holdChats] is set, answered at once with no chats.
class QueuedGateway implements ApiGateway {
QueuedGateway({this.holdChats = false});
final bool holdChats;
final calls = <JsonMap>[];
final pending = <Completer<JsonMap>>[];
final chatCalls = <JsonMap>[];
final chatPending = <Completer<JsonMap>>[];
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
final search = fields['search'];
if (search is Map && search['kind'] == 'chat') {
chatCalls.add(Map.of(fields));
if (!holdChats) return Future.value(envelope(const []));
final completer = Completer<JsonMap>();
chatPending.add(completer);
return completer.future;
}
calls.add(Map.of(fields));
final completer = Completer<JsonMap>();
pending.add(completer);
@@ -48,3 +64,18 @@ OmniSearchController controllerFor(ApiGateway gateway) => OmniSearchController(
repository: SearchRepository(gateway),
debounce: Duration.zero,
);
/// A server-shaped `kind: chat` hit; a [snippet] makes it a message match.
JsonMap chatHit(String id, {String title = 'Fix CI', String? snippet}) => {
'kind': 'chat',
'target': 'chat:$id',
'score': snippet == null ? 3 : 1,
'matched_field': snippet == null ? 'title' : 'message',
'chat': {
'session_id': id,
'title': title,
'directory': '/work/api',
'backend': 'claude',
'snippet': ?snippet,
},
};
+79
View File
@@ -0,0 +1,79 @@
// Server-shaped `kind: chat` search replies over the `?chats=N` sessions
// (tool/perf/perf_fixture.dart), so Search can show and open chat hits in
// captures. Without `?chats=` there are no chats and no hits.
import 'package:pipelines_app/core/api_gateway.dart';
import 'perf_fixture.dart';
/// Hits the way `internal/server/search_chats.go` answers: a title or
/// directory match from the registry row, else the newest transcript message
/// whose text matches, with a snippet around the match. One hit per chat, best
/// match first. A blank query lists every chat.
List<JsonMap> perfChatSearchHits(String query) {
final needle = query.trim().toLowerCase();
final hits = <JsonMap>[];
for (final row in perfChatRows()) {
final title = '${row['title'] ?? ''}';
final directory = '${row['directory'] ?? ''}';
final chat = <String, dynamic>{
'session_id': row['id'],
'title': title,
'directory': directory,
'backend': row['backend'] ?? 'opencode',
'updated_at': ?row['updated_at'],
};
String field;
int score;
if (needle.isEmpty) {
field = '';
score = 0;
} else if (title.toLowerCase().contains(needle)) {
field = 'title';
score = 3;
} else if (directory.toLowerCase().contains(needle)) {
field = 'directory';
score = 2;
} else {
final match = _newestMatch(needle);
if (match == null) continue;
field = 'message';
score = 1;
chat
..['message_id'] = 'perf-m${match.index}'
..['role'] = match.index.isEven ? 'user' : 'assistant'
..['snippet'] = match.snippet;
}
final updated = row['updated_at'];
hits.add({
'kind': 'chat',
'target': 'chat:${row['id']}',
'score': score,
'matched_field': field,
if (updated is int)
'recency': DateTime.fromMillisecondsSinceEpoch(
updated,
isUtc: true,
).toIso8601String(),
'chat': chat,
});
}
hits.sort((a, b) => (b['score'] as int).compareTo(a['score'] as int));
return hits;
}
({int index, String snippet})? _newestMatch(String needle) {
for (var m = 19; m >= 0; m--) {
final line = perfChatMessageText(m).replaceAll(RegExp(r'\s+'), ' ');
final at = line.toLowerCase().indexOf(needle);
if (at < 0) continue;
final start = at - 40 < 0 ? 0 : at - 40;
final end = at + needle.length + 40 > line.length
? line.length
: at + needle.length + 40;
final snippet =
'${start > 0 ? '…' : ''}${line.substring(start, end)}'
'${end < line.length ? '…' : ''}';
return (index: m, snippet: snippet);
}
return null;
}
+7
View File
@@ -264,3 +264,10 @@ JsonMap? perfChatReply(JsonMap request) {
}
return null;
}
/// The `?chats=N` list rows, as chat_sessions serves them.
List<JsonMap> perfChatRows() => [for (var i = 0; i < _chats; i++) _chatRow(i)];
/// The text of message `perf-m<m>` in the bench's short transcript, newest
/// last (20 messages).
String perfChatMessageText(int m) => m.isEven ? 'Question $m' : _answer(m);
@@ -28,6 +28,7 @@ import 'package:web/web.dart' as web;
import 'package:web_socket_channel/web_socket_channel.dart';
import 'perf/backdrop_census.dart';
import 'perf/chat_search_fixture.dart';
import 'perf/chat_scroll_fixture.dart';
import 'perf/chat_scroll_probe.dart';
import 'perf/frame_log.dart';
@@ -449,6 +450,24 @@ JsonMap? probeReply(JsonMap request) {
}
final query = (search['query'] as String).trim().toLowerCase();
final kind = search['kind'] as String;
if (kind == 'chat') {
// The server answers chats as their own request (search_chats.go).
return {
'id': id,
'type': 'search_results',
'search_results': {
'query': search['query'],
'kind': kind,
'results': perfChatSearchHits(query),
'truncated': false,
'scanned_steps': 0,
'scanned_bytes': 0,
'cap': 50,
'scan_bound_bytes': 1048576,
'scanned_chats': 3,
},
};
}
final results = [
for (final entry in probeHits)
if ((kind.isEmpty || entry.hit['kind'] == kind) &&
+14
View File
@@ -118,6 +118,20 @@ confirmation.
- Targets are stable and navigable: `pipeline:<id>`, `pipeline:<id>:v<version>`,
`run:<id>`, `run:<id>:<sequence>`, `run:<id>:<sequence>:<field>`, or an
artifact URL served by the artifact endpoint.
- Chats: a `search` request with `kind: "chat"` (protocol only; the all-kind
search never includes chats, so older clients see no change) matches the
operator's chat sessions. Every listed chat's title and directory are
matched from the registry; for up to 24 of the most recently used chats not
matched there, the newest 100 messages' text is read through the chat broker,
four at a time, within a one-second budget. A transcript still unread when the
budget expires is left out and the reply says `truncated`; `scanned_chats`
reports how many transcripts were read. Each chat yields at most one hit
(`target` `chat:<session id>`, `matched_field` `title`, `directory` or
`message`) whose `chat` payload carries the title, directory, harness and,
for a message match, the message id, role and a snippet. The server answers it
off the connection's read loop, so it never delays other replies; a newer chat
search on the same connection cancels the previous one. The app sends it after
its run search and shows the hits as a Chats group.
```sh
pipelines search "release notes" --json
+2 -36
View File
@@ -701,42 +701,8 @@ func findMatch(value any, text string) (string, bool) {
return "", false
}
// searchSnippet reduces text to a single clean line and centers a short window
// on the first case-insensitive match, folding runes so UTF-8 boundaries are
// never split and the result is always well-formed.
func searchSnippet(text, query string) string {
normalized := protocol.NormalizeText(text)
runes := []rune(normalized)
index := protocol.RuneIndexFold(runes, []rune(query))
if index < 0 {
return truncateRunes(normalized, 80)
}
const margin = 40
start := index - margin
if start < 0 {
start = 0
}
end := index + len([]rune(query)) + margin
if end > len(runes) {
end = len(runes)
}
snippet := string(runes[start:end])
if start > 0 {
snippet = "…" + snippet
}
if end < len(runes) {
snippet = snippet + "…"
}
return snippet
}
func truncateRunes(text string, limit int) string {
runes := []rune(text)
if len(runes) <= limit {
return text
}
return string(runes[:limit]) + "…"
}
// searchSnippet is the shared protocol snippet window.
func searchSnippet(text, query string) string { return protocol.SearchSnippet(text, query) }
func searchPipelineTarget(id int64) string { return fmt.Sprintf("pipeline:%d", id) }
+71 -1
View File
@@ -24,6 +24,12 @@ const (
SearchKindStep = "step"
SearchKindField = "field"
SearchKindArtifact = "artifact"
// SearchKindChat narrows to operator chat sessions. It is not part of
// SearchKinds: the store's all-kind search never includes chats, so an
// older client's reply is unchanged. A client asks for chats with this
// kind as its own request, which the server answers concurrently with
// (and never ahead of or blocking) the run/artifact search.
SearchKindChat = "chat"
)
// SearchKinds is the accepted Kind vocabulary in display order; the CLI help
@@ -52,6 +58,13 @@ const (
// SearchMaxScanSteps bounds how many recorded steps one query inspects while
// scanning input/output/transcript field text.
SearchMaxScanSteps = 2000
// SearchMaxScanChats bounds how many of the most recently used operator
// chats one chat search reads message text from; titles and directories
// of every listed chat are always matched.
SearchMaxScanChats = 24
// SearchChatMessagesPerChat is how many of a chat's newest messages one
// chat search reads.
SearchChatMessagesPerChat = 100
// SearchMaxScanBytes bounds the total field bytes (input_json + output_json +
// evidence_json + transcript) one query decodes and searches before it stops
// and reports Truncated.
@@ -85,12 +98,15 @@ type SearchResponse struct {
ScannedBytes int `json:"scanned_bytes"`
Cap int `json:"cap"`
ScanBoundBytes int `json:"scan_bound_bytes"`
// ScannedChats is how many chat transcripts a chat search read message
// text from (kind chat only); additive, so older peers ignore it.
ScannedChats int `json:"scanned_chats,omitempty"`
}
// SearchResult is one typed, navigable match. Kind selects which payload is
// set; Target is a stable token an existing CLI command can resolve
// (pipeline:<id>, pipeline:<id>:v<version>, run:<id>, run:<id>:<sequence>,
// run:<id>:<sequence>:<field>, or an artifact URL). Score and MatchedField
// run:<id>:<sequence>:<field>, an artifact URL, or chat:<session id>). Score and MatchedField
// expose the ranking tier and why the hit matched so a client can re-rank;
// Recency is the hit's sortable UTC timestamp.
type SearchResult struct {
@@ -105,6 +121,7 @@ type SearchResult struct {
Step *SearchStep `json:"step,omitempty"`
Field *SearchField `json:"field,omitempty"`
Artifact *SearchArtifact `json:"artifact,omitempty"`
Chat *SearchChat `json:"chat,omitempty"`
}
// SearchPipeline is a pipeline name/identity hit: its latest version and stage count.
@@ -166,6 +183,24 @@ type SearchArtifact struct {
URL string `json:"url"`
}
// SearchChat is an operator chat session hit: its registry facts and, for a
// message-text match, the matching message's id, role and a snippet around
// the first match. MatchedField is "title", "directory" or "message".
type SearchChat struct {
SessionID string `json:"session_id"`
Title string `json:"title"`
Directory string `json:"directory,omitempty"`
Backend string `json:"backend,omitempty"`
Closed bool `json:"closed,omitempty"`
UpdatedAt int64 `json:"updated_at,omitempty"`
MessageID string `json:"message_id,omitempty"`
Role string `json:"role,omitempty"`
Snippet string `json:"snippet,omitempty"`
}
// SearchChatTarget is a chat hit's target token.
func SearchChatTarget(sessionID string) string { return "chat:" + sessionID }
// Label is the compact human description of a hit, built from the result's
// typed payload rather than its target token, so it is the single definition
// shared by the CLI and the TUI. A text-field hit's snippet is deliberately not
@@ -198,10 +233,45 @@ func (r SearchResult) Label() string {
if r.Artifact != nil {
return fmt.Sprintf("run %d · step %d · %s · %s", r.Artifact.RunID, r.Artifact.Sequence, r.Artifact.Name, r.Artifact.ContentType)
}
case SearchKindChat:
if r.Chat != nil {
label := "chat · " + r.Chat.Title
if r.Chat.Directory != "" {
label += " · " + r.Chat.Directory
}
return label
}
}
return r.Target
}
// SearchSnippet reduces text to a single clean line and centers a short window
// on the first case-insensitive match, folding runes so UTF-8 boundaries are
// never split and the result is always well-formed. Text with no match is
// truncated from its start.
func SearchSnippet(text, query string) string {
normalized := NormalizeText(text)
runes := []rune(normalized)
index := RuneIndexFold(runes, []rune(query))
if index < 0 {
if len(runes) <= 80 {
return normalized
}
return string(runes[:80]) + "…"
}
const margin = 40
start := max(index-margin, 0)
end := min(index+len([]rune(query))+margin, len(runes))
snippet := string(runes[start:end])
if start > 0 {
snippet = "…" + snippet
}
if end < len(runes) {
snippet = snippet + "…"
}
return snippet
}
// RuneIndexFold returns the rune index where query first matches text
// case-insensitively, or -1 when it does not. It folds runes rather than bytes
// so a caller never splits a UTF-8 boundary, and an empty query never matches.
+67
View File
@@ -0,0 +1,67 @@
package protocol
import (
"encoding/json"
"slices"
"strings"
"testing"
)
// TestSearchChatResultRoundTrip pins the additive chat hit: its payload and
// ScannedChats survive the wire, and a reply without them encodes neither key,
// so an older peer's search_results body is unchanged.
func TestSearchChatResultRoundTrip(t *testing.T) {
response := Message{Type: SearchResults, ID: "c1", SearchResults: &SearchResponse{
Query: "flaky", Kind: SearchKindChat, Cap: 50, ScannedChats: 3,
Results: []SearchResult{{
Kind: SearchKindChat, Target: SearchChatTarget("ses_abc"), Score: 1, MatchedField: "message",
Chat: &SearchChat{SessionID: "ses_abc", Title: "Fix CI", Directory: "/work/repo", Backend: "claude", MessageID: "m9", Role: "assistant", Snippet: "the flaky test", UpdatedAt: 1700000000000},
}},
}}
encoded, err := json.Marshal(response)
if err != nil {
t.Fatal(err)
}
var echoed Message
if err := json.Unmarshal(encoded, &echoed); err != nil {
t.Fatal(err)
}
got := echoed.SearchResults
if got == nil || got.ScannedChats != 3 || got.Kind != SearchKindChat || len(got.Results) != 1 {
t.Fatalf("chat search response lost: %+v", got)
}
hit := got.Results[0]
if hit.Target != "chat:ses_abc" || hit.Chat == nil || *hit.Chat != *response.SearchResults.Results[0].Chat {
t.Fatalf("chat payload lost: %+v", hit)
}
if label := hit.Label(); label != "chat · Fix CI · /work/repo" {
t.Fatalf("label = %q", label)
}
plain, err := json.Marshal(SearchResponse{Results: []SearchResult{{Kind: SearchKindRun, Target: "run:1"}}})
if err != nil {
t.Fatal(err)
}
if strings.Contains(string(plain), "scanned_chats") || strings.Contains(string(plain), `"chat"`) {
t.Fatalf("a run-only reply encodes chat keys: %s", plain)
}
}
// TestSearchKindChatIsNotAStoreKind keeps chats out of the all-kind store
// vocabulary, so an older client's default search never changes shape.
func TestSearchKindChatIsNotAStoreKind(t *testing.T) {
if slices.Contains(SearchKinds, SearchKindChat) {
t.Fatalf("SearchKinds = %v, chat must be requested on its own", SearchKinds)
}
}
func TestSearchSnippetWindowsTheMatch(t *testing.T) {
text := strings.Repeat("a", 60) + " Needle here " + strings.Repeat("b", 60)
got := SearchSnippet(text, "needle")
if !strings.HasPrefix(got, "…") || !strings.HasSuffix(got, "…") || !strings.Contains(got, "Needle") {
t.Fatalf("snippet = %q", got)
}
if got := SearchSnippet("short\nline", "zzz"); got != "short line" {
t.Fatalf("unmatched short snippet = %q", got)
}
}
+228
View File
@@ -0,0 +1,228 @@
package server
import (
"context"
"sort"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// chatSearchBudget bounds how long one chat search waits for transcript
// readback. Registry (title/directory) hits never wait on it; a transcript
// still unread when it expires is left out and the reply says Truncated.
// It is short because a client that serializes its requests (the app does)
// holds its next request behind this reply. It is a variable so a test can
// shorten it.
var chatSearchBudget = time.Second
// chatSearchConcurrency is how many transcripts one chat search reads at once.
const chatSearchConcurrency = 4
// Chat hit scores: a title match outranks a directory match, which outranks a
// message-text match; recency breaks ties.
const (
chatScoreTitleExact = 4
chatScoreTitle = 3
chatScoreDirectory = 2
chatScoreMessage = 1
)
// isChatSearch reports a search request narrowed to chats. It is answered by
// searchChats, off the connection's read loop, so it never delays the
// run/artifact search a client sends beside it.
func isChatSearch(request protocol.Message) bool {
return request.Type == protocol.Search && request.Search != nil &&
strings.TrimSpace(request.Search.Kind) == protocol.SearchKindChat
}
// chatSearchReply answers one kind=chat search request.
func chatSearchReply(ctx context.Context, request protocol.Message, broker chatBroker, registry operatorRegistry) protocol.Message {
if registry == nil {
return protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat search unavailable: operator session registry is not configured on this server"}
}
response, err := searchChats(ctx, *request.Search, broker, registry)
if err != nil {
return protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}
}
return protocol.Message{Type: protocol.SearchResults, ID: request.ID, SearchResults: response}
}
// searchChats matches the operator's chat sessions: the title and directory of
// every listed registry session (one bounded statement), then the newest
// SearchChatMessagesPerChat messages of up to SearchMaxScanChats of the most
// recently used sessions the registry did not already match, read through the
// chat broker concurrently within chatSearchBudget. One session yields at most
// one hit, its best match. A blank query lists the most recent chats.
func searchChats(ctx context.Context, req protocol.SearchRequest, broker chatBroker, registry operatorRegistry) (*protocol.SearchResponse, error) {
query := strings.TrimSpace(req.Query)
response := &protocol.SearchResponse{
Query: req.Query,
Kind: protocol.SearchKindChat,
Results: []protocol.SearchResult{},
Cap: chatSearchLimit(req.Limit),
ScanBoundBytes: protocol.SearchMaxScanBytes,
}
sessions, err := registry.OperatorSessions(ctx)
if err != nil {
return nil, err
}
var results []protocol.SearchResult
var unmatched []pipeline.OperatorSession
for _, session := range sessions {
if query == "" {
results = append(results, chatSearchHit(session, 0, ""))
continue
}
switch {
case strings.EqualFold(session.Title, query):
results = append(results, chatSearchHit(session, chatScoreTitleExact, "title"))
case containsFold(session.Title, query):
results = append(results, chatSearchHit(session, chatScoreTitle, "title"))
case containsFold(session.Directory, query):
results = append(results, chatSearchHit(session, chatScoreDirectory, "directory"))
default:
unmatched = append(unmatched, session)
}
}
if query != "" && broker != nil && len(unmatched) > 0 {
if len(unmatched) > protocol.SearchMaxScanChats {
unmatched = unmatched[:protocol.SearchMaxScanChats]
}
hits, scanned, complete := searchChatTranscripts(ctx, broker, unmatched, query)
results = append(results, hits...)
response.ScannedChats = scanned
if !complete {
response.Truncated = true
}
}
sort.SliceStable(results, func(i, j int) bool {
a, b := results[i], results[j]
if a.Score != b.Score {
return a.Score > b.Score
}
if a.Recency != b.Recency {
return a.Recency > b.Recency
}
return a.Target < b.Target
})
if len(results) > response.Cap {
results = results[:response.Cap]
response.Truncated = true
}
if results != nil {
response.Results = results
}
return response, nil
}
// chatSearchLimit clamps a requested cap like the store's search does.
func chatSearchLimit(limit int) int {
if limit <= 0 {
return protocol.SearchDefaultLimit
}
return min(limit, protocol.SearchMaxLimit)
}
// chatTranscriptHit is one transcript read's outcome.
type chatTranscriptHit struct {
hit *protocol.SearchResult
scanned bool
}
// searchChatTranscripts reads each session's newest messages with bounded
// concurrency and returns the message hits that arrived within the budget,
// how many transcripts were read, and whether every read finished. Workers
// that outlive the budget see a canceled context and write into a buffered
// channel, so none of them blocks or leaks past its own read.
func searchChatTranscripts(ctx context.Context, broker chatBroker, sessions []pipeline.OperatorSession, query string) ([]protocol.SearchResult, int, bool) {
ctx, cancel := context.WithTimeout(ctx, chatSearchBudget)
defer cancel()
jobs := make(chan pipeline.OperatorSession, len(sessions))
for _, session := range sessions {
jobs <- session
}
close(jobs)
out := make(chan chatTranscriptHit, len(sessions))
for range min(chatSearchConcurrency, len(sessions)) {
go func() {
for session := range jobs {
if ctx.Err() != nil {
out <- chatTranscriptHit{}
continue
}
out <- searchChatTranscript(ctx, broker, session, query)
}
}()
}
var hits []protocol.SearchResult
scanned := 0
for range sessions {
select {
case result := <-out:
if result.scanned {
scanned++
}
if result.hit != nil {
hits = append(hits, *result.hit)
}
case <-ctx.Done():
return hits, scanned, false
}
}
return hits, scanned, scanned == len(sessions)
}
// searchChatTranscript matches query against the text parts of one session's
// newest messages, newest first, and returns a hit for the newest match.
func searchChatTranscript(ctx context.Context, broker chatBroker, session pipeline.OperatorSession, query string) chatTranscriptHit {
page, err := broker.Messages(ctx, session.ID, protocol.SearchChatMessagesPerChat, "")
if err != nil || ctx.Err() != nil {
return chatTranscriptHit{}
}
for i := len(page.Messages) - 1; i >= 0; i-- {
message := page.Messages[i]
for _, part := range message.Parts {
if part.Type != protocol.ChatPartText || !containsFold(part.Text, query) {
continue
}
hit := chatSearchHit(session, chatScoreMessage, "message")
hit.Chat.MessageID = message.ID
hit.Chat.Role = message.Role
hit.Chat.Snippet = protocol.SearchSnippet(part.Text, query)
return chatTranscriptHit{hit: &hit, scanned: true}
}
}
return chatTranscriptHit{scanned: true}
}
func chatSearchHit(session pipeline.OperatorSession, score int, field string) protocol.SearchResult {
backend := session.Backend
if backend == "" {
backend = "opencode"
}
hit := protocol.SearchResult{
Kind: protocol.SearchKindChat,
Target: protocol.SearchChatTarget(session.ID),
Score: score,
MatchedField: field,
Chat: &protocol.SearchChat{
SessionID: session.ID,
Title: session.Title,
Directory: session.Directory,
Backend: backend,
Closed: session.ClosedAt > 0,
UpdatedAt: session.UpdatedAt,
},
}
if session.UpdatedAt > 0 {
hit.Recency = time.UnixMilli(session.UpdatedAt).UTC().Format(time.RFC3339)
}
return hit
}
func containsFold(value, query string) bool {
return query != "" && strings.Contains(strings.ToLower(value), strings.ToLower(query))
}
+166
View File
@@ -0,0 +1,166 @@
package server
import (
"context"
"testing"
"time"
"github.com/coder/websocket"
"github.com/coder/websocket/wsjson"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// transcriptChat serves a fixed newest page per session. A session listed in
// slow blocks until its read is canceled, like a harness that never answers.
type transcriptChat struct {
*fakeChat
pages map[string][]protocol.ChatMessage
slow map[string]bool
}
func (c *transcriptChat) Messages(ctx context.Context, sessionID string, limit int, _ string) (protocol.ChatHistoryPage, error) {
if c.slow[sessionID] {
<-ctx.Done()
return protocol.ChatHistoryPage{}, ctx.Err()
}
if limit != protocol.SearchChatMessagesPerChat {
return protocol.ChatHistoryPage{}, context.Canceled
}
return protocol.ChatHistoryPage{Messages: c.pages[sessionID]}, nil
}
func chatText(id, role, text string) protocol.ChatMessage {
return protocol.ChatMessage{ID: id, Role: role, Parts: []protocol.ChatPart{{Type: protocol.ChatPartText, Text: text}}}
}
func chatSearchFixture(t *testing.T, broker *transcriptChat) (context.Context, *websocket.Conn) {
t.Helper()
store := newOperatorStore(t)
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
rows := []struct{ id, directory, title, backend string }{
{"ses_title", "/work/site", "Flaky test hunt", "claude"},
{"ses_dir", "/work/flaky-repo", "Docs pass", "codex"},
{"ses_text", "/work/api", "API refactor", ""},
{"ses_none", "/work/other", "Unrelated", ""},
{"ses_slow", "/work/slow", "Slow harness", ""},
}
for _, row := range rows {
if err := store.RecordOperatorSession(ctx, row.id, row.directory, row.title, protocol.ChatSessionTagOperator); err != nil {
t.Fatal(err)
}
if row.backend != "" {
if err := store.SetOperatorSessionBackend(ctx, row.id, row.backend); err != nil {
t.Fatal(err)
}
}
}
return ctx, conn
}
func chatSearch(t *testing.T, ctx context.Context, conn *websocket.Conn, id, query string) {
t.Helper()
writeChat(t, ctx, conn, protocol.Message{Type: protocol.Search, ID: id, Search: &protocol.SearchRequest{Query: query, Kind: protocol.SearchKindChat}})
}
func readReply(t *testing.T, ctx context.Context, conn *websocket.Conn, id string) protocol.Message {
t.Helper()
for {
var reply protocol.Message
if err := wsjson.Read(ctx, conn, &reply); err != nil {
t.Fatalf("read reply %s: %v", id, err)
}
if reply.ID == id {
return reply
}
}
}
func TestChatSearchMatchesTitleDirectoryAndMessageText(t *testing.T) {
broker := &transcriptChat{fakeChat: scriptedChat(), pages: map[string][]protocol.ChatMessage{
"ses_text": {
chatText("m1", protocol.ChatRoleUser, "Why is the build flaky?"),
chatText("m2", protocol.ChatRoleAssistant, "The FLAKY part is the retry loop in client.go."),
{ID: "m3", Role: protocol.ChatRoleAssistant, Parts: []protocol.ChatPart{{Type: protocol.ChatPartReasoning, Text: "flaky reasoning is not searched"}}},
},
"ses_none": {chatText("n1", protocol.ChatRoleUser, "nothing relevant")},
"ses_title": {chatText("t1", protocol.ChatRoleUser, "flaky again")},
}}
ctx, conn := chatSearchFixture(t, broker)
chatSearch(t, ctx, conn, "c1", "flaky")
reply := readReply(t, ctx, conn, "c1")
if reply.Type != protocol.SearchResults || reply.SearchResults == nil {
t.Fatalf("reply = %+v", reply)
}
got := reply.SearchResults
if got.Kind != protocol.SearchKindChat || got.Truncated || got.ScannedChats != 3 {
t.Fatalf("bounds = kind %q truncated %v scanned %d, want chat, complete, 3 transcripts (title/dir hits skip readback)", got.Kind, got.Truncated, got.ScannedChats)
}
if len(got.Results) != 3 {
t.Fatalf("results = %+v, want title, directory and message hits", got.Results)
}
title, dir, text := got.Results[0], got.Results[1], got.Results[2]
if title.Target != "chat:ses_title" || title.MatchedField != "title" || title.Chat.Backend != "claude" || title.Chat.Snippet != "" {
t.Fatalf("title hit = %+v %+v", title, title.Chat)
}
if dir.Target != "chat:ses_dir" || dir.MatchedField != "directory" || dir.Chat.Directory != "/work/flaky-repo" || dir.Chat.Backend != "codex" {
t.Fatalf("directory hit = %+v %+v", dir, dir.Chat)
}
if text.Target != "chat:ses_text" || text.MatchedField != "message" || text.Chat.MessageID != "m2" || text.Chat.Role != protocol.ChatRoleAssistant || text.Chat.Backend != "opencode" {
t.Fatalf("message hit = %+v %+v (want the newest matching text part)", text, text.Chat)
}
if text.Chat.Snippet != "The FLAKY part is the retry loop in client.go." || text.Chat.Title != "API refactor" || text.Recency == "" {
t.Fatalf("message hit facts = %+v", text.Chat)
}
}
// TestChatSearchBudgetNeverBlocksOtherReplies: a harness that never answers
// only costs its own transcript. The connection keeps answering other requests
// while the chat search waits, and the chat reply still arrives within the
// budget with the registry and finished-transcript hits, marked Truncated.
func TestChatSearchBudgetNeverBlocksOtherReplies(t *testing.T) {
previous := chatSearchBudget
chatSearchBudget = 400 * time.Millisecond
t.Cleanup(func() { chatSearchBudget = previous })
broker := &transcriptChat{fakeChat: scriptedChat(), slow: map[string]bool{"ses_slow": true}, pages: map[string][]protocol.ChatMessage{
"ses_text": {chatText("m1", protocol.ChatRoleUser, "a flaky retry")},
}}
ctx, conn := chatSearchFixture(t, broker)
started := time.Now()
chatSearch(t, ctx, conn, "c1", "flaky")
writeChat(t, ctx, conn, protocol.Message{Type: protocol.Ping, ID: "p1"})
var first protocol.Message
if err := wsjson.Read(ctx, conn, &first); err != nil {
t.Fatal(err)
}
if first.ID != "p1" {
t.Fatalf("first reply = %s %s, want the ping answered while transcripts load", first.ID, first.Type)
}
reply := readReply(t, ctx, conn, "c1")
if elapsed := time.Since(started); elapsed > 3*time.Second {
t.Fatalf("chat search took %v, budget is %v", elapsed, chatSearchBudget)
}
got := reply.SearchResults
if got == nil || !got.Truncated || len(got.Results) != 3 {
t.Fatalf("reply = %+v, want three hits and Truncated", got)
}
if got.Results[2].Target != "chat:ses_text" {
t.Fatalf("message hit missing: %+v", got.Results)
}
}
func TestChatSearchBlankListsRecentAndNeedsRegistry(t *testing.T) {
broker := &transcriptChat{fakeChat: scriptedChat()}
ctx, conn := chatSearchFixture(t, broker)
chatSearch(t, ctx, conn, "b1", " ")
reply := readReply(t, ctx, conn, "b1")
if reply.SearchResults == nil || len(reply.SearchResults.Results) != 5 || reply.SearchResults.ScannedChats != 0 {
t.Fatalf("blank chat search = %+v, want every listed chat and no transcript reads", reply.SearchResults)
}
ctx, _, bare := dialChatOptions(t, Options{Chat: broker})
chatSearch(t, ctx, bare, "n1", "x")
if reply := readReply(t, ctx, bare, "n1"); reply.Type != protocol.Error {
t.Fatalf("no-registry chat search = %+v, want an error", reply)
}
}
+15
View File
@@ -217,6 +217,11 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
if notes != nil {
defer notes.detach(clientID)
}
// A chat search runs beside the read loop so its transcript readback
// never delays the run search sent with it; a newer one cancels the
// previous, whose reply the client would discard as stale anyway.
cancelChatSearch := func() {}
defer func() { cancelChatSearch() }()
for {
var request protocol.Message
if err := wsjson.Read(connCtx, conn, &request); err != nil {
@@ -227,6 +232,16 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "pipeline authoring is disabled on this execution server; ask the operator to publish through an explicitly enabled authoring server"})
continue
}
if isChatSearch(request) {
cancelChatSearch()
searchCtx, cancel := context.WithCancel(connCtx)
cancelChatSearch = cancel
go func(request protocol.Message) {
defer cancel()
_ = write(chatSearchReply(searchCtx, request, options.Chat, registry))
}(request)
continue
}
if handleChat(connCtx, request, options.Chat, hub, registry, clientID, write) {
continue
}