diff --git a/android/README.md b/android/README.md index add68f53..44a598b7 100644 --- a/android/README.md +++ b/android/README.md @@ -5641,3 +5641,145 @@ the counter and the kept file). The APK was republished for this stage as at `http://10.0.0.75:8080/artifacts/249/3/pipelines-debug-wip-d1a859e.apk` (`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, `Content-Length: 18470240`). + +## New activity in the session list (17 Oct 2026) + +With several operator sessions open the list gave no sign of where a reply +arrived: an idle chat and one streaming a reply right now looked the same, so the +operator lost the conversation they were in. A row now signals a transcript the +operator has not read, and a turn streaming right now, distinctly from each other +and from an idle chat; opening a chat clears its mark; and the marks survive a +restart, not only a reconnect. The signal is derived from what the app already +receives — the sessions' own `updated_at` recency and the message ids/timestamps +of pushed chat events and history — so no server request is added for it. +`android/` only; nothing in the Pipelines server, its Go source, the installer or +the Docker files was touched, no dependency was added beyond the already-declared +material-icons-extended, and no run is started from the app. + +- **Read state, persisted.** `ui/chat/ChatSeen.kt` adds `ChatSeenState`: a + per-session recency watermark (`seenAt`, the newest `updated_at` the operator + has read) plus the ids that moved on while the app was open (`unseen`). It is + stored as one opaque JSON preference (`SettingsRepository.chat_seen`, observed + by `AppViewModel.observeChatSeen`), exactly like `ChatSessionOverrides`, so a + mark is still there after a restart. +- **Unseen, derived not requested.** `ChatState.isUnseen` marks a session that is + not on screen and either carried a live mark (a pushed frame arrived for it + while it was backgrounded — `ChatStore.event`/`permission` mark any activity for + a chat that is not active) or, if it has never been opened on this device, is + newer than its stored watermark. First sight of a session is seeded to its + current recency (`ChatSeenState.seeded`), so a chat that predates the feature is + not reported as new; a reply that arrived while the app was closed is newer than + the watermark and reads as unseen after a restart. An **open** thread is judged + by its live mark alone, so a conversation the operator has been in is never + re-flagged by a later list refresh — only by activity after they leave it. +- **Opened means read.** `ChatStore.open`/`activate` advance the watermark to the + session's recency and clear its live mark; `history` for the active chat also + advances it to the newest message the server reports; `close` clears a live mark + because a chat the operator had open was read. +- **Three distinguishable states.** `ChatFormat.sessionActivity(running, unseen)` + is the one pure derivation (streaming outranks finished-unseen, which outranks + idle) and `SessionActivityBadge` renders it as a labelled dot: `Streaming` + (tertiary) while a turn is in flight, `New` (primary) once it settles unseen, + and the existing `Open` (outline) otherwise. The kind chip and the directory + line are unchanged beside it — this adds a signal, it does not replace them. +- **Ordering untouched.** The list is still the server's most-recently-used order; + nothing here reorders it. + +Tests (`ChatActivityTest`, 5 cases): an unseen session is marked (a pushed frame +for a background chat, and a session newer than the stored watermark with no frame +at all), opening clears the mark from the persisted state too, the pure activity +derivation distinguishes streaming/finished-unseen/idle and the store agrees +across a background turn, and the seen state survives an encode/decode into a +fresh store. + +Evidence (this run's implementer pass, macOS, Gradle 9.7.1 `--offline +--no-daemon`, `ANDROID_HOME=/Users/alan/Library/Android/sdk`): `gradle --offline +--no-daemon :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the JUnit XMLs total **54 +suites / 492 tests / 0 failures / 0 errors / 0 skipped** (5 new in +`ChatActivityTest`). `gradle --offline --no-daemon :app:assembleDebug` → `BUILD +SUCCESSFUL`; the APK was published to this run's artifacts directory as +`pipelines-debug-wip-5adc961.apk` (18,470,240 bytes, sha256 +`0866b7c2c1cfbd51f55bd8a81e3550437553ff542a04de605d7f994060ee63ea`; `5adc961` is +`git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it) and is +served at +`http://10.0.0.75:8080/artifacts/270/1/pipelines-debug-wip-5adc961.apk` +(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, +`Content-Length: 18470240`). + +Not verified in this pass: the badge on a device, the wide/narrow layouts, and a +mark surviving a real process restart — the brief keeps implementation +verification to the build and the unit tests, and visual review owns the operator's +Pixel 9 Pro XL. Known limitation: a reply streamed and watched while the chat was +active carries no wall-clock stamp on its pushed frames, so its exact recency is +only learned from the server's history/`updated_at` on a later read; if the app is +killed before that, a restart can conservatively re-flag that chat until it is +opened again. Opening always clears the mark. + +## Finding a session among many: search and directory grouping (17 Oct 2026) + +The chat list is the operator's own sessions in recency order, but as a day's work +accumulates it is a flat, unsearchable wall and the session that is wanted is the +one that cannot be found. The list can now be narrowed by typing over each chat's +title and directory, sessions of one repository are grouped together, and a +narrowing that matches nothing says so and offers to clear it. +`android/` only; no dependency was added beyond the already-declared +material-icons-extended, nothing in the Pipelines server, its Go source, the +installer or the Docker files was touched, and no run is started from the app. + +- **The search control reuses the list-filter pattern.** + `ChatListSearchControl` is the shared `FilterMenu` (the same top-bar icon with + an active-count badge used by the pipelines and runs lists), carrying one + `OutlinedTextField` and a `Clear search` reset. It is not a new control: the + field narrows the list as the operator types and the menu stays open behind it, + exactly like the pipelines name filter. +- **The match rule is one pure derivation.** `ui/chat/ChatListFilter.kt` + adds `sessionMatchesQuery` / `filterChatSessions`: a case-insensitive substring + over the session's title (the local rename included, since it is applied to the + visible list first) and its directory. A blank or whitespace query narrows + nothing, and the survivors keep their incoming order — so the search composes + with the recency order rather than re-sorting it. +- **Same repository, together.** `groupChatSessionsByDirectory` groups the + narrowed sessions by directory, each group keeping the recency order inside it + and the groups ordered by their first (most recent) session, so the top of the + list still leads with the newest activity. The list pane renders a directory + heading per group only when there is more than one directory; a single directory + (or none) stays the flat list, which is already together. Every row still shows + its directory as before. +- **Empty result and the create path.** A narrowing that matches nothing renders + the shared `EmptyState` — `No chats match "".` with a `Clear search` + action — the same empty-state pattern the other lists use. The trailing + `New chat` action is never hidden while the list is narrowed, so creating stays + one tap away. +- **State and marks untouched.** `ChatState.sessionQuery` (set through + `ChatStore.searchSessions` / `AppViewModel.setChatSessionQuery`) is a display + narrowing only: it never touches the server's list or an open conversation, and + the activity marks derive from the same session ids as before. + +Tests (`ChatListFilterTest`, 9 cases): the match rule over title and directory +(case-insensitive, blank matches all, a miss is empty), that filtering preserves +the recency order, grouping by directory (order by the first session, order kept +inside a group, a single directory yields one group, a blank directory groups +too), and — through the store — that searching narrows `filteredSessions`, +clearing restores the full list, the server's list is untouched, and a filtered +session still reports its activity mark. + +Evidence (this run's implementer pass, macOS, Gradle 8.11.1 at +`~/.gradle/wrapper/dists/gradle-8.11.1-bin/bpt9gzteqjrbo1mjrsomdt32c/gradle-8.11.1/bin/gradle` +with `JAVA_HOME="/Applications/Android Studio.app/Contents/jbr/Contents/Home"` +(JDK 17) and `ANDROID_HOME=/Users/alan/Library/Android/sdk`): +`gradle --offline --no-daemon :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the +JUnit XMLs total **55 suites / 501 tests / 0 failures / 0 errors / 0 skipped** (9 +new in `ChatListFilterTest`). `gradle --offline --no-daemon :app:assembleDebug` → +`BUILD SUCCESSFUL`; the APK was published to this run's artifacts directory as +`pipelines-debug-wip-bb486ac.apk` (18,486,624 bytes, sha256 +`d276f7be66501c7becdd83628e3407f955ec982552a87a6a5146d4f44cb5598d`; `bb486ac` is +`git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it) and is +served at +`http://10.0.0.75:8080/artifacts/271/1/pipelines-debug-wip-bb486ac.apk` +(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, +`Content-Length: 18486624`). + +Not verified in this pass: the search field, the directory sections and the +empty state on a device, and the narrow/wide layouts — the brief keeps +implementation verification to the build and the unit tests, and visual review +owns the operator's Pixel 9 Pro XL. diff --git a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt index 48bdc9c8..282cfa42 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt @@ -59,6 +59,12 @@ class SettingsRepository(context: Context) { private val _chatOverrides = MutableStateFlow(prefs.getString(KEY_CHAT_OVERRIDES, "").orEmpty()) val chatOverrides: StateFlow = _chatOverrides.asStateFlow() + // What the operator has read of the chat session list, stored as one opaque + // JSON string the same way the overrides above are: the chat layer owns the + // shape, so this repository stays unaware of the chat model. + private val _chatSeen = MutableStateFlow(prefs.getString(KEY_CHAT_SEEN, "").orEmpty()) + val chatSeen: StateFlow = _chatSeen.asStateFlow() + fun setServerUrl(value: String) { val trimmed = value.trim() _serverUrl.value = trimmed @@ -117,6 +123,12 @@ class SettingsRepository(context: Context) { prefs.edit().putString(KEY_CHAT_OVERRIDES, value).apply() } + fun setChatSeen(value: String) { + if (value == _chatSeen.value) return + _chatSeen.value = value + prefs.edit().putString(KEY_CHAT_SEEN, value).apply() + } + /** True only when the user has explicitly supplied both required values. */ fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank() @@ -132,5 +144,6 @@ class SettingsRepository(context: Context) { const val KEY_PIPELINE_FILTER_RUN_STATUSES = "pipeline_filter_run_statuses" const val KEY_PIPELINE_FILTER_NAME = "pipeline_filter_name" const val KEY_CHAT_OVERRIDES = "chat_overrides" + const val KEY_CHAT_SEEN = "chat_seen" } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index 0d2f6707..77d6ca34 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -38,6 +38,7 @@ import net.awan.pipelines.data.transport.ConnectionState import net.awan.pipelines.data.transport.ServerUrl import net.awan.pipelines.ui.chat.ChatAttachment import net.awan.pipelines.ui.chat.ChatSessionOverrides +import net.awan.pipelines.ui.chat.ChatSeenState import net.awan.pipelines.ui.chat.ChatState import net.awan.pipelines.ui.chat.ChatStore import net.awan.pipelines.ui.chat.attachmentFiles @@ -134,7 +135,10 @@ class AppViewModel( private val retryKeys = ConcurrentHashMap() /** The multi-chat screen state (sessions, open conversations, drafts, scroll). */ - private val chatStore = ChatStore(overrides = ChatSessionOverrides.decode(settings.chatOverrides.value)) + private val chatStore = ChatStore( + overrides = ChatSessionOverrides.decode(settings.chatOverrides.value), + seen = ChatSeenState.decode(settings.chatSeen.value), + ) val chat: StateFlow = chatStore.state // The live run subscription: the workspace currently watched, the job that @@ -177,6 +181,7 @@ class AppViewModel( observeRunEvents() observeConnection() observeChatOverrides() + observeChatSeen() } /** @@ -475,6 +480,21 @@ class AppViewModel( } } + /** + * Persists what the operator has read of the session list (the recency + * watermarks and the live unread marks) as they change, so the marks a chat + * carries are still there after a restart, not only across a reconnect. Only a + * real change is written; the settings repository ignores a repeat, so the + * initial emission is a no-op. + */ + private fun observeChatSeen() { + viewModelScope.launch { + chatStore.state.map { it.seen }.distinctUntilChanged().collect { + settings.setChatSeen(it.encode()) + } + } + } + fun updateServerUrlDraft(value: String) { _serverUrlDraft.value = value _urlError.value = null @@ -819,6 +839,14 @@ class AppViewModel( /** Shows the session list again while keeping every open conversation. */ fun showChatList() = chatStore.showList() + /** + * Narrows the session list to what matches [query] over each chat's title and + * directory, as the operator types. It is a display narrowing only, so no + * request is made and open conversations are untouched; a blank query clears + * it. + */ + fun setChatSessionQuery(query: String) = chatStore.searchSessions(query) + fun closeChat(sessionId: String) = chatStore.close(sessionId) fun updateChatDraft(sessionId: String, text: String) = chatStore.draft(sessionId, text) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt index 970ba2f4..56836c07 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt @@ -116,6 +116,25 @@ internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): else -> "Idle" } +/** + * The activity a session row signals beyond its open/tag/directory state. An + * idle session has nothing extra; an unseen one finished since the operator last + * read it; a streaming one is producing a reply right now. + */ +enum class SessionActivity { IDLE, UNSEEN, STREAMING } + +/** + * The one derivation of a row's activity, so the badge and its unit test cannot + * disagree: a turn streaming right now outranks a finished-but-unread + * transcript, which outranks an idle session. Kept pure (no Compose, no + * transport) like the other chat formatting. + */ +internal fun sessionActivity(running: Boolean, unseen: Boolean): SessionActivity = when { + running -> SessionActivity.STREAMING + unseen -> SessionActivity.UNSEEN + else -> SessionActivity.IDLE +} + /** Which action the composer's single primary control offers for a chat. */ enum class ComposerAction { Send, Stop } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListFilter.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListFilter.kt new file mode 100644 index 00000000..747e74b7 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListFilter.kt @@ -0,0 +1,53 @@ +package net.awan.pipelines.ui.chat + +import net.awan.pipelines.data.protocol.ChatSession + +/** + * The session-list narrowing: a case-insensitive substring the operator types to + * find a chat by what it is called or where it lives. Blank narrows nothing, and + * the list's own recency order is never touched — filtering keeps the order the + * server returned (and the operator's local overrides applied on top). + * + * Kept pure (no Compose, no transport) like the other chat formatting, so the + * match rule and its unit test share one derivation. + */ +internal fun sessionMatchesQuery(session: ChatSession, query: String): Boolean { + val needle = query.trim() + if (needle.isEmpty()) return true + return sessionTitle(session).contains(needle, ignoreCase = true) || + session.directory.contains(needle, ignoreCase = true) +} + +/** + * Narrows [sessions] to those matching [query] over their title and directory. A + * blank query changes nothing, and the surviving sessions keep their original + * relative order, so a narrowing composes with the recency order rather than + * re-sorting it. + */ +internal fun filterChatSessions(sessions: List, query: String): List = + if (query.isBlank()) sessions else sessions.filter { sessionMatchesQuery(it, query) } + +/** + * One run of sessions sharing one directory, so sessions of the same repository + * can be placed together while each keeps its recency position inside the run. + */ +data class ChatSessionGroup(val directory: String, val sessions: List) + +/** + * Groups [sessions] by directory, so sessions in the same repository sit together. + * The sessions keep their incoming recency order (within each group), and the + * groups themselves are ordered by the first — most recent — session they contain, + * so the top of the list still leads with the newest activity. A blank directory is + * a group of its own, labelled by the row as usual. + * + * The caller renders the groups as sections only when there is more than one; + * with a single directory the flat list is already "together". + */ +internal fun groupChatSessionsByDirectory(sessions: List): List { + if (sessions.isEmpty()) return emptyList() + val order = LinkedHashMap>() + for (session in sessions) { + order.getOrPut(session.directory) { mutableListOf() }.add(session) + } + return order.map { (directory, grouped) -> ChatSessionGroup(directory, grouped) } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt index de40d731..189ecb1a 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt @@ -119,6 +119,8 @@ import net.awan.pipelines.ui.components.CODE_BLOCK_MAX_HEIGHT import net.awan.pipelines.ui.components.CodeBlock import net.awan.pipelines.ui.components.EmptyState import net.awan.pipelines.ui.components.ErrorState +import net.awan.pipelines.ui.components.FilterMenu +import net.awan.pipelines.ui.components.FilterSectionHeader import net.awan.pipelines.ui.components.LabelChip import net.awan.pipelines.ui.components.ListRow import net.awan.pipelines.ui.components.LoadingState @@ -136,6 +138,7 @@ import net.awan.pipelines.ui.theme.ICON_INLINE_DP import net.awan.pipelines.ui.theme.ICON_LIST_DP import net.awan.pipelines.ui.theme.ICON_STATUS_DP import net.awan.pipelines.ui.theme.SPACING_S +import net.awan.pipelines.ui.theme.SPACING_M import net.awan.pipelines.ui.theme.SPACING_XXS import net.awan.pipelines.ui.theme.TOOL_PANEL_MAX_WIDTH_DP import net.awan.pipelines.ui.theme.pipelinesText @@ -256,8 +259,12 @@ private 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. - val sessions = state.visibleSessions + // 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. + val sessions = state.filteredSessions + val groups = groupChatSessionsByDirectory(sessions) + val query = state.sessionQuery // A removal is reported for what it is: a local, undoable change, never a // pretend delete — the server is not asked to remove anything. @@ -282,9 +289,12 @@ private fun ChatListPane( TopAppBar( title = { Text("Chat") }, actions = { + ChatListSearchControl(query = query, onQuery = vm::setChatSessionQuery) IconButton(onClick = vm::refreshChatSessions) { Icon(Icons.Default.Refresh, contentDescription = "Refresh chats") } + // The create path stays one tap away while the list is + // narrowed: it is the same trailing action, never hidden. IconButton(onClick = vm::startNewChat) { Icon(Icons.Default.Add, contentDescription = "New chat") } @@ -304,27 +314,37 @@ private fun ChatListPane( NotConnectedNotice() } when { - state.sessionsLoading && sessions.isEmpty() -> LoadingState("Loading chats…") - state.sessionsError != null && sessions.isEmpty() -> { + state.sessionsLoading && state.sessions.isEmpty() -> LoadingState("Loading chats…") + state.sessionsError != null && state.sessions.isEmpty() -> { ErrorState(state.sessionsError, onRetry = vm::refreshChatSessions) } + sessions.isEmpty() && query.isNotBlank() -> EmptyState( + // A narrowing that matches nothing says so plainly and offers + // to clear it, the same empty-state pattern the other lists use. + message = "No chats match \"${query.trim()}\".", + actionLabel = "Clear search", + onAction = { vm.setChatSessionQuery("") }, + ) sessions.isEmpty() -> EmptyState( message = "No chat sessions on this server yet.", actionLabel = "New chat", onAction = vm::startNewChat, ) else -> LazyColumn(Modifier.fillMaxSize()) { - items(sessions, key = { it.id }) { session -> - val thread = state.thread(session.id) - SessionRow( - session = session, - open = thread != null, - running = thread?.running == true, - active = state.activeId == session.id, - onClick = { vm.openChatSession(session) }, - onRename = { renaming = session }, - onRemove = { vm.removeChat(session.id) }, - ) + if (groups.size > 1) { + // More than one directory: one section per repository so + // same-directory chats sit together, each keeping the + // recency order inside it. + 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 }) + } + } + } else { + items(sessions, key = { it.id }) { session -> + SessionListItem(state, session, vm, onRename = { renaming = it }) + } } if (state.sessionsError != null) { item("error") { @@ -353,17 +373,92 @@ private fun ChatListPane( } } +/** + * The session-list search control: the same top-bar filter-menu pattern the other + * lists use, with one free-text field that narrows the list by title and directory + * as the operator types. The active-count badge and the reset action report and + * clear the narrowing, and the create action beside it is never hidden. + */ +@Composable +private fun ChatListSearchControl(query: String, onQuery: (String) -> Unit) { + FilterMenu( + activeCount = if (query.isBlank()) 0 else 1, + contentDescription = "Search chats", + resetLabel = "Clear search", + onReset = { onQuery("") }, + ) { + FilterSectionHeader("Search") + OutlinedTextField( + value = query, + onValueChange = onQuery, + label = { Text("Title or directory contains") }, + singleLine = true, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = SPACING_M, vertical = SPACING_S), + ) + } +} + +/** + * One session of the list, whether it is rendered flat or inside a directory + * section: [SessionRow] fed from the live [state], so the activity marks, the open + * flag and the rename/remove actions are identical in both layouts. + */ +@Composable +private fun SessionListItem( + state: ChatState, + session: ChatSession, + vm: AppViewModel, + onRename: (ChatSession) -> Unit, +) { + val thread = state.thread(session.id) + SessionRow( + session = session, + open = thread != null, + running = thread?.running == true, + unseen = state.isUnseen(session), + active = state.activeId == session.id, + onClick = { vm.openChatSession(session) }, + onRename = { onRename(session) }, + onRemove = { vm.removeChat(session.id) }, + ) +} + +/** + * The heading of one directory section. The directory is shown here as well as on + * every row, so the grouping is legible even after a row scrolls out of view. + */ +@Composable +private fun DirectoryHeader(directory: String) { + Text( + text = directory.ifBlank { NO_DIRECTORY_LABEL }, + style = MaterialTheme.typography.labelLarge, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP), + ) +} + +/** The section heading for sessions the server reported without a directory. */ +private const val NO_DIRECTORY_LABEL = "No directory" + @Composable private fun SessionRow( session: ChatSession, open: Boolean, running: Boolean, + unseen: Boolean, active: Boolean, onClick: () -> Unit, onRename: () -> Unit, onRemove: () -> Unit, ) { val texts = pipelinesText() + val activity = sessionActivity(running, unseen) ListRow(selected = active, onClick = onClick) { Row( verticalAlignment = Alignment.CenterVertically, @@ -380,7 +475,9 @@ 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) } - if (open) SessionBadge("Open", running) + // 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) } val meta = buildList { @@ -596,11 +693,16 @@ private const val CHAT_REMOVED_MESSAGE = "Removed from this list; the chat stays /** A running/busy/open indicator: a coloured dot plus a word, never colour alone. */ @Composable -private fun SessionBadge(label: String, running: Boolean = false) { - val color = when { - running -> MaterialTheme.colorScheme.tertiary - label == "Open" -> MaterialTheme.colorScheme.primary - else -> MaterialTheme.colorScheme.outline +private fun SessionActivityBadge(activity: SessionActivity, open: Boolean) { + val label = when (activity) { + SessionActivity.STREAMING -> "Streaming" + SessionActivity.UNSEEN -> "New" + SessionActivity.IDLE -> if (open) "Open" else return + } + val color = when (activity) { + SessionActivity.STREAMING -> MaterialTheme.colorScheme.tertiary + SessionActivity.UNSEEN -> MaterialTheme.colorScheme.primary + SessionActivity.IDLE -> MaterialTheme.colorScheme.outline } Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp)) { Box(Modifier.size(CHAT_STATUS_DOT).clip(CircleShape).background(color)) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatSeen.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatSeen.kt new file mode 100644 index 00000000..ad03f2cb --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatSeen.kt @@ -0,0 +1,78 @@ +package net.awan.pipelines.ui.chat + +import kotlinx.serialization.Serializable +import net.awan.pipelines.data.protocol.PipelinesJson + +/** + * What the operator has already seen of the session list, derived from data the + * app already receives — the sessions' own `updated_at` recency and the message + * ids/timestamps of the pushed chat events and history — so no server request is + * added to tell a chat with new activity from an idle one. + * + * - [seenAt] is the recency watermark per session: the newest `updated_at` the + * operator has seen. A session the operator has never opened is compared + * against it, so a reply that arrived while the app was closed (a newer + * `updated_at`) still reads as unseen after a restart. First sight of a session + * is seeded, so a chat that predates this feature is not reported as new. + * - [unseen] is the session ids that moved on while the app was open (a pushed + * frame for a chat that is not on screen). It is kept explicitly because a + * live stream carries no wall-clock stamp to compare, and it is what survives a + * restart for a chat whose server recency has not been re-read yet. + * + * Kept as a serializable value so it survives a restart as one preference, + * exactly like the app's other stored chat state ([ChatSessionOverrides]). + */ +@Serializable +data class ChatSeenState( + val seenAt: Map = emptyMap(), + val unseen: Set = emptySet(), +) { + /** The newest recency the operator has seen for [id], or 0 when never seen. */ + fun watermark(id: String): Long = seenAt[id] ?: 0L + + /** True when [updatedAt] is newer than everything seen for [id]. */ + fun isNewer(id: String, updatedAt: Long): Boolean = updatedAt > watermark(id) + + /** + * Records the first sight of [id] at [updatedAt]: its baseline recency, so a + * pre-existing chat is not reported as new activity. A session already known + * (or with no recency to record) is left untouched, and an explicit [unseen] + * mark is never cleared here — this only opens a baseline, it does not read. + */ + fun seeded(id: String, updatedAt: Long): ChatSeenState = + if (id.isBlank() || updatedAt <= 0 || watermark(id) != 0L) this + else copy(seenAt = seenAt + (id to updatedAt)) + + /** + * Records that [id] has been read up to [updatedAt]: its watermark advances + * (never rewinds, so a stale list cannot un-read it) and any [unseen] mark is + * cleared. Called when the operator opens a conversation. + */ + fun read(id: String, updatedAt: Long): ChatSeenState { + if (id.isBlank()) return this + val advanced = updatedAt > watermark(id) + if (!advanced && id !in unseen) return this + return copy( + seenAt = if (advanced) seenAt + (id to updatedAt) else seenAt, + unseen = unseen - id, + ) + } + + /** Marks [id] as having moved on while it was not on screen. */ + fun unread(id: String): ChatSeenState = + if (id.isBlank() || id in unseen) this else copy(unseen = unseen + id) + + /** The one-line JSON this value is stored as; never fails on our own value. */ + fun encode(): String = PipelinesJson.encodeToString(serializer(), this) + + companion object { + /** Decodes a stored value; anything unreadable falls back to nothing seen. */ + fun decode(stored: String): ChatSeenState = + if (stored.isBlank()) { + ChatSeenState() + } else { + runCatching { PipelinesJson.decodeFromString(serializer(), stored) } + .getOrDefault(ChatSeenState()) + } + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt index bc1282a3..4a094e28 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt @@ -157,11 +157,32 @@ data class ChatState( val overrides: ChatSessionOverrides = ChatSessionOverrides(), /** The id of the session most recently removed, while its removal can be undone. */ val lastRemoved: String? = null, + /** What the operator has read of the list (see [ChatSeenState]). */ + val seen: ChatSeenState = ChatSeenState(), + /** + * The operator's search over the list: free text matched against each + * session's title and directory (see [sessionMatchesQuery]). Blank narrows + * nothing, so the default list is the server's order unchanged. + */ + val sessionQuery: String = "", ) { val active: ChatThread? get() = open.firstOrNull { it.sessionId == activeId } fun thread(sessionId: String): ChatThread? = open.firstOrNull { it.sessionId == sessionId } + /** + * Whether [session]'s transcript has moved on unseen: a session that is not + * on screen and either carried a live mark (a push arrived while it was + * backgrounded) or, if it has never been opened here, is newer than the + * recency watermark. An open thread is judged by its live mark alone, so a + * conversation the operator has been in is never re-marked by a later list + * refresh — only by new activity after they leave it. + */ + fun isUnseen(session: ChatSession): Boolean = + session.id != activeId && + (session.id in seen.unseen || + (thread(session.id) == null && seen.isNewer(session.id, session.updatedAt))) + /** * The sessions the list shows: the server's list with the operator's own * local changes applied — a removed chat is hidden and a renamed one shows its @@ -193,6 +214,15 @@ data class ChatState( val hiddenIds = overrides.hiddenIds sessions.count { it.id !in hiddenIds } } + + /** + * The sessions the list shows after the operator's own changes and their + * search: [visibleSessions] narrowed by [sessionQuery], in the same order, so + * the search composes with the recency order instead of re-sorting it. The + * list pane groups the result by directory (see [groupChatSessionsByDirectory]). + */ + val filteredSessions: List + get() = filterChatSessions(visibleSessions, sessionQuery) } /** @@ -214,9 +244,10 @@ data class ChatState( class ChatStore( private val now: () -> Long = System::currentTimeMillis, overrides: ChatSessionOverrides = ChatSessionOverrides(), + seen: ChatSeenState = ChatSeenState(), ) { - private val _state = MutableStateFlow(ChatState(overrides = overrides)) + private val _state = MutableStateFlow(ChatState(overrides = overrides, seen = seen)) val state: StateFlow = _state.asStateFlow() val value: ChatState get() = _state.value @@ -242,6 +273,16 @@ class ChatStore( _state.value = _state.value.copy(sessionsLoading = false, sessionsError = message) } + /** + * Narrows the list by the operator's search text. It is a display narrowing + * only: the server's list and every open conversation are untouched, and a + * blank [query] restores the full, recency-ordered list. + */ + fun searchSessions(query: String) { + if (query == _state.value.sessionQuery) return + _state.value = _state.value.copy(sessionQuery = query) + } + /** * Replaces the server's session list and folds its title/busy flags into any * already-open thread, so a status change is reflected without dropping the @@ -260,9 +301,22 @@ class ChatStore( busy = session.busy, ) } + // Fold the read state in: the active conversation is on screen, so its + // current recency is read; every session seen for the first time is seeded + // so a pre-existing chat is never reported as new activity. A session whose + // recency is now newer than its watermark stays unseen by the model, with + // no extra bookkeeping. + val activeId = _state.value.activeId + val seen = sessions.fold(_state.value.seen) { acc, session -> + when { + session.id == activeId -> acc.read(session.id, session.updatedAt) + else -> acc.seeded(session.id, session.updatedAt) + } + } _state.value = _state.value.copy( sessions = sessions, open = open, + seen = seen, sessionsLoading = false, sessionsLoaded = true, sessionsError = null, @@ -382,6 +436,9 @@ class ChatStore( // A local rename always wins over the server's title, whether the thread // is new or already open. val title = _state.value.overrides.titles[session.id] ?: session.title + // Opening reads the transcript: its current recency is seen and any + // unread mark is cleared, whether the thread is new or being returned to. + val seen = _state.value.seen.read(session.id, session.updatedAt) if (existing == null) { val thread = ChatThread( sessionId = session.id, @@ -392,7 +449,7 @@ class ChatStore( updatedAt = session.updatedAt, busy = session.busy, ) - _state.value = _state.value.copy(open = _state.value.open + thread, activeId = session.id) + _state.value = _state.value.copy(open = _state.value.open + thread, activeId = session.id, seen = seen) return true } val merged = existing.copy( @@ -403,6 +460,7 @@ class ChatStore( _state.value = _state.value.copy( open = _state.value.open.map { if (it.sessionId == session.id) merged else it }, activeId = session.id, + seen = seen, ) return needsResync(merged) } @@ -414,14 +472,27 @@ class ChatStore( */ fun activate(sessionId: String): Boolean { val thread = _state.value.thread(sessionId) ?: return false - _state.value = _state.value.copy(activeId = sessionId) + // Returning to a chat reads it, so a live unread mark clears; the + // watermark advances to the session's recency when the list knows it. + val session = _state.value.sessions.firstOrNull { it.id == sessionId } + val seen = _state.value.seen.read(sessionId, session?.updatedAt ?: 0L) + _state.value = _state.value.copy(activeId = sessionId, seen = seen) return needsResync(thread) } fun close(sessionId: String) { + // Closing a chat the operator had open is still having read it, so a live + // unread mark clears rather than reappearing once the thread is gone. + val thread = _state.value.thread(sessionId) + val session = _state.value.sessions.firstOrNull { it.id == sessionId } + val seen = if (thread != null) { + _state.value.seen.read(sessionId, maxOf(thread.updatedAt, session?.updatedAt ?: 0L)) + } else { + _state.value.seen + } val open = _state.value.open.filterNot { it.sessionId == sessionId } val active = if (_state.value.activeId == sessionId) open.lastOrNull()?.sessionId else _state.value.activeId - _state.value = _state.value.copy(open = open, activeId = active) + _state.value = _state.value.copy(open = open, activeId = active, seen = seen) } /** @@ -498,8 +569,17 @@ class ChatStore( * The running flag is left as-is: history alone cannot say whether a turn is * still in flight. */ - fun history(sessionId: String, messages: List) = update(sessionId) { - it.copy(messages = messages, loading = false, loaded = true, error = null) + fun history(sessionId: String, messages: List) { + update(sessionId) { + it.copy(messages = messages, loading = false, loaded = true, error = null) + } + // A conversation on screen is read as its history arrives: its recency + // watermark advances to the newest message the server reports (its own + // wall clock), so a later restart does not re-flag what was just watched. + if (sessionId == _state.value.activeId) { + val session = _state.value.sessions.firstOrNull { it.id == sessionId } + markRead(sessionId, maxOf(messages.lastOrNull()?.createdAt ?: 0L, session?.updatedAt ?: 0L)) + } } fun running(sessionId: String, running: Boolean) = update(sessionId) { setRunning(it, running) } @@ -554,6 +634,9 @@ class ChatStore( permissionAnswer = if (sameRequest) it.permissionAnswer else "", ) } + // A request waiting on the operator is activity they have not seen yet, so + // a background chat that raises one is marked just like a reply. + markUnread(frame.sessionId) } /** @@ -614,6 +697,7 @@ class ChatStore( fun event(frame: ChatEventFrame) { if (frame.sessionId.isBlank()) return ensureThread(frame.sessionId) + markUnread(frame.sessionId) when (frame.kind) { ChatProtocol.PART_TEXT, ChatProtocol.PART_REASONING -> applyDelta(frame) ChatProtocol.PART_TOOL -> applyTool(frame) @@ -705,6 +789,23 @@ class ChatStore( ) } + /** Advances the read watermark for [sessionId]; a no-op when nothing changed. */ + private fun markRead(sessionId: String, updatedAt: Long) { + val seen = _state.value.seen.read(sessionId, updatedAt) + if (seen !== _state.value.seen) _state.value = _state.value.copy(seen = seen) + } + + /** + * Marks a chat as having moved on while it was not on screen. Activity for the + * active conversation is skipped: the operator is looking at it, so it is read + * as it arrives. + */ + private fun markUnread(sessionId: String) { + if (sessionId == _state.value.activeId) return + val seen = _state.value.seen.unread(sessionId) + if (seen !== _state.value.seen) _state.value = _state.value.copy(seen = seen) + } + companion object { const val LOCAL_MESSAGE_PREFIX = "local-" } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatActivityTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatActivityTest.kt new file mode 100644 index 00000000..47c8ea2a --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatActivityTest.kt @@ -0,0 +1,117 @@ +package net.awan.pipelines.ui.chat + +import net.awan.pipelines.data.protocol.ChatEventFrame +import net.awan.pipelines.data.protocol.ChatPart +import net.awan.pipelines.data.protocol.ChatProtocol +import net.awan.pipelines.data.protocol.ChatSession +import net.awan.pipelines.data.protocol.ChatStep +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * Which session has new activity: a chat whose transcript the operator has not + * read is marked, opening it clears the mark, a chat streaming right now reads + * differently from one that just finished unseen, and the marks survive a restart + * (an encode/decode of the stored state into a fresh store). Driven directly + * against [ChatStore] with no device, server or Compose runtime. + */ +class ChatActivityTest { + + private fun session(id: String, updatedAt: Long = 0) = ChatSession(id = id, title = id, updatedAt = updatedAt) + + private fun delta(sessionId: String, messageId: String = "m1") = ChatEventFrame( + sessionId = sessionId, + messageId = messageId, + kind = ChatProtocol.PART_TEXT, + delta = "hello", + part = ChatPart(type = ChatProtocol.PART_TEXT, id = "$messageId#0"), + ) + + private fun step(sessionId: String, status: String) = ChatEventFrame( + sessionId = sessionId, + kind = ChatProtocol.EVENT_STEP, + step = ChatStep(status = status), + ) + + @Test + fun anUnseenSessionIsMarked() { + val store = ChatStore() + val a = session("a", updatedAt = 100) + store.sessionsLoaded(listOf(a)) + // The first sight of a pre-existing chat is a baseline, not new activity. + assertFalse(store.value.isUnseen(a)) + + // A pushed frame for the chat that is not on screen marks it unseen. + store.event(delta("a")) + assertTrue(store.value.isUnseen(a)) + } + + @Test + fun aSessionNewerThanWhatWasReadIsMarkedWithoutAnyFrame() { + // A reply that arrived while the app was closed: the server's recency moved + // past the stored watermark, and no frame was ever seen. + val stored = ChatSeenState().seeded("a", 100).encode() + val store = ChatStore(seen = ChatSeenState.decode(stored)) + store.sessionsLoaded(listOf(session("a", updatedAt = 200))) + assertTrue(store.value.isUnseen(session("a", updatedAt = 200))) + } + + @Test + fun openingASessionClearsItsMark() { + val store = ChatStore() + val a = session("a") + store.sessionsLoaded(listOf(a)) + store.event(delta("a")) + assertTrue(store.value.isUnseen(a)) + + store.open(a) + assertFalse(store.value.isUnseen(a)) + // The mark is gone from the state that gets persisted too, not just the row. + assertTrue(store.value.seen.unseen.isEmpty()) + } + + @Test + fun aStreamingSessionIsMarkedDifferentlyFromAFinishedUnseenOne() { + // The one activity derivation: streaming outranks unseen, which outranks idle. + assertEquals(SessionActivity.IDLE, sessionActivity(running = false, unseen = false)) + assertEquals(SessionActivity.UNSEEN, sessionActivity(running = false, unseen = true)) + assertEquals(SessionActivity.STREAMING, sessionActivity(running = true, unseen = false)) + assertEquals(SessionActivity.STREAMING, sessionActivity(running = true, unseen = true)) + + // And the same distinction through the store: a background turn is + // streaming while it runs, then finished-unseen once it settles. + val store = ChatStore() + val a = session("a") + store.sessionsLoaded(listOf(a)) + store.event(step("a", ChatProtocol.STEP_STARTED)) + assertEquals( + SessionActivity.STREAMING, + sessionActivity(store.value.thread("a")!!.running, store.value.isUnseen(a)), + ) + store.event(step("a", ChatProtocol.STEP_ENDED)) + assertFalse(store.value.thread("a")!!.running) + assertEquals( + SessionActivity.UNSEEN, + sessionActivity(store.value.thread("a")!!.running, store.value.isUnseen(a)), + ) + } + + @Test + fun theSeenStateSurvivesAReload() { + val seen = ChatSeenState().seeded("a", 100).read("c", 200).unread("b") + assertEquals(seen, ChatSeenState.decode(seen.encode())) + // Nothing stored, or something unreadable, is simply nothing seen. + assertEquals(ChatSeenState(), ChatSeenState.decode("")) + assertEquals(ChatSeenState(), ChatSeenState.decode("{")) + + // A fresh store built from the stored state still reports the unread chat + // and the chat whose server recency moved past what was read. + val store = ChatStore(seen = ChatSeenState.decode(seen.encode())) + store.sessionsLoaded(listOf(session("a", 300), session("b"), session("c", 200))) + assertTrue(store.value.isUnseen(session("a", 300))) + assertTrue(store.value.isUnseen(session("b"))) + assertFalse(store.value.isUnseen(session("c", 200))) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatListFilterTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatListFilterTest.kt new file mode 100644 index 00000000..e071ac37 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatListFilterTest.kt @@ -0,0 +1,124 @@ +package net.awan.pipelines.ui.chat + +import net.awan.pipelines.data.protocol.ChatEventFrame +import net.awan.pipelines.data.protocol.ChatPart +import net.awan.pipelines.data.protocol.ChatProtocol +import net.awan.pipelines.data.protocol.ChatSession +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * The session-list narrowing and grouping: the match rule over a chat's title and + * directory, that a narrowing keeps the recency order, and that sessions of one + * directory group together. Pure, so it needs no device, server or Compose. + */ +class ChatListFilterTest { + + private fun session( + id: String, + title: String = id, + directory: String = "", + updatedAt: Long = 0, + ) = ChatSession(id = id, title = title, directory = directory, updatedAt = updatedAt) + + private fun delta(sessionId: String) = ChatEventFrame( + sessionId = sessionId, + messageId = "m1", + kind = ChatProtocol.PART_TEXT, + delta = "hello", + part = ChatPart(type = ChatProtocol.PART_TEXT, id = "m1#0"), + ) + + private val deploy = session("a", title = "Deploy API", directory = "/repos/api") + private val webBug = session("b", title = "Fix login", directory = "/repos/web") + private val webDocs = session("c", title = "Write docs", directory = "/repos/web") + + // --- the match rule: title and directory ------------------------------------ + + @Test + fun aBlankQueryMatchesEverySession() { + assertTrue(sessionMatchesQuery(deploy, "")) + assertTrue(sessionMatchesQuery(deploy, " ")) + assertEquals(listOf(deploy, webBug, webDocs), filterChatSessions(listOf(deploy, webBug, webDocs), "")) + } + + @Test + fun theQueryMatchesTheTitleOrTheDirectoryIgnoringCase() { + // Title, case-insensitively. + assertTrue(sessionMatchesQuery(deploy, "deploy")) + assertTrue(sessionMatchesQuery(deploy, "API")) + // Directory, case-insensitively. + assertTrue(sessionMatchesQuery(webBug, "REPOS/WEB")) + assertEquals(listOf(webBug, webDocs), filterChatSessions(listOf(deploy, webBug, webDocs), "web")) + } + + @Test + fun aQueryThatMatchesNothingYieldsAnEmptyList() { + assertTrue(filterChatSessions(listOf(deploy, webBug), "no-such-chat").isEmpty()) + } + + // --- narrowing preserves the underlying order -------------------------------- + + @Test + fun filteringKeepsTheRecencyOrderOfTheSurvivors() { + val ordered = listOf(deploy, webBug, webDocs) + // Both web chats are kept in the order they were given, not re-sorted. + assertEquals(listOf("b", "c"), filterChatSessions(ordered, "web").map { it.id }) + // A single hit is still just that hit. + assertEquals(listOf("a"), filterChatSessions(ordered, "deploy").map { it.id }) + } + + // --- grouping by directory -------------------------------------------------- + + @Test + fun sessionsOfTheSameDirectoryGroupTogetherKeepingTheirOrder() { + val groups = groupChatSessionsByDirectory(listOf(deploy, webBug, webDocs)) + // The first group is the one whose most recent session comes first. + assertEquals(listOf("/repos/api", "/repos/web"), groups.map { it.directory }) + assertEquals(listOf("b", "c"), groups[1].sessions.map { it.id }) + } + + @Test + fun aSingleDirectoryYieldsOneGroupSoTheFlatListIsAlreadyTogether() { + assertEquals(1, groupChatSessionsByDirectory(listOf(webBug, webDocs)).size) + assertTrue(groupChatSessionsByDirectory(emptyList()).isEmpty()) + } + + @Test + fun sessionsWithoutADirectoryGroupTogetherToo() { + val groups = groupChatSessionsByDirectory(listOf(session("a"), session("b", directory = "/repos/x"))) + assertEquals(listOf("", "/repos/x"), groups.map { it.directory }) + } + + // --- through the store ------------------------------------------------------ + + @Test + fun searchNarrowsTheStoreListAndClearingRestoresIt() { + val store = ChatStore() + store.sessionsLoaded(listOf(deploy, webBug, webDocs)) + assertEquals(listOf("a", "b", "c"), store.value.filteredSessions.map { it.id }) + + store.searchSessions("web") + // The list is narrowed but the order is untouched. + assertEquals(listOf("b", "c"), store.value.filteredSessions.map { it.id }) + // The server's list itself is untouched. + assertEquals(3, store.value.sessions.size) + + store.searchSessions("") + assertEquals(listOf("a", "b", "c"), store.value.filteredSessions.map { it.id }) + } + + @Test + fun theActivityMarkIsReportedForAFilteredSession() { + val store = ChatStore() + store.sessionsLoaded(listOf(deploy, webBug, webDocs)) + // A pushed frame for a background chat marks it, whether or not it matches. + store.event(delta("b")) + store.searchSessions("web") + assertTrue(store.value.isUnseen(webBug)) + val groups = groupChatSessionsByDirectory(store.value.filteredSessions) + assertEquals(1, groups.size) + assertEquals(listOf("b", "c"), groups.single().sessions.map { it.id }) + } +}