Files
pipelines/app/lib/features/chat/domain/chat_commands.dart
T

171 lines
6.5 KiB
Dart

/// One command the chat composer offers. [name] is the word after the slash,
/// [usage] is what the operator types (including any argument) and [summary] is
/// the few-word description shown beside it. [takesArgument] is false for the
/// commands that act on the current session alone.
///
/// The words and order are the web client's `CHAT_COMMANDS`, which the Android
/// client records too. They are a fixed client-side vocabulary, not server data.
class ChatCommand {
const ChatCommand({
required this.name,
required this.summary,
required this.usage,
this.takesArgument = false,
});
final String name;
final String summary;
final String usage;
final bool takesArgument;
}
const String chatCommandNew = 'new';
const String chatCommandClose = 'close';
const String chatCommandRename = 'rename';
const String chatCommandStop = 'stop';
const String chatCommandHelp = 'help';
/// The recorded command list, in the order the palette shows it.
const List<ChatCommand> chatCommands = <ChatCommand>[
ChatCommand(
name: chatCommandNew,
summary: 'Start a fresh session in this directory',
usage: '/new',
),
ChatCommand(
name: chatCommandClose,
summary: 'Finish this session for every client, keeping its history',
usage: '/close',
),
ChatCommand(
name: chatCommandRename,
summary: 'Rename this session',
usage: '/rename <title>',
takesArgument: true,
),
ChatCommand(
name: chatCommandStop,
summary: 'Stop the turn that is running',
usage: '/stop',
),
ChatCommand(
name: chatCommandHelp,
summary: 'List every command',
usage: '/help',
),
];
final RegExp _whitespace = RegExp(r'\s');
/// The lower-case name prefix a draft offers commands for, or null when the
/// draft is not a single slash word.
///
/// Only the start of the draft counts. Once whitespace follows the word an
/// argument has begun, so the palette hides; text that does not start with a
/// slash offers nothing.
String? chatCommandQuery(String draft) {
final trimmed = draft.trimLeft();
if (!trimmed.startsWith('/')) return null;
if (_whitespace.hasMatch(trimmed)) return null;
return trimmed.substring(1).toLowerCase();
}
/// The recorded commands matching [draft], filtered case-insensitively by name
/// prefix. Empty when no palette should show.
List<ChatCommand> chatCommandSuggestions(String draft) {
final query = chatCommandQuery(draft);
if (query == null) return const <ChatCommand>[];
return <ChatCommand>[
for (final command in chatCommands)
if (command.name.toLowerCase().startsWith(query)) command,
];
}
/// The slash word [draft] starts with, including its `/`, or null when the
/// draft does not start with one. Only the first word counts, so an argument
/// (`/rename My chat`) still names `/rename`.
String? chatCommandWord(String draft) {
final trimmed = draft.trimLeft();
if (!trimmed.startsWith('/')) return null;
final boundary = _whitespace.firstMatch(trimmed);
return boundary == null ? trimmed : trimmed.substring(0, boundary.start);
}
/// The recorded command [draft] names, matched case-insensitively against the
/// whole slash word, or null when that word names no recorded command.
///
/// This is the routing question, not the palette filter: a completed command
/// (`/close`) and one carrying its argument (`/rename My chat`) both resolve.
ChatCommand? chatCommandNamed(String draft) {
final word = chatCommandWord(draft);
if (word == null) return null;
final name = word.substring(1).toLowerCase();
for (final command in chatCommands) {
if (command.name.toLowerCase() == name) return command;
}
return null;
}
/// The trimmed text after the command word, or empty when there is no argument.
String chatCommandArgument(String draft) {
final word = chatCommandWord(draft);
if (word == null) return '';
return draft.trimLeft().substring(word.length).trim();
}
/// `/help`'s local listing, in the same order and wording as the palette.
String chatCommandHelpText() => chatCommands
.map((command) => '${command.usage} — ${command.summary}')
.join('\n');
/// The local no-send report for a slash draft naming no recorded command,
/// verbatim from the web client's unknown-command notice. The report offers the
/// draft back, so only an explicit "Send as message" reaches the agent.
String chatUnknownCommandReport(String word) =>
'“$word” is not a command, so nothing was sent to the agent. '
'Send it as a message, or cancel.';
/// The local no-send report for a recorded command whose action this client
/// does not run yet. Command actions are a later slice; until they land the
/// text must never become an implicit prompt.
String chatCommandUnavailableReport(String word) =>
'“$word” is not available yet, so nothing was sent to the agent.';
/// The behaviour brief a `/new` session is created with, verbatim from the web
/// client's `DEFAULT_CHAT_INSTRUCTIONS`.
const String chatDefaultSessionInstructions =
"Act as a careful coding agent. Read the repository's AGENTS.md and the "
'relevant skills before acting. Inspect the current state, keep changes '
'scoped to the request, run the relevant checks, and report exactly what '
'changed and what was not verified. Ask only about real ambiguity, '
'destructive actions or changes outside the request.';
/// The title every `/new` session is created with, as the web client sends it.
const String chatNewSessionTitle = 'New chat';
/// `/new` and `/close` act on the open session alone, so an argument is a
/// usage error the web reports in these exact words.
String chatCommandArgumentReport(ChatCommand command) =>
'${command.usage} does not take an argument.';
/// `/rename` without a title sends nothing and reports its usage.
const String chatRenameUsageReport =
'Usage: /rename <title> — renames this session.';
/// `/new` needs the open session's directory; without one nothing is sent.
const String chatNoDirectoryReport =
"Can't start a new session here: the server reported no directory for "
'this chat.';
/// The notice the created session opens with.
String chatSessionStartedNotice(String title, String directory) =>
'Started a new session “$title” in $directory.';
/// The failed notice the current session shows when the create is refused.
String chatSessionStartFailedNotice(String directory, String reason) =>
"Couldn't start a new session in $directory: $reason";
/// The notice after the server accepted the shared rename.
String chatSessionRenamedNotice(String title) =>
'Renamed this session to “$title”.';