diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index dafe2157..64c58cad 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -41,12 +41,15 @@ import net.awan.pipelines.data.transport.ServerUrl import net.awan.pipelines.notify.NoRunAlerts import net.awan.pipelines.notify.RunAlertSink import net.awan.pipelines.notify.runAlerts +import net.awan.pipelines.ui.chat.CHAT_CLOSE_UNAVAILABLE import net.awan.pipelines.ui.chat.ChatAttachment +import net.awan.pipelines.ui.chat.ChatCommandHost import net.awan.pipelines.ui.chat.ChatSessionOverrides import net.awan.pipelines.ui.chat.ChatSeenState import net.awan.pipelines.ui.chat.ChatState import net.awan.pipelines.ui.chat.ChatStore import net.awan.pipelines.ui.chat.attachmentFiles +import net.awan.pipelines.ui.chat.runChatSlashCommand /** Generic loading/empty/error/data state used by every screen. */ data class LoadState( @@ -1131,13 +1134,25 @@ class AppViewModel( if (!thread.canSend) return val text = thread.draft.trim() val attachments = thread.attachments - val localId = chatStore.appendLocalUserMessage(sessionId, text, attachments) ?: return chatStore.clearDraft(sessionId) chatStore.clearAttachments(sessionId) + postChatPrompt(sessionId, text, attachments) + } + + /** + * One prompt, from the composer or from an unknown-command offer the operator + * chose to send: appends the optimistic turn, flags the chat running and posts + * it, taking the bubble and the attachments back out if the server rejects it. + * Every caller has already cleared the draft it sent. + */ + private fun postChatPrompt(sessionId: String, text: String, attachments: List) { + val body = text.trim() + if (body.isEmpty()) return + val localId = chatStore.appendLocalUserMessage(sessionId, body, attachments) ?: return chatStore.running(sessionId, true) viewModelScope.launch { try { - val queued = repository.chatPrompt(sessionId, text, attachmentFiles(attachments)) + val queued = repository.chatPrompt(sessionId, body, attachmentFiles(attachments)) // The server accepted the prompt (queued or sent); a queued prompt // is one waiting behind an in-flight turn, and the composer says so // instead of blocking input. @@ -1154,6 +1169,88 @@ class AppViewModel( } } + // ---- Slash commands ------------------------------------------------------ + + /** + * Runs one composer slash command against [sessionId]'s conversation. The + * draft is always consumed here — a slash draft is never handed to the prompt + * path — so only an explicit "Send as message" from an unknown-command offer + * reaches the agent. Every outcome is reported as a local transcript line. + */ + fun submitChatCommand(sessionId: String, text: String) { + val thread = chatStore.value.thread(sessionId) ?: return + chatStore.clearDraft(sessionId) + runChatSlashCommand(text, thread, SessionChatCommandHost(sessionId)) + } + + /** Dismisses one local command line (the operator cancelled its offer). */ + fun dismissChatCommandNotice(sessionId: String, noticeId: String) = + chatStore.dismissNotice(sessionId, noticeId) + + /** + * Sends the draft an unknown-command offer kept, through the ordinary prompt + * path, once the operator chose to. The offer is taken first, so a stale tap + * can neither send the same draft twice nor send anything at all. + */ + fun sendChatCommandOffer(sessionId: String, noticeId: String) { + if (chatStore.value.thread(sessionId) == null) return + val text = chatStore.takeNoticeOffer(sessionId, noticeId) ?: return + postChatPrompt(sessionId, text, emptyList()) + } + + /** + * The real effects behind a slash command. `/new` creates in the current + * session's directory and switches to it (the old one stays open, listed, with + * its history); `/rename` uses the device's own rename; `/stop` interrupts; + * `/close` reports that this build has no real close instead of hiding the + * session. Nothing here is ever a prompt. + */ + private inner class SessionChatCommandHost(private val sessionId: String) : ChatCommandHost { + override fun startSession(directory: String) { + viewModelScope.launch { + try { + val created = repository.chatCreate(title = "New chat", directory = directory) + chatStore.createSucceeded(created) + chatStore.history(created.id, emptyList()) + chatStore.notice( + created.id, + "Started a new session “${created.title.ifBlank { "New chat" }}” in $directory.", + ) + } catch (t: Throwable) { + if (t is CancellationException) throw t + chatStore.notice( + sessionId, + "Couldn't start a new session in $directory: ${ErrorMessages.describe(t)}", + failed = true, + ) + } + } + } + + override fun finishSession() { + // No session close exists in this revision: the honest answer, never + // the local hide dressed up as one. + chatStore.notice(sessionId, CHAT_CLOSE_UNAVAILABLE, failed = true) + } + + override fun renameSession(title: String) { + chatStore.rename(sessionId, title) + chatStore.notice( + sessionId, + "Renamed this session to “$title” on this device only; the server's title is unchanged.", + ) + } + + override fun stopTurn() { + stopChat(sessionId) + chatStore.notice(sessionId, "Stopping the running turn…") + } + + override fun notify(text: String, failed: Boolean, offer: String?) { + chatStore.notice(sessionId, text, failed, offer) + } + } + /** * Answers a pending approval. The card settles in place optimistically so a * laggy round-trip over a tunnel never shows the old buttons again; a failed diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatCommandUi.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatCommandUi.kt new file mode 100644 index 00000000..80712982 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatCommandUi.kt @@ -0,0 +1,154 @@ +package net.awan.pipelines.ui.chat + +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Terminal +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.minimumInteractiveComponentSize +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.semantics.selected +import androidx.compose.ui.text.style.TextOverflow +import net.awan.pipelines.ui.theme.CHAT_COMMAND_LIST_MAX_HEIGHT +import net.awan.pipelines.ui.theme.ICON_INLINE_DP +import net.awan.pipelines.ui.theme.SPACING_M +import net.awan.pipelines.ui.theme.SPACING_S +import net.awan.pipelines.ui.theme.SPACING_XS +import net.awan.pipelines.ui.theme.pipelinesText + +/** + * The slash-command offer list, shown above the composer while the draft is a + * bare command word. Each row names the command and says in a few words what it + * does; the highlighted row is the one Enter runs, and a tap runs a row directly. + * It is capped and scrolls rather than growing without bound over the transcript. + */ +@Composable +internal fun ChatCommandSuggestions( + commands: List, + selectedIndex: Int, + onPick: (ChatCommand) -> Unit, + modifier: Modifier = Modifier, +) { + if (commands.isEmpty()) return + Surface( + color = MaterialTheme.colorScheme.surfaceContainerHigh, + shape = MaterialTheme.shapes.medium, + modifier = modifier.fillMaxWidth().heightIn(max = CHAT_COMMAND_LIST_MAX_HEIGHT), + ) { + Column(Modifier.fillMaxWidth().verticalScroll(rememberScrollState())) { + commands.forEachIndexed { index, command -> + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(SPACING_M), + modifier = Modifier + .fillMaxWidth() + .background( + if (index == selectedIndex) { + MaterialTheme.colorScheme.secondaryContainer + } else { + Color.Transparent + }, + ) + .minimumInteractiveComponentSize() + // The highlight is also reported to assistive tech, so the + // row Enter runs is not conveyed by colour alone. + .semantics { selected = index == selectedIndex } + .clickable(role = Role.Button) { onPick(command) } + .padding(horizontal = SPACING_M, vertical = SPACING_S), + ) { + Text( + text = "/" + command.name, + style = pipelinesText().cardTitle, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + Text( + text = command.summary, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + modifier = Modifier.weight(1f), + ) + } + } + } + } +} + +/** + * One local command line in the transcript. It is deliberately unlike a message + * bubble: full width, a `Command` label and a terminal glyph, and a container + * that turns to the error colour when the command could not be honoured. An + * unrecognised command keeps the operator's draft as an offer — send it as a + * message or cancel — so a typo never becomes a prompt on its own. + */ +@Composable +internal fun ChatCommandNoticeItem( + notice: ChatCommandNotice, + onSendAsMessage: () -> Unit, + onDismiss: () -> Unit, +) { + val container = if (notice.failed) { + MaterialTheme.colorScheme.errorContainer + } else { + MaterialTheme.colorScheme.surfaceContainerHigh + } + val content = if (notice.failed) { + MaterialTheme.colorScheme.onErrorContainer + } else { + MaterialTheme.colorScheme.onSurface + } + Surface( + color = container, + shape = MaterialTheme.shapes.medium, + modifier = Modifier.fillMaxWidth(), + ) { + Column( + modifier = Modifier.fillMaxWidth().padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP), + verticalArrangement = Arrangement.spacedBy(SPACING_XS), + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(SPACING_S), + ) { + Icon( + Icons.Default.Terminal, + contentDescription = null, + tint = content, + modifier = Modifier.size(ICON_INLINE_DP), + ) + Text( + text = if (notice.failed) "Command failed" else "Command", + style = MaterialTheme.typography.labelMedium, + color = content, + ) + } + Text(text = notice.text, style = MaterialTheme.typography.bodySmall, color = content) + if (notice.offer != null) { + Row(horizontalArrangement = Arrangement.spacedBy(SPACING_S)) { + TextButton(onClick = onSendAsMessage) { Text("Send as message") } + TextButton(onClick = onDismiss) { Text("Cancel") } + } + } + } + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatCommands.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatCommands.kt new file mode 100644 index 00000000..79b42d4d --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatCommands.kt @@ -0,0 +1,218 @@ +package net.awan.pipelines.ui.chat + +/** + * One command the composer understands. [name] is the word after the slash, + * [usage] is what the operator types (including any argument) and [summary] is + * the few-word description the offer list shows beside it. [takesArgument] is + * false for the commands that act on the current session alone, so a stray + * argument is reported instead of being silently ignored. + */ +internal data class ChatCommand( + val name: String, + val summary: String, + val usage: String, + val takesArgument: Boolean = false, +) + +internal const val CHAT_COMMAND_NEW = "new" +internal const val CHAT_COMMAND_CLOSE = "close" +internal const val CHAT_COMMAND_RENAME = "rename" +internal const val CHAT_COMMAND_STOP = "stop" +internal const val CHAT_COMMAND_HELP = "help" + +/** + * The commands offered by the composer, in the order the list shows them. The + * terminal's own vocabulary is the model here (`:status`, `:logs`, …): a command + * acts on the chat surface itself and is never sent to the agent. + * + * `/close` is shown as unavailable in this revision: the server has no request + * that finishes a session for every client yet, and the app will not pretend the + * local "remove from list" is that close. + */ +internal val CHAT_COMMANDS: List = listOf( + ChatCommand(CHAT_COMMAND_NEW, "Start a fresh session in this directory", "/new"), + ChatCommand( + CHAT_COMMAND_CLOSE, + "Finish this session for every client (not available in this build)", + "/close", + ), + ChatCommand(CHAT_COMMAND_RENAME, "Rename this session on this device", "/rename ", takesArgument = true), + ChatCommand(CHAT_COMMAND_STOP, "Stop the turn that is running", "/stop"), + ChatCommand(CHAT_COMMAND_HELP, "List every command", "/help"), +) + +/** + * What the composer's draft parses to. [Plain] is any text that is not a slash + * command and follows the ordinary send path. [Unknown] is a draft that starts + * with a slash but names no command: it must never be sent as a prompt without + * the operator explicitly choosing to, so [text] is carried verbatim. + */ +internal sealed interface ChatInput { + data object Plain : ChatInput + data class Invocation(val command: ChatCommand, val argument: String) : ChatInput + data class Unknown(val text: String, val token: String) : ChatInput +} + +/** + * Parses [text] as a slash command. Only the start of the draft counts, the + * command word is the run of non-space characters after the slash, and the rest + * (trimmed) is its argument. Recognition is case-insensitive; the returned + * command is always the canonical entry from [CHAT_COMMANDS]. + */ +internal fun parseChatInput(text: String): ChatInput { + val trimmed = text.trim() + if (!trimmed.startsWith("/")) return ChatInput.Plain + val token = trimmed.takeWhile { !it.isWhitespace() } + val argument = trimmed.drop(token.length).trim() + val name = token.removePrefix("/") + val command = CHAT_COMMANDS.firstOrNull { it.name.equals(name, ignoreCase = true) } + ?: return ChatInput.Unknown(text = trimmed, token = token) + return ChatInput.Invocation(command = command, argument = argument) +} + +/** + * The commands the offer list shows for [draft]: every command after a bare `/`, + * narrowed by the command word as the operator keeps typing. The list is for the + * command word only, so once an argument begins (a space follows the word) it + * hides and the draft is executed as typed. Text that does not start with a + * slash offers nothing. + */ +internal fun chatCommandSuggestions(draft: String): List<ChatCommand> { + val trimmed = draft.trimStart() + if (!trimmed.startsWith("/")) return emptyList() + if (trimmed.any { it.isWhitespace() }) return emptyList() + val query = trimmed.drop(1) + return CHAT_COMMANDS.filter { it.name.startsWith(query, ignoreCase = true) } +} + +/** + * The command text Enter runs for [draft] while the offer list is showing. The + * list's highlighted entry wins, so a partially typed word (`/clo`) is runnable + * with Enter without also being sent as a prompt; the caller clamps [selected] + * to the list. Returns null when no list is showing, which is when the ordinary + * send path applies. + */ +internal fun chatCommandForEnter(draft: String, selected: Int): String? { + val suggestions = chatCommandSuggestions(draft) + if (suggestions.isEmpty()) return null + val command = suggestions.getOrNull(selected) ?: suggestions.first() + return "/" + command.name +} + +/** The `/help` reply: every command with its usage and what it does. */ +internal fun chatCommandHelp(): String = + CHAT_COMMANDS.joinToString("\n") { "${it.usage} — ${it.summary}" } + +/** + * What a parsed invocation asks the chat surface to do. Kept separate from the + * side effects so the routing (which command is available, which one needs an + * argument, which argument it receives) is unit-testable without a server. + */ +internal sealed interface ChatCommandEffect { + /** Create a fresh session in [directory] and switch to it. */ + data class StartSession(val directory: String) : ChatCommandEffect + + /** Finish the current session for every client. */ + data object FinishSession : ChatCommandEffect + + /** Rename the current session to [title] (the device's own rename today). */ + data class RenameSession(val title: String) : ChatCommandEffect + + /** Interrupt the session's running turn. */ + data object StopTurn : ChatCommandEffect + + /** Show the command list in the transcript. */ + data object ShowHelp : ChatCommandEffect + + /** + * A command that cannot act as asked; [text] says why. [offer] is set for an + * unknown command and carries the operator's draft, so the transcript can + * offer to send it as a message instead — the one way it reaches the agent. + */ + data class Report(val text: String, val offer: String? = null) : ChatCommandEffect +} + +/** + * Routes parsed [input] to one effect. [thread] supplies the current session's + * directory (which `/new` must reuse) and whether a turn is running (which + * `/stop` needs). A null result is text that is not a command at all. + */ +internal fun chatCommandEffect(input: ChatInput, thread: ChatThread): ChatCommandEffect? = when (input) { + ChatInput.Plain -> null + is ChatInput.Unknown -> ChatCommandEffect.Report( + "“${input.token}” is not a command, so nothing was sent to the agent. Send it as a message, or cancel.", + offer = input.text, + ) + is ChatInput.Invocation -> { + val command = input.command + if (!command.takesArgument && input.argument.isNotBlank()) { + ChatCommandEffect.Report("${command.usage} does not take an argument.") + } else { + when (command.name) { + CHAT_COMMAND_NEW -> + if (thread.directory.isBlank()) { + ChatCommandEffect.Report( + "Can't start a new session here: the server reported no directory for this chat.", + ) + } else { + ChatCommandEffect.StartSession(thread.directory) + } + CHAT_COMMAND_CLOSE -> ChatCommandEffect.FinishSession + CHAT_COMMAND_RENAME -> + if (input.argument.isBlank()) { + ChatCommandEffect.Report( + "Usage: ${command.usage} — renames this session on this device.", + ) + } else { + ChatCommandEffect.RenameSession(input.argument) + } + CHAT_COMMAND_STOP -> + if (thread.running) { + ChatCommandEffect.StopTurn + } else { + ChatCommandEffect.Report("No turn is running in this chat.") + } + CHAT_COMMAND_HELP -> ChatCommandEffect.ShowHelp + else -> ChatCommandEffect.Report("“/${command.name}” is not a command.") + } + } + } +} + +/** + * The effects the chat surface actually performs. [notify] appends a local + * command line to the transcript; it is not a prompt, so nothing here reaches + * the agent unless the operator explicitly sends an unknown command as a + * message from its offer. + */ +internal interface ChatCommandHost { + fun startSession(directory: String) + fun finishSession() + fun renameSession(title: String) + fun stopTurn() + fun notify(text: String, failed: Boolean = false, offer: String? = null) +} + +/** + * Runs [text] against the current [thread] through [host]. A draft that starts + * with a slash is always consumed here (the caller clears it) and is never + * handed to the prompt path; an unknown command becomes an offer the operator + * must answer, and an argument-less command rejects extra words instead of + * guessing what they meant. + */ +internal fun runChatSlashCommand(text: String, thread: ChatThread, host: ChatCommandHost) { + when (val effect = chatCommandEffect(parseChatInput(text), thread)) { + null -> Unit + is ChatCommandEffect.StartSession -> host.startSession(effect.directory) + ChatCommandEffect.FinishSession -> host.finishSession() + is ChatCommandEffect.RenameSession -> host.renameSession(effect.title) + ChatCommandEffect.StopTurn -> host.stopTurn() + ChatCommandEffect.ShowHelp -> host.notify(chatCommandHelp()) + is ChatCommandEffect.Report -> host.notify(effect.text, failed = true, offer = effect.offer) + } +} + +/** What `/close` says in this revision, where no real session close exists. */ +internal const val CHAT_CLOSE_UNAVAILABLE = + "Can't finish this session: this build has no real session close yet, so nothing was " + + "changed. The session stays open and listed; no local hide was used instead." diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt index 4c6e21b6..3363229c 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt @@ -19,9 +19,19 @@ import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.input.key.Key +import androidx.compose.ui.input.key.KeyEventType +import androidx.compose.ui.input.key.key +import androidx.compose.ui.input.key.onPreviewKeyEvent +import androidx.compose.ui.input.key.type import androidx.compose.ui.platform.LocalContext import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch @@ -35,8 +45,27 @@ internal fun ChatComposer( onRemoveAttachment: (String) -> Unit, onSend: () -> Unit, onStop: () -> Unit, + onRunCommand: (String) -> Unit, ) { val action = composerAction(thread) + // The slash-command offer list follows the draft: every command after a bare + // `/`, narrowed as the operator keeps typing, hidden once an argument begins. + // The highlighted row is what Enter runs, and a tap runs a row directly, so a + // half-typed command is never sent as a prompt. + val suggestions = chatCommandSuggestions(thread.draft) + var selected by remember(thread.sessionId) { mutableIntStateOf(0) } + LaunchedEffect(suggestions) { + if (selected !in suggestions.indices) selected = 0 + } + val slashDraft = thread.draft.trimStart().startsWith("/") + val submit: () -> Unit = { + val command = chatCommandForEnter(thread.draft, selected) + when { + command != null -> onRunCommand(command) + slashDraft -> onRunCommand(thread.draft) + action == ComposerAction.Send && thread.canSend -> onSend() + } + } val context = LocalContext.current val scope = rememberCoroutineScope() // The platform picker: the operator chooses files and they are only resolved @@ -62,6 +91,12 @@ internal fun ChatComposer( if (thread.attachments.isNotEmpty()) { ChatAttachmentStrip(attachments = thread.attachments, onRemove = onRemoveAttachment) } + ChatCommandSuggestions( + commands = suggestions, + selectedIndex = selected, + onPick = { onRunCommand("/" + it.name) }, + modifier = Modifier.padding(bottom = CHAT_ITEM_GAP), + ) Row(verticalAlignment = Alignment.Bottom, horizontalArrangement = Arrangement.spacedBy(CHAT_COMPOSER_GAP)) { IconButton( onClick = { picker.launch(arrayOf("*/*")) }, @@ -71,13 +106,30 @@ internal fun ChatComposer( OutlinedTextField( value = thread.draft, onValueChange = onDraft, - placeholder = { Text("Message the agent…") }, + placeholder = { Text("Message the agent… or / for commands") }, minLines = 1, maxLines = 6, - keyboardActions = KeyboardActions( - onSend = { if (action == ComposerAction.Send && thread.canSend) onSend() }, - ), - modifier = Modifier.weight(1f), + keyboardActions = KeyboardActions(onSend = { submit() }), + // Up/Down move the highlight and Enter runs it, but only while + // the offer list is showing, so every other key — and the + // field's ordinary send action — is left untouched. + modifier = Modifier.weight(1f).onPreviewKeyEvent { event -> + if (suggestions.isEmpty()) return@onPreviewKeyEvent false + when (event.key) { + Key.DirectionDown, Key.DirectionUp -> { + if (event.type == KeyEventType.KeyDown) { + val step = if (event.key == Key.DirectionDown) 1 else -1 + selected = (selected + step + suggestions.size) % suggestions.size + } + true + } + Key.Enter, Key.NumPadEnter -> { + if (event.type == KeyEventType.KeyDown) submit() + true + } + else -> false + } + }, ) when (action) { // While a turn is in flight the send control becomes the stop @@ -85,7 +137,7 @@ internal fun ChatComposer( ComposerAction.Stop -> IconButton(onClick = onStop) { Icon(Icons.Default.Stop, contentDescription = "Stop", tint = MaterialTheme.colorScheme.error) } - ComposerAction.Send -> IconButton(onClick = onSend, enabled = thread.canSend) { + ComposerAction.Send -> IconButton(onClick = { submit() }, enabled = thread.canSend || slashDraft) { Icon(Icons.AutoMirrored.Filled.Send, contentDescription = "Send") } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt index c01ee5a7..e446ccc5 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt @@ -102,10 +102,11 @@ internal fun ChatConversationPane( // A turn blocked on an approval is not generating, so the running indicator // (and its ticking clock) stands down while the card is unanswered. val showRunning = thread.running && !awaiting - // The count of the transcript's items: the messages, the running indicator - // while a turn is in flight and a pending approval card, which is the last item - // the top bar's approval action jumps to. - val itemCount = thread.messages.size + (if (showRunning) 1 else 0) + (if (approval != null) 1 else 0) + // The count of the transcript's items: the messages, the local command lines, + // the running indicator while a turn is in flight and a pending approval card, + // which is the last item the top bar's approval action jumps to. + val itemCount = thread.messages.size + thread.notices.size + + (if (showRunning) 1 else 0) + (if (approval != null) 1 else 0) // The position the operator left this conversation at, read once: a // conversation with none of its own opens at its newest message instead (see // chatOpensAtNewest), so the current turn is never hunted for. @@ -212,9 +213,10 @@ internal fun ChatConversationPane( message = thread.error, onRetry = { vm.loadChatHistory(thread.sessionId) }, ) - thread.messages.isEmpty() && !thread.running && approval == null -> EmptyState( - message = "This chat has no messages yet. Ask something below.", - ) + thread.messages.isEmpty() && thread.notices.isEmpty() && !thread.running && approval == null -> + EmptyState( + message = "This chat has no messages yet. Ask something below.", + ) else -> ChatTranscript( thread = thread, listState = listState, @@ -227,6 +229,8 @@ internal fun ChatConversationPane( onDecision = { decision -> approval?.let { vm.replyChatPermission(thread.sessionId, it.requestId, decision) } }, + onNoticeSend = { vm.sendChatCommandOffer(thread.sessionId, it) }, + onNoticeDismiss = { vm.dismissChatCommandNotice(thread.sessionId, it) }, ) } } @@ -245,6 +249,7 @@ internal fun ChatConversationPane( onRemoveAttachment = { vm.removeChatAttachment(thread.sessionId, it) }, onSend = { vm.sendChatPrompt(thread.sessionId) }, onStop = { vm.stopChat(thread.sessionId) }, + onRunCommand = { vm.submitChatCommand(thread.sessionId, it) }, ) } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt index f7348374..e5f28ed3 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt @@ -41,6 +41,20 @@ data class ChatAttachment( val displayName: String get() = name.ifBlank { uri.substringAfterLast('/').ifBlank { "file" } } } +/** + * One local line in a conversation reporting what a slash command did. It is + * rendered as its own transcript item, visibly distinct from a message to the + * agent, and is never part of [ChatThread.messages]. [failed] marks a command + * that could not be honoured; [offer] carries the draft of an unrecognised + * command so the operator can choose to send it as a message, or cancel. + */ +data class ChatCommandNotice( + val id: String, + val text: String, + val failed: Boolean = false, + val offer: String? = null, +) + /** * One open conversation. The conversation itself, whether it is running, its * unsent composer draft and its scroll position all live here, so switching to @@ -87,6 +101,14 @@ data class ChatThread( * sent, and restored (flagged with the server's error) if the send fails. */ val attachments: List<ChatAttachment> = emptyList(), + /** + * The local command lines this conversation has shown (a slash command's + * outcome, its `/help` list or an unknown-command offer). They are part of the + * thread so a switch away and back keeps them, but they are never part of + * [messages] and are never sent to the agent: running a command adds nothing + * to the model's context. + */ + val notices: List<ChatCommandNotice> = emptyList(), /** * Where the operator left this conversation's transcript, or null while they * have not been there yet. Null is distinct from any position — including the @@ -284,6 +306,9 @@ class ChatStore( /** Monotonic source of attachment ids, so two attachments are never keyed alike. */ private var attachmentSeq = 0 + /** Monotonic source of command-notice ids, so two transcript lines never share a key. */ + private var noticeSeq = 0 + /** * Monotonic source of optimistic user-turn ids. Counting the local messages a * thread currently holds would re-mint the id of a turn that was removed (a @@ -544,6 +569,45 @@ class ChatStore( private fun needsResync(thread: ChatThread): Boolean = thread.running || !thread.loaded + // ---- Local command lines ------------------------------------------------- + + /** + * Appends a local command line to [sessionId]'s transcript and returns its id. + * A notice lives beside the conversation, never inside it: it is not a + * [ChatMessage] and nothing here is sent to the agent. [offer] is set only for + * an unrecognised command, whose draft the operator can still choose to send. + */ + fun notice( + sessionId: String, + text: String, + failed: Boolean = false, + offer: String? = null, + ): String? { + var id: String? = null + update(sessionId) { thread -> + id = NOTICE_PREFIX + (++noticeSeq) + thread.copy(notices = thread.notices + ChatCommandNotice(id!!, text, failed, offer)) + } + return id + } + + /** Drops one local command line (the operator answered or dismissed its offer). */ + fun dismissNotice(sessionId: String, noticeId: String) = update(sessionId) { + it.copy(notices = it.notices.filterNot { notice -> notice.id == noticeId }) + } + + /** + * Takes the draft an unrecognised-command notice offers to send, removing the + * notice. Null when the notice is gone or carries no offer, so a stale tap can + * never send anything. + */ + fun takeNoticeOffer(sessionId: String, noticeId: String): String? { + val notice = _state.value.thread(sessionId)?.notices?.firstOrNull { it.id == noticeId } ?: return null + val offer = notice.offer ?: return null + dismissNotice(sessionId, noticeId) + return offer + } + // ---- Per-thread edits ---------------------------------------------------- fun draft(sessionId: String, text: String) = update(sessionId) { it.copy(draft = text) } @@ -892,5 +956,6 @@ class ChatStore( companion object { const val LOCAL_MESSAGE_PREFIX = "local-" + const val NOTICE_PREFIX = "notice-" } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt index d9a653f9..9b63b83d 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt @@ -93,6 +93,8 @@ internal fun ChatTranscript( reasoning: ReasoningExpansion, onToggleReasoning: (String) -> Unit, onDecision: (String) -> Unit, + onNoticeSend: (String) -> Unit, + onNoticeDismiss: (String) -> Unit, ) { val scope = rememberCoroutineScope() val density = LocalDensity.current @@ -147,7 +149,7 @@ internal fun ChatTranscript( // re-place (and re-follow) a transcript the operator had scrolled up. var placed by rememberSaveable(thread.sessionId) { mutableStateOf(false) } val viewportHeight by remember(listState) { derivedStateOf { listState.layoutInfo.viewportSize.height } } - LaunchedEffect(thread.messages, thread.running, approval?.requestId, viewportHeight) { + LaunchedEffect(thread.messages, thread.notices, thread.running, approval?.requestId, viewportHeight) { if (itemCount <= 0) return@LaunchedEffect if (!placed) { // Wait for the first measure: placement run before it would no-op and @@ -192,6 +194,15 @@ internal fun ChatTranscript( onToggleReasoning = onToggleReasoning, ) } + // A slash command reports as its own line, after the turns it acted + // between and visually distinct from any message to the agent. + items(thread.notices, key = { it.id }) { notice -> + ChatCommandNoticeItem( + notice = notice, + onSendAsMessage = { onNoticeSend(notice.id) }, + onDismiss = { onNoticeDismiss(notice.id) }, + ) + } if (showRunning) { item(key = "pending") { RunningIndicator(thread) } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt index a1e2c969..a80920e2 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt @@ -246,6 +246,13 @@ internal val CHAT_ATTACHMENT_PREVIEW_DP = 160.dp /** An attachment's name column stops here so its remove action keeps its place. */ internal val CHAT_ATTACHMENT_NAME_MAX_WIDTH_DP = 180.dp +/** + * How tall the composer's slash-command offer list may grow before it scrolls: + * tall enough for the whole vocabulary at a normal text size, so the composer + * never covers the transcript with an unbounded menu. + */ +internal val CHAT_COMMAND_LIST_MAX_HEIGHT = 240.dp + /** * How close to the end of the transcript the viewport must be for new content to * keep following it: about one comfortable line of text, so the operator can be a diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatCommandsTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatCommandsTest.kt new file mode 100644 index 00000000..2eba9b4a --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatCommandsTest.kt @@ -0,0 +1,308 @@ +package net.awan.pipelines.ui.chat + +import net.awan.pipelines.data.protocol.ChatMessage +import net.awan.pipelines.data.protocol.ChatPart +import net.awan.pipelines.data.protocol.ChatProtocol +import net.awan.pipelines.data.protocol.ChatSession +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * The composer's slash commands: parsing a draft, narrowing the offer list, + * routing to the real effect, and — the point of the whole feature — never + * letting a typo become a prompt. All pure, so no device or server is involved; + * the store-backed cases drive [ChatStore] itself for the create/rename/close + * transitions the effects delegate to. + */ +class ChatCommandsTest { + + private fun thread( + id: String = "s", + directory: String = "/repo", + running: Boolean = false, + ) = ChatThread(sessionId = id, directory = directory, running = running) + + private fun session(id: String, title: String = id, directory: String = "/repo") = + ChatSession(id = id, title = title, directory = directory) + + private fun message(id: String, role: String, body: String) = ChatMessage( + id = id, + sessionId = "", + role = role, + parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, id = "$id-p", text = body)), + ) + + /** A host that records every effect instead of performing it. */ + private class RecordingHost : ChatCommandHost { + data class Notice(val text: String, val failed: Boolean, val offer: String?) + + val started = mutableListOf<String>() + var finishes = 0 + val renames = mutableListOf<String>() + var stops = 0 + val notices = mutableListOf<Notice>() + + override fun startSession(directory: String) { started += directory } + override fun finishSession() { finishes++ } + override fun renameSession(title: String) { renames += title } + override fun stopTurn() { stops++ } + override fun notify(text: String, failed: Boolean, offer: String?) { + notices += Notice(text, failed, offer) + } + } + + // ---- Parsing ------------------------------------------------------------- + + @Test + fun aLoneSlashIsNotACommand() { + val parsed = parseChatInput("/") + assertTrue(parsed is ChatInput.Unknown) + assertEquals("/", (parsed as ChatInput.Unknown).token) + } + + @Test + fun aKnownCommandParsesWithItsArgument() { + val bare = parseChatInput("/new") + assertEquals( + ChatInput.Invocation(CHAT_COMMANDS.first { it.name == CHAT_COMMAND_NEW }, ""), + bare, + ) + val withArg = parseChatInput("/rename My session ") + assertTrue(withArg is ChatInput.Invocation) + withArg as ChatInput.Invocation + assertEquals(CHAT_COMMAND_RENAME, withArg.command.name) + assertEquals("My session", withArg.argument) + } + + @Test + fun textThatMerelyStartsWithASlashIsUnknown() { + val parsed = parseChatInput("/usr/bin/env go test") + assertTrue(parsed is ChatInput.Unknown) + assertEquals("/usr/bin/env", (parsed as ChatInput.Unknown).token) + } + + @Test + fun textThatDoesNotStartWithASlashIsPlain() { + assertEquals(ChatInput.Plain, parseChatInput("hello /new")) + assertEquals(ChatInput.Plain, parseChatInput("")) + assertEquals(ChatInput.Plain, parseChatInput(" plain message")) + } + + // ---- Filtering the offer list -------------------------------------------- + + @Test + fun aSlashOffersEveryCommandAndTypingNarrowsThem() { + assertEquals(CHAT_COMMANDS.map { it.name }, chatCommandSuggestions("/").map { it.name }) + assertEquals(listOf(CHAT_COMMAND_NEW), chatCommandSuggestions("/n").map { it.name }) + assertEquals(listOf(CHAT_COMMAND_RENAME), chatCommandSuggestions("/re").map { it.name }) + // Case-insensitive, so a capitalised word still finds the command. + assertEquals(listOf(CHAT_COMMAND_CLOSE), chatCommandSuggestions("/CL").map { it.name }) + } + + @Test + fun theOfferListHidesOnceAnArgumentBeginsOrTheWordMatchesNothing() { + assertTrue(chatCommandSuggestions("/rename My chat").isEmpty()) + assertTrue(chatCommandSuggestions("/close ").isEmpty()) + assertTrue(chatCommandSuggestions("/zzz").isEmpty()) + assertTrue(chatCommandSuggestions("plain text").isEmpty()) + } + + @Test + fun enterRunsTheHighlightedCommandButNeverAPartialWord() { + // A bare slash with a later row highlighted runs that row, not a prompt. + assertEquals("/close", chatCommandForEnter("/", 1)) + assertEquals("/rename", chatCommandForEnter("/", 2)) + assertEquals("/new", chatCommandForEnter("/", 0)) + assertEquals("/new", chatCommandForEnter("/n", 0)) + // With no offer list showing, Enter is the ordinary send path. + assertNull(chatCommandForEnter("/rename My chat", 0)) + assertNull(chatCommandForEnter("hello", 0)) + } + + // ---- Routing ------------------------------------------------------------- + + @Test + fun newUsesTheCurrentSessionsDirectoryAndSwitchesToTheFreshSession() { + val store = ChatStore() + val old = session("old", "Old chat", directory = "/repo/work") + store.sessionsLoaded(listOf(old)) + store.open(old) + store.history("old", listOf(message("m1", ChatProtocol.ROLE_USER, "keep me"))) + + val host = object : ChatCommandHost by RecordingHost() { + override fun startSession(directory: String) { + val created = session("fresh", "New chat", directory = directory) + store.createSucceeded(created) + store.history(created.id, emptyList()) + store.notice(created.id, "Started a new session “New chat” in $directory.") + } + } + runChatSlashCommand("/new", store.value.thread("old")!!, host) + + // Created in the current session's directory and switched to. + assertEquals("fresh", store.value.activeId) + assertEquals("/repo/work", store.value.thread("fresh")!!.directory) + // The old session is untouched: still open, still listed, history intact. + assertEquals(listOf("m1"), store.value.thread("old")!!.messages.map { it.id }) + assertTrue(store.value.open.any { it.sessionId == "old" }) + assertTrue(store.value.visibleSessions.any { it.id == "old" }) + // The command is reported as its own line on the new conversation. + assertEquals(1, store.value.thread("fresh")!!.notices.size) + } + + @Test + fun newWithoutADirectoryIsRefusedInsteadOfGuessingOne() { + val host = RecordingHost() + runChatSlashCommand("/new", thread(directory = ""), host) + assertTrue(host.started.isEmpty()) + assertEquals(1, host.notices.size) + assertTrue(host.notices.single().failed) + assertTrue(host.notices.single().text.contains("no directory")) + } + + @Test + fun renameDelegatesToTheRealLocalRename() { + val store = ChatStore() + store.sessionsLoaded(listOf(session("old", "Old chat"))) + store.open(session("old", "Old chat")) + + val host = object : ChatCommandHost by RecordingHost() { + override fun renameSession(title: String) { + store.rename("old", title) + store.notice("old", "Renamed locally.") + } + } + runChatSlashCommand("/rename Cool name", store.value.thread("old")!!, host) + + assertEquals("Cool name", store.value.thread("old")!!.title) + assertEquals("Cool name", store.value.visibleSessions.single().title) + // The report is honest that the rename is the device's own. + assertTrue(store.value.thread("old")!!.notices.single().text.contains("Renamed")) + } + + @Test + fun closeDelegatesToTheRealCloseWhichThisRevisionDoesNotHave() { + val store = ChatStore() + store.sessionsLoaded(listOf(session("old"))) + store.open(session("old")) + store.history("old", listOf(message("m1", ChatProtocol.ROLE_USER, "kept"))) + + val host = object : ChatCommandHost by RecordingHost() { + override fun finishSession() { + store.notice("old", CHAT_CLOSE_UNAVAILABLE, failed = true) + } + } + runChatSlashCommand("/close", store.value.thread("old")!!, host) + + // The close is reported plainly and nothing is faked with the local hide. + assertTrue(store.value.thread("old")!!.notices.single().text.contains("no real session close")) + assertTrue(store.value.open.any { it.sessionId == "old" }) + assertTrue(store.value.visibleSessions.any { it.id == "old" }) + } + + @Test + fun aRenameWithoutATitleReportsTheUsage() { + val host = RecordingHost() + runChatSlashCommand("/rename", thread(), host) + assertTrue(host.renames.isEmpty()) + assertTrue(host.notices.single().text.contains("/rename <title>")) + } + + @Test + fun stopOnlyInterruptsARunningTurn() { + val idle = RecordingHost() + runChatSlashCommand("/stop", thread(running = false), idle) + assertEquals(0, idle.stops) + assertTrue(idle.notices.single().text.contains("No turn is running")) + + val running = RecordingHost() + runChatSlashCommand("/stop", thread(running = true), running) + assertEquals(1, running.stops) + } + + @Test + fun helpListsEveryCommand() { + val host = RecordingHost() + runChatSlashCommand("/help", thread(), host) + val text = host.notices.single().text + CHAT_COMMANDS.forEach { assertTrue("missing ${it.usage}", text.contains(it.usage)) } + } + + @Test + fun aCommandThatTakesNoArgumentRejectsOne() { + val host = RecordingHost() + runChatSlashCommand("/new please", thread(), host) + assertTrue(host.started.isEmpty()) + assertTrue(host.notices.single().text.contains("does not take an argument")) + } + + @Test + fun plainTextIsNotACommandAndRunsNoEffect() { + val host = RecordingHost() + runChatSlashCommand("just a question", thread(), host) + assertTrue(host.notices.isEmpty()) + assertEquals(0, host.finishes) + assertTrue(host.started.isEmpty()) + assertTrue(host.renames.isEmpty()) + assertEquals(0, host.stops) + } + + // ---- The unknown-command guard ------------------------------------------- + + @Test + fun anUnknownCommandIsOfferedNeverSentAndNeverReachesThePromptPath() { + val store = ChatStore() + store.open(session("old")) + store.history("old", listOf(message("m1", ChatProtocol.ROLE_USER, "existing"))) + + // The host writes the offer to the real store and counts any effect; the + // prompt path is structurally absent from ChatCommandHost, so an unknown + // command cannot reach the agent through it. + val effects = RecordingHost() + val host = object : ChatCommandHost by effects { + override fun notify(text: String, failed: Boolean, offer: String?) { + store.notice("old", text, failed, offer) + } + } + runChatSlashCommand("/nonsense", store.value.thread("old")!!, host) + + val notice = store.value.thread("old")!!.notices.single() + assertTrue(notice.failed) + assertTrue(notice.text.contains("is not a command")) + assertEquals("/nonsense", notice.offer) + // Nothing reached the agent and no other command ran. + assertEquals(listOf("m1"), store.value.thread("old")!!.messages.map { it.id }) + assertTrue(effects.started.isEmpty()) + assertEquals(0, effects.finishes) + assertTrue(effects.renames.isEmpty()) + assertEquals(0, effects.stops) + } + + @Test + fun theOfferCanBeTakenOnceToSendAsAMessage() { + val store = ChatStore() + store.open(session("old")) + val id = store.notice("old", "not a command", failed = true, offer = "/nonsense")!! + assertEquals("/nonsense", store.takeNoticeOffer("old", id)) + // Taking it removes the offer so a stale tap sends nothing. + assertNull(store.takeNoticeOffer("old", id)) + assertTrue(store.value.thread("old")!!.notices.isEmpty()) + } + + @Test + fun noticesDoNotTouchTheModelConversation() { + val store = ChatStore() + store.open(session("old")) + store.history("old", listOf(message("m1", ChatProtocol.ROLE_USER, "existing"))) + store.notice("old", "Command", failed = false) + store.notice("old", "Command failed", failed = true) + // Local command lines sit beside the conversation; the messages are as the + // server reported them, so running a command adds nothing to the model. + assertEquals(listOf("m1"), store.value.thread("old")!!.messages.map { it.id }) + assertEquals(2, store.value.thread("old")!!.notices.size) + assertFalse(store.value.thread("old")!!.notices.any { it.id == "m1" }) + } +}