android: add slash commands to the chat composer, starting with /new

The composer now reads a leading slash as a command instead of a prompt, so the
operator can start a session, rename it, stop a turn or ask for help without
leaving the input field — the same surface the pipeline terminal gives with
`:status`, `:logs`, …

- ChatCommands.kt: parsing (a bare `/`, an unknown word, an argument, text that
  merely starts with a slash), the filtered offer list, the Enter target, the
  `/help` listing, the effect routing and the host interface. Pure, so the
  routing is testable without a device or server.
- ChatComposer.kt: the offer list above the field, Up/Down to move the highlight
  and Enter/tap to run the highlighted row, shown only while the draft is a bare
  command word. Sending, attachments, stop-while-streaming, queued state and the
  field's ordinary keyboard action are unchanged.
- AppViewModel.kt: one shared prompt path (`postChatPrompt`) for the composer and
  the unknown-command offer, and a host that performs the effects. `/new` creates
  in the current session's directory and switches to it, leaving the old session
  open, listed and with its history; `/rename` uses the device's own local rename
  and says so; `/stop` interrupts a running turn; `/close` reports that this
  revision has no real session close rather than dressing up the local hide.
- ChatStore.kt / ChatTranscript.kt / ChatCommandUi.kt: local command lines
  (`ChatCommandNotice`) rendered as their own transcript item, visually distinct
  from a message to the agent, with an error container for a failed command.
- An unrecognised `/…` is never sent to the agent: it becomes an offer to send it
  as a message or cancel, and the offer is taken once so a stale tap sends
  nothing. Running a command adds nothing to the model's conversation.
- Dimens.kt: one new token, CHAT_COMMAND_LIST_MAX_HEIGHT, for the capped list.
- ChatCommandsTest.kt: parsing, filtering, `/new` in the current directory and
  switching, `/rename` and `/close` delegating, `/stop` only while running, and
  the unknown command never reaching the prompt path.

Checks made before committing: this is an Android-app-only change with no
protocol, server, installer or Docker change, so the packaged templates and the
packaged authoring skill references (internal/author/skill/references/) are
unaffected and no managed-file inventory in internal/author/install.go changes;
none of them needed updating. No dependency was added — Icons.Default.Terminal
comes from the already-declared material-icons-extended. Verified with the
Android map's own checks for an implementation change, build plus unit tests
(`--offline --no-daemon :app:assembleDebug` and `:app:testDebugUnitTest`), and
DimensTest's geometry-token rule holds: the only new dimension is the named token
above. Device behaviour was deliberately not exercised here (this stage does not
use adb); the rendered offer list, D-pad handling and notice item belong to
visual review.

Documentation that is now stale (not edited here; a single writer folds shared
docs): android/README.md's chat section describes the composer without the slash
commands — it should gain the command vocabulary, the offer list and the
unknown-command guard.
This commit is contained in:
2026-10-18 00:22:33 +01:00
parent 2c1dfe9a35
commit fa6106ea46
9 changed files with 933 additions and 16 deletions
@@ -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<T>(
@@ -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<ChatAttachment>) {
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
@@ -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<ChatCommand>,
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") }
}
}
}
}
}
@@ -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<ChatCommand> = 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 <title>", 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."
@@ -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")
}
}
@@ -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) },
)
}
}
@@ -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-"
}
}
@@ -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) }
}
@@ -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
@@ -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" })
}
}