Merge main into slash-commands: combine the composer's slash commands with the

server-side chat close

What was combined:

- main brought the server-side close (chat_close/chat_reopen over the protocol,
  PipelinesRepository.chatClose/chatReopen, ChatStore.sessionClosed/sessionReopened
  and active/closed session projections, the list's Close chat… confirmation and
  the Closed chip), plus the destinations-pill overlay and the omni-search and
  status-label work from the lanes that landed beside this one.
- this branch brought the composer's slash commands: parsing, the filtered offer
  list with Enter/tap/D-pad, the shared prompt path, /new in the current
  directory, the local /rename, /stop, /help and the unknown-command offer, with
  local command lines rendered outside the model's conversation.

Resolution (the one place the two sides disagreed):

The branch's /close reported that no real session close existed, because none did
when it was written. main now has one, so /close delegates to it instead:
AppViewModel.SessionChatCommandHost.finishSession calls closeChatSession, which
uses the server's own chat_close (a running turn is stopped, the session is marked
closed for every client, the history is kept), and then chatStore.close returns the
operator to the list. A failure is reported on the list, where the list's own close
reports it. The now-false "this build has no real session close yet" line and its
CHAT_CLOSE_UNAVAILABLE constant are removed, /close's offer summary says it
finishes the session for every client, and its test now drives the real store
close (sessionClosed + close) and asserts the row is closed, kept as history and
off the pane.

Checks run after resolving, on the merged tree (HEAD = this merge):
`--offline --no-daemon :app:assembleDebug` BUILD SUCCESSFUL, and
`:app:testDebugUnitTest` BUILD SUCCESSFUL with 646 tests, 0 failures (including
ChatCommandsTest.closeDelegatesToTheRealServerCloseAndReturnsToTheList). DimensTest
still holds: no raw dimension was added outside the token files. The packaged
templates and packaged authoring skill references are unaffected — this is an
Android-app-only change with no protocol, server, installer or Docker change — so
none of them needed updating.

Documentation now stale (not edited here; one writer folds shared docs):
android/README.md's chat section describes the composer and the session list
without the slash commands (vocabulary, offer list, unknown-command guard) and
without the composer's /close path to the server close.
This commit is contained in:
2026-10-18 00:24:41 +01:00
46 changed files with 2111 additions and 265 deletions
@@ -333,6 +333,26 @@ class PipelinesRepository(
client.call(ChatProtocol.interruptRequest(sessionId))
}
/**
* Finishes a chat on the server: any running turn is stopped and the session
* is recorded closed, so every client sees it. Nothing is deleted. The
* server returns the closed session, which the caller folds into its list.
*/
suspend fun chatClose(sessionId: String): ChatSession {
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
val response = client.call(ChatProtocol.closeRequest(sessionId))
return response.chatSession
?: throw ProtocolException("The server did not return the closed chat session.")
}
/** Clears a closed chat's state so it returns to the active list. */
suspend fun chatReopen(sessionId: String): ChatSession {
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
val response = client.call(ChatProtocol.reopenRequest(sessionId))
return response.chatSession
?: throw ProtocolException("The server did not return the reopened chat session.")
}
suspend fun chatReply(sessionId: String, requestId: String, decision: String, message: String = "") {
if (sessionId.isBlank() || requestId.isBlank()) {
throw ProtocolException("A pending permission request is required.")
@@ -33,6 +33,26 @@ data class ChatSession(
// run. Kept for wire compatibility; the server no longer sets it, and a
// session is never read-only for a client.
val busy: Boolean = false,
// The operator finished with this session: the server recorded it as closed,
// so every client sees the same state. The session, its transcript and its
// history are kept and the closed chat stays in the list (grouped as history),
// where it can be reopened. [closedAt] is the epoch-millisecond close time, 0
// while open. Additive/optional, so an older server simply never sets them.
val closed: Boolean = false,
@SerialName("closed_at") val closedAt: Long = 0,
)
/**
* The outcome of a `chat_close`, mirroring `internal/protocol/chat.go`
* ChatCloseResult: the closed session's id, the epoch-millisecond close time and
* whether an in-flight turn was interrupted to stop it. It is the record that a
* running turn was stopped.
*/
@Serializable
data class ChatCloseResult(
@SerialName("session_id") val sessionId: String = "",
@SerialName("closed_at") val closedAt: Long = 0,
val interrupted: Boolean = false,
)
@Serializable
@@ -288,6 +308,24 @@ object ChatProtocol {
fun interruptRequest(sessionId: String): Message =
Message(type = Protocol.CHAT_INTERRUPT, chatQuery = ChatQuery(sessionId = sessionId))
/**
* The `chat_close` frame that finishes [sessionId]: the server stops any
* running turn (through the same interrupt) and records the session closed on
* the server, sharing the state with every client. Nothing is deleted. Built
* here (not inline in the repository) so production and its unit test share
* the one wire shape.
*/
fun closeRequest(sessionId: String): Message =
Message(type = Protocol.CHAT_CLOSE, chatQuery = ChatQuery(sessionId = sessionId))
/**
* The `chat_reopen` frame that clears a closed session's state so it returns
* to the active list; the inverse of [closeRequest]. Built here so production
* and its unit test share the one wire shape.
*/
fun reopenRequest(sessionId: String): Message =
Message(type = Protocol.CHAT_REOPEN, chatQuery = ChatQuery(sessionId = sessionId))
/**
* The `chat_reply` frame that answers one permission request: [decision] is
* one of [DECISION_ONCE]/[DECISION_ALWAYS]/[DECISION_REJECT]. Built here (not
@@ -68,6 +68,11 @@ object Protocol {
const val CHAT_MESSAGES = "chat_messages"
const val CHAT_INTERRUPT = "chat_interrupt"
const val CHAT_REPLY = "chat_reply"
// Close/reopen an operator session on the server (its closed state is
// recorded so every client sees it). Both ride on chat_query like
// chat_interrupt; chat_close also carries a ChatCloseResult on the response.
const val CHAT_CLOSE = "chat_close"
const val CHAT_REOPEN = "chat_reopen"
// Attaches this connection to one session's shared live stream, so every
// client watching a session receives every frame any client's turn produces.
const val CHAT_SUBSCRIBE = "chat_subscribe"
@@ -688,5 +693,8 @@ data class Message(
@SerialName("chat_event") val chatEvent: ChatEventFrame? = null,
@SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null,
@SerialName("chat_reply") val chatReply: ChatReplyRequest? = null,
// The outcome of a chat_close (session id, closed_at, interrupted); the
// close/reopen requests themselves ride on chat_query like chat_interrupt.
@SerialName("chat_close") val chatClose: ChatCloseResult? = null,
@SerialName("chat_directories") val chatDirectories: List<String>? = null,
)
@@ -41,7 +41,6 @@ import net.awan.pipelines.data.transport.ServerUrl
import net.awan.pipelines.notify.NoRunAlerts
import net.awan.pipelines.notify.RunAlertSink
import net.awan.pipelines.notify.runAlerts
import net.awan.pipelines.ui.chat.CHAT_CLOSE_UNAVAILABLE
import net.awan.pipelines.ui.chat.ChatAttachment
import net.awan.pipelines.ui.chat.ChatCommandHost
import net.awan.pipelines.ui.chat.ChatSessionOverrides
@@ -1157,6 +1156,9 @@ class AppViewModel(
// is one waiting behind an in-flight turn, and the composer says so
// instead of blocking input.
chatStore.setQueued(sessionId, queued)
// Prompting a closed session reopens it on the server; clear the
// closed mark locally too so the list agrees without a re-fetch.
chatStore.sessionReopened(sessionId)
} catch (t: Throwable) {
if (t is CancellationException) throw t
val message = ErrorMessages.describe(t)
@@ -1202,8 +1204,8 @@ class AppViewModel(
* The real effects behind a slash command. `/new` creates in the current
* session's directory and switches to it (the old one stays open, listed, with
* its history); `/rename` uses the device's own rename; `/stop` interrupts;
* `/close` reports that this build has no real close instead of hiding the
* session. Nothing here is ever a prompt.
* `/close` finishes the session for every client through the server's own
* close and returns to the list. Nothing here is ever a prompt.
*/
private inner class SessionChatCommandHost(private val sessionId: String) : ChatCommandHost {
override fun startSession(directory: String) {
@@ -1228,9 +1230,13 @@ class AppViewModel(
}
override fun finishSession() {
// No session close exists in this revision: the honest answer, never
// the local hide dressed up as one.
chatStore.notice(sessionId, CHAT_CLOSE_UNAVAILABLE, failed = true)
// The server's own close: any running turn is stopped and the session
// is marked closed for every client, with its history kept. Then the
// conversation leaves the pane, so the operator is back at the list,
// where the closed chat sits as history. A failure is reported on the
// list — the same place the list's own close reports it.
closeChatSession(sessionId)
chatStore.close(sessionId)
}
override fun renameSession(title: String) {
@@ -1284,6 +1290,44 @@ class AppViewModel(
}
}
/**
* Finishes a chat on the server: any running turn is stopped (the server
* reuses its interrupt) and the session is recorded closed, so every client
* sees the same state. Nothing is deleted — the session and its history stay —
* and the chat is kept in the list as closed history. Errors are reported on
* the list, which is where the action lives.
*/
fun closeChatSession(sessionId: String) {
if (sessionId.isBlank()) return
viewModelScope.launch {
try {
val closed = repository.chatClose(sessionId)
chatStore.sessionClosed(sessionId, closed.closedAt)
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.sessionsFailed(ErrorMessages.describe(t))
}
}
}
/**
* Reopens a closed chat so it returns to the active list. Sending another
* message also reopens it (the server clears the closed state on prompt), so
* this is the explicit path beside that one.
*/
fun reopenChatSession(sessionId: String) {
if (sessionId.isBlank()) return
viewModelScope.launch {
try {
repository.chatReopen(sessionId)
chatStore.sessionReopened(sessionId)
} catch (t: Throwable) {
if (t is CancellationException) throw t
chatStore.sessionsFailed(ErrorMessages.describe(t))
}
}
}
private fun <T> load(target: MutableStateFlow<LoadState<T>>, block: suspend () -> T) {
viewModelScope.launch {
target.value = target.value.copy(loading = true, error = null)
@@ -32,6 +32,7 @@ import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
@@ -60,19 +61,27 @@ import net.awan.pipelines.ui.chat.ChatScreen
import net.awan.pipelines.ui.components.AttentionIndicator
import net.awan.pipelines.ui.components.AttentionSheet
import net.awan.pipelines.ui.components.ConnectionBanner
import net.awan.pipelines.ui.components.LocalPillBottomInset
import net.awan.pipelines.ui.components.MotionStandard
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.spec
import net.awan.pipelines.ui.screens.SettingsScreen
import net.awan.pipelines.ui.theme.ATTENTION_CHIP_RESERVE
import net.awan.pipelines.ui.theme.DESTINATION_PILL_RESERVE
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_S
/** One destination the floating pill holds: its nav [route], the accessible [label] and its glyph. */
internal data class TopDestination(val route: String, val label: String, val icon: ImageVector)
private val destinations = listOf(
/**
* The pill's destinations, in display order. Templates is deliberately absent: it
* is configuration, reached from the Settings page instead, so the pill holds only
* the surfaces a person moves between constantly. The pill's width derives from
* this list (its icon row), never a fixed value, so removing a destination only
* narrows it.
*/
internal val destinations = listOf(
TopDestination("pipelines", "Pipelines", Icons.Default.AccountTree),
TopDestination("templates", "Templates", TemplatesIcon),
TopDestination("runs", "Runs", Icons.Default.History),
TopDestination("chat", "Chat", Icons.AutoMirrored.Filled.Chat),
TopDestination("settings", "Settings", Icons.Default.Settings),
@@ -272,74 +281,78 @@ fun PipelinesApp(
// screens' app bars (a Material 3 TopAppBar applies the top safe-area inset),
// which removed the duplicate top band. The bottom is owned by each screen's
// Scaffold, and the floating pill explicitly clears the safe area (system
// bars, cutout, gesture area and IME) via windowInsetsPadding. The Column
// reserves DESTINATION_PILL_RESERVE at the bottom so no scrollable content is
// permanently hidden behind the pill; while the pill is hidden (an open
// conversation, see [destinationPillVisible]) that reservation is dropped too,
// so the composer sits at the true bottom instead of over an empty band.
// bars, cutout, gesture area and IME) via windowInsetsPadding.
//
// The pill is a true overlay: it is drawn in its own bottom-anchored layer over
// the content and never takes layout space, so the content keeps its full
// height. Nothing is positioned by the pill; its bottom clearance
// ([pillScrollInset], published through [LocalPillBottomInset]) is applied
// inside each scrollable screen's own scroll content, so scrolling to the end
// still reveals the last row clear of the pill, and while the pill is hidden
// (an open conversation, see [destinationPillVisible]) that clearance is zero
// so a hidden pill leaves no empty band. See [contentPillPadding].
val bannerVisible = connectionState !is ConnectionState.Connected
Scaffold(contentWindowInsets = WindowInsets(0, 0, 0, 0)) { padding ->
Box(Modifier.fillMaxSize().padding(padding)) {
Column(Modifier.fillMaxSize().padding(bottom = destinationPillReserve(pillVisible) + ATTENTION_CHIP_RESERVE)) {
ConnectionBanner(
state = connectionState,
configuredUrl = configuredUrl,
onReconnect = vm::reconnect,
)
NavHost(
navController = navController,
startDestination = "pipelines",
// While the banner is visible it owns the status-bar inset, so
// the inner app bars below must not apply it a second time.
modifier = Modifier
.weight(1f)
.then(
if (bannerVisible) {
Modifier.consumeWindowInsets(
paneSafeArea().only(WindowInsetsSides.Top),
)
} else {
Modifier
},
),
) {
composable("pipelines") {
PipelineDestination(
vm = vm,
wide = wide,
selection = pipelineSelection,
onSelectionChange = { pipelineSelection = it },
listState = pipelineListState,
onOpenRun = { runId ->
runSelection = PaneSelection(
pane = MasterPane.Detail,
itemId = runId,
)
navController.navigate("runs") { launchSingleTop = true }
},
)
}
composable("runs") {
RunsDestination(
vm = vm,
wide = wide,
selection = runSelection,
onSelectionChange = { runSelection = it },
pendingNav = runSearchNav,
onPendingNavResolved = { runSearchNav = null },
listState = runListState,
decisionRequest = decisionRequest,
onDecisionRequestHandled = { decisionRequest = null },
)
}
composable("chat") {
ChatScreen(vm = vm, wide = wide)
}
composable("templates") {
TemplatesDestination(vm = vm, wide = wide, listState = templateListState)
}
composable("settings") {
SettingsScreen(vm, wide = wide)
CompositionLocalProvider(LocalPillBottomInset provides pillScrollInset(pillVisible)) {
Column(Modifier.fillMaxSize().padding(bottom = contentPillPadding(pillVisible))) {
ConnectionBanner(
state = connectionState,
configuredUrl = configuredUrl,
onReconnect = vm::reconnect,
)
NavHost(
navController = navController,
startDestination = "pipelines",
// While the banner is visible it owns the status-bar inset, so
// the inner app bars below must not apply it a second time.
modifier = Modifier
.weight(1f)
.then(
if (bannerVisible) {
Modifier.consumeWindowInsets(
paneSafeArea().only(WindowInsetsSides.Top),
)
} else {
Modifier
},
),
) {
composable("pipelines") {
PipelineDestination(
vm = vm,
wide = wide,
selection = pipelineSelection,
onSelectionChange = { pipelineSelection = it },
listState = pipelineListState,
onOpenRun = { runId ->
runSelection = PaneSelection(
pane = MasterPane.Detail,
itemId = runId,
)
navController.navigate("runs") { launchSingleTop = true }
},
)
}
composable("runs") {
RunsDestination(
vm = vm,
wide = wide,
selection = runSelection,
onSelectionChange = { runSelection = it },
pendingNav = runSearchNav,
onPendingNavResolved = { runSearchNav = null },
listState = runListState,
decisionRequest = decisionRequest,
onDecisionRequestHandled = { decisionRequest = null },
)
}
composable("chat") {
ChatScreen(vm = vm, wide = wide)
}
composable("settings") {
SettingsDestination(vm = vm, wide = wide, listState = templateListState)
}
}
}
}
@@ -362,21 +375,29 @@ fun PipelinesApp(
// Composed after the NavHost, so while the field is open Back (button
// or gesture) dismisses the morph before any pane's own Back handler.
BackHandler(enabled = searchState.open) { dismissSearch() }
// The results panel and the destination bar share one bottom-anchored,
// inset-clearing column. `paneSafeArea` (WindowInsets.safeDrawing) is
// applied once here: the panel then takes exactly the height the IME and
// navigation bar leave (weight, `fill = false` so a short panel wraps)
// and scrolls inside it, and the input always sits directly below the
// panel and above the keyboard. The activity declares `adjustResize`
// and the app is edge-to-edge, so the Compose window inset is the only
// source of the IME geometry and it is applied once, here.
// The results panel, the attention chip and the destination bar share
// one bottom-anchored, inset-clearing column — the overlay layer, drawn
// above the content and never part of its layout. `paneSafeArea`
// (WindowInsets.safeDrawing) is applied once here, so the pill clears the
// system bars, cutout, gesture area and IME: the panel then takes exactly
// the height the IME and navigation bar leave (weight, `fill = false` so
// a short panel wraps) and scrolls inside it, and the input always sits
// directly below the panel and above the keyboard. The activity declares
// `adjustResize` and the app is edge-to-edge, so the Compose window inset
// is the only source of the IME geometry and it is applied once, here.
//
// The overlay's resting place is the window width's in [destinationPillAlignment]:
// horizontally centred on a narrow window, anchored to the bottom-right
// corner on a wide one. Its margin comes from the named [SPACING_L], so the
// corner placement adds no new number. That rule positions the pill; the
// attention chip above it keeps its own bottom-right place at every width.
Column(
modifier = Modifier
.fillMaxSize()
.windowInsetsPadding(paneSafeArea())
.padding(end = 16.dp, bottom = 16.dp),
.padding(end = if (wide) SPACING_L else 0.dp, bottom = SPACING_L),
verticalArrangement = Arrangement.Bottom,
horizontalAlignment = Alignment.End,
horizontalAlignment = destinationPillAlignment(wide),
) {
if (searchState.open) {
SearchResultsPanel(
@@ -389,13 +410,17 @@ fun PipelinesApp(
modifier = Modifier
.fillMaxWidth()
.weight(1f, fill = false)
.padding(bottom = 16.dp),
.padding(bottom = SPACING_L),
)
}
// The attention chip is not part of the pill's placement rule: it
// keeps its own bottom-right resting place at every width (as it
// had before the pill became width-dependent), so only the pill
// follows [destinationPillAlignment].
AttentionIndicator(
entries = attention,
onClick = { attentionOpen = true },
modifier = Modifier.padding(bottom = SPACING_S),
modifier = Modifier.align(Alignment.End).padding(bottom = SPACING_S),
)
// The pill stands down while a conversation is open; the search
// field it morphs into is unreachable there anyway (the field opens
@@ -469,14 +494,40 @@ internal fun destinationPillVisible(currentRoute: String?, conversationOpen: Boo
!(currentRoute == CHAT_ROUTE && conversationOpen)
/**
* The bottom space the content reserves for the pill: the named
* [DESTINATION_PILL_RESERVE] while the pill is drawn, and none while it is
* hidden, so a hidden pill leaves no empty band at the end of scrollable content
* and the composer sits at the true bottom. Derived from [pillVisible] alone, so
* the reservation and the drawn pill can never disagree into a frame with a
* drawn pill over content it does not clear, or a reserved gap behind a hidden
* one — which is what keeps the content from jumping as the pill appears and
* disappears.
* Where the bottom overlay — the destination pill and the attention chip above it
* — rests in the window: horizontally centred on a **narrow** window and anchored
* to the bottom-right **corner** on a **wide** one. The overlay is drawn above the
* content and never takes layout space either way, so this is purely where it
* sits. A pure function of the window width, so the one arrangement rule is
* unit-testable and no screen hardcodes a width.
*/
internal fun destinationPillReserve(pillVisible: Boolean): Dp =
if (pillVisible) DESTINATION_PILL_RESERVE else 0.dp
internal fun destinationPillAlignment(wide: Boolean): Alignment.Horizontal =
if (wide) Alignment.End else Alignment.CenterHorizontally
/**
* The bottom padding the app's content column applies for the pill: none, whether
* the pill is [pillVisible] or not. The pill is an overlay drawn above the
* content, so it must never size or offset it — the content keeps its own full
* height and the pill's clearance lives in each scrollable's own scroll content
* (see [pillScrollInset]). The value is a function of the drawn state (both of
* which the unit test pins at zero) rather than left implicit in an absent
* modifier, so a later change that reintroduces a reserved band here fails the
* test.
*/
internal fun contentPillPadding(pillVisible: Boolean): Dp = 0.dp
/**
* The trailing bottom space a scrollable screen keeps so its last row scrolls clear
* of the floating bottom stack — the destination pill and the attention chip above
* it — built from the named [DESTINATION_PILL_RESERVE] and [ATTENTION_CHIP_RESERVE]
* while the pill is drawn, and none while it is hidden (an open conversation, see
* [destinationPillVisible]) so a hidden pill leaves no empty band at the end of a
* list. Published to the content through `LocalPillBottomInset` and applied inside
* each scrollable's own scroll content, never as layout padding on the content. It
* is derived from [pillVisible] alone, so the clearance and the drawn pill can
* never disagree into a frame with a drawn pill over content it does not clear, or
* a reserved gap behind a hidden one — which is what keeps a list from jumping as
* the pill appears and disappears.
*/
internal fun pillScrollInset(pillVisible: Boolean): Dp =
if (pillVisible) DESTINATION_PILL_RESERVE + ATTENTION_CHIP_RESERVE else 0.dp
@@ -0,0 +1,89 @@
package net.awan.pipelines.ui
import androidx.activity.compose.PredictiveBackHandler
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Settings
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import kotlinx.coroutines.flow.collect
import net.awan.pipelines.ui.components.SlidingPaneStack
import net.awan.pipelines.ui.components.rememberPaneContent
import net.awan.pipelines.ui.screens.SettingsScreen
import net.awan.pipelines.ui.screens.TemplateDetailScreen
import net.awan.pipelines.ui.screens.TemplateGalleryScreen
/**
* The Settings destination: the same shared pane stack the other destinations
* use, with the settings page as pane 0 and the templates gallery it opens from
* its Templates row as pane 1 and the selected template's detail as pane 2.
* Templates is configuration, so it is one of the settings destinations rather
* than a floating-pill entry; the gallery is the existing [TemplateGalleryScreen]
* (and its detail the existing [TemplateDetailScreen]), so no second templates
* surface is built. Its selection is saved state, so it survives rotation,
* configuration change and process death; the covered-pane strip, the back gesture
* and the pane's own back control all step exactly one level via [settingsBack].
* Nothing here starts a run.
*/
@Composable
internal fun SettingsDestination(
vm: AppViewModel,
wide: Boolean,
listState: LazyListState,
) {
var selection by rememberSaveable(stateSaver = SettingsSelectionSaver) {
mutableStateOf(SettingsSelection())
}
val depth = selection.depth
val onBack: () -> Unit = { selection = settingsBack(selection) }
PredictiveBackHandler(enabled = depth >= 1) { progress ->
// Consume the gesture; on completion perform exactly one Back step.
progress.collect { }
onBack()
}
SlidingPaneStack(
depth = depth,
wide = wide,
onPopTo = { level -> selection = settingsPopTo(selection, level) },
compactLabel = "Settings",
compactIcon = Icons.Filled.Settings,
backContentDescription = { level ->
if (level == 0) "Back to settings" else "Back to templates"
},
pane = { level, covered, paneModifier ->
when (level) {
0 -> SettingsScreen(
vm = vm,
onOpenTemplates = { selection = openTemplatesGallery(selection) },
wide = wide,
modifier = paneModifier,
covered = covered,
)
1 -> TemplateGalleryScreen(
vm = vm,
wide = wide,
onOpen = { key -> selection = openTemplateDetail(selection, key) },
listState = listState,
modifier = paneModifier,
covered = covered,
)
2 -> rememberPaneContent(selection.templateKey)?.let { key ->
TemplateDetailScreen(
vm = vm,
templateKey = key,
onBack = onBack,
wide = wide,
modifier = paneModifier,
covered = covered,
)
}
}
},
)
}
@@ -0,0 +1,86 @@
package net.awan.pipelines.ui
import androidx.compose.runtime.saveable.Saver
/**
* Which pane of the Settings destination's sliding stack is rightmost: the
* settings page itself (level 0), the templates gallery opened from its Templates
* row (level 1) or the selected template's detail (level 2). Templates is
* configuration, so it is one of the settings destinations reached from the
* Settings page rather than an entry in the floating destination pill; modelling
* the stack here is what gives the gallery the same covered-pane strip and
* one-level Back step the other destinations use.
*/
internal enum class SettingsPane(val level: Int) {
Settings(0),
Gallery(1),
Template(2),
}
/**
* The Settings destination's saved pane selection. The only state beyond the
* rightmost pane is the open template's key, so the whole selection is
* Bundle-able primitives and survives rotation, configuration change and process
* death. Geometry (peek widths, insets) is deliberately not part of the model; it
* is derived from layout by the shared stack.
*/
internal data class SettingsSelection(
val pane: SettingsPane = SettingsPane.Settings,
val templateKey: String? = null,
) {
/** How many panes are stacked: 0 settings, 1 gallery, 2 template detail. */
val depth: Int
get() = pane.level
}
/** The Settings page's Templates row opens the gallery as its own pane. */
internal fun openTemplatesGallery(selection: SettingsSelection): SettingsSelection =
selection.copy(pane = SettingsPane.Gallery, templateKey = null)
/** A gallery card opens the selected template's detail as the next pane. */
internal fun openTemplateDetail(selection: SettingsSelection, key: String): SettingsSelection =
selection.copy(pane = SettingsPane.Template, templateKey = key)
/**
* Exactly one pane level of Back, so the back gesture, the covered strip's tap and
* the detail's own back control all step the same single level: detail → gallery →
* settings. At settings there is nothing to close and the selection is unchanged,
* so the caller lets Back leave the destination.
*/
internal fun settingsBack(selection: SettingsSelection): SettingsSelection = when (selection.pane) {
SettingsPane.Settings -> selection
SettingsPane.Gallery -> selection.copy(pane = SettingsPane.Settings, templateKey = null)
SettingsPane.Template -> selection.copy(pane = SettingsPane.Gallery, templateKey = null)
}
/**
* The selection after tapping a covered pane's strip at [level]: every pane to its
* right is closed. Level 0 closes back to the settings page, level 1 closes the
* template detail back to the gallery, and a [level] at or beyond the current
* depth is a no-op. Peeks exist only on a wide window; narrow windows use
* Back/gesture for the same one-level step.
*/
internal fun settingsPopTo(selection: SettingsSelection, level: Int): SettingsSelection = when {
level <= 0 -> SettingsSelection()
level == 1 -> selection.copy(pane = SettingsPane.Gallery, templateKey = null)
else -> selection
}
/**
* Encodes a [SettingsSelection] as Bundle-able primitives. Paired with
* [decodeSettingsSelection].
*/
internal fun encodeSettingsSelection(selection: SettingsSelection): List<Any> =
listOf(selection.pane.name, selection.templateKey ?: "")
/** Restores a [SettingsSelection] encoded by [encodeSettingsSelection]. */
internal fun decodeSettingsSelection(encoded: List<Any>): SettingsSelection = SettingsSelection(
pane = SettingsPane.valueOf(encoded[0] as String),
templateKey = (encoded[1] as String).takeIf { it.isNotEmpty() },
)
/** Saves/restores a [SettingsSelection] across configuration change and process death. */
internal val SettingsSelectionSaver: Saver<SettingsSelection, List<Any>> = Saver(
save = { encodeSettingsSelection(it) },
restore = { decodeSettingsSelection(it) },
)
@@ -1,70 +0,0 @@
package net.awan.pipelines.ui
import androidx.activity.compose.PredictiveBackHandler
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import kotlinx.coroutines.flow.collect
import net.awan.pipelines.ui.components.SlidingPaneStack
import net.awan.pipelines.ui.components.rememberPaneContent
import net.awan.pipelines.ui.screens.TemplateDetailScreen
import net.awan.pipelines.ui.screens.TemplateGalleryScreen
/**
* The Templates destination: the same shared pane stack, with the template
* gallery as pane 0 and the selected template's detail as pane 1. The selected
* template key is the saved state, so it survives rotation, configuration change
* and process death; Back/the peek pop one level. Nothing here starts a run.
*/
@Composable
internal fun TemplatesDestination(
vm: AppViewModel,
wide: Boolean,
listState: LazyListState,
) {
var selectedKey by rememberSaveable { mutableStateOf<String?>(null) }
val depth = if (selectedKey == null) 0 else 1
val onBack: () -> Unit = { selectedKey = null }
PredictiveBackHandler(enabled = depth >= 1) { progress ->
progress.collect { }
onBack()
}
SlidingPaneStack(
depth = depth,
wide = wide,
onPopTo = { level -> if (level <= 0) selectedKey = null },
compactLabel = "Templates",
compactIcon = TemplatesIcon,
backContentDescription = { level ->
if (level == 0) "Back to templates" else "Back to template"
},
pane = { level, covered, paneModifier ->
when (level) {
0 -> TemplateGalleryScreen(
vm = vm,
wide = wide,
onOpen = { key -> selectedKey = key },
listState = listState,
modifier = paneModifier,
covered = covered,
)
1 -> rememberPaneContent(selectedKey)?.let { key ->
TemplateDetailScreen(
vm = vm,
templateKey = key,
onBack = onBack,
wide = wide,
modifier = paneModifier,
covered = covered,
)
}
}
},
)
}
@@ -25,15 +25,15 @@ internal const val CHAT_COMMAND_HELP = "help"
* terminal's own vocabulary is the model here (`:status`, `:logs`, …): a command
* acts on the chat surface itself and is never sent to the agent.
*
* `/close` is shown as unavailable in this revision: the server has no request
* that finishes a session for every client yet, and the app will not pretend the
* local "remove from list" is that close.
* `/close` is the server's own close (`chat_close`, shared by every client), not
* the local "remove from list": the chat is finished for every device, its
* history is kept, and it can be reopened.
*/
internal val CHAT_COMMANDS: List<ChatCommand> = listOf(
ChatCommand(CHAT_COMMAND_NEW, "Start a fresh session in this directory", "/new"),
ChatCommand(
CHAT_COMMAND_CLOSE,
"Finish this session for every client (not available in this build)",
"Finish this session for every client, keeping its history",
"/close",
),
ChatCommand(CHAT_COMMAND_RENAME, "Rename this session on this device", "/rename <title>", takesArgument = true),
@@ -211,8 +211,3 @@ internal fun runChatSlashCommand(text: String, thread: ChatThread, host: ChatCom
is ChatCommandEffect.Report -> host.notify(effect.text, failed = true, offer = effect.offer)
}
}
/** What `/close` says in this revision, where no real session close exists. */
internal const val CHAT_CLOSE_UNAVAILABLE =
"Can't finish this session: this build has no real session close yet, so nothing was " +
"changed. The session stays open and listed; no local hide was used instead."
@@ -3,6 +3,7 @@ package net.awan.pipelines.ui.chat
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
@@ -33,6 +34,7 @@ import net.awan.pipelines.ui.AppViewModel
import net.awan.pipelines.ui.components.ErrorState
import net.awan.pipelines.ui.components.ListRow
import net.awan.pipelines.ui.components.LoadingState
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
import net.awan.pipelines.ui.theme.pipelinesText
@@ -85,7 +87,10 @@ internal fun NewChatPane(
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
)
LazyColumn(Modifier.weight(1f).fillMaxWidth()) {
LazyColumn(
modifier = Modifier.weight(1f).fillMaxWidth(),
contentPadding = pillContentPadding(PaddingValues()),
) {
items(choices, key = { it.createDirectory }) { choice ->
DirectoryRow(
choice = choice,
@@ -252,11 +252,20 @@ private const val OPERATOR_TAG_LABEL = "Operator"
* prompt from any client, so the session stays writable everywhere.
*/
internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String =
sessionStatusLabel(runningLocally)
sessionStatusLabel(runningLocally, session.closed)
/** The status of a conversation from its own running flag (see [sessionStatusLabel]). */
internal fun sessionStatusLabel(runningLocally: Boolean): String =
if (runningLocally) "Running" else "Idle"
/**
* The status of a conversation from its own flags (see [sessionStatusLabel]).
* A closed session reads `Closed` first: it is finished, whatever a stale local
* running mark says. A session is never reported `Busy` or read-only because
* another client is watching it — the server fans the stream out and accepts a
* prompt from any client, so the session stays writable everywhere.
*/
internal fun sessionStatusLabel(runningLocally: Boolean, closed: Boolean = false): String = when {
closed -> "Closed"
runningLocally -> "Running"
else -> "Idle"
}
/**
* The activity a session row signals beyond its open/tag/directory state. An
@@ -298,7 +307,7 @@ internal data class ConversationHeader(
internal fun conversationHeader(thread: ChatThread): ConversationHeader = ConversationHeader(
title = sessionTitle(ChatSession(id = thread.sessionId, title = thread.title)),
kind = sessionTagLabel(thread.tag),
activity = sessionStatusLabel(thread.running),
activity = sessionStatusLabel(thread.running, thread.closed),
directory = thread.directory,
model = thread.model,
)
@@ -388,6 +397,19 @@ internal fun reasoningLabel(count: Int, streaming: Boolean): String = when {
else -> REASONING_SETTLED_LABEL
}
/**
* The close confirmation's body: it says exactly what closing does — stops a
* running turn, marks the chat closed on every device — and what it does not do:
* nothing is deleted, the chat and its history are kept and can be reopened. Kept
* pure so the confirmation wording and its unit test share one string instead of
* the copy drifting from the promise.
*/
internal fun closeChatConfirmation(title: String): String =
"Closes \"$title\" and marks it closed on every device. " +
"A turn that is running is stopped first. " +
"Nothing is deleted — the chat and its history are kept, " +
"and you can reopen it from the list."
/**
* The elapsed time the server's own timing gives a settled turn: from the
* earliest start to the latest completion across the parts that carry a timing
@@ -4,6 +4,7 @@ import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
@@ -55,6 +56,7 @@ import net.awan.pipelines.ui.components.LabelChip
import net.awan.pipelines.ui.components.ListRow
import net.awan.pipelines.ui.components.LoadingState
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.theme.ICON_BUTTON_SMALL_DP
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
import net.awan.pipelines.ui.theme.SPACING_M
@@ -94,10 +96,12 @@ internal fun ChatListPane(
// The server returns operator sessions only, with the operator's own local
// renames and removals applied on top; the app never guesses which session
// belongs to a run. The operator's search narrows that list without touching
// its order, and the survivors are grouped by directory when there is more
// than one so sessions in the same repository sit together.
// its order. Active sessions are grouped by directory when there is more than
// one; the closed ones the operator finished with sit below them as history.
val sessions = state.filteredSessions
val groups = groupChatSessionsByDirectory(sessions)
val active = state.activeSessions
val closed = state.closedSessions
val groups = groupChatSessionsByDirectory(active)
val query = state.sessionQuery
// A removal is reported for what it is: a local, undoable change, never a
@@ -115,6 +119,7 @@ internal fun ChatListPane(
}
}
var renaming by remember { mutableStateOf<ChatSession?>(null) }
var closing by remember { mutableStateOf<ChatSession?>(null) }
Scaffold(
modifier = modifier,
@@ -169,7 +174,10 @@ internal fun ChatListPane(
// drift hundreds of pixels from its title, the same constraint the
// other lists and detail bodies use; narrow windows fill as before.
else -> DetailTabBody(wide, Modifier.fillMaxSize()) { listModifier ->
LazyColumn(listModifier) {
LazyColumn(
modifier = listModifier,
contentPadding = pillContentPadding(PaddingValues()),
) {
if (groups.size > 1) {
// More than one directory: one section per repository so
// same-directory chats sit together, each keeping the
@@ -177,12 +185,21 @@ internal fun ChatListPane(
groups.forEach { group ->
item(key = "dir-" + group.directory) { DirectoryHeader(group.directory) }
items(group.sessions, key = { it.id }) { session ->
SessionListItem(state, session, vm, onRename = { renaming = it })
SessionListItem(state, session, vm, onRename = { renaming = it }, onClose = { closing = it })
}
}
} else {
items(sessions, key = { it.id }) { session ->
SessionListItem(state, session, vm, onRename = { renaming = it })
items(active, key = { it.id }) { session ->
SessionListItem(state, session, vm, onRename = { renaming = it }, onClose = { closing = it })
}
}
if (closed.isNotEmpty()) {
// Finished chats stay reachable as history: a clearly
// labelled section, in the same recency order, from which
// each one can be reopened.
item(key = "closed-header") { DirectoryHeader(CLOSED_SECTION_LABEL) }
items(closed, key = { it.id }) { session ->
SessionListItem(state, session, vm, onRename = { renaming = it }, onClose = { closing = it })
}
}
if (state.sessionsError != null) {
@@ -211,6 +228,16 @@ internal fun ChatListPane(
},
)
}
closing?.let { session ->
CloseChatDialog(
session = session,
onDismiss = { closing = null },
onConfirm = {
vm.closeChatSession(session.id)
closing = null
},
)
}
}
/**
@@ -251,17 +278,20 @@ private fun SessionListItem(
session: ChatSession,
vm: AppViewModel,
onRename: (ChatSession) -> Unit,
onClose: (ChatSession) -> Unit,
) {
val thread = state.thread(session.id)
SessionRow(
session = session,
thread = thread,
open = thread != null,
unseen = state.isUnseen(session),
unseen = !session.closed && state.isUnseen(session),
active = state.activeId == session.id,
onClick = { vm.openChatSession(session) },
onRename = { onRename(session) },
onRemove = { vm.removeChat(session.id) },
onClose = { onClose(session) },
onReopen = { vm.reopenChatSession(session.id) },
onHide = { vm.removeChat(session.id) },
)
}
@@ -295,7 +325,9 @@ private fun SessionRow(
active: Boolean,
onClick: () -> Unit,
onRename: () -> Unit,
onRemove: () -> Unit,
onClose: () -> Unit,
onReopen: () -> Unit,
onHide: () -> Unit,
) {
val texts = pipelinesText()
val running = thread?.running == true
@@ -316,10 +348,20 @@ private fun SessionRow(
// The kind chip names the session kind the server reported, so an
// operator chat is tellable from anything run-related at a glance.
sessionTagLabel(session)?.let { LabelChip(it, SPACING_S, SPACING_XXS) }
// A closed chat is named as such on the row itself, so it is never
// confused with a hide (which only affects this device) or with a
// still-open chat.
if (session.closed) LabelChip(CLOSED_CHIP_LABEL, SPACING_S, SPACING_XXS)
// The activity badge is the new-activity signal; the tag and the
// directory below are unchanged beside it.
SessionActivityBadge(activity, open)
SessionMenu(onRename = onRename, onRemove = onRemove)
SessionMenu(
closed = session.closed,
onRename = onRename,
onClose = onClose,
onReopen = onReopen,
onHide = onHide,
)
}
val meta = buildList {
add(sessionWorkLabel(session.busy, thread))
@@ -330,9 +372,19 @@ private fun SessionRow(
}
}
/** A session row's management actions: rename and remove from this device's list. */
/**
* A session row's management actions. Closing is the real, server-side finish
* (shared by every device); hiding only affects this device and is named so the
* two cannot be confused. A closed chat offers Reopen instead of Close.
*/
@Composable
private fun SessionMenu(onRename: () -> Unit, onRemove: () -> Unit) {
private fun SessionMenu(
closed: Boolean,
onRename: () -> Unit,
onClose: () -> Unit,
onReopen: () -> Unit,
onHide: () -> Unit,
) {
var expanded by remember { mutableStateOf(false) }
Box {
IconButton(onClick = { expanded = true }, modifier = Modifier.size(ICON_BUTTON_SMALL_DP)) {
@@ -350,17 +402,52 @@ private fun SessionMenu(onRename: () -> Unit, onRemove: () -> Unit) {
onRename()
},
)
if (closed) {
DropdownMenuItem(
text = { Text("Reopen") },
onClick = {
expanded = false
onReopen()
},
)
} else {
DropdownMenuItem(
text = { Text("Close chat…") },
onClick = {
expanded = false
onClose()
},
)
}
DropdownMenuItem(
text = { Text("Remove from list") },
text = { Text("Hide on this device") },
onClick = {
expanded = false
onRemove()
onHide()
},
)
}
}
}
/**
* The close confirmation. It says exactly what closing does and does not do:
* stops any running turn, keeps the whole history, and marks the chat closed for
* every device — never a delete, and distinct from the local hide.
*/
@Composable
private fun CloseChatDialog(session: ChatSession, onDismiss: () -> Unit, onConfirm: () -> Unit) {
AlertDialog(
onDismissRequest = onDismiss,
title = { Text("Close chat?") },
text = {
Text(closeChatConfirmation(sessionTitle(session)))
},
confirmButton = { TextButton(onClick = onConfirm) { Text("Close chat") } },
dismissButton = { TextButton(onClick = onDismiss) { Text("Cancel") } },
)
}
/**
* The rename dialog. The brokered protocol has no rename for a chat session, so
* the dialog says plainly that the name is kept on this device rather than
@@ -396,7 +483,13 @@ private fun RenameChatDialog(session: ChatSession, onDismiss: () -> Unit, onConf
}
/** The removal report: what happened and how to undo it. */
private const val CHAT_REMOVED_MESSAGE = "Removed from this list; the chat stays on the server."
private const val CHAT_REMOVED_MESSAGE = "Hidden on this device; the chat stays on the server."
/** The row chip and section heading for a chat the operator finished with. */
private const val CLOSED_CHIP_LABEL = "Closed"
/** The heading of the section that keeps closed chats reachable as history. */
private const val CLOSED_SECTION_LABEL = "Closed"
/** A running/busy/open indicator: a coloured dot plus a word, never colour alone. */
@Composable
@@ -5,16 +5,17 @@ import net.awan.pipelines.data.protocol.PipelinesJson
/**
* The operator's own changes to the session list, which the server has no
* request for: a chat cannot be renamed or deleted through the brokered
* protocol (there is no chat_rename/chat_delete type, and the OpenCode session
* endpoint is not exposed), so both are kept here, on the device, and applied
* over whatever the server lists.
* request for: a chat cannot be renamed through the brokered protocol (there is
* no chat_rename type), so it is kept here, on the device, and applied over
* whatever the server lists. Closing a chat and reopening it are *not* here: they
* are server-side (`chat_close`/`chat_reopen`) so every device sees them.
*
* - [titles] are local renames, keyed by session id; a renamed chat shows its
* local title and the server's title is left untouched.
* - [hidden] are sessions the operator removed from the list. Nothing is deleted
* on the server, so the removal is honest and reversible ([remove] can be
* undone with [restore]).
* - [hidden] are sessions the operator hid on this device. Nothing is deleted on
* the server, and no other device is affected, so the hide is honest and
* reversible ([remove] can be undone with [restore]). It is distinct from a
* server-side close, which marks the chat closed for every client.
*
* Kept as a serializable value so it survives a restart as one preference,
* exactly like the app's other stored settings.
@@ -71,6 +71,12 @@ data class ChatThread(
val updatedAt: Long = 0,
/** The server reports another client (or an active run) holds this session. */
val busy: Boolean = false,
/**
* The server reports this session closed: the operator finished with it. The
* conversation and its history are kept; the chat can be reopened, and sending
* another message reopens it too.
*/
val closed: Boolean = false,
val messages: List<ChatMessage> = emptyList(),
val loading: Boolean = false,
val loaded: Boolean = false,
@@ -274,6 +280,21 @@ data class ChatState(
*/
val filteredSessions: List<ChatSession>
get() = filterChatSessions(visibleSessions, sessionQuery)
/**
* The sessions still in play: [filteredSessions] without the closed ones, in
* the same recency order. The list shows these as the active conversations.
*/
val activeSessions: List<ChatSession>
get() = filteredSessions.filterNot { it.closed }
/**
* The finished sessions: [filteredSessions] the server reports as closed, in
* the same order. They are shown as history — nothing was deleted — and can be
* reopened from the list.
*/
val closedSessions: List<ChatSession>
get() = filteredSessions.filter { it.closed }
}
/**
@@ -356,6 +377,7 @@ class ChatStore(
agent = session.agent.ifBlank { thread.agent },
tag = session.tag.ifBlank { thread.tag },
busy = session.busy,
closed = session.closed,
)
}
// Fold the read state in: the active conversation is on screen, so its
@@ -457,9 +479,11 @@ class ChatStore(
}
/**
* Removes a session from the device's list and closes its conversation, if
* open. Nothing is deleted on the server — the session still exists there — so
* the removal is honest and reversible through [undoRemove].
* Hides a session on this device only and closes its conversation, if open.
* Nothing is deleted on the server — the session still exists there — and no
* other device is affected, so the hide is honest and reversible through
* [undoRemove]. It is deliberately not a "close": the server-side close (see
* [sessionClosed]) is shared by every client.
*/
fun remove(sessionId: String) {
if (sessionId.isBlank()) return
@@ -481,6 +505,44 @@ class ChatStore(
)
}
// ---- Closing and reopening (server-side, shared by every client) ---------
/**
* Records that the server closed [sessionId]: the row is marked closed with
* the server's [closedAt] and any in-flight turn is settled, because the
* server stopped it. The session is not removed from [ChatState.sessions] —
* closed chats stay listed as history.
*/
fun sessionClosed(sessionId: String, closedAt: Long) {
if (sessionId.isBlank()) return
val at = if (closedAt > 0) closedAt else now()
_state.value = _state.value.copy(
sessions = _state.value.sessions.map {
if (it.id == sessionId) it.copy(closed = true, closedAt = at) else it
},
open = _state.value.open.map {
if (it.sessionId == sessionId) setRunning(it.copy(closed = true), false) else it
},
)
}
/**
* Clears the closed state of [sessionId] — an explicit reopen, or a prompt
* that the server treated as reopening it — so the chat returns to the active
* list without a re-fetch.
*/
fun sessionReopened(sessionId: String) {
if (sessionId.isBlank()) return
_state.value = _state.value.copy(
sessions = _state.value.sessions.map {
if (it.id == sessionId) it.copy(closed = false, closedAt = 0) else it
},
open = _state.value.open.map {
if (it.sessionId == sessionId) it.copy(closed = false) else it
},
)
}
// ---- Opening / switching -------------------------------------------------
/**
@@ -506,6 +568,7 @@ class ChatStore(
agent = session.agent,
updatedAt = session.updatedAt,
busy = session.busy,
closed = session.closed,
)
_state.value = _state.value.copy(open = _state.value.open + thread, activeId = session.id, seen = seen)
return true
@@ -517,6 +580,7 @@ class ChatStore(
agent = session.agent.ifBlank { existing.agent },
tag = session.tag.ifBlank { existing.tag },
busy = session.busy,
closed = session.closed,
)
_state.value = _state.value.copy(
open = _state.value.open.map { if (it.sessionId == session.id) merged else it },
@@ -868,6 +932,7 @@ class ChatStore(
agent = session?.agent ?: "",
tag = session?.tag ?: "",
busy = session?.busy ?: false,
closed = session?.closed ?: false,
)
_state.value = _state.value.copy(open = _state.value.open + placeholder)
}
@@ -0,0 +1,53 @@
package net.awan.pipelines.ui.components
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalLayoutDirection
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
/**
* The floating destination pill's clearance at the bottom of the content, as the
* app shell computes it for the current window and route (see
* `pillScrollInset`). It is published around the content so a scrollable screen
* can add it to its own scroll content's bottom padding and let its last row
* scroll clear of the pill, without the pill ever taking or positioning layout
* space. Defaults to zero, so a screen composed outside the app shell (a preview,
* a test) keeps exactly its own padding.
*/
internal val LocalPillBottomInset = compositionLocalOf { 0.dp }
/**
* [base] with the floating pill's clearance added at the bottom, for a scroll
* container's `contentPadding`. It adds the clearance **inside** the scroll
* content, so the container keeps its full height and its last row can still be
* scrolled into view above the pill; it is deliberately not a layout padding on
* the container, which would shrink the viewport and hide the row behind the pill
* instead. Returns [base] unchanged when no pill is drawn.
*/
@Composable
internal fun pillContentPadding(base: PaddingValues): PaddingValues {
val inset = LocalPillBottomInset.current
if (inset == 0.dp) return base
val direction = LocalLayoutDirection.current
return PaddingValues(
start = base.calculateLeftPadding(direction),
top = base.calculateTopPadding(),
end = base.calculateRightPadding(direction),
bottom = base.calculateBottomPadding() + inset,
)
}
/**
* Adds the floating pill's clearance as bottom padding on a scrollable's **own
* content** (a `Column` inside `verticalScroll`, or any content whose end must
* clear the pill), for the cases a `LazyColumn`'s `contentPadding` cannot reach.
* Like [pillContentPadding] it is content padding, not a layout inset, so the
* container keeps its full height and only its last content scrolls clear of the
* pill. A no-op when no pill is drawn.
*/
@Composable
internal fun Modifier.pillBottomPadding(): Modifier = padding(bottom = LocalPillBottomInset.current)
@@ -32,6 +32,7 @@ import net.awan.pipelines.data.protocol.Graph
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.copyText
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberSectionExpansion
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
import net.awan.pipelines.ui.theme.SPACING_L
@@ -71,7 +72,7 @@ internal fun PipelineSourceView(
LazyColumn(
modifier = modifier.fillMaxSize(),
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "source-actions") {
Row(
@@ -48,6 +48,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.components.pillBottomPadding
import net.awan.pipelines.ui.STAGE_RUN_LABEL_LINES
import net.awan.pipelines.ui.displayMap
import net.awan.pipelines.ui.fileChangeLine
@@ -520,7 +521,8 @@ private fun StageDetailBody(
Column(
modifier = columnModifier
.verticalScroll(rememberScrollState())
.padding(horizontal = SPACING_L, vertical = SPACING_S),
.padding(horizontal = SPACING_L, vertical = SPACING_S)
.pillBottomPadding(),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
// A run parked on this stage surfaces its decision here, at the top of
@@ -755,7 +757,8 @@ private fun StageSectionBody(
Column(
modifier = columnModifier
.verticalScroll(rememberScrollState())
.padding(horizontal = SPACING_L, vertical = SPACING_L),
.padding(horizontal = SPACING_L, vertical = SPACING_L)
.pillBottomPadding(),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
KeyValueRow("Stage", GraphSemantics.nodeLabel(stageKey))
@@ -52,6 +52,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.detailLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.pipelineDetailTabs
import net.awan.pipelines.ui.components.rememberPaneContent
import net.awan.pipelines.ui.formatLocalTimestamp
@@ -200,7 +201,7 @@ private fun PipelineSummaryTab(detail: PipelineDetail, wide: Boolean, modifier:
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "pipeline-summary") {
Column(
@@ -256,7 +257,7 @@ private fun PipelineGraphTab(
val text = pipelinesText()
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "pipeline-graph") {
Column(
@@ -55,6 +55,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.formatLocalTimestamp
import net.awan.pipelines.ui.stageCountText
@@ -227,7 +228,7 @@ fun PipelineListScreen(
LazyColumn(
state = listState,
modifier = listModifier,
contentPadding = PaddingValues(vertical = SPACING_S),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_S)),
) {
items(items, key = { it.id }) { pipeline ->
PipelineRow(
@@ -20,6 +20,7 @@ import net.awan.pipelines.ui.LoadState
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberSectionExpansion
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_S
@@ -45,7 +46,7 @@ internal fun RunEvidenceTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "evidence-reload") {
Row(
@@ -10,6 +10,7 @@ import kotlinx.serialization.json.JsonElement
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberSectionExpansion
import net.awan.pipelines.ui.displayText
import net.awan.pipelines.ui.theme.SPACING_L
@@ -35,7 +36,7 @@ internal fun RunFieldSectionsTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
if (entries.isEmpty()) {
item(key = "$keyPrefix-empty") {
@@ -12,6 +12,7 @@ import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import net.awan.pipelines.data.protocol.RunDetail
import net.awan.pipelines.data.protocol.RunGraphState
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.graph.WorkflowGraph
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_S
@@ -39,7 +40,7 @@ internal fun RunGraphTab(
val timeline = remember(run.steps) { runTimeline(run.steps) }
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "run-graph") {
Column(
@@ -68,6 +68,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.components.runStateColor
import net.awan.pipelines.ui.components.runStateOf
@@ -330,7 +331,7 @@ private fun RunHistoryContent(
LazyColumn(
state = listState,
modifier = listModifier,
contentPadding = PaddingValues(bottom = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(bottom = SPACING_L)),
) {
entries.forEach { entry ->
when (entry) {
@@ -20,6 +20,7 @@ import net.awan.pipelines.ui.RUN_VIEW_TITLE_LINES
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.KeyValueRow
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.StatusChip
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.rememberLiveNowMillis
@@ -68,7 +69,7 @@ internal fun RunSummaryTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
// The artifacts gallery still leads the summary, but inside one
// collapsed section: its header alone carries the run's capture
@@ -27,6 +27,7 @@ import net.awan.pipelines.data.protocol.RunDetail
import net.awan.pipelines.ui.components.ColoredChip
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.RunStatusIcon
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.runStateIcon
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.graph.graphColors
@@ -60,7 +61,7 @@ internal fun RunTimelineTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
if (timeline.entries.isEmpty()) {
item(key = "timeline-empty") {
@@ -1,9 +1,11 @@
package net.awan.pipelines.ui.screens
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.WindowInsetsSides
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.only
import androidx.compose.foundation.layout.padding
@@ -11,6 +13,8 @@ import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
import androidx.compose.material.icons.filled.Settings
import androidx.compose.material.icons.filled.WarningAmber
import androidx.compose.material3.Button
import androidx.compose.material3.Card
@@ -26,18 +30,32 @@ import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import net.awan.pipelines.data.transport.ConnectionState
import net.awan.pipelines.ui.AppViewModel
import net.awan.pipelines.ui.TemplatesIcon
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillBottomPadding
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_M
import net.awan.pipelines.ui.theme.SPACING_XS
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier, wide: Boolean = false) {
fun SettingsScreen(
vm: AppViewModel,
onOpenTemplates: () -> Unit,
modifier: Modifier = Modifier,
wide: Boolean = false,
covered: Boolean = false,
) {
val serverUrl by vm.serverUrlDraft.collectAsStateWithLifecycle()
val workspace by vm.workspaceDraft.collectAsStateWithLifecycle()
val urlError by vm.urlError.collectAsStateWithLifecycle()
@@ -47,6 +65,17 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier, wide: Boolea
val configuredWorkspace by vm.configuredWorkspace.collectAsStateWithLifecycle()
val workspaceError by vm.workspaceError.collectAsStateWithLifecycle()
if (covered) {
// A covered pane shows only its compact identity, never its fields
// squeezed into the peek strip (the same rule as the other destinations).
PaneIdentity(
title = "Settings",
icon = Icons.Filled.Settings,
modifier = modifier.fillMaxSize(),
)
return
}
Scaffold(
modifier = modifier,
contentWindowInsets = paneSafeArea(),
@@ -75,6 +104,7 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier, wide: Boolea
onDisconnect = vm::disconnect,
onReconnect = vm::reconnect,
onSaveWorkspace = vm::saveWorkspace,
onOpenTemplates = onOpenTemplates,
)
}
}
@@ -98,15 +128,19 @@ private fun SettingsContent(
onDisconnect: () -> Unit,
onReconnect: () -> Unit,
onSaveWorkspace: () -> Unit,
onOpenTemplates: () -> Unit,
) {
// The settings body keeps the app's comfortable reading width on a wide
// window (centred) instead of letting a helper line run the whole 2000px.
// The floating pill is an overlay, so the scrolled body adds its clearance to
// its own scroll content and its last control scrolls clear of the pill.
DetailTabBody(wide, padding) { columnModifier ->
Column(
modifier = columnModifier
.verticalScroll(rememberScrollState())
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
.padding(SPACING_L)
.pillBottomPadding(),
verticalArrangement = Arrangement.spacedBy(SPACING_M),
) {
Text("Connection", style = MaterialTheme.typography.titleMedium)
@@ -163,6 +197,51 @@ private fun SettingsContent(
)
Button(onClick = onSaveWorkspace, enabled = workspaceError == null) { Text("Save workspace") }
Text("Saved workspace: ${configuredWorkspace.ifBlank { "(none)" }}")
Text("Templates", style = MaterialTheme.typography.titleMedium)
// The templates gallery is configuration, so it lives here rather than in
// the floating pill. The row is the settings page's idiom: a section
// label followed by a card, with a leading glyph and a forward chevron.
Card(
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
),
modifier = Modifier
.fillMaxWidth()
.clickable(
role = Role.Button,
onClickLabel = "Open templates",
onClick = onOpenTemplates,
),
) {
Row(
modifier = Modifier.fillMaxWidth().padding(SPACING_L),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(SPACING_M),
) {
Icon(
imageVector = TemplatesIcon,
contentDescription = null,
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
Column(
modifier = Modifier.weight(1f),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
Text("Browse templates", style = MaterialTheme.typography.bodyLarge)
Text(
text = "Reusable pipeline definitions offered by the server.",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Icon(
imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
contentDescription = null,
)
}
}
}
}
}
@@ -50,6 +50,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.clampTabIndex
import net.awan.pipelines.ui.components.detailLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.pipelineDetailTabs
import net.awan.pipelines.ui.graph.PipelineSourceView
import net.awan.pipelines.ui.graph.WorkflowGraph
@@ -161,7 +162,7 @@ private fun TemplateSummaryTab(entry: TemplateEntry, wide: Boolean, modifier: Mo
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "template-summary") {
Column(
@@ -232,7 +233,7 @@ private fun TemplateGraphTab(entry: TemplateEntry, modifier: Modifier) {
}
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "template-graph") {
Column(
@@ -49,6 +49,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.templateCard
import net.awan.pipelines.ui.templateGridColumns
import net.awan.pipelines.ui.templateStageCountLabel
@@ -151,7 +152,7 @@ private fun TemplateGrid(
LazyColumn(
state = listState,
modifier = Modifier.fillMaxSize(),
contentPadding = PaddingValues(SPACING_L),
contentPadding = pillContentPadding(PaddingValues(SPACING_L)),
verticalArrangement = Arrangement.spacedBy(SPACING_S),
) {
items(rows, key = { it.first().key }) { row ->
@@ -76,17 +76,21 @@ internal val MIN_COVERED_PANE_WIDTH_DP = 112.dp
// ---- Destination pill (ui/PipelinesApp.kt) ---------------------------------
/**
* Bottom space reserved by the floating destination pill, so content is never
* permanently hidden behind it (pill height + its margins + a small gap).
* The trailing bottom space a scrollable screen keeps at the end of its own scroll
* content so its last row is never permanently hidden behind the floating
* destination pill (pill height + its margins + a small gap). The pill itself is
* an overlay and takes no layout space; this is clearance inside the scroll
* content, applied through `LocalPillBottomInset`.
*/
internal val DESTINATION_PILL_RESERVE = 88.dp
/**
* Bottom space the floating attention chip occupies above the destination pill:
* the chip's own height (its single label line plus its vertical padding) plus the
* gap below it. Reserved at the bottom of the content whether or not a chip is
* present, so the chip can never be laid out over a row, a field or a button and
* the content does not jump as it appears and clears.
* gap below it. Added to a scrollable's trailing space alongside
* [DESTINATION_PILL_RESERVE] while the pill is drawn, so the chip can never be laid
* out over a row, a field or a button and the content does not jump as it appears
* and clears.
*/
internal val ATTENTION_CHIP_RESERVE = SPACING_XXL + SPACING_M
@@ -350,6 +350,58 @@ class ChatProtocolTest {
assertNull(message.chatEvent)
assertNull(message.chatSessions)
assertNull(message.chatPermission)
assertNull(message.chatClose)
}
/**
* The session list carries the server's closed state: a closed session decodes
* with its flag and close time, and an open one stays open, so the app can
* group finished chats as history without a second request.
*/
@Test
fun chatSessionsParseTheClosedState() {
val json = """
{"type":"chat_sessions","chat_sessions":[
{"id":"ses_open","title":"Active"},
{"id":"ses_done","title":"Finished","closed":true,"closed_at":1792112367999}]}
""".trimIndent()
val sessions = PipelinesJson.decodeFromString(Message.serializer(), json).chatSessions!!
assertEquals(false, sessions[0].closed)
assertEquals(0L, sessions[0].closedAt)
assertTrue(sessions[1].closed)
assertEquals(1792112367999L, sessions[1].closedAt)
}
/**
* The close/reopen frames use the same builder the repository sends and carry
* only the session id; the close reply's result (closed_at, interrupted)
* round-trips, so the app can report that a turn was stopped.
*/
@Test
fun chatCloseAndReopenFramesRoundTrip() {
val close = ChatProtocol.closeRequest("ses_1")
assertEquals(Protocol.CHAT_CLOSE, close.type)
assertEquals("ses_1", close.chatQuery!!.sessionId)
val decodedClose = PipelinesJson.decodeFromString(
Message.serializer(),
PipelinesJson.encodeToString(Message.serializer(), close.copy(id = "android-1")),
)
assertEquals(Protocol.CHAT_CLOSE, decodedClose.type)
val reopen = ChatProtocol.reopenRequest("ses_1")
assertEquals(Protocol.CHAT_REOPEN, reopen.type)
assertEquals("ses_1", reopen.chatQuery!!.sessionId)
val reply = """
{"type":"chat_close","id":"android-1",
"chat_session":{"id":"ses_1","closed":true,"closed_at":1792112367999},
"chat_close":{"session_id":"ses_1","closed_at":1792112367999,"interrupted":true}}
""".trimIndent()
val decodedReply = PipelinesJson.decodeFromString(Message.serializer(), reply)
assertEquals(true, decodedReply.chatSession!!.closed)
assertEquals(1792112367999L, decodedReply.chatSession!!.closedAt)
assertTrue(decodedReply.chatClose!!.interrupted)
assertEquals(1792112367999L, decodedReply.chatClose!!.closedAt)
}
private fun toolDuration(part: ChatPart): Long? {
@@ -1,6 +1,8 @@
package net.awan.pipelines.ui
import androidx.compose.ui.Alignment
import androidx.compose.ui.unit.Dp
import net.awan.pipelines.ui.theme.ATTENTION_CHIP_RESERVE
import net.awan.pipelines.ui.theme.DESTINATION_PILL_RESERVE
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
@@ -9,6 +11,31 @@ import org.junit.Test
class PipelinesNavTest {
@Test
fun thePillDoesNotHoldTemplates() {
// Templates is configuration and moved to the Settings page; the pill keeps
// only the surfaces a person moves between constantly.
assertFalse(destinations.any { it.route == "templates" })
}
@Test
fun thePillKeepsItsRemainingDestinationsInOrder() {
// The pill's width derives from exactly this list, so removing a
// destination only narrows it.
assertEquals(
listOf("pipelines", "runs", "chat", "settings"),
destinations.map { it.route },
)
}
@Test
fun thePillIsCentredOnANarrowWindowAndOnTheRightCornerOnAWideOne() {
// The overlay is bottom-anchored; only its horizontal arrangement follows
// the window width: centred when narrow, the right corner when wide.
assertEquals(Alignment.CenterHorizontally, destinationPillAlignment(wide = false))
assertEquals(Alignment.End, destinationPillAlignment(wide = true))
}
@Test
fun listRoutesSelectTheirOwnDestination() {
assertTrue(destinationSelected("pipelines", "pipelines"))
@@ -59,7 +86,7 @@ class PipelinesNavTest {
// the chat list keeps it, and so does every other destination.
assertFalse(destinationPillVisible("chat", conversationOpen = true))
assertTrue(destinationPillVisible("chat", conversationOpen = false))
for (route in listOf("pipelines", "templates", "runs", "settings", null)) {
for (route in listOf("pipelines", "runs", "settings", null)) {
assertTrue(destinationPillVisible(route, conversationOpen = false))
}
// A conversation only exists on the chat route; even if the flag were set
@@ -68,24 +95,38 @@ class PipelinesNavTest {
}
@Test
fun theReserveTracksTheDrawnPillSoContentNeitherJumpsNorLeavesAGap() {
// Drawn: content reserves the named pill space and clears it. Hidden: no
// reservation, so there is no empty band where the pill used to be.
assertDp(DESTINATION_PILL_RESERVE.value, destinationPillReserve(pillVisible = true))
assertDp(0f, destinationPillReserve(pillVisible = false))
// One predicate drives both, so the space can never disagree with the
// pill: reserved exactly when drawn, gone exactly when hidden.
fun theContentKeepsItsOwnHeightBecauseThePillIsAnOverlay() {
// The pill floats above the content and never takes layout space, so the
// content column's own bottom padding for it is zero — whether the pill is
// drawn or hidden — and a scrollable list's last row scrolls under the pill
// rather than the whole content being shortened by it.
assertDp(0f, contentPillPadding(pillVisible = true))
assertDp(0f, contentPillPadding(pillVisible = false))
}
@Test
fun theScrollInsetTracksTheDrawnPillSoAListNeitherJumpsNorHidesItsLastRow() {
// Drawn: a scrollable keeps the named pill + attention-chip space at the
// end of its own scroll content and its last row scrolls clear of the whole
// floating bottom stack. Hidden: no clearance, so there is no empty band
// where the pill used to be.
val drawnInset = DESTINATION_PILL_RESERVE + ATTENTION_CHIP_RESERVE
assertDp(drawnInset.value, pillScrollInset(pillVisible = true))
assertDp(0f, pillScrollInset(pillVisible = false))
// One predicate drives both the drawing and the clearance, so the space can
// never disagree with the pill: cleared exactly when drawn, gone exactly
// when hidden.
for (route in listOf("pipelines", "chat", "runs", "settings", null)) {
for (open in listOf(false, true)) {
val drawn = destinationPillVisible(route, open)
val reserve = destinationPillReserve(drawn)
val inset = pillScrollInset(drawn)
assertTrue(
"reserve held behind a hidden pill on $route (open=$open)",
drawn || reserve.value == 0f,
"scroll clearance held behind a hidden pill on $route (open=$open)",
drawn || inset.value == 0f,
)
assertTrue(
"content not cleared of a drawn pill on $route (open=$open)",
!drawn || reserve.value == DESTINATION_PILL_RESERVE.value,
"list not cleared of a drawn pill on $route (open=$open)",
!drawn || inset.value == drawnInset.value,
)
}
}
@@ -0,0 +1,74 @@
package net.awan.pipelines.ui
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test
/**
* The Settings destination's one-level navigation: its Templates row opens the
* gallery as its own pane, a gallery card opens the template detail as the next
* pane, and Back (the gesture, the covered strip's tap and the detail's own back
* control) steps exactly one pane at a time — detail → gallery → settings. Pure,
* so none of this needs a device.
*/
class SettingsSelectionTest {
@Test
fun theTemplatesRowOpensTheGalleryAsItsOwnPane() {
val opened = openTemplatesGallery(SettingsSelection())
assertEquals(SettingsPane.Gallery, opened.pane)
assertEquals(1, opened.depth)
assertNull(opened.templateKey)
}
@Test
fun aGalleryCardOpensTheSelectedTemplatesDetailPane() {
val opened = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
assertEquals(SettingsPane.Template, opened.pane)
assertEquals(2, opened.depth)
assertEquals("three-stage", opened.templateKey)
}
@Test
fun backStepsExactlyOnePaneAndClearsTheTemplateKey() {
val detail = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
val gallery = settingsBack(detail)
assertEquals(SettingsPane.Gallery, gallery.pane)
assertEquals(1, gallery.depth)
assertNull(gallery.templateKey)
val settings = settingsBack(gallery)
assertEquals(SettingsPane.Settings, settings.pane)
assertEquals(0, settings.depth)
}
@Test
fun backAtSettingsLeavesTheSelectionSoBackCanLeaveTheDestination() {
assertEquals(SettingsSelection(), settingsBack(SettingsSelection()))
}
@Test
fun tappingACoveredStripPopsEveryPaneToItsRight() {
val detail = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
// The settings strip closes everything back to the settings page.
assertEquals(SettingsSelection(), settingsPopTo(detail, level = 0))
// The gallery strip closes only the template detail above it.
assertEquals(
SettingsSelection(pane = SettingsPane.Gallery),
settingsPopTo(detail, level = 1),
)
// A strip at or beyond the current depth has nothing to its right.
assertEquals(detail, settingsPopTo(detail, level = 2))
}
@Test
fun theSelectionSurvivesThroughItsSaverPayload() {
val detail = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
assertEquals(detail, decodeSettingsSelection(encodeSettingsSelection(detail)))
assertEquals(
SettingsSelection(),
decodeSettingsSelection(encodeSettingsSelection(SettingsSelection())),
)
}
}
@@ -0,0 +1,107 @@
package net.awan.pipelines.ui.chat
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* Closing a chat: the server-side finish (shared by every client) marks the row
* closed, keeps it as history, settles a running turn, and can be reversed by a
* reopen or a prompt. Driven against [ChatStore] with no device or server.
*/
class ChatCloseTest {
private fun session(
id: String,
title: String = id,
closed: Boolean = false,
closedAt: Long = 0,
) = ChatSession(
id = id,
title = title,
tag = ChatProtocol.TAG_OPERATOR,
directory = "/home/op",
closed = closed,
closedAt = closedAt,
)
@Test
fun closingMarksTheRowClosedAndKeepsItAsHistory() {
val store = ChatStore()
store.sessionsLoaded(listOf(session("a"), session("b")))
store.sessionClosed("a", 1_700_000_000_000)
// Still in the server list (nothing deleted), but no longer active.
assertEquals(listOf("a", "b"), store.value.sessions.map { it.id })
assertEquals(listOf("b"), store.value.activeSessions.map { it.id })
val closed = store.value.closedSessions.single()
assertEquals("a", closed.id)
assertTrue(closed.closed)
assertEquals(1_700_000_000_000, closed.closedAt)
}
@Test
fun reopeningReturnsTheChatToTheActiveList() {
val store = ChatStore()
store.sessionsLoaded(listOf(session("a"), session("b")))
store.sessionClosed("a", 1_700_000_000_000)
store.sessionReopened("a")
assertEquals(listOf("a", "b"), store.value.activeSessions.map { it.id })
assertTrue(store.value.closedSessions.isEmpty())
assertFalse(store.value.sessions.first { it.id == "a" }.closed)
assertEquals(0, store.value.sessions.first { it.id == "a" }.closedAt)
}
@Test
fun closingSettlesARunningThreadAndMarksItClosed() {
val store = ChatStore()
store.sessionsLoaded(listOf(session("a")))
store.open(session("a"))
store.running("a", true)
store.sessionClosed("a", 1_700_000_000_000)
val thread = store.value.thread("a")!!
assertFalse("the stopped turn must not still read as running", thread.running)
assertTrue(thread.closed)
// The conversation is kept: its history is not deleted.
assertTrue(store.value.thread("a") != null)
}
@Test
fun aServerListRefreshCarriesTheClosedStateIntoTheStore() {
val store = ChatStore()
// The list arrives closed (the server is the source of truth).
store.sessionsLoaded(listOf(session("a", closed = true, closedAt = 5), session("b")))
assertEquals(listOf("b"), store.value.activeSessions.map { it.id })
assertEquals(listOf("a"), store.value.closedSessions.map { it.id })
}
@Test
fun aRefreshMarksAnAlreadyOpenThreadClosed() {
val store = ChatStore()
store.sessionsLoaded(listOf(session("a")))
store.open(session("a"))
assertFalse(store.value.thread("a")!!.closed)
store.sessionsLoaded(listOf(session("a", closed = true, closedAt = 5)))
assertTrue(store.value.thread("a")!!.closed)
}
@Test
fun theRowStatusReadsClosedAndTheConfirmationSaysWhatCloseDoes() {
assertEquals("Closed", sessionStatusLabel(session("a", closed = true), runningLocally = false))
val wording = closeChatConfirmation("Fix the parser")
assertTrue("names the stop of a running turn", wording.contains("running is stopped"))
assertTrue("says it affects every device", wording.contains("every device"))
assertTrue("says nothing is deleted", wording.contains("Nothing is deleted"))
assertTrue("says it can be reopened", wording.contains("reopen"))
assertTrue("names the chat", wording.contains("Fix the parser"))
}
}
@@ -184,23 +184,34 @@ class ChatCommandsTest {
}
@Test
fun closeDelegatesToTheRealCloseWhichThisRevisionDoesNotHave() {
fun closeDelegatesToTheRealServerCloseAndReturnsToTheList() {
val store = ChatStore()
store.sessionsLoaded(listOf(session("old")))
store.open(session("old"))
store.sessionsLoaded(listOf(session("old", "Old chat")))
store.open(session("old", "Old chat"))
store.history("old", listOf(message("m1", ChatProtocol.ROLE_USER, "kept")))
val host = object : ChatCommandHost by RecordingHost() {
override fun finishSession() {
store.notice("old", CHAT_CLOSE_UNAVAILABLE, failed = true)
// The real close: mark the session closed for every client — the
// conversation and its history are kept — then leave it for the
// list. Nothing is hidden.
store.sessionClosed("old", closedAt = 42)
val kept = store.value.thread("old")!!
assertTrue(kept.closed)
assertEquals(listOf("m1"), kept.messages.map { it.id })
store.close("old")
}
}
runChatSlashCommand("/close", store.value.thread("old")!!, host)
// The close is reported plainly and nothing is faked with the local hide.
assertTrue(store.value.thread("old")!!.notices.single().text.contains("no real session close"))
assertTrue(store.value.open.any { it.sessionId == "old" })
// Closed for every client and kept as history, exactly as the list's own
// close does — never the local hide dressed up as one.
assertTrue(store.value.sessions.single { it.id == "old" }.closed)
assertTrue(store.value.closedSessions.any { it.id == "old" })
assertTrue(store.value.visibleSessions.any { it.id == "old" })
// Its conversation has left the pane: the operator is back at the list.
assertTrue(store.value.open.none { it.sessionId == "old" })
assertNull(store.value.activeId)
}
@Test