From bb486acc1199b2da2994c3297bb9b31f7d0f8bb7 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 17 Oct 2026 14:40:02 +0100 Subject: [PATCH 1/2] chat: mark new activity in the session list With several operator sessions 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. Add a per-session read state that the session list derives from data it already receives, and render it as a three-state activity badge: - ChatSeenState (ui/chat/ChatSeen.kt) keeps a per-session recency watermark (the newest updated_at the operator has read) plus the ids that moved on while the app was open. It is persisted as one opaque JSON preference (SettingsRepository chat_seen, observed by AppViewModel.observeChatSeen), the same way ChatSessionOverrides is, so the marks survive a restart and not only a reconnect. - ChatState.isUnseen marks a background session that carried a live mark (a pushed chat_event/permission frame) or, if never opened here, is newer than its stored watermark; first sight of a session is seeded to its current recency so a pre-existing chat is not reported as new. Opening, activating and closing a conversation reads it and clears the mark; history for the active chat advances the watermark to the newest server message. No server request is added. - ChatFormat.sessionActivity(running, unseen) is the one pure derivation (streaming outranks finished-unseen, which outranks idle) and SessionActivityBadge renders it as Streaming/New/Open beside the unchanged kind chip and directory line. Most-recently-used order is untouched. Tests (ChatActivityTest): unseen is marked, opening clears it including in the persisted state, the derivation distinguishes streaming/finished-unseen/ idle, and the seen state survives an encode/decode into a fresh store. Checked before commit: android/README.md was updated in this change with the behaviour, tests and evidence. The packaged authoring skill references (internal/author/skill/references/) describe the Pipelines server and its chat_* protocol surface, neither of which changed - this is a client-side derivation over existing frames - so none needed updating, and the internal/author/install.go managed reference inventory is unchanged. No repository template or root/topic doc describes the Android session list, so none was stale. android/ only; no dependency added; no run is started from the app. --- android/README.md | 73 +++++++++++ .../awan/pipelines/data/SettingsRepository.kt | 13 ++ .../net/awan/pipelines/ui/AppViewModel.kt | 22 +++- .../net/awan/pipelines/ui/chat/ChatFormat.kt | 19 +++ .../net/awan/pipelines/ui/chat/ChatScreen.kt | 22 +++- .../net/awan/pipelines/ui/chat/ChatSeen.kt | 78 ++++++++++++ .../net/awan/pipelines/ui/chat/ChatStore.kt | 88 ++++++++++++- .../pipelines/ui/chat/ChatActivityTest.kt | 117 ++++++++++++++++++ 8 files changed, 419 insertions(+), 13 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/chat/ChatSeen.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/chat/ChatActivityTest.kt diff --git a/android/README.md b/android/README.md index add68f53..d0936dcd 100644 --- a/android/README.md +++ b/android/README.md @@ -5641,3 +5641,76 @@ 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. 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..82c8aa31 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 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/ChatScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatScreen.kt index de40d731..aced4464 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 @@ -320,6 +320,7 @@ private fun ChatListPane( session = session, open = thread != null, running = thread?.running == true, + unseen = state.isUnseen(session), active = state.activeId == session.id, onClick = { vm.openChatSession(session) }, onRename = { renaming = session }, @@ -358,12 +359,14 @@ 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 +383,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 +601,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..9ac99b8d 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,26 @@ 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(), ) { 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 @@ -214,9 +229,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 @@ -260,9 +276,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 +411,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 +424,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 +435,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 +447,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 +544,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 +609,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 +672,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 +764,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))) + } +} From 355fe4e908412fd865ef91a7528b0719979fbb19 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sat, 17 Oct 2026 14:50:30 +0100 Subject: [PATCH 2/2] chat: search the session list and group it by directory With a day's sessions the list was a flat, unsearchable wall in recency order, so the chat the operator wanted was the one that could not be found, and sessions of one repository were scattered through it. Narrow the list as the operator types and keep same-repository chats together, using the control and empty-state patterns the other lists already use: - ChatListFilter.kt adds the one pure derivation: sessionMatchesQuery / filterChatSessions match a case-insensitive substring over a session's title and directory, a blank query narrows nothing, and the survivors keep their incoming (recency) order. groupChatSessionsByDirectory groups the narrowed list by directory, each group keeping that order and the groups ordered by their first (most recent) session, so the top still leads with the newest activity. - ChatState.sessionQuery (set through ChatStore.searchSessions / AppViewModel.setChatSessionQuery) is a display narrowing only: the server's list, open conversations and the activity marks are untouched. filteredSessions is visibleSessions narrowed by the query. - ChatListPane renders the existing FilterMenu with one OutlinedTextField and a Clear search reset (the pipelines/runs filter pattern), shows a directory heading per group only when more than one directory is present, and renders the shared EmptyState ("No chats match ...") with a Clear search action when nothing matches. The trailing New chat action is never hidden while the list is narrowed, and every row still shows its directory. Tests (ChatListFilterTest, 9 cases): the match rule over title and directory, that a narrowing 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. Checked before commit: android/README.md was updated in this change with the behaviour, tests and evidence. The packaged authoring skill references (internal/author/skill/references/) document the Pipelines server, its chat_* protocol surface and authoring, none of which changed - this is a client-side narrowing over the already-listed sessions - so none needed updating, and the internal/author/install.go managed reference inventory is unchanged. No repository template or root/topic doc describes the Android session list, so none was stale. android/ only; no dependency added beyond the already-declared material-icons-extended; no run is started from the app. --- android/README.md | 69 ++++++++++ .../net/awan/pipelines/ui/AppViewModel.kt | 8 ++ .../awan/pipelines/ui/chat/ChatListFilter.kt | 53 ++++++++ .../net/awan/pipelines/ui/chat/ChatScreen.kt | 124 +++++++++++++++--- .../net/awan/pipelines/ui/chat/ChatStore.kt | 25 ++++ .../pipelines/ui/chat/ChatListFilterTest.kt | 124 ++++++++++++++++++ 6 files changed, 387 insertions(+), 16 deletions(-) create mode 100644 android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListFilter.kt create mode 100644 android/app/src/test/java/net/awan/pipelines/ui/chat/ChatListFilterTest.kt diff --git a/android/README.md b/android/README.md index d0936dcd..44a598b7 100644 --- a/android/README.md +++ b/android/README.md @@ -5714,3 +5714,72 @@ 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/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index 82c8aa31..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 @@ -839,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/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 aced4464..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,28 +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, - unseen = state.isUnseen(session), - 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") { @@ -354,6 +373,79 @@ 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, 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 9ac99b8d..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 @@ -159,6 +159,12 @@ data class ChatState( 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 } @@ -208,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) } /** @@ -258,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 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 }) + } +}