From 94a22c46d759ce6f4fdf04cd96d6a49289db4ad7 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 18 Oct 2026 15:06:45 +0100 Subject: [PATCH] android: preserve run summary title and changes work --- .../pipelines/ui/changes/ChangeDiffViewer.kt | 512 ++++++++++++++++++ .../awan/pipelines/ui/changes/RunChanges.kt | 411 ++++++++++++++ .../awan/pipelines/ui/chat/ChatDiffCard.kt | 37 +- .../pipelines/ui/screens/RunSummaryTab.kt | 111 ++-- .../net/awan/pipelines/ui/theme/Dimens.kt | 19 + .../net/awan/pipelines/ui/RunTitlesTest.kt | 81 +++ .../pipelines/ui/changes/RunChangesTest.kt | 346 ++++++++++++ .../awan/pipelines/ui/chat/ChatFormatTest.kt | 9 + docs/notes/run-summary-title-spacing.md | 55 ++ 9 files changed, 1537 insertions(+), 44 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/changes/ChangeDiffViewer.kt create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/changes/RunChanges.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/changes/RunChangesTest.kt create mode 100644 docs/notes/run-summary-title-spacing.md diff --git a/android/app/src/main/java/net/awan/pipelines/ui/changes/ChangeDiffViewer.kt b/android/app/src/main/java/net/awan/pipelines/ui/changes/ChangeDiffViewer.kt new file mode 100644 index 00000000..75f6a91c --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/changes/ChangeDiffViewer.kt @@ -0,0 +1,512 @@ +package net.awan.pipelines.ui.changes + +import android.view.WindowManager +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.windowInsetsPadding +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.ArrowBack +import androidx.compose.material.icons.automirrored.filled.ArrowForward +import androidx.compose.material.icons.filled.Add +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.filled.ContentCopy +import androidx.compose.material.icons.filled.Delete +import androidx.compose.material.icons.filled.Edit +import androidx.compose.material.icons.filled.QuestionMark +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.SideEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.platform.LocalClipboardManager +import androidx.compose.ui.platform.LocalView +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.window.Dialog +import androidx.compose.ui.window.DialogProperties +import androidx.compose.ui.window.DialogWindowProvider +import net.awan.pipelines.ui.chat.DiffKind +import net.awan.pipelines.ui.chat.diffLineColor +import net.awan.pipelines.ui.chat.diffLineSymbol +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.RunStatusPalette +import net.awan.pipelines.ui.components.copyText +import net.awan.pipelines.ui.components.paneSafeArea +import net.awan.pipelines.ui.theme.ICON_INLINE_DP +import net.awan.pipelines.ui.theme.SPACING_L +import net.awan.pipelines.ui.theme.SPACING_M +import net.awan.pipelines.ui.theme.SPACING_S +import net.awan.pipelines.ui.theme.SPACING_XL +import net.awan.pipelines.ui.theme.SPACING_XS +import net.awan.pipelines.ui.theme.SPACING_XXS +import net.awan.pipelines.ui.theme.pipelinesText + +/** + * The run summary's Changes section body: the observed-file list plus the honest + * capture notes. It is a non-lazy [Column] of rows so it nests safely inside the + * summary's single `LazyColumn` (the artifacts gallery does the same), and it + * renders the same [ChangeFileRow] for every file, tapping any row open into + * [ChangeDiffViewer]. + * + * The whole section is read-only evidence of the workspace the run changed; the + * wording never claims the model authored a change. + */ +@Composable +internal fun ChangeFileList( + changes: RunChanges, + modifier: Modifier = Modifier, +) { + val text = pipelinesText() + var openIndex by remember(changes) { mutableStateOf(NO_OPEN_FILE) } + Column( + modifier = modifier.fillMaxWidth().padding(horizontal = SPACING_L, vertical = SPACING_S), + verticalArrangement = Arrangement.spacedBy(SPACING_XS), + ) { + Text(changesListSummary(changes), style = text.label, color = MaterialTheme.colorScheme.primary) + val note = runChangesNote(changes) + if (note.isNotBlank()) Text(note, style = text.meta) + if (changes.isEmpty) { + Text(noChangeDetail(changes), style = text.meta) + } else { + Column(Modifier.fillMaxWidth()) { + changes.files.forEachIndexed { index, entry -> + ChangeFileRow(entry = entry, onClick = { openIndex = index }) + } + } + } + } + if (openIndex in changes.files.indices) { + ChangeDiffViewer( + files = changes.files, + index = openIndex, + onIndexChange = { openIndex = it }, + onDismiss = { openIndex = NO_OPEN_FILE }, + ) + } +} + +/** No file is open in the changes viewer. */ +private const val NO_OPEN_FILE = -1 + +/** Why no change is listed: a pending capture, an unavailable one, or a recorded none. */ +private fun noChangeDetail(changes: RunChanges): String = when { + changes.pending -> "The capture runs after the stage finishes; nothing is recorded yet." + changes.unavailable -> "The workspace snapshot could not be compared, so no changes can be shown." + changes.stepsWithChanges == 0 -> + "This run recorded no change capture (a historical step, or a stage that does not capture)." + else -> "The captured snapshots were identical: the workspace was unchanged." +} + +/** + * One file in the changes list: a kind glyph, the path in monospace, the `+N -M` + * stat, the read-me-first tags, and the stage(s) that changed it. Tapping opens + * the diff viewer on this file, whose location is confirmed by its position there. + */ +@Composable +private fun ChangeFileRow(entry: FileChangeEntry, onClick: () -> Unit) { + val text = pipelinesText() + val stat = changeStat(entry.added, entry.removed) + Row( + modifier = Modifier + .fillMaxWidth() + .clickable(role = Role.Button, onClick = onClick, onClickLabel = "Open ${entry.path}") + .padding(vertical = SPACING_XS), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(SPACING_S), + ) { + Icon( + imageVector = changeKindIcon(entry.kind), + contentDescription = changeKindLabel(entry.kind), + tint = changeKindTint(entry.kind), + modifier = Modifier.size(ICON_INLINE_DP), + ) + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(SPACING_XXS)) { + Text( + entry.path, + style = text.mono, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + Text(changeRowMeta(entry), style = text.meta, maxLines = 2, overflow = TextOverflow.Ellipsis) + } + if (stat.isNotBlank()) { + Row(horizontalArrangement = Arrangement.spacedBy(SPACING_S)) { + if (entry.added > 0) StatText("+${entry.added}", RunStatusPalette.of(RunState.Succeeded).color) + if (entry.removed > 0) StatText("-${entry.removed}", RunStatusPalette.of(RunState.Failed).color) + } + } + } +} + +/** The row's secondary line: which stage(s) changed it, and how to read the entry. */ +internal fun changeRowMeta(entry: FileChangeEntry): String = buildString { + append("changed by ") + append(entry.steps.joinToString(" → ")) + changeEntryTags(entry).forEach { append(" · $it") } + if (entry.modeChanged && !entry.binary) { + append(" · mode ${entry.beforeMode.orEmpty()}→${entry.afterMode.orEmpty()}") + } +} + +/** One side of a file's stat, monospace in the app's success/failure hue. */ +@Composable +private fun StatText(value: String, color: Color) { + Text( + text = value, + style = MaterialTheme.typography.labelMedium.copy(fontFamily = FontFamily.Monospace), + color = color, + ) +} + +/** The glyph for a file's recorded kind, so the list reads at a glance. */ +internal fun changeKindIcon(kind: ChangeKind): ImageVector = when (kind) { + ChangeKind.Added -> Icons.Default.Add + ChangeKind.Modified -> Icons.Default.Edit + ChangeKind.Deleted -> Icons.Default.Delete + ChangeKind.Other -> Icons.Default.QuestionMark +} + +/** The tint for a file's kind: added green, deleted red, anything else neutral. */ +@Composable +private fun changeKindTint(kind: ChangeKind): Color = when (kind) { + ChangeKind.Added -> RunStatusPalette.of(RunState.Succeeded).color + ChangeKind.Deleted -> RunStatusPalette.of(RunState.Failed).color + else -> MaterialTheme.colorScheme.onSurfaceVariant +} + +/** The two forms one file's change can be read in. */ +private enum class ChangeViewForm { Rendered, Raw } + +/** + * The full-screen diff viewer for one changed file. It pages through the run's + * changed files exactly as the artifact viewer pages through a gallery's media + * (one shared index, previous/next affordances, Back/the close button dismissing), + * and it shows both forms the brief requires, switchable from one control row: + * + * - **Rendered** — the file header with its `+N -M` stat, then each hunk's `@@` + * header, the added/removed/context colouring and the old/new line numbers, + * through the app's one diff language. + * - **Raw patch** — the server's unified patch verbatim in monospace, so the + * operator can read the exact evidence alongside the rendered reading. + * + * A file the server could not give a patch for (binary, truncated, or a capture + * that recorded none) shows the honest reason in place of a diff rather than a + * fabricated one. Nothing here claims authorship: it reports the workspace change + * the server observed. + */ +@Composable +internal fun ChangeDiffViewer( + files: List, + index: Int, + onIndexChange: (Int) -> Unit, + onDismiss: () -> Unit, +) { + val entry = files.getOrNull(index) ?: return + var form by remember(entry.path) { mutableStateOf(ChangeViewForm.Rendered) } + Dialog( + onDismissRequest = onDismiss, + properties = DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = false), + ) { + // Stretch the dialog window over the whole display (behind the status bar + // and navigation bar), exactly as the artifact viewer does. Without a + // bounded window height a weighted child measures its full content and + // pushes the page row off-screen; MATCH_PARENT gives the body the space + // that remains, so the header, the form switch, the diff body and the + // page controls are all on screen. + val dialogWindow = (LocalView.current.parent as? DialogWindowProvider)?.window + SideEffect { + dialogWindow?.setLayout( + WindowManager.LayoutParams.MATCH_PARENT, + WindowManager.LayoutParams.MATCH_PARENT, + ) + } + Box(Modifier.fillMaxSize().windowInsetsPadding(paneSafeArea())) { + Column( + modifier = Modifier + .fillMaxSize() + .background(MaterialTheme.colorScheme.background), + ) { + ChangeViewerHeader(entry = entry, index = index, count = files.size, onDismiss = onDismiss) + // The form switch and the file pager share one control row: the + // Rendered/Raw choice on the left, the previous/next file + // affordances on the right, so moving between files never depends + // on the diff body's height. + ChangeViewerControls( + entry = entry, + form = form, + onSelect = { form = it }, + hasPrevious = index > 0, + hasNext = index < files.lastIndex, + onPrevious = { onIndexChange((index - 1).coerceAtLeast(0)) }, + onNext = { onIndexChange((index + 1).coerceAtMost(files.lastIndex)) }, + ) + ChangeViewerBody( + entry = entry, + form = form, + modifier = Modifier.weight(1f), + ) + } + } + } +} + +/** The open file: its kind, path, stat, position, stages and the close affordance. */ +@Composable +private fun ChangeViewerHeader( + entry: FileChangeEntry, + index: Int, + count: Int, + onDismiss: () -> Unit, +) { + val text = pipelinesText() + val clipboard = LocalClipboardManager.current + Row( + modifier = Modifier.fillMaxWidth().padding(horizontal = SPACING_L, vertical = SPACING_M), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(SPACING_S), + ) { + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(SPACING_XXS)) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(SPACING_S), + ) { + Icon( + imageVector = changeKindIcon(entry.kind), + contentDescription = null, + tint = changeKindTint(entry.kind), + modifier = Modifier.size(ICON_INLINE_DP), + ) + Text( + changeKindLabel(entry.kind).replaceFirstChar { it.uppercase() }, + style = text.label, + color = changeKindTint(entry.kind), + ) + if (changeStat(entry.added, entry.removed).isNotBlank()) { + Text(changeStat(entry.added, entry.removed), style = text.mono) + } + } + Text(entry.path, style = text.mono, maxLines = 2, overflow = TextOverflow.Ellipsis) + Text( + "${changePositionLabel(index, count)} · changed by ${entry.steps.joinToString(" → ")}", + style = text.meta, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + IconButton( + onClick = { entry.patch?.takeIf { it.isNotBlank() }?.let { clipboard.copyText(it) } }, + enabled = !entry.patch.isNullOrBlank(), + ) { + Icon(Icons.Default.ContentCopy, contentDescription = "Copy raw patch for ${entry.path}") + } + IconButton(onClick = onDismiss) { + Icon(Icons.Default.Close, contentDescription = "Close diff") + } + } +} + +/** + * The Rendered/Raw switch and the file pager in one control row: each form is a + * labelled control whose selected form is disabled and emphasised, so the + * operator can always see which reading is open, and the previous/next + * affordances page through the run's changed files, disabled exactly at the ends. + * Keeping the pager in this row (rather than a bottom band) means moving between + * files never depends on the diff body's height. + */ +@Composable +private fun ChangeViewerControls( + entry: FileChangeEntry, + form: ChangeViewForm, + onSelect: (ChangeViewForm) -> Unit, + hasPrevious: Boolean, + hasNext: Boolean, + onPrevious: () -> Unit, + onNext: () -> Unit, +) { + val text = pipelinesText() + Row( + modifier = Modifier.fillMaxWidth().padding(horizontal = SPACING_L, vertical = SPACING_XS), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(SPACING_S), + ) { + TextButton(onClick = { onSelect(ChangeViewForm.Rendered) }, enabled = form != ChangeViewForm.Rendered) { + Text("Rendered", style = if (form == ChangeViewForm.Rendered) text.body else text.label) + } + TextButton( + onClick = { onSelect(ChangeViewForm.Raw) }, + enabled = !entry.patch.isNullOrBlank(), + ) { + Text("Raw patch", style = if (form == ChangeViewForm.Raw) text.body else text.label) + } + Spacer(Modifier.weight(1f)) + IconButton(onClick = onPrevious, enabled = hasPrevious) { + Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Previous file") + } + IconButton(onClick = onNext, enabled = hasNext) { + Icon(Icons.AutoMirrored.Filled.ArrowForward, contentDescription = "Next file") + } + } +} + +/** The open file's body in the chosen form, or the honest reason a diff cannot be shown. */ +@Composable +private fun ChangeViewerBody(entry: FileChangeEntry, form: ChangeViewForm, modifier: Modifier = Modifier) { + when { + entry.binary || entry.patch.isNullOrBlank() -> HonestMessage( + if (entry.binary) { + "This is a binary file: the server recorded the change but has no textual diff to show." + } else { + patchUnavailableReason(entry) + }, + modifier, + ) + form == ChangeViewForm.Raw -> Column( + modifier + .fillMaxWidth() + .verticalScroll(rememberScrollState()) + .padding(SPACING_L), + ) { + Text(entry.patch.orEmpty(), style = pipelinesText().mono, modifier = Modifier.fillMaxWidth()) + } + else -> Column( + modifier + .fillMaxWidth() + .verticalScroll(rememberScrollState()) + .padding(SPACING_L), + verticalArrangement = Arrangement.spacedBy(SPACING_M), + ) { + val parsed = remember(entry.patch) { parseUnifiedPatch(entry.patch) } + ChangeDiffStat(parsed) + if (entry.truncated) { + Text( + "The server truncated this patch at its capture limit; the raw text is the whole record.", + style = pipelinesText().meta, + ) + } + parsed.hunks.forEach { hunk -> HunkView(hunk) } + } + } +} + +/** A centred honest explanation where a diff cannot be rendered. */ +@Composable +private fun HonestMessage(message: String, modifier: Modifier = Modifier) { + Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + Text(message, style = pipelinesText().meta, modifier = Modifier.padding(SPACING_XL)) + } +} + +/** Why a file has no patch to render, in the entry's own recorded terms. */ +internal fun patchUnavailableReason(entry: FileChangeEntry): String = when { + entry.truncated -> "The server truncated this file's patch at its capture limit; no diff text was recorded." + entry.otherModeChange -> + "Only the file's mode changed (${entry.beforeMode.orEmpty()}→${entry.afterMode.orEmpty()}); the server recorded no text diff." + else -> "The server recorded this change without a patch." +} + +/** The file's `+N -M` stat line above the rendered hunks. */ +@Composable +private fun ChangeDiffStat(parsed: FileDiff) { + val text = pipelinesText() + Row(horizontalArrangement = Arrangement.spacedBy(SPACING_S)) { + if (parsed.added > 0) StatText("+${parsed.added}", RunStatusPalette.of(RunState.Succeeded).color) + if (parsed.removed > 0) StatText("-${parsed.removed}", RunStatusPalette.of(RunState.Failed).color) + if (parsed.added == 0 && parsed.removed == 0) Text("no line changes recorded", style = text.meta) + } +} + +/** + * One `@@` hunk: its header, then its numbered lines. Each line is drawn with the + * app's shared diff symbols and colours ([diffLineSymbol]/[diffLineColor], the + * same the chat's edit card uses), preceded by its old/new gutter numbers, so the + * changes viewer and the chat diff are one renderer rather than two. + */ +@Composable +private fun HunkView(hunk: ChangeHunk) { + val text = pipelinesText() + Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(SPACING_XXS)) { + Text( + hunk.header, + style = text.mono, + color = MaterialTheme.colorScheme.primary, + modifier = Modifier + .fillMaxWidth() + .background(MaterialTheme.colorScheme.surfaceContainerHigh) + .padding(horizontal = SPACING_XS, vertical = SPACING_XXS), + ) + val gutter = remember(hunk) { gutterWidth(hunk) } + Column( + Modifier + .fillMaxWidth() + .background(MaterialTheme.colorScheme.surfaceContainer) + .horizontalScroll(rememberScrollState()) + .padding(vertical = SPACING_XS), + ) { + hunk.lines.forEach { line -> NumberedDiffLine(line, gutter) } + } + } +} + +/** The widest line number in a hunk, so its gutter lines up across every row. */ +internal fun gutterWidth(hunk: ChangeHunk): Int = + (hunk.lines.maxOfOrNull { maxOf(it.oldLine, it.newLine) } ?: 1).toString().length + +/** + * One rendered diff line: the old/new gutter numbers (blank on the side a line + * has no number, and on a `\ No newline` annotation) and the marked content. + */ +@Composable +private fun NumberedDiffLine(line: ChangeLine, gutter: Int) { + val text = pipelinesText() + val kind = line.kind.toDiffKind() + Row(horizontalArrangement = Arrangement.spacedBy(SPACING_S)) { + Text( + text = if (line.noNewlineMarker) { + " ".repeat(gutter * 2 + 1) + } else { + gutterText(line.oldLine, gutter) + " " + gutterText(line.newLine, gutter) + }, + style = text.meta, + maxLines = 1, + ) + Text( + text = "${diffLineSymbol(kind)} ${line.text}", + style = text.mono, + color = diffLineColor(kind), + ) + } +} + +/** One gutter number padded to [width]; 0 means no number on that side. */ +private fun gutterText(value: Int, width: Int): String = + if (value <= 0) " ".repeat(width) else value.toString().padStart(width) + +/** A parsed line's kind in the app's shared diff vocabulary. */ +internal fun ChangeLineKind.toDiffKind(): DiffKind = when (this) { + ChangeLineKind.Add -> DiffKind.ADD + ChangeLineKind.Remove -> DiffKind.REMOVE + ChangeLineKind.Context -> DiffKind.CONTEXT +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/changes/RunChanges.kt b/android/app/src/main/java/net/awan/pipelines/ui/changes/RunChanges.kt new file mode 100644 index 00000000..ebebcaa3 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/changes/RunChanges.kt @@ -0,0 +1,411 @@ +package net.awan.pipelines.ui.changes + +import java.util.Locale +import net.awan.pipelines.data.protocol.FileChange +import net.awan.pipelines.data.protocol.RunStep +import net.awan.pipelines.data.protocol.StageFileChanges + +/** + * The kind of observed file change the server recorded, mirroring + * `internal/protocol/runs.go` FileChange.Kind (added|modified|deleted). An + * unrecognised or blank kind stays [Other] rather than being guessed, so a + * future server value is shown read-only instead of mislabelled. + */ +enum class ChangeKind { Added, Modified, Deleted, Other } + +/** Maps the server's kind token to [ChangeKind]; never invents one. Pure. */ +internal fun changeKind(kind: String): ChangeKind = when (kind.trim().lowercase(Locale.US)) { + "added" -> ChangeKind.Added + "modified" -> ChangeKind.Modified + "deleted" -> ChangeKind.Deleted + else -> ChangeKind.Other +} + +/** The word a file's kind is named by in the list and the diff header. */ +internal fun changeKindLabel(kind: ChangeKind): String = when (kind) { + ChangeKind.Added -> "added" + ChangeKind.Modified -> "modified" + ChangeKind.Deleted -> "deleted" + ChangeKind.Other -> "changed" +} + +/** Which kind of line this is within a unified patch. */ +enum class ChangeLineKind { Context, Add, Remove } + +/** + * One line of a parsed unified patch, with the old/new line numbers a rendered + * diff gutter shows (0 where the line has no number on that side: an added line + * has no old number, a removed line no new one, a `\ No newline` marker neither). + * [text] is the line's content without its leading marker; [noNewlineMarker] marks + * the `\ No newline at end of file` annotation so a renderer draws no numbers for + * it. + */ +internal data class ChangeLine( + val kind: ChangeLineKind, + val text: String, + val oldLine: Int = 0, + val newLine: Int = 0, + val noNewlineMarker: Boolean = false, +) + +/** One `@@` hunk: the server's own header plus its parsed lines. */ +internal data class ChangeHunk( + val header: String, + val oldStart: Int, + val oldCount: Int, + val newStart: Int, + val newCount: Int, + val lines: List, +) + +/** + * A parsed unified patch for one file: the raw text exactly as the server + * recorded it ([raw], the thing the raw view shows verbatim), the file header + * lines the patch carried, the parsed [hunks], and the true `+N -M` stat counted + * from the hunk body (never from the header text, so a relocated header cannot + * misstate the change). + */ +internal data class FileDiff( + val raw: String, + val headerLines: List, + val hunks: List, + val added: Int, + val removed: Int, +) + +/** + * Parses a server-recorded unified patch into hunks, lines, line numbers and + * the true `+N -M` stat. The server builds these patches with a Go unified-diff + * writer (internal/filediff), so the shape is a standard `---`/`+++` header, + * optional metadata lines, `@@ -a,b +c,d @@` hunk headers and a ` `/`+`/`-` + * body. Anything unrecognised (a truncated tail, an exotic header) is carried + * verbatim in [FileDiff.headerLines] when it sits before the first hunk, and + * otherwise skipped, so the raw view always has the exact source while the + * rendered view shows only lines it can stand behind. A blank patch parses to an + * empty [FileDiff] rather than a fabricated one. + */ +internal fun parseUnifiedPatch(patch: String?): FileDiff { + val text = patch.orEmpty() + if (text.isBlank()) return FileDiff(raw = "", headerLines = emptyList(), hunks = emptyList(), added = 0, removed = 0) + val rawLines = text.split("\n") + val headers = ArrayList() + val hunks = ArrayList() + var current: HunkBuilder? = null + for (line in rawLines) { + val hunkStart = parseHunkHeader(line) + when { + hunkStart != null -> { + current?.let { hunks += it.build() } + current = HunkBuilder(line, hunkStart.oldStart, hunkStart.oldCount, hunkStart.newStart, hunkStart.newCount) + } + current == null -> headers += line + else -> current.lines += parseBodyLine(line, current) + } + } + current?.let { hunks += it.build() } + val added = hunks.sumOf { hunk -> hunk.lines.count { it.kind == ChangeLineKind.Add } } + val removed = hunks.sumOf { hunk -> hunk.lines.count { it.kind == ChangeLineKind.Remove } } + return FileDiff(raw = text, headerLines = headers, hunks = hunks, added = added, removed = removed) +} + +/** + * Mutable accumulator for one hunk as it is parsed, carrying the running old/new + * line counters so each body line gets its gutter numbers without a second pass. + */ +private class HunkBuilder( + val header: String, + val oldStart: Int, + val oldCount: Int, + val newStart: Int, + val newCount: Int, +) { + val lines = ArrayList() + private var oldLine = oldStart + private var newLine = newStart + + fun build(): ChangeHunk = ChangeHunk( + header = header, + oldStart = oldStart, + oldCount = oldCount, + newStart = newStart, + newCount = newCount, + lines = lines, + ) + + fun nextOld(): Int = oldLine++ + + fun nextNew(): Int = newLine++ +} + +/** + * The parsed `@@ -oldStart,oldCount +newStart,newCount @@` of a hunk header, or + * null when [line] is not one. A missing count defaults to 1 (the unified-diff + * rule) so a single-line hunk header is still read exactly. Pure. + */ +private fun parseHunkHeader(line: String): HunkStart? { + if (!line.startsWith("@@")) return null + val end = line.indexOf("@@", 2) + if (end < 0) return null + val ranges = tokenizeRanges(line.substring(2, end)) ?: return null + return HunkStart(ranges[0], ranges[1], ranges[2], ranges[3]) +} + +private data class HunkStart(val oldStart: Int, val oldCount: Int, val newStart: Int, val newCount: Int) + +/** The four numbers of a hunk header's range text, or null when malformed. Pure. */ +private fun tokenizeRanges(body: String): List? { + val old = body.substringBefore('+') + val new = body.substringAfter('+', "") + if (old.isEmpty() || new.isEmpty()) return null + val oldRange = parseRange(old) ?: return null + val newRange = parseRange(new) ?: return null + return listOf(oldRange.first, oldRange.second, newRange.first, newRange.second) +} + +/** One `-start,count` / `+start,count` side of a hunk header. Pure. */ +private fun parseRange(text: String): Pair? { + val trimmed = text.trim().removePrefix("-").removePrefix("+") + if (trimmed.isEmpty()) return null + val start = trimmed.substringBefore(',').trim().toIntOrNull() ?: return null + val countText = trimmed.substringAfter(',', "").trim() + val count = if (countText.isEmpty()) 1 else countText.toIntOrNull() ?: return null + return start to count +} + +/** One body line of a hunk, tagged and numbered from [builder]'s counters. */ +private fun parseBodyLine(line: String, builder: HunkBuilder): ChangeLine = when { + line.startsWith("+") -> ChangeLine(ChangeLineKind.Add, line.substring(1), oldLine = 0, newLine = builder.nextNew()) + line.startsWith("-") -> ChangeLine(ChangeLineKind.Remove, line.substring(1), oldLine = builder.nextOld(), newLine = 0) + line.startsWith("\\") -> ChangeLine(ChangeLineKind.Context, line, noNewlineMarker = true) + line.startsWith(" ") -> ChangeLine(ChangeLineKind.Context, line.substring(1), oldLine = builder.nextOld(), newLine = builder.nextNew()) + line.isEmpty() -> ChangeLine(ChangeLineKind.Context, "", oldLine = builder.nextOld(), newLine = builder.nextNew()) + // A truncated tail or an unexpected marker: keep the text, don't number it. + else -> ChangeLine(ChangeLineKind.Context, line) +} + +/** + * One file the run changed, aggregated across the steps that changed it. A file + * touched by several steps appears once; [steps] names every stage that changed + * it (in the run's step order), so the section can say which stage(s) did. + * + * [added]/[removed] sum the patches the server actually recorded for this path. + * [binary] is true when any step recorded it as binary, [truncated] when any + * step's patch was truncated (or omitted), and [otherModeChange] when the mode + * changed without the content — all of which the viewer states plainly rather + * than rendering a diff it does not have. + */ +internal data class FileChangeEntry( + val path: String, + val kind: ChangeKind, + val added: Int, + val removed: Int, + val binary: Boolean, + val truncated: Boolean, + val beforeMode: String?, + val afterMode: String?, + val otherModeChange: Boolean, + val steps: List, + val patch: String?, +) { + /** True when a patch the operator can read is present. */ + val hasPatch: Boolean get() = !patch.isNullOrBlank() && !binary + + /** True when the recorded permissions differ and no content change explains it. */ + val modeChanged: Boolean get() = beforeMode != null && afterMode != null && beforeMode != afterMode + + /** The number of stages that changed this file. */ + val stepCount: Int get() = steps.size +} + +/** + * The Changes disclosure's entire state, derived purely from the run's steps. + * + * It aggregates every stage step's observed `file_changes` capture: a path + * changed by several steps appears once ([files]), each carrying the stages that + * changed it, and the totals describe the recorded patches. The capture's own + * honesty flags are preserved: [unavailable] when a step's snapshot could not be + * compared, [partial] when a capture was incomplete, truncated or omitted, + * [pending] when nothing has been recorded yet, and [diagnostic] the server's own + * explanation. [status] is the one-line summary the collapsed section shows. + */ +internal data class RunChanges( + val files: List, + val stepsWithChanges: Int, + val stepsPending: Int, + val added: Int, + val removed: Int, + val partial: Boolean, + val unavailable: Boolean, + val pending: Boolean, + val skipped: Int, + val omitted: Int, + val diagnostic: String, +) { + val fileCount: Int get() = files.size + + /** No recorded change of any kind: the section states so rather than showing an empty list. */ + val isEmpty: Boolean get() = files.isEmpty() +} + +/** A file is captured as binary when either side of the snapshot was binary. */ +private fun binaryOf(change: FileChange): Boolean = change.binary + +/** + * Aggregates a run's stage steps into its Changes state. Pure and total over its + * input: a null `file_changes` on a step is a historical (or non-capturing) step + * and contributes nothing (it is not "no changes"); a present capture with no + * files is a real, observed no-change. Files are keyed by path and keep first-seen + * order, so a path several steps changed is one entry naming all of them. + */ +internal fun runChanges(steps: List): RunChanges { + val entries = LinkedHashMap() + var stepsWithChanges = 0 + var stepsPending = 0 + var partial = false + var unavailable = false + var skipped = 0 + var omitted = 0 + val diagnostics = LinkedHashSet() + + for (step in steps) { + val changes = step.fileChanges + if (changes == null) { + if (step.status == "running" || step.status == "waiting") stepsPending++ + continue + } + stepsWithChanges++ + if (changes.status == "unavailable") unavailable = true + if (changes.status == "partial") partial = true + if (!changes.diagnostic.isNullOrBlank()) diagnostics += changes.diagnostic.orEmpty().trim() + skipped += changes.skipped + omitted += changes.omitted + val stage = step.stage.ifBlank { "stage" } + for (file in changes.files) { + if (file.path.isBlank()) continue + val kind = changeKind(file.kind) + val parsed = parseUnifiedPatch(file.patch) + val existing = entries[file.path] + val mergedSteps = buildList { + if (existing != null) addAll(existing.steps) + if (stage !in this) add(stage) + } + val entry = FileChangeEntry( + path = file.path, + // A later step wins the kind: it is the observed state the run left. + kind = if (existing == null || kind != ChangeKind.Other) kind else existing.kind, + added = (existing?.added ?: 0) + parsed.added, + removed = (existing?.removed ?: 0) + parsed.removed, + binary = (existing?.binary == true) || file.binary, + truncated = (existing?.truncated == true) || file.truncated, + // Keep the first-seen before-mode and the last-seen after-mode, so the + // pair describes the run's net effect on the file. + beforeMode = existing?.beforeMode ?: file.beforeMode, + afterMode = file.afterMode ?: existing?.afterMode, + otherModeChange = (existing?.otherModeChange == true) || + (file.beforeMode != null && file.afterMode != null && + file.beforeMode != file.afterMode && !file.binary && parsed.added == 0 && parsed.removed == 0), + steps = mergedSteps, + patch = file.patch?.takeIf { it.isNotBlank() } ?: existing?.patch, + ) + entries[file.path] = entry + } + } + + val files = entries.values.toList() + val pending = stepsWithChanges == 0 && stepsPending > 0 + val totalPartial = partial || files.any { it.truncated } || omitted > 0 + return RunChanges( + files = files, + stepsWithChanges = stepsWithChanges, + stepsPending = stepsPending, + added = files.sumOf { it.added }, + removed = files.sumOf { it.removed }, + partial = totalPartial, + unavailable = unavailable, + pending = pending, + skipped = skipped, + omitted = omitted, + diagnostic = diagnostics.joinToString(" "), + ) +} + +/** + * The Changes section header's one-line summary: the observed file count, the + * total `+N -M`, and the honest capture caveats. Wording never implies the + * server proved authorship — it reports the workspace change it observed. A run + * with no recorded change, an unavailable capture and a still-running one each + * say exactly that rather than showing a fabricated zero. + */ +internal fun runChangesHeader(changes: RunChanges): String { + if (changes.unavailable) return "Changes · capture unavailable" + if (changes.isEmpty) { + return when { + changes.pending -> "Changes · capture pending" + changes.stepsWithChanges == 0 -> "Changes · not recorded for this run" + else -> "Changes · no changes observed" + } + } + val stat = changeStat(changes.added, changes.removed) + val label = if (stat.isBlank()) { + "${changes.fileCount} ${if (changes.fileCount == 1) "file" else "files"} changed" + } else { + "${changes.fileCount} ${if (changes.fileCount == 1) "file" else "files"} changed · $stat" + } + return if (changes.partial) "$label · partial capture" else label +} + +/** + * The honest one-line note under the header for a capture that is not complete, + * or "" when the capture was. The wording distinguishes an unavailable capture, a + * partial one (with its counts) and a capture that has recorded nothing yet. + */ +internal fun runChangesNote(changes: RunChanges): String = when { + changes.unavailable -> changes.diagnostic.ifBlank { + "The workspace snapshot could not be compared; the changes below may be incomplete." + } + changes.isEmpty -> "" + else -> buildString { + if (changes.partial) { + append("Partial capture: some changes may be missing.") + val caveats = ArrayList() + if (changes.skipped > 0) caveats += "${changes.skipped} files skipped" + if (changes.omitted > 0) caveats += "${changes.omitted} omitted" + val truncated = changes.files.count { it.truncated } + if (truncated > 0) caveats += "$truncated truncated" + if (caveats.isNotEmpty()) append(" (" + caveats.joinToString(", ") + ")") + if (changes.diagnostic.isNotBlank()) append(" ${changes.diagnostic}") + } + }.trim() +} + +/** The `+N -M` stat, or "" when both counts are zero. Shared by the header and a file row. */ +internal fun changeStat(added: Int, removed: Int): String = buildString { + if (added > 0) append("+$added") + if (removed > 0) { + if (isNotEmpty()) append(" ") + append("-$removed") + } +} + +/** + * The tags shown beside a file row: the traits that change how the entry must be + * read (binary, truncated, a mode-only change), never a fabricated diff. + */ +internal fun changeEntryTags(entry: FileChangeEntry): List = buildList { + if (entry.binary) add("binary") + if (entry.truncated) add("truncated") + if (entry.otherModeChange && !entry.binary) add("mode change") +} + +/** + * The file list's own summary line: the observed file count and the aggregate + * stat, with the same ambiguity-free wording as the header. + */ +internal fun changesListSummary(changes: RunChanges): String { + val count = "${changes.fileCount} ${if (changes.fileCount == 1) "file" else "files"} changed" + val stat = changeStat(changes.added, changes.removed) + return if (stat.isBlank()) count else "$count · $stat" +} + +/** The `N of M` position label the viewer shows for its open file. Pure. */ +internal fun changePositionLabel(index: Int, count: Int): String = "${index + 1} of $count" diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatDiffCard.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatDiffCard.kt index a91c1fb6..493e00d5 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatDiffCard.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatDiffCard.kt @@ -14,6 +14,7 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.unit.dp import net.awan.pipelines.ui.components.CODE_BLOCK_MAX_HEIGHT @@ -38,6 +39,30 @@ internal fun DiffStat(diff: ToolDiff) { } } +/** + * The gutter symbol one [DiffKind] is drawn with, the app's one spelling of the + * unified-diff marker (`+`/`-`/space). Shared by the chat's edit card and the run + * summary's changes viewer, so the two renderers never disagree about what a kind + * looks like. Pure. + */ +internal fun diffLineSymbol(kind: DiffKind): String = when (kind) { + DiffKind.ADD -> "+" + DiffKind.REMOVE -> "-" + DiffKind.CONTEXT -> " " +} + +/** + * The colour one [DiffKind] is drawn in: the app's success hue for an addition, + * its failure hue for a removal and the secondary on-surface role for context. + * The one place a diff line's colour is decided, shared by every renderer. + */ +@Composable +internal fun diffLineColor(kind: DiffKind): Color = when (kind) { + DiffKind.ADD -> RunStatusPalette.of(RunState.Succeeded).color + DiffKind.REMOVE -> RunStatusPalette.of(RunState.Failed).color + DiffKind.CONTEXT -> MaterialTheme.colorScheme.onSurfaceVariant +} + /** * The unified diff body of an edit card: line-by-line monospace with `+`/`-` * gutter symbols and the app's success/failure hues, bounded so a long diff @@ -45,9 +70,6 @@ internal fun DiffStat(diff: ToolDiff) { */ @Composable internal fun DiffView(diff: ToolDiff) { - val added = RunStatusPalette.of(RunState.Succeeded).color - val removed = RunStatusPalette.of(RunState.Failed).color - val context = MaterialTheme.colorScheme.onSurfaceVariant Card( modifier = Modifier.fillMaxWidth(), colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainer), @@ -73,15 +95,10 @@ internal fun DiffView(diff: ToolDiff) { ) } diff.lines.forEach { line -> - val (symbol, color) = when (line.kind) { - DiffKind.ADD -> "+" to added - DiffKind.REMOVE -> "-" to removed - DiffKind.CONTEXT -> " " to context - } Text( - text = "$symbol ${line.text}", + text = "${diffLineSymbol(line.kind)} ${line.text}", style = pipelinesText().mono, - color = color, + color = diffLineColor(line.kind), ) } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunSummaryTab.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunSummaryTab.kt index 559a7029..47e1b3db 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunSummaryTab.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunSummaryTab.kt @@ -17,6 +17,9 @@ import androidx.compose.ui.text.style.TextOverflow import net.awan.pipelines.data.protocol.RunDetail import net.awan.pipelines.ui.ArtifactGroup import net.awan.pipelines.ui.RUN_VIEW_TITLE_LINES +import net.awan.pipelines.ui.changes.ChangeFileList +import net.awan.pipelines.ui.changes.runChanges +import net.awan.pipelines.ui.changes.runChangesHeader import net.awan.pipelines.ui.components.CodeBlock import net.awan.pipelines.ui.components.DetailTabBody import net.awan.pipelines.ui.components.KeyValueRow @@ -35,6 +38,8 @@ import net.awan.pipelines.ui.runLabel import net.awan.pipelines.ui.theme.SPACING_L import net.awan.pipelines.ui.theme.SPACING_S import net.awan.pipelines.ui.theme.SPACING_XS +import net.awan.pipelines.ui.theme.SUMMARY_SECTION_GAP +import net.awan.pipelines.ui.theme.SUMMARY_TOP_SPACING import net.awan.pipelines.ui.theme.pipelinesText import net.awan.pipelines.ui.visitCount @@ -58,53 +63,50 @@ internal fun RunSummaryTab( ) { val text = pipelinesText() val state = runStateOf(run.status) - // The artifacts section starts collapsed and its expand/collapse choice is - // remembered/saved per run id, so a different run reseeds it and a run opened - // fresh starts collapsed. Both the header and the gallery read the same - // snapshot, so they can never disagree. - val artifactsExpansion = rememberSectionExpansion(run.id) + // One expansion state for the summary's collapsible sections (artifacts and + // Changes), keyed by their own stable section keys. It is remembered/saved per + // run id, so a different run reseeds it and a run opened fresh starts with + // both sections collapsed. + val sections = rememberSectionExpansion(run.id) + // The artifacts header and body read the same snapshot, so they can never + // disagree. val artifactsHeader = remember(run.steps, run.executing) { runArtifactsHeader(run.steps, run.executing) } + // The Changes section is derived from the same step snapshot the artifacts + // header is, once per data change: a path several steps changed is aggregated + // to one entry naming every stage, and the total `+N -M` describes the patches + // the server actually recorded (never a model's claim). + val changes = remember(run.steps) { runChanges(run.steps) } DetailTabBody(wide, modifier) { columnModifier -> LazyColumn( modifier = columnModifier, - contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)), + // The leading clearance belongs to the identity block below, so the + // title sits off the app bar by the screen's standard top spacing + // rather than by whatever the list happens to add; the trailing + // reserve still comes from the shared pill helper. + contentPadding = pillContentPadding( + PaddingValues(top = SUMMARY_TOP_SPACING, bottom = SPACING_L), + ), ) { - // The artifacts gallery still leads the summary, but inside one - // collapsed section: its header alone carries the run's capture - // wording until the operator expands it, and expanding reveals the - // unchanged gallery (nothing when no artifacts were recorded). - collapsibleSection( - title = artifactsHeader, - key = SUMMARY_ARTIFACTS_KEY, - expanded = artifactsExpansion.isExpanded(SUMMARY_ARTIFACTS_KEY), - onToggle = { artifactsExpansion.toggle(SUMMARY_ARTIFACTS_KEY) }, - ) { - if (artifactGroups.isNotEmpty()) { - Column( - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = SPACING_L, vertical = SPACING_S), - ) { - ArtifactGallery( - groups = artifactGroups, - configuredServerUrl = configuredServerUrl, - fetchArtifactBytes = fetchArtifactBytes, - selection = selection, - onSelectionChange = onSelectionChange, - ) - } - } - } + // The run's identity leads the summary: the operator reads what the + // run is called before anything else. The block keeps the standard + // top spacing above it and the standard section gap below it, so the + // title is neither jammed against the app bar nor glued to the + // artifacts section that follows. item(key = "run-summary") { Column( - modifier = Modifier.fillMaxWidth().padding(horizontal = SPACING_L), + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = SPACING_L) + .padding(bottom = SUMMARY_SECTION_GAP), verticalArrangement = Arrangement.spacedBy(SPACING_XS), ) { // 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 + // it wraps over as many lines as it needs and clips rather + // than ellipsises. Nothing here shortens it: the title is + // already as long as the server stores it. The compact app-bar // copy above stays a one-line label for context while this // scrollable, complete one is what the operator reads. Text( @@ -142,6 +144,42 @@ internal fun RunSummaryTab( CodeBlock("Diagnostic", run.diagnostic, Modifier.padding(top = SPACING_S)) } } + // The artifacts section follows the identity block, in one + // collapsed section: its header alone carries the run's capture + // wording until the operator expands it, and expanding reveals the + // unchanged gallery (nothing when no artifacts were recorded). + collapsibleSection( + title = artifactsHeader, + key = SUMMARY_ARTIFACTS_KEY, + expanded = sections.isExpanded(SUMMARY_ARTIFACTS_KEY), + onToggle = { sections.toggle(SUMMARY_ARTIFACTS_KEY) }, + ) { + if (artifactGroups.isNotEmpty()) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = SPACING_L, vertical = SPACING_S), + ) { + ArtifactGallery( + groups = artifactGroups, + configuredServerUrl = configuredServerUrl, + fetchArtifactBytes = fetchArtifactBytes, + selection = selection, + onSelectionChange = onSelectionChange, + ) + } + } + } + // Changes follows artifacts with its own stable disclosure key. Its + // header names the observed file count and total stat while collapsed. + collapsibleSection( + title = runChangesHeader(changes), + key = SUMMARY_CHANGES_KEY, + expanded = sections.isExpanded(SUMMARY_CHANGES_KEY), + onToggle = { sections.toggle(SUMMARY_CHANGES_KEY) }, + ) { + ChangeFileList(changes = changes) + } } } } @@ -164,3 +202,8 @@ private fun RunDurationRow(run: RunDetail) { // is remembered consistently (it is namespaced under the summary tab's saved // state and reseeded by run id). private const val SUMMARY_ARTIFACTS_KEY = "artifacts" + +// The run summary's changes section key: its own stable key, so the Changes +// disclosure's expand/collapse choice is remembered separately from the artifacts +// section's under the same per-run saved state. +private const val SUMMARY_CHANGES_KEY = "changes" 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 caace198..b5798a36 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 @@ -271,3 +271,22 @@ internal val CHAT_COMMAND_LIST_MAX_HEIGHT = 240.dp * up to read history stops the view moving under them. */ internal val CHAT_FOLLOW_THRESHOLD_DP = 32.dp + +// ---- Run summary (ui/screens/RunSummaryTab.kt) ------------------------------ + +/** + * Clearance above the run summary's leading identity block (the run's own title + * and its facts). The summary leads with that block, so this is what keeps the + * title off the app bar; it is the screen's standard top padding ([SPACING_L]), + * named here so the title's clearance is a deliberate choice rather than an + * accident of the scroll container's own padding. Applied as the scroll + * content's own top padding. + */ +internal val SUMMARY_TOP_SPACING = SPACING_L + +/** + * The gap between the run summary's identity block and the artifacts section + * that follows it, so the title block and the section header are not glued + * together. The app's standard block-to-block step ([SPACING_S]). + */ +internal val SUMMARY_SECTION_GAP = SPACING_S 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 index f49f18b9..5ef1cffc 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/RunTitlesTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/RunTitlesTest.kt @@ -1,5 +1,10 @@ package net.awan.pipelines.ui +import java.io.File +import net.awan.pipelines.ui.theme.SPACING_L +import net.awan.pipelines.ui.theme.SPACING_S +import net.awan.pipelines.ui.theme.SUMMARY_SECTION_GAP +import net.awan.pipelines.ui.theme.SUMMARY_TOP_SPACING import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test @@ -12,6 +17,11 @@ import org.junit.Test * 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. + * + * Two source-scan cases also pin where the run view's own title is rendered: the + * summary must lead with it, give it its own top spacing and section gap, and + * apply the complete budget with `Clip` — so the rule survives in the pixels, + * not only in the constant. */ class RunTitlesTest { @@ -35,4 +45,75 @@ class RunTitlesTest { 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) } + + /** + * The budget is only real where the operator reads it: the run summary must + * render its own title with the complete budget and clip rather than + * ellipsise, so no edit can quietly leave the summary eliding its title while + * the budget above still says it may not. A source scan keeps this honest + * without a device, the same way `CollapseRemovalTest` and `DimensTest` scan + * sources. + */ + @Test + fun theRunSummaryRendersItsTitleWithTheCompleteBudgetAndClip() { + val source = summarySource() + assertTrue( + "the run summary's title must take the complete line budget", + source.contains("maxLines = RUN_VIEW_TITLE_LINES"), + ) + assertTrue( + "the run summary's title must clip rather than ellipsise", + source.contains("overflow = TextOverflow.Clip"), + ) + } + + /** + * The summary leads with the run's identity: the title block is emitted + * before the artifacts section, and it owns the screen's top spacing and the + * section gap so it is neither jammed against the app bar nor glued to the + * section header below it. + */ + @Test + fun theRunSummaryLeadsWithItsTitleAndGivesItItsOwnSpacing() { + val source = summarySource() + val summary = source.indexOf("item(key = \"run-summary\")") + val artifacts = source.indexOf("title = artifactsHeader") + assertTrue("could not find the summary's identity item", summary >= 0) + assertTrue("could not find the artifacts section", artifacts >= 0) + assertTrue( + "the summary's title must lead before the artifacts section", + summary < artifacts, + ) + assertTrue( + "the summary's title must take the screen's top spacing", + source.contains("top = SUMMARY_TOP_SPACING"), + ) + assertTrue( + "the summary's title block must be separated from the artifacts section", + source.contains("bottom = SUMMARY_SECTION_GAP"), + ) + } + + /** + * Those two spacings are the app's own standard steps rather than numbers + * this screen invented: the leading clearance is the standard screen padding + * ([SPACING_L]) and the section gap is the standard stack step ([SPACING_S]), + * so the layout the scan above pins cannot quietly drift onto a value only + * the summary uses. + */ + @Test + fun theRunSummarySpacingUsesTheAppsStandardSteps() { + assertEquals(SPACING_L, SUMMARY_TOP_SPACING) + assertEquals(SPACING_S, SUMMARY_SECTION_GAP) + } + + private fun summarySource(): String { + val candidates = listOf( + "src/main/java/net/awan/pipelines/ui/screens/RunSummaryTab.kt", + "app/src/main/java/net/awan/pipelines/ui/screens/RunSummaryTab.kt", + ).map { File(System.getProperty("user.dir"), it) } + val source = candidates.firstOrNull { it.isFile } + assertTrue("could not locate RunSummaryTab.kt from ${System.getProperty("user.dir")}: $candidates", source != null) + return source!!.readText() + } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/changes/RunChangesTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/changes/RunChangesTest.kt new file mode 100644 index 00000000..41ee7939 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/changes/RunChangesTest.kt @@ -0,0 +1,346 @@ +package net.awan.pipelines.ui.changes + +import net.awan.pipelines.data.protocol.FileChange +import net.awan.pipelines.data.protocol.RunStep +import net.awan.pipelines.data.protocol.StageFileChanges +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 run summary's Changes model: the unified-patch parse (hunks, gutters, + * numbered lines, the true `+N -M`), the run-level aggregation across steps, and + * every honest state (binary, truncated, partial/unavailable capture, a recorded + * none, a historical null). Pure, so it is asserted without a device. + */ +class RunChangesTest { + + private val patch = """ + --- "a/a.txt" + +++ "b/a.txt" + @@ -1,3 +1,4 @@ + one + -two + +TWO + three + +four + """.trimIndent() + + @Test + fun parseUnifiedPatchReadsHunksLinesLineNumbersAndStat() { + val diff = parseUnifiedPatch(patch) + assertEquals(listOf("--- \"a/a.txt\"", "+++ \"b/a.txt\""), diff.headerLines) + assertEquals(1, diff.hunks.size) + val hunk = diff.hunks[0] + assertEquals("@@ -1,3 +1,4 @@", hunk.header) + assertEquals(1, hunk.oldStart) + assertEquals(3, hunk.oldCount) + assertEquals(1, hunk.newStart) + assertEquals(4, hunk.newCount) + assertEquals(2, diff.added) + assertEquals(1, diff.removed) + assertEquals( + listOf( + ChangeLine(ChangeLineKind.Context, "one", oldLine = 1, newLine = 1), + ChangeLine(ChangeLineKind.Remove, "two", oldLine = 2), + ChangeLine(ChangeLineKind.Add, "TWO", newLine = 2), + ChangeLine(ChangeLineKind.Context, "three", oldLine = 3, newLine = 3), + ChangeLine(ChangeLineKind.Add, "four", newLine = 4), + ), + hunk.lines, + ) + } + + @Test + fun parseUnifiedPatchReadsSeveralHunksAndDefaultsAMissingCount() { + val diff = parseUnifiedPatch( + """ + --- a/a.txt + +++ b/a.txt + @@ -1 +1 @@ + -old + +new + @@ -8,2 +10,2 @@ + eight + -nine + +NINE + """.trimIndent(), + ) + assertEquals(2, diff.hunks.size) + // A missing count is one line, per the unified-diff rule. + assertEquals(1, diff.hunks[0].oldCount) + assertEquals(1, diff.hunks[0].newCount) + assertEquals(1, diff.hunks[0].oldStart) + // The second hunk numbers from its own header, not the first hunk's end. + assertEquals(10, diff.hunks[1].newStart) + val second = diff.hunks[1].lines + assertEquals(ChangeLine(ChangeLineKind.Context, "eight", oldLine = 8, newLine = 10), second[0]) + assertEquals(ChangeLine(ChangeLineKind.Remove, "nine", oldLine = 9), second[1]) + assertEquals(ChangeLine(ChangeLineKind.Add, "NINE", newLine = 11), second[2]) + assertEquals(2, diff.added) + assertEquals(2, diff.removed) + } + + @Test + fun parseUnifiedPatchMarksAMissingNewlineAndDoesNotNumberIt() { + val diff = parseUnifiedPatch( + """ + --- a/a.txt + +++ b/a.txt + @@ -1 +1 @@ + -old + \ No newline at end of file + +new + \ No newline at end of file + """.trimIndent(), + ) + val lines = diff.hunks[0].lines + assertEquals(2, lines.count { it.noNewlineMarker }) + assertTrue(lines.first { it.noNewlineMarker }.noNewlineMarker) + // The marker carries no old/new number, so a renderer draws no gutter for it. + assertEquals(0, lines.first { it.noNewlineMarker }.oldLine) + assertEquals(0, lines.first { it.noNewlineMarker }.newLine) + assertEquals(1, diff.added) + assertEquals(1, diff.removed) + } + + @Test + fun parseUnifiedPatchOfADeletionWithAZeroCountHunkHeader() { + // A whole-file deletion: the new side ranges over zero lines. + val diff = parseUnifiedPatch( + """ + --- a/a.txt + +++ /dev/null + @@ -1,2 +0,0 @@ + -one + -two + """.trimIndent(), + ) + assertEquals(0, diff.added) + assertEquals(2, diff.removed) + assertEquals(0, diff.hunks[0].newCount) + assertEquals(0, diff.hunks[0].newStart) + } + + @Test + fun parseUnifiedPatchCountsTheBodyNotTheHeader() { + // A header whose counts disagree with the body must not misstate the stat: + // the `+N -M` is counted from the lines actually present. + val diff = parseUnifiedPatch( + """ + --- a/a.txt + +++ b/a.txt + @@ -1,99 +1,99 @@ + -gone + +added + """.trimIndent(), + ) + assertEquals(1, diff.added) + assertEquals(1, diff.removed) + } + + @Test + fun parseUnifiedPatchIsEmptyForABlankOrMissingPatch() { + assertEquals(FileDiff(raw = "", headerLines = emptyList(), hunks = emptyList(), added = 0, removed = 0), parseUnifiedPatch(null)) + assertEquals(FileDiff(raw = "", headerLines = emptyList(), hunks = emptyList(), added = 0, removed = 0), parseUnifiedPatch(" ")) + } + + @Test + fun kindAndStatHelpersReadTheServersTokens() { + assertEquals(ChangeKind.Added, changeKind("added")) + assertEquals(ChangeKind.Modified, changeKind("MODIFIED")) + assertEquals(ChangeKind.Deleted, changeKind("deleted")) + // An unknown token is never guessed into a real kind. + assertEquals(ChangeKind.Other, changeKind("renamed")) + assertEquals(ChangeKind.Other, changeKind("")) + assertEquals("added", changeKindLabel(ChangeKind.Added)) + assertEquals("+3 -2", changeStat(3, 2)) + assertEquals("+3", changeStat(3, 0)) + assertEquals("-2", changeStat(0, 2)) + assertEquals("", changeStat(0, 0)) + } + + @Test + fun runChangesAggregatesAFileAcrossStepsAndNamesEveryStage() { + val changes = runChanges( + listOf( + step(stage = "implementer", changes = capture(file("a.txt", "modified", patch))), + step(stage = "reviewer", changes = capture(file("a.txt", "modified", patch))), + ), + ) + assertEquals(1, changes.fileCount) + val file = changes.files.single() + assertEquals("a.txt", file.path) + assertEquals(ChangeKind.Modified, file.kind) + // One entry, both stages, and the stat summed over the two recorded patches. + assertEquals(listOf("implementer", "reviewer"), file.steps) + assertEquals(4, file.added) + assertEquals(2, file.removed) + assertEquals(4, changes.added) + assertEquals(2, changes.removed) + assertEquals("1 file changed · +4 -2", runChangesHeader(changes)) + } + + @Test + fun runChangesSeedsAndReseedsFileEntriesInFirstSeenOrder() { + val changes = runChanges( + listOf( + step(changes = capture(file("b.txt", "modified", patch), file("a.txt", "added", patch))), + step(stage = "committer", changes = capture(file("c.txt", "deleted", null))), + ), + ) + assertEquals(listOf("b.txt", "a.txt", "c.txt"), changes.files.map { it.path }) + } + + @Test + fun aBinaryFileCarriesNoRenderablePatch() { + val changes = runChanges( + listOf(step(changes = capture(FileChange(path = "shot.png", kind = "modified", binary = true)))), + ) + val file = changes.files.single() + assertTrue(file.binary) + assertFalse(file.hasPatch) + assertNull(file.patch) + assertTrue("binary" in changeEntryTags(file)) + } + + @Test + fun aTruncatedPatchIsTaggedAndMakesTheCapturePartial() { + val changes = runChanges( + listOf(step(changes = capture(file("big.kt", "modified", patch, truncated = true)))), + ) + assertTrue(changes.files.single().truncated) + assertTrue(changes.partial) + assertTrue("truncated" in changeEntryTags(changes.files.single())) + assertEquals("1 file changed · +2 -1 · partial capture", runChangesHeader(changes)) + assertTrue(runChangesNote(changes).startsWith("Partial capture")) + } + + @Test + fun aModeOnlyChangeIsReportedWithoutAFabricatedDiff() { + val changes = runChanges( + listOf( + step( + changes = capture( + FileChange(path = "run.sh", kind = "modified", beforeMode = "0644", afterMode = "0755"), + ), + ), + ), + ) + val file = changes.files.single() + assertTrue(file.modeChanged) + assertTrue(file.otherModeChange) + assertFalse(file.hasPatch) + assertTrue("mode change" in changeEntryTags(file)) + assertTrue(patchUnavailableReason(file).contains("mode")) + } + + @Test + fun anAddedFileDoesNotReadAsAModeChange() { + // An added file has no before-mode, so the mode pair must not be flagged. + val changes = runChanges( + listOf(step(changes = capture(FileChange(path = "new.kt", kind = "added", afterMode = "0644", patch = patch)))), + ) + assertFalse(changes.files.single().otherModeChange) + assertFalse(changes.files.single().modeChanged) + } + + @Test + fun anUnavailableOrPartialCaptureIsReportedHonestly() { + val unavailable = runChanges( + listOf( + step( + changes = StageFileChanges( + status = "unavailable", + diagnostic = "Workspace snapshot unavailable; changes could not be compared.", + ), + ), + ), + ) + assertEquals("Changes · capture unavailable", runChangesHeader(unavailable)) + assertTrue(runChangesNote(unavailable).contains("could not be compared")) + + val partial = runChanges( + listOf( + step( + changes = StageFileChanges( + status = "partial", + skipped = 2, + diagnostic = "Some patches were omitted/truncated by capture limits.", + files = listOf(file("a.txt", "modified", patch, truncated = true)), + ), + ), + ), + ) + assertEquals("1 file changed · +2 -1 · partial capture", runChangesHeader(partial)) + val note = runChangesNote(partial) + assertTrue(note.contains("2 files skipped")) + assertTrue(note.contains("1 truncated")) + } + + @Test + fun aRunWithNoRecordedChangesSaysSoRatherThanShowingAFabricatedDiff() { + // A capture that ran and observed nothing. + assertEquals("Changes · no changes observed", runChangesHeader(runChanges(listOf(step(changes = StageFileChanges(status = "complete")))))) + // A historical step whose capture predates the field (nil) is not "no changes". + assertEquals("Changes · not recorded for this run", runChangesHeader(runChanges(listOf(step(changes = null))))) + // A still-running step that has not captured yet. + assertEquals("Changes · capture pending", runChangesHeader(runChanges(listOf(step(status = "running", changes = null))))) + // Nothing at all. + assertEquals("Changes · not recorded for this run", runChangesHeader(runChanges(emptyList()))) + } + + @Test + fun theAncillaryHelpersReadConsistently() { + val changes = runChanges(listOf(step(changes = capture(file("a.txt", "modified", patch))))) + assertEquals("1 file changed · +2 -1", changesListSummary(changes)) + assertEquals("1 of 3", changePositionLabel(0, 3)) + assertEquals("3 of 3", changePositionLabel(2, 3)) + assertEquals(0, runChanges(emptyList()).fileCount) + assertTrue(runChanges(emptyList()).isEmpty) + } + + @Test + fun gutterWidthFitsTheWidestLineNumberInTheHunk() { + val diff = parseUnifiedPatch( + """ + --- a/a.txt + +++ b/a.txt + @@ -98,3 +98,3 @@ + a + -b + +B + """.trimIndent(), + ) + assertEquals(2, gutterWidth(diff.hunks.single())) + assertEquals(1, gutterWidth(parseUnifiedPatch( + """ + --- a/a.txt + +++ b/a.txt + @@ -1 +1 @@ + -a + +A + """.trimIndent(), + ).hunks.single())) + } + + // ---- builders ---------------------------------------------------------- + + private fun step( + stage: String = "implementer", + status: String = "succeeded", + changes: StageFileChanges?, + ): RunStep = RunStep(stage = stage, status = status, fileChanges = changes) + + private fun capture(vararg files: FileChange): StageFileChanges = + StageFileChanges(status = "complete", files = files.toList()) + + private fun file( + path: String, + kind: String, + patch: String?, + truncated: Boolean = false, + ): FileChange = FileChange(path = path, kind = kind, patch = patch, truncated = truncated) +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt index d9f5e03a..2e39fbb6 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt @@ -138,6 +138,15 @@ class ChatFormatTest { assertNull(toolEditDiff(JsonObject(mapOf("command" to JsonPrimitive("ls"))))) } + @Test + fun theSharedDiffVocabularySpellsEachKindOnce() { + // The one spelling of a unified-diff marker, shared by the chat's edit + // card and the run summary's changes viewer. + assertEquals("+", diffLineSymbol(DiffKind.ADD)) + assertEquals("-", diffLineSymbol(DiffKind.REMOVE)) + assertEquals(" ", diffLineSymbol(DiffKind.CONTEXT)) + } + @Test fun toolFailedOnlyForTheErrorStatus() { assertTrue(toolFailed(ChatToolState(status = ChatProtocol.TOOL_ERROR))) diff --git a/docs/notes/run-summary-title-spacing.md b/docs/notes/run-summary-title-spacing.md new file mode 100644 index 00000000..4abd7ea9 --- /dev/null +++ b/docs/notes/run-summary-title-spacing.md @@ -0,0 +1,55 @@ +# Run summary: title spacing, section gap, and the server's title cap + +Item: the run summary's title was reported glued to the top of the pane, glued to +the artifacts section, and "cut off". Android-only change (`android/`). + +## What changed + +- `android/app/src/main/java/net/awan/pipelines/ui/screens/RunSummaryTab.kt`: the + summary now leads with the run's identity block (title, status row, facts) and + the artifacts collapsible section follows it; the identity block carries the + screen's standard top spacing above it and the standard stack step below it. + The title keeps `maxLines = RUN_VIEW_TITLE_LINES` (`Int.MAX_VALUE`) and + `TextOverflow.Clip`. +- `android/app/src/main/java/net/awan/pipelines/ui/theme/Dimens.kt`: two named + tokens, `SUMMARY_TOP_SPACING` (= `SPACING_L`) and `SUMMARY_SECTION_GAP` + (= `SPACING_S`); no new number, no raw `dp` at the call site. +- `android/app/src/test/java/net/awan/pipelines/ui/RunTitlesTest.kt`: the + run-identity/title-line test gained the source-scan cases pinning the title's + budget/`Clip`, the identity block leading the artifacts section, its two + spacing tokens' call sites, and their values. + +## Confirmed runtime limitation: a run title is capped at 80 runes by the server + +The "cut off" title is not app-side clipping. The app renders the whole string it +is given: `runLabel` (`ui/RunIdentity.kt`) does not shorten a title and the +summary's title line takes `RUN_VIEW_TITLE_LINES = Int.MAX_VALUE` with +`TextOverflow.Clip`. The string itself is bounded before it reaches the app: + +- `internal/summarise/summarise.go` defines `TitleCap = 80` runes and applies it + through `capRunes` in `Title` (model-derived), `DeriveTitle` (prompt fallback) + and `ExplicitTitle` (`--title`/rename), so every stored run title is already + capped when the server persists it. +- Evidence (18 Oct 2026): `pipelines inspect 347` returns + `"title": "Two chat UX gaps: the working indicator does not distinguish thinking from waiti"` + — exactly 80 runes, ending mid-word — while that run's input prompt's first line + is 82 runes (`… from waiting`). A `uiautomator` dump of the run summary shows + the same 80-rune string, i.e. the app holds exactly what the server stored. + +So a title can end mid-word by design of the server's cap, and no Android change +can render the missing characters. Widening or raising `TitleCap` is a +Pipelines-server change (Go), outside this item's Android-only scope and not +something this item deploys. + +## Documentation now stale (for `docs-fold`) + +- `android/README.md`, section "Run title readability: whole in the run view, two + lines in the list (17 Oct 2026)" (~line 6278): says the run view "guarantees the + operator can read it whole". It should also state that the stored title is + itself capped at 80 runes by `internal/summarise/summarise.go` (`TitleCap`), so + "whole" means the complete stored title, which can end mid-word; only the app's + own renderer is guaranteed not to shorten it. +- `android/README.md`, section "Collapsible artifacts gallery in the run summary + (16 Oct 2026)" (~line 4130-4136): "The order is unchanged: the artifacts section + still leads the summary and the facts item follows it" is now wrong — the + summary leads with the identity block and the artifacts section follows.