diff --git a/android/README.md b/android/README.md index 952f3062..cfc094e9 100644 --- a/android/README.md +++ b/android/README.md @@ -5862,6 +5862,71 @@ the brief keeps implementation verification to the build and the unit tests, and visual review owns the operator's Pixel 9 Pro XL. No packaged skill reference was touched: this is an app-UI change and no reference describes the chat surface. +## Conversation reading: markdown, collapsed reasoning, one identity (17 Oct 2026) + +Making the conversation readable on a phone. `android/` only; no new dependency +(the declared `material-icons-extended` only), no Pipelines server/Go/installer/ +Docker file touched and no run started from the app. + +- **Markdown reaches the transcript (tested).** The assistant `text` part was + already rendered through `MarkdownText`, but the transcript's decision was + buried in a private composable. `ChatFormat.partRendering(part)` now names the + one decision the transcript makes (`MARKDOWN` / `REASONING` / `PLAIN` / + `HIDDEN`), `MessagePart` consumes it, and `ChatTranscriptTest` drives a sample + covering the whole documented subset (headings, paragraph, bullet and ordered + lists, quote, table, fenced code, rule, inline code/bold/italic/link) from a + `ChatPart` into `parseMarkdown`/`parseInline`. Text outside the subset (raw + HTML, `~~strike~~`) still parses to a paragraph and renders verbatim; an + unknown part kind still renders its text, never drops it. +- **Reasoning collapsed by default.** `ReasoningBlock` is now one compact, + muted line per part — a `Psychology` icon, a label (`Thinking…` while the + newest turn streams, `Reasoning` once settled) and a chevron — that expands on + tap to the full, still-muted text. Expansion is a pure + `ReasoningExpansion` set hoisted to the conversation pane (not the lazy + transcript), so a part keeps its state while the operator scrolls and its item + is disposed, and every part starts collapsed in a freshly opened chat. The + choice for a running turn: its streaming reasoning stays collapsed and keeps + following the stream under the live `Thinking…` label, so it signals progress + without competing with the answer. +- **One identity in the header.** `ChatFormat.conversationHeader(thread)` builds + the app-bar title plus the only extra context — the labelled kind chip + (`Operator`) from the server's own tag, the activity (`Running` / + `Busy · read-only` / `Idle`), the directory and the model — and the app bar and + context line read the same value. The conversation's active chip is omitted + from the open-chat strip (`openChatsBeside`), so the session's title is shown + once; every *other* open chat is still one tap away, and the session list is + unchanged. + +Tests (`ChatTranscriptTest`, 7 cases, plus the existing `ChatFormatTest`): the +markdown subset reaches the renderer from a `ChatPart`; text outside the subset +and an unknown part kind still render; reasoning starts collapsed, toggles per +part and never expands on a blank key; the header names the session once with +only kind/activity/directory/model beside it; and the conversation strip offers +only the other open chats. + +Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`, `--no-daemon`, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`): + +- `gradle :app:assembleDebug --no-daemon --offline --rerun-tasks` → `BUILD + SUCCESSFUL` (35 tasks executed). +- `gradle :app:testDebugUnitTest --no-daemon --offline --rerun-tasks` → + `BUILD SUCCESSFUL`; the JUnit XMLs total **508 tests, 0 failures, 0 errors, 0 + skipped** (7 new in `ChatTranscriptTest`). +- **APK publish.** `app-debug.apk` copied to this run's artifacts directory as + `pipelines-debug-wip-5ac196c.apk` (18,486,624 bytes, sha256 + `0df6899429a8f5632ec568340dddb63a5617b1a04af19f52c6ebb793470a0b23`; `5ac196c` + is `git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it). + It is served at + `http://10.0.0.75:8080/artifacts/274/1/pipelines-debug-wip-5ac196c.apk` + (`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18486624`). + +Not verified in this pass: the conversation, the collapsed/expanded reasoning +and the header on a device — the brief keeps implementation verification to the +build and the unit tests, and visual review owns the operator's Pixel 9 Pro XL +(captures: headings/list/fenced code/table, reasoning collapsed then expanded, +and the header). + ## Answer a waiting human decision from the phone (17 Oct 2026) The last piece of the original goal the app was missing: a run parked on a person @@ -6069,3 +6134,53 @@ Not verified in this pass: the conversation/list screenshots — the brief keeps implementation and ordinary code review to the build and the unit tests, and visual review owns the operator's Pixel 9 Pro XL (its captures are the ones the brief names: a conversation with no pill, and the chat list with it). + +## Run title readability: whole in the run view, two lines in the list (17 Oct 2026) + +A run's title is derived from its prompt, so it is often long. The run view now +guarantees the operator can read it whole, while the places that are one of many +clamp deliberately. `android/` only; no new dependency, no Pipelines +server/Go/installer/Docker file touched and no run started from the app; the build +and unit tests only, no device command run. + +- **Run view shows the whole title.** The run-summary title line rendered + `runLabel(run.title, run.name)` with the Compose default; it now states the + intent with `RUN_VIEW_TITLE_LINES` (`Int.MAX_VALUE`) and `TextOverflow.Clip`, so + it wraps over as many lines as it needs and is never ellipsised. The fixed-height + M3 app-bar copy stays a compact one-line label; the summary's scrollable title is + the complete one. +- **Runs-list rows grow, then clamp.** `RunHistoryScreen.RunRow`'s title went from + `maxLines = 1` to `RUN_ROW_TITLE_LINES` (2), so a longer title takes a second + line before it ellipsises; the row's glyph, status chip and meta line keep their + alignment and the selection highlight and tap target are unchanged. +- **Stage-pane context line.** `StageDetailPane`'s run-label line went from + `maxLines = 1` to `STAGE_RUN_LABEL_LINES` (2) — the pane is compact context, not + the place the whole title lives. +- **One named budget.** `ui/RunIdentity.kt` holds the three named line budgets so + the choice is deliberate at each call site. `RunTitlesTest` (4 cases) pins them + and asserts a clamping place is never more generous than the run view; + `RunIdentityTest` gained a case that `runLabel`/`runIdentity` never shorten a + long title, so re-introducing a truncating helper here fails. + +Tests: the 57 result XMLs aggregate to **513 tests, 0 failures, 0 errors, 0 +skipped** (`RunTitlesTest` 4/0, `RunIdentityTest` 6/0). + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1 `--offline`, +`--no-daemon`, `ANDROID_HOME=/Users/alan/Library/Android/sdk`): + +- `gradle :app:testDebugUnitTest --no-daemon --offline --rerun` → `BUILD + SUCCESSFUL`. +- `gradle :app:assembleDebug --no-daemon --offline` → `BUILD SUCCESSFUL`; + `app-debug.apk` 18,486,624 bytes, sha256 + `2b23762b54f011bbec680804a232f32bd43c244fb52c465a0f4b2c2c9a0148cb`. +- **APK publish.** Copied to this run's artifacts directory as + `pipelines-debug-wip-2bc00a2.apk` (`2bc00a2` = `git rev-parse --short HEAD`, the + tree being uncommitted WIP on top of it), served at + `http://10.0.0.75:8080/artifacts/278/4/pipelines-debug-wip-2bc00a2.apk` + (`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`; the + downloaded bytes hash to the same sha256). + +Not verified in this pass: how the wrapping summary title, the two-line list row +and the two-line stage header actually render — that needs the device, which this +build-and-unit-test pass did not use; visual review owns the operator's Pixel 9 +Pro XL. diff --git a/android/app/src/main/java/net/awan/pipelines/ui/RunIdentity.kt b/android/app/src/main/java/net/awan/pipelines/ui/RunIdentity.kt index 79e9c079..38ebeaf2 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/RunIdentity.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/RunIdentity.kt @@ -24,3 +24,22 @@ fun runIdentity(title: String?, name: String): RunIdentity { val stored = title?.trim().orEmpty() return if (stored.isEmpty()) RunIdentity(name, null) else RunIdentity(stored, name) } + +/** + * The line budget for a run's title in each place the app shows it. A title is + * derived from the run's prompt, so it is often long, and the places it appears + * have different jobs: the run view exists to let the operator read the run, so + * its own title is complete, while a runs-list row (one of many) and the stage + * pane's compact run-context line may clamp because the run view still carries + * the whole title. Kept here, named, so the budgets are a deliberate choice the + * tests pin rather than a bare `maxLines` literal at each call site. + */ + +/** The run view's own title never elides: it wraps over as many lines as it needs. */ +internal const val RUN_VIEW_TITLE_LINES: Int = Int.MAX_VALUE + +/** A runs-list row's title grows to two lines for a longer title, then ellipsises. */ +internal const val RUN_ROW_TITLE_LINES: Int = 2 + +/** The stage pane's compact run-context line shows at most two lines, then ellipsises. */ +internal const val STAGE_RUN_LABEL_LINES: Int = 2 diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt index 1f872f03..563d261b 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt @@ -93,14 +93,16 @@ internal fun sessionTitle(session: ChatSession): String = * session shows no chip. This only *labels*; the app never filters on the tag, * because the server already lists operator sessions only. */ -internal fun sessionTagLabel(session: ChatSession): String? = sessionTagLabel(session.tag) +internal fun sessionTagLabel(session: ChatSession): String? = tagLabel(session.tag) /** * The kind chip label for a session's own tag value (see [sessionTagLabel]). * Kept as the single mapping so a session and the conversation it opens cannot * label the same tag differently. */ -internal fun sessionTagLabel(tag: String): String? = when { +internal fun sessionTagLabel(tag: String): String? = tagLabel(tag) + +private fun tagLabel(tag: String): String? = when { tag.isBlank() -> null tag == ChatProtocol.TAG_OPERATOR -> OPERATOR_TAG_LABEL else -> tag @@ -131,9 +133,13 @@ private const val OPERATOR_TAG_LABEL = "Operator" * `Running` and writable, never the read-only the server's own `busy` flag alone * would imply. */ -internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String = when { +internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String = + sessionStatusLabel(session.busy, runningLocally) + +/** The status of a conversation from its own model flags (see [sessionStatusLabel]). */ +internal fun sessionStatusLabel(busy: Boolean, runningLocally: Boolean): String = when { runningLocally -> "Running" - session.busy -> "Busy · read-only" + busy -> "Busy · read-only" else -> "Idle" } @@ -156,6 +162,73 @@ internal fun sessionActivity(running: Boolean, unseen: Boolean): SessionActivity else -> SessionActivity.IDLE } +/** + * The one identity a conversation header shows: the title is the session's + * name, and everything else is context that cannot be mistaken for a second + * name — the server's kind tag, the live activity and the directory/model. + * Kept pure so the header and its unit test agree that the title appears once. + */ +internal data class ConversationHeader( + val title: String, + val kind: String?, + val activity: String, + val directory: String, + val model: String, +) { + /** The extra identity context, in reading order, with blank fields omitted. */ + val context: List = listOf(directory, model).filter { it.isNotBlank() } +} + +/** Builds the conversation header from the open thread's copied session fields. */ +internal fun conversationHeader(thread: ChatThread): ConversationHeader = ConversationHeader( + title = sessionTitle(ChatSession(id = thread.sessionId, title = thread.title)), + kind = sessionTagLabel(thread.tag), + activity = sessionStatusLabel(thread.busy, thread.running), + directory = thread.directory, + model = thread.model, +) + +/** + * The open chats a conversation still offers to switch to: every other open + * chat, never the active one, so its title is not repeated beside its own + * header. The session list keeps showing all open chats. + */ +internal fun openChatsBeside(open: List, activeSessionId: String): List = + open.filterNot { it.sessionId == activeSessionId } + +/** + * How the transcript renders one part. The decision is pure so the markdown + * route out of the transcript can be tested without Compose: assistant text is + * markdown, reasoning is its own collapsed presentation, any other part with + * text is plain, and an empty part renders nothing. + */ +internal enum class PartRendering { MARKDOWN, REASONING, PLAIN, HIDDEN } + +internal fun partRendering(part: ChatPart): PartRendering = when { + part.type == ChatProtocol.PART_TEXT && part.text.isNotBlank() -> PartRendering.MARKDOWN + part.type == ChatProtocol.PART_REASONING && part.text.isNotBlank() -> PartRendering.REASONING + part.text.isNotBlank() -> PartRendering.PLAIN + else -> PartRendering.HIDDEN +} + +/** + * Which reasoning parts the operator has opened. A set keyed by the stable + * per-part key, so a streaming part keeps its state as deltas arrive and every + * part starts collapsed in a freshly opened conversation. + */ +internal data class ReasoningExpansion(private val expanded: Set = emptySet()) { + fun isExpanded(partKey: String): Boolean = partKey in expanded + + fun toggled(partKey: String): ReasoningExpansion { + if (partKey.isBlank()) return this + return copy(expanded = if (partKey in expanded) expanded - partKey else expanded + partKey) + } +} + +/** The stable key for one reasoning part, even when the server omitted its id. */ +internal fun reasoningKey(messageId: String, part: ChatPart, index: Int): String = + messageId + ":" + part.id.ifBlank { index.toString() } + /** Which action the composer's single primary control offers for a chat. */ enum class ComposerAction { Send, Stop } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt index e87abbeb..ab0767f0 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt @@ -70,6 +70,7 @@ import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.material3.TopAppBar +import androidx.compose.material3.minimumInteractiveComponentSize import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect @@ -139,6 +140,7 @@ import net.awan.pipelines.ui.theme.ICON_LIST_DP import net.awan.pipelines.ui.theme.ICON_STATUS_DP import net.awan.pipelines.ui.theme.SPACING_S import net.awan.pipelines.ui.theme.SPACING_M +import net.awan.pipelines.ui.theme.SPACING_XS import net.awan.pipelines.ui.theme.SPACING_XXS import net.awan.pipelines.ui.theme.TOOL_PANEL_MAX_WIDTH_DP import net.awan.pipelines.ui.theme.pipelinesText @@ -739,17 +741,26 @@ private fun NotConnectedNotice() { } /** - * The open-conversation switcher: one chip per conversation the operator has - * open, so several chats can be kept at once and switched between in one tap. - * A running chat carries a `Running` badge; the X closes that chat (optional - * close is provided). + * The open-conversation switcher: one chip per open conversation, so several + * chats can be kept at once and switched between in one tap. A running chat + * carries its live dot, a chat waiting on an approval carries its hand, and the + * X closes that chat (optional close is provided). [excludeSessionId] omits one + * chat — the conversation pane omits its own active one, whose title already + * stands in the app bar, while the session list shows every open chat. */ @Composable private fun OpenChatStrip( state: ChatState, onSelect: (String) -> Unit, onClose: (String) -> Unit, + excludeSessionId: String? = null, ) { + val threads = if (excludeSessionId == null) { + state.open + } else { + openChatsBeside(state.open, excludeSessionId) + } + if (threads.isEmpty()) return Row( modifier = Modifier .fillMaxWidth() @@ -757,7 +768,7 @@ private fun OpenChatStrip( .padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP), horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP), ) { - state.open.forEach { thread -> + threads.forEach { thread -> val selected = state.activeId == thread.sessionId Surface( shape = RoundedCornerShape(50), @@ -813,6 +824,41 @@ private fun OpenChatStrip( // ---- Pane 1: the active conversation ----------------------------------------- +/** + * The conversation's identity context, directly below the app bar that carries + * its title: the session kind (labelled, never a bare name), its activity and, + * when the server knows them, the directory and model. The title is not repeated + * here — this block adds only what the title cannot say. + */ +@Composable +private fun ConversationHeader(header: ConversationHeader) { + val texts = pipelinesText() + Column( + modifier = Modifier.fillMaxWidth().padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP), + verticalArrangement = Arrangement.spacedBy(SPACING_XS), + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP), + ) { + header.kind?.let { LabelChip(it, SPACING_S, SPACING_XXS) } + Text( + text = header.activity, + style = texts.label, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + if (header.context.isNotEmpty()) { + Text( + text = header.context.joinToString(" · "), + style = texts.meta, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + } +} + @OptIn(ExperimentalMaterial3Api::class) @Composable private fun ChatConversationPane( @@ -823,6 +869,15 @@ private fun ChatConversationPane( ) { val approval = approvalCard(thread.permission, thread.permissionAnswer) val awaiting = approval?.actionable == true + // The header's one identity: the title, with the kind, activity, directory and + // model as context below it. It is built once so the app bar and the context + // line cannot disagree about the session's name. + val header = conversationHeader(thread) + // Reasoning expansion is hoisted here, not into the lazy transcript: a + // reasoning part keeps its open/closed state while the operator scrolls (and + // the item is disposed), and the state is per conversation, so a newly opened + // chat starts with every reasoning part collapsed. + var reasoning by remember(thread.sessionId) { mutableStateOf(ReasoningExpansion()) } // 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 @@ -864,17 +919,18 @@ private fun ChatConversationPane( topBar = { TopAppBar( title = { + // The one identity: the app bar carries the title (the value + // the context line below is built beside), and under it the + // model meta the server reports — its model, kind tag and + // directory — so what is answering is visible without leaving + // the conversation. Every part is server-reported; a blank one + // is simply omitted. Column { Text( - text = thread.title.ifBlank { sessionTitle(ChatSession(id = thread.sessionId)) }, + text = header.title, maxLines = 1, overflow = TextOverflow.Ellipsis, ) - // The model the server reports is answering this session, - // beside the session's kind tag and its directory, so what - // is replying is always visible without leaving the - // conversation. Every part is server-reported; a blank one - // is simply omitted. val meta = chatHeaderMeta(thread) if (meta.isNotBlank()) { Text( @@ -919,7 +975,15 @@ private fun ChatConversationPane( }, ) { padding -> Column(Modifier.fillMaxSize().padding(padding).imePadding()) { - OpenChatStrip(state = state, onSelect = vm::activateChat, onClose = vm::closeChat) + ConversationHeader(header) + // Every *other* open chat is still one tap away; the active one is + // already named by the app bar, so it is not repeated here. + OpenChatStrip( + state = state, + onSelect = vm::activateChat, + onClose = vm::closeChat, + excludeSessionId = thread.sessionId, + ) Box(Modifier.weight(1f).fillMaxWidth()) { when { thread.loading && !thread.loaded -> LoadingState("Loading conversation…") @@ -941,6 +1005,8 @@ private fun ChatConversationPane( itemCount = itemCount, approval = approval, showRunning = showRunning, + reasoning = reasoning, + onToggleReasoning = { reasoning = reasoning.toggled(it) }, onDecision = { decision -> approval?.let { vm.replyChatPermission(thread.sessionId, it.requestId, decision) } }, @@ -991,6 +1057,8 @@ private fun ChatTranscript( itemCount: Int, approval: ApprovalCard?, showRunning: Boolean, + reasoning: ReasoningExpansion, + onToggleReasoning: (String) -> Unit, onDecision: (String) -> Unit, ) { val scope = rememberCoroutineScope() @@ -1073,6 +1141,9 @@ private fun ChatTranscript( if (following) listState.scrollToEnd(itemCount, animated = true) } Box(Modifier.fillMaxSize()) { + // Only the newest turn can be streaming, so its reasoning wears the live + // label; a settled turn's reasoning is labelled as settled. + val streamingMessageId = thread.messages.lastOrNull()?.id?.takeIf { thread.running } LazyColumn( state = listState, modifier = Modifier.fillMaxSize(), @@ -1080,7 +1151,12 @@ private fun ChatTranscript( verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP, Alignment.Bottom), ) { items(thread.messages, key = { it.id }) { message -> - MessageItem(message) + MessageItem( + message = message, + reasoning = reasoning, + streaming = message.id == streamingMessageId, + onToggleReasoning = onToggleReasoning, + ) } if (showRunning) { item(key = "pending") { RunningIndicator(thread) } @@ -1211,7 +1287,12 @@ private fun rememberElapsedNow(runningSince: Long): Long { } @Composable -private fun MessageItem(message: ChatMessage) { +private fun MessageItem( + message: ChatMessage, + reasoning: ReasoningExpansion, + streaming: Boolean, + onToggleReasoning: (String) -> Unit, +) { val isUser = message.role == ChatProtocol.ROLE_USER Row( modifier = Modifier.fillMaxWidth(), @@ -1231,7 +1312,13 @@ private fun MessageItem(message: ChatMessage) { if (isUser) { UserParts(message.parts) } else { - AssistantParts(message.parts) + AssistantParts( + messageId = message.id, + parts = message.parts, + reasoning = reasoning, + streaming = streaming, + onToggleReasoning = onToggleReasoning, + ) } } } @@ -1264,7 +1351,13 @@ private fun UserParts(parts: List) { * as they fit, instead of each taking a row, so the transcript stays scannable. */ @Composable -private fun AssistantParts(parts: List) { +private fun AssistantParts( + messageId: String, + parts: List, + reasoning: ReasoningExpansion, + streaming: Boolean, + onToggleReasoning: (String) -> Unit, +) { var index = 0 while (index < parts.size) { if (parts[index].type == ChatProtocol.PART_TOOL) { @@ -1273,42 +1366,101 @@ private fun AssistantParts(parts: List) { ToolCalls(parts.subList(index, end)) index = end } else { - MessagePart(parts[index]) + val part = parts[index] + MessagePart( + part = part, + reasoningKey = reasoningKey(messageId, part, index), + reasoning = reasoning, + streaming = streaming, + onToggleReasoning = onToggleReasoning, + ) index++ } } } @Composable -private fun MessagePart(part: ChatPart) { - when (part.type) { - ChatProtocol.PART_TEXT -> if (part.text.isNotBlank()) { - MarkdownText(part.text) - } - ChatProtocol.PART_REASONING -> ReasoningBlock(part.text) - else -> if (part.text.isNotBlank()) Text(part.text, style = MaterialTheme.typography.bodyMedium) +private fun MessagePart( + part: ChatPart, + reasoningKey: String, + reasoning: ReasoningExpansion, + streaming: Boolean, + onToggleReasoning: (String) -> Unit, +) { + when (partRendering(part)) { + PartRendering.MARKDOWN -> MarkdownText(part.text) + PartRendering.REASONING -> ReasoningBlock( + text = part.text, + expanded = reasoning.isExpanded(reasoningKey), + streaming = streaming, + onToggle = { onToggleReasoning(reasoningKey) }, + ) + PartRendering.PLAIN -> Text(part.text, style = MaterialTheme.typography.bodyMedium) + PartRendering.HIDDEN -> Unit } } -/** Reasoning is visually secondary: a muted, bordered block, never body weight. */ +/** + * Reasoning is visually secondary and collapsed by default: one compact, muted + * line per part (its spinner-free label names the state; the live label is + * `Thinking…`) that expands on tap to the full, still-muted text. The expansion + * state lives on the conversation, so it survives the transcript disposing the + * item while the operator scrolls and a streaming part keeps its state as + * deltas arrive. + */ @Composable -private fun ReasoningBlock(text: String) { +private fun ReasoningBlock( + text: String, + expanded: Boolean, + streaming: Boolean, + onToggle: () -> Unit, +) { if (text.isBlank()) return - Row(horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP), modifier = Modifier.padding(vertical = 4.dp)) { - Icon( - Icons.Default.Psychology, - contentDescription = null, - tint = MaterialTheme.colorScheme.onSurfaceVariant, - modifier = Modifier.size(16.dp), - ) - Text( - text = text, - style = MaterialTheme.typography.bodySmall.copy(fontFamily = FontFamily.Default), - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) + val label = if (streaming) REASONING_STREAMING_LABEL else REASONING_SETTLED_LABEL + Column(Modifier.fillMaxWidth()) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP), + modifier = Modifier + .fillMaxWidth() + .minimumInteractiveComponentSize() + .clickable(role = Role.Button, onClick = onToggle) + .padding(vertical = SPACING_XS), + ) { + Icon( + Icons.Default.Psychology, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.size(ICON_INLINE_DP), + ) + Text( + text = label, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.weight(1f), + ) + Icon( + imageVector = if (expanded) Icons.Default.KeyboardArrowUp else Icons.Default.KeyboardArrowDown, + contentDescription = if (expanded) "Hide reasoning" else "Show reasoning", + tint = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.size(ICON_INLINE_DP), + ) + } + if (expanded) { + Text( + text = text, + style = MaterialTheme.typography.bodySmall.copy(fontFamily = FontFamily.Default), + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.padding(start = ICON_INLINE_DP + CHAT_ITEM_GAP, bottom = CHAT_ITEM_GAP), + ) + } } } +/** The live and settled labels of a reasoning part's one collapsed line. */ +private const val REASONING_STREAMING_LABEL = "Thinking…" +private const val REASONING_SETTLED_LABEL = "Reasoning" + /** * One turn's tool calls as a single group of compact chips, mirroring the * reference transcript's `_ToolCalls`/`_ToolChip` (research §1.3): each call 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 96f95bfe..a3d80f75 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 @@ -51,9 +51,9 @@ data class ChatThread( val title: String = "", val directory: String = "", val model: String = "", - val agent: String = "", /** The session's kind tag the server reported (see [ChatSession.tag]). */ val tag: String = "", + val agent: String = "", val updatedAt: Long = 0, /** The server reports another client (or an active run) holds this session. */ val busy: Boolean = false, @@ -450,8 +450,8 @@ class ChatStore( title = title, directory = session.directory, model = session.model, - agent = session.agent, tag = session.tag, + agent = session.agent, updatedAt = session.updatedAt, busy = session.busy, ) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt index 9277f9d0..838a5cbb 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailPane.kt @@ -50,6 +50,7 @@ import net.awan.pipelines.ui.components.KeyValueRow import net.awan.pipelines.ui.components.PaneIdentity import net.awan.pipelines.ui.components.SectionHeader import net.awan.pipelines.ui.components.paneSafeArea +import net.awan.pipelines.ui.STAGE_RUN_LABEL_LINES import net.awan.pipelines.ui.displayMap import net.awan.pipelines.ui.fileChangeLine import net.awan.pipelines.ui.fileChangesSummary @@ -428,7 +429,10 @@ fun StageDetailPane( Text( label, style = pipelinesText().meta, - maxLines = 1, + // The run's own complete title lives in the run + // view; here it is a compact context line, so it may + // take a second line but not run away with the pane. + maxLines = STAGE_RUN_LABEL_LINES, overflow = TextOverflow.Ellipsis, ) } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index 42d80ab9..adc2d623 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -91,6 +91,7 @@ import net.awan.pipelines.ui.runArtifactGroups import net.awan.pipelines.ui.runArtifactsHeader import net.awan.pipelines.ui.runIdentity import net.awan.pipelines.ui.runLabel +import net.awan.pipelines.ui.RUN_VIEW_TITLE_LINES import net.awan.pipelines.ui.theme.ICON_INLINE_DP import net.awan.pipelines.ui.theme.ICON_STATUS_DP import net.awan.pipelines.ui.theme.SPACING_L @@ -195,7 +196,11 @@ fun RunDetailScreen( // The header names the run by its title and keeps the pipeline // it belongs to on a second line, so a stage pane opened from // here carries the same context. Without a title the pipeline - // name is the single identity, never a blank first line. + // name is the single identity, never a blank first line. This + // app-bar copy is a compact one-line label (the M3 app bar is a + // fixed height, so it cannot grow); the run's own complete, + // wrapping title is the summary's title line below, which is + // never elided. val identity = run?.let { runIdentity(it.title, it.name) } Column { Text( @@ -447,7 +452,17 @@ private fun RunSummaryTab( modifier = Modifier.fillMaxWidth().padding(horizontal = SPACING_L), verticalArrangement = Arrangement.spacedBy(SPACING_XS), ) { - Text(runLabel(run.title, run.name), style = text.screenTitle) + // The run view's own copy of the title: the operator must be + // able to read what the run is called, so it is never elided - + // it wraps over as many lines as it needs. The compact app-bar + // copy above stays a one-line label for context while this + // scrollable, complete one is what the operator reads. + Text( + runLabel(run.title, run.name), + style = text.screenTitle, + maxLines = RUN_VIEW_TITLE_LINES, + overflow = TextOverflow.Clip, + ) Row( verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(SPACING_S), diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt index 4cd57055..40b39c62 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt @@ -70,6 +70,7 @@ import net.awan.pipelines.ui.components.paneSafeArea import net.awan.pipelines.ui.components.rememberLiveNowMillis import net.awan.pipelines.ui.components.runStateColor import net.awan.pipelines.ui.components.runStateOf +import net.awan.pipelines.ui.RUN_ROW_TITLE_LINES import net.awan.pipelines.ui.formatDuration import net.awan.pipelines.ui.runDurationText import net.awan.pipelines.ui.runIdentity @@ -529,7 +530,7 @@ private fun RunRow( Text( identity.label, style = text.cardTitle, - maxLines = 1, + maxLines = RUN_ROW_TITLE_LINES, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f), ) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/RunIdentityTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/RunIdentityTest.kt index cfd1e135..53fcfba9 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/RunIdentityTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/RunIdentityTest.kt @@ -47,4 +47,16 @@ class RunIdentityTest { assertEquals("android-app", runLabel(null, "android-app")) assertEquals("android-app", runLabel(" ", "android-app")) } + + @Test + fun aVeryLongTitleIsKeptWholeAtTheDataLevel() { + // The run view's own title is rendered from this value with no line limit, + // so the identity itself must never silently shorten it: a prompt-derived + // title stays complete and the view, not this function, decides the + // layout. Guards against re-introducing a truncating helper here. + val long = "Implement the whole thing carefully, then review it ".repeat(40).trim() + assertEquals(long, runLabel(long, "android-app")) + assertEquals(long, runIdentity(long, "android-app").label) + assertEquals("android-app", runIdentity(long, "android-app").pipeline) + } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/RunTitlesTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/RunTitlesTest.kt new file mode 100644 index 00000000..f49f18b9 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/RunTitlesTest.kt @@ -0,0 +1,38 @@ +package net.awan.pipelines.ui + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * The run title's line budget in each place it is shown. A title is derived from + * the run's prompt and is often long, so the run view - the place whose whole job + * is to let the operator read the run - must show it complete, while the places + * that are one of many (a runs-list row) or a compact label (the stage pane's + * run-context line) clamp. The budgets are pinned here so a change to one is a + * deliberate, reviewed decision and the run view can never become the most + * generous place by accident. + */ +class RunTitlesTest { + + @Test + fun theRunViewShowsTheWholeTitleNeverEliding() { + assertEquals(Int.MAX_VALUE, RUN_VIEW_TITLE_LINES) + } + + @Test + fun aRunsListRowGrowsForALongTitleThenClampsAtTwoLines() { + assertEquals(2, RUN_ROW_TITLE_LINES) + } + + @Test + fun theStagePaneRunContextTakesASecondLineThenClamps() { + assertEquals(2, STAGE_RUN_LABEL_LINES) + } + + @Test + fun aClampingPlaceIsNeverMoreGenerousThanTheCompleteOne() { + assertTrue("a list row may not outlive the run view", RUN_ROW_TITLE_LINES < RUN_VIEW_TITLE_LINES) + assertTrue("a stage context line may not outlive the run view", STAGE_RUN_LABEL_LINES < RUN_VIEW_TITLE_LINES) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatTranscriptTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatTranscriptTest.kt new file mode 100644 index 00000000..43712b85 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatTranscriptTest.kt @@ -0,0 +1,152 @@ +package net.awan.pipelines.ui.chat + +import net.awan.pipelines.data.protocol.ChatPart +import net.awan.pipelines.data.protocol.ChatProtocol +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 conversation's reading decisions, all pure so they need no device: the + * markdown route out of the transcript, reasoning collapsed and remembering its + * expansion, and a header that names the session once with only context beside + * and below it. + */ +class ChatTranscriptTest { + + @Test + fun assistantTextReachesTheMarkdownRendererWithTheDocumentedSubset() { + val sample = """ + # Release notes + + Intro with **bold**, *italic*, `inline code` and a [link](https://example.com/x). + + - first + - second + + 1. one + 2. two + + > quoted line + + | Name | Value | + | --- | --- | + | a | 1 | + + ```kotlin + val gap = 8.dp + ``` + + --- + """.trimIndent() + val part = ChatPart(type = ChatProtocol.PART_TEXT, id = "p1", text = sample) + + // The transcript's own decision routes assistant text through markdown... + assertEquals(PartRendering.MARKDOWN, partRendering(part)) + // ...and the whole documented subset parses into the renderer's blocks. + val blocks = parseMarkdown(part.text) + assertTrue(blocks.any { it is MdHeading }) + assertTrue(blocks.any { it is MdParagraph }) + assertTrue(blocks.any { it is MdListBlock }) + assertTrue(blocks.any { it is MdQuote }) + assertTrue(blocks.any { it is MdTableBlock }) + assertTrue(blocks.any { it is MdCodeBlock }) + assertTrue(blocks.contains(MdRule)) + val spans = parseInline("**bold** *italic* `code` [link](https://example.com/x)") + assertTrue(spans.any { it is MdStrong }) + assertTrue(spans.any { it is MdEmphasis }) + assertTrue(spans.any { it is MdCodeSpan }) + assertTrue(spans.any { it is MdLinkSpan }) + } + + @Test + fun textOutsideTheMarkdownSubsetStillRendersAsItsOwnText() { + val text = "~~struck~~ and raw html; \$_unclosed" + val part = ChatPart(type = ChatProtocol.PART_TEXT, id = "p1", text = text) + assertEquals(PartRendering.MARKDOWN, partRendering(part)) + // Nothing in the subset matches, so the paragraph keeps the source verbatim. + assertEquals(listOf(MdParagraph(text)), parseMarkdown(text)) + + // A part kind the renderer does not know still shows its text, never drops it. + val unknown = ChatPart(type = "status", id = "p2", text = "connection restored") + assertEquals(PartRendering.PLAIN, partRendering(unknown)) + assertEquals(PartRendering.HIDDEN, partRendering(ChatPart(type = ChatProtocol.PART_TEXT, id = "p3"))) + } + + @Test + fun reasoningStartsCollapsedAndKeepsItsExpansionPerPart() { + var reasoning = ReasoningExpansion() + assertFalse(reasoning.isExpanded("m:r1")) + assertFalse(reasoning.isExpanded("m:r2")) + + reasoning = reasoning.toggled("m:r1") + assertTrue(reasoning.isExpanded("m:r1")) + assertFalse(reasoning.isExpanded("m:r2")) + + // Expanding a second part does not disturb the first. + reasoning = reasoning.toggled("m:r2") + assertTrue(reasoning.isExpanded("m:r1")) + assertTrue(reasoning.isExpanded("m:r2")) + + // Collapsing brings only that part back. + reasoning = reasoning.toggled("m:r1") + assertFalse(reasoning.isExpanded("m:r1")) + assertTrue(reasoning.isExpanded("m:r2")) + + // A blank key is never a key: it can never expand every id-less part at once. + val untouched = ReasoningExpansion().toggled("") + assertFalse(untouched.isExpanded("")) + } + + @Test + fun reasoningKeyIsStableForAServerPartAndFallsBackToTheIndex() { + assertEquals("m:r1", reasoningKey("m", ChatPart(id = "r1"), 0)) + assertEquals("m:2", reasoningKey("m", ChatPart(id = ""), 2)) + } + + @Test + fun theHeaderNamesTheSessionOnceAndOnlyAddsContext() { + val header = conversationHeader( + ChatThread( + sessionId = "ses_1", + title = "Fix the parser", + directory = "/Users/alan/repos/pipelines", + model = "openai/gpt-5", + tag = ChatProtocol.TAG_OPERATOR, + running = true, + ), + ) + assertEquals("Fix the parser", header.title) + assertEquals("Operator", header.kind) + assertEquals("Running", header.activity) + assertEquals(listOf("/Users/alan/repos/pipelines", "openai/gpt-5"), header.context) + + // The title is the only identity: the context never repeats it. + assertFalse(header.context.contains(header.title)) + assertFalse(header.kind == header.title) + assertFalse(header.activity == header.title) + } + + @Test + fun theHeaderFallsBackToTheIdAndOmitsUnknownContext() { + val header = conversationHeader(ChatThread(sessionId = "ses_untitled", running = false)) + assertEquals("ses_untitled", header.title) + assertNull(header.kind) + assertEquals("Idle", header.activity) + assertEquals(emptyList(), header.context) + } + + @Test + fun theConversationOffersOnlyTheOtherOpenChatsToSwitchTo() { + val a = ChatThread(sessionId = "a", title = "Alpha") + val b = ChatThread(sessionId = "b", title = "Beta") + val open = listOf(a, b) + + // The active chat is never repeated beside its own header... + assertEquals(listOf(b), openChatsBeside(open, "a")) + // ...and a single open chat leaves nothing to switch to. + assertEquals(emptyList(), openChatsBeside(listOf(a), "a")) + } +}