Merge lane-chat2: combine operator chat session management with live run updates
Both sides are reviewed work and both are kept: - android/app/.../ui/AppViewModel.kt: HEAD's live-run push wiring (RunStreamState/_runStream, combine(connectionState, settings.workspace), subscribeRuns/streamDown/resync, applyRunEvent, scheduleRunsResync/ scheduleRunDetailSync, observeRunEvents) together with lane-chat2's chat management (ChatStore overrides, observeChatOverrides, refreshChatDirectories, startNewChat/selectChatDirectory/cancelNewChat/createNewChat, renameChat/removeChat/undoRemoveChat). The only textual conflict was the import list; combine (HEAD) plus map and ui.chat.ChatSessionOverrides (lane) are all kept and all used. No duplicated definitions. - android/README.md: HEAD's "Live run updates from the socket" section and lane-chat2's "Operator chat sessions: choose the directory, list only your own" section are both present once, in file order. - The rest of lane-chat2's chat files (ChatDirectories.kt, ChatOverrides.kt, ChatStore.kt, ChatScreen.kt, ChatFormat.kt, protocol Chat/Message, repositories, tests) merge cleanly on top of HEAD's work. Documentation check: android/README.md is updated by this merge and its new section is consistent with HEAD's. docs/cli.md and internal/author/skill/references/operations.md already describe the server's chat_sessions/chat_create/chat_directories surface this client builds on, and the authoring skill (SKILL.md, references/) contains no Android-client behaviour to stale, so nothing there needed changing and no packaged reference or inventory entry was touched. No server, installer or template change is part of this merge. Checks (android/, Gradle 8.11.1, --offline): - gradle :app:testDebugUnitTest --offline --rerun-tasks -> BUILD SUCCESSFUL; test-results report 463 tests, 0 failures, 0 errors across 50 suites (including ChatDirectoriesTest and ChatSessionManagementTest). - gradle :app:assembleDebug --offline -> BUILD SUCCESSFUL (debug APK built). Not verified here: on-device picker/rendering, which the visual-review stage owns.
This commit is contained in:
@@ -5353,3 +5353,65 @@ owns the operator's Pixel 9 Pro XL): the on-device status change with no refresh
|
||||
and the live/reconnecting badge rendering. The captures and the phone's
|
||||
main-revision restore are that stage's evidence.
|
||||
|
||||
## Operator chat sessions: choose the directory, list only your own (17 Oct 2026)
|
||||
|
||||
The Chat destination now starts a chat by asking where it should live, and its
|
||||
list is the operator's own sessions only. Before this change "New chat" created a
|
||||
session with no directory of its own choosing (it passed the workspace, so the
|
||||
session landed wherever the server happened to be) and the list was whatever
|
||||
`chat_sessions` returned with no way to tell an operator chat from anything
|
||||
run-related. The server change this builds on (operator sessions tagged
|
||||
`operator`, `chat_sessions` returning exactly those with their directory and
|
||||
recency, and a `chat_directories` request) is already in this revision; 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.
|
||||
|
||||
- **Starting a chat asks where first.** `ChatScreen`'s level-1 pane is now the
|
||||
directory picker while a create is in flight: the server's
|
||||
`chat_directories` reply (the operator's home first, then the directories of
|
||||
previous operator sessions, most recently used first) rendered through the
|
||||
shared `ListRow`, each with its full path, home shown as `Home (~)` with its
|
||||
absolute path beneath it. It is a normal pane of the chat stack, so Back, the
|
||||
app bar's back control, the footer's Cancel and the predictive-back gesture all
|
||||
leave it without creating anything — not a modal dead end.
|
||||
- **The directory is always sent.** The picker starts on the operator's home
|
||||
(`directoryChoices`/`defaultDirectoryChoice`) and `chat_create` is sent the
|
||||
chosen directory — `~` for home, the absolute path for a recent — so a session
|
||||
is never created in the server's own working directory. The server resolves or
|
||||
rejects it, and its error is shown in the pane.
|
||||
- **The list is the server's, and says so.** The list renders
|
||||
`ChatState.visibleSessions`: exactly the server's `chat_sessions` (operator
|
||||
sessions only — the app never guesses which session belongs to a run) with the
|
||||
operator's own local changes applied. Each row carries its directory and the
|
||||
kind chip derived from the server's own tag (`sessionTagLabel`, `operator` →
|
||||
`Operator`), so an operator chat is tellable at a glance.
|
||||
- **Managing a session, honestly.** The brokered protocol has no rename and no
|
||||
delete for a chat session (there is no `chat_rename`/`chat_delete` type and the
|
||||
native session endpoint is not exposed), so both are the operator's own,
|
||||
device-local changes, persisted with the other settings
|
||||
(`SettingsRepository.chat_overrides`, `ChatSessionOverrides`): rename stores a
|
||||
local title that wins over the server's on every later list load, and "Remove
|
||||
from list" hides the row and closes its conversation while a snackbar reports
|
||||
it as a local, undoable change ("Removed from this list; the chat stays on the
|
||||
server.") with an Undo action. Nothing is deleted on the server, and a refresh
|
||||
cannot bring a removed row back.
|
||||
- **Everything else is unchanged.** Multi-chat drafts/scroll/running, streaming,
|
||||
tool chips, diff cards, approval cards, stop and the reconnect path are
|
||||
untouched; the picker only reuses the stack's second level the conversation
|
||||
already used.
|
||||
|
||||
Tests (`app/src/test`): `ChatDirectoriesTest` (home first and the default, the
|
||||
recents' order and their full-path create value, an empty/blank reply still
|
||||
yielding home), `ChatSessionManagementTest` (the chip from the server's tag, the
|
||||
create flow's home default and chosen directory, rename winning over the server
|
||||
title and surviving a refresh, removal hiding until undone and leaving the
|
||||
server's list intact, the override encode/decode round trip) and the new
|
||||
`ChatProtocolTest` cases for the `tag` field and the `chat_directories`
|
||||
request/reply.
|
||||
|
||||
Not verified in this pass: the on-device picker, the tagged list and a session
|
||||
open in a chosen directory — the brief keeps implementation verification to the
|
||||
build and the unit tests, and visual review owns the device. The chip, menu and
|
||||
dialog are Compose UI, which this module has no unit harness for; they are
|
||||
covered by compilation only.
|
||||
|
||||
@@ -210,14 +210,29 @@ class PipelinesRepository(
|
||||
// ---- Brokered OpenCode chat (route B): the phone never speaks OpenCode
|
||||
// directly and never holds its credentials. ----
|
||||
|
||||
/** Lists the sessions this server owns, with the `busy` flag the phone renders read-only. */
|
||||
/**
|
||||
* Lists the sessions this server owns, with the `busy` flag the phone renders
|
||||
* read-only. The server already returns operator sessions only, so the app
|
||||
* never filters this list by ownership.
|
||||
*/
|
||||
suspend fun chatSessions(): List<ChatSession> =
|
||||
client.call(Message(type = Protocol.CHAT_SESSIONS)).chatSessions ?: emptyList()
|
||||
|
||||
/**
|
||||
* Creates a session and returns it. The server currently answers this type
|
||||
* with an explicit error when it does not broker creation; the caller
|
||||
* surfaces that message rather than guessing at a session id.
|
||||
* The directories a new chat can be started in: the operator's home first,
|
||||
* then the directories of previous operator sessions, most recently used
|
||||
* first. The server is the only source of these choices — the app never
|
||||
* invents one.
|
||||
*/
|
||||
suspend fun chatDirectories(): List<String> =
|
||||
client.call(Message(type = Protocol.CHAT_DIRECTORIES)).chatDirectories ?: emptyList()
|
||||
|
||||
/**
|
||||
* Creates a session in an explicit [directory] and returns it. The directory
|
||||
* is always sent (the server resolves `~` to the operator's home), so a chat
|
||||
* is never created in whatever directory the server happens to be running in.
|
||||
* The server reports its own error when it does not broker creation; the
|
||||
* caller surfaces that message rather than guessing at a session id.
|
||||
*/
|
||||
suspend fun chatCreate(title: String, directory: String): ChatSession {
|
||||
val response = client.call(
|
||||
|
||||
@@ -6,7 +6,8 @@ import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
|
||||
/**
|
||||
* Persists the explicitly configured server URL and workspace path as plain,
|
||||
* Persists the explicitly configured server URL and workspace path, the list
|
||||
* sort/filter choices and the operator's local chat-session changes as plain,
|
||||
* non-secret preferences. No credentials or tokens are ever stored, because the
|
||||
* server has no authentication.
|
||||
*/
|
||||
@@ -52,6 +53,12 @@ class SettingsRepository(context: Context) {
|
||||
private val _pipelineFilterName = MutableStateFlow(prefs.getString(KEY_PIPELINE_FILTER_NAME, "").orEmpty())
|
||||
val pipelineFilterName: StateFlow<String> = _pipelineFilterName.asStateFlow()
|
||||
|
||||
// The operator's local chat-session changes (renames and removals), stored as
|
||||
// one opaque JSON string: the chat layer owns the shape, so this repository
|
||||
// stays unaware of the chat model, exactly like the sort/filter keys above.
|
||||
private val _chatOverrides = MutableStateFlow(prefs.getString(KEY_CHAT_OVERRIDES, "").orEmpty())
|
||||
val chatOverrides: StateFlow<String> = _chatOverrides.asStateFlow()
|
||||
|
||||
fun setServerUrl(value: String) {
|
||||
val trimmed = value.trim()
|
||||
_serverUrl.value = trimmed
|
||||
@@ -104,6 +111,12 @@ class SettingsRepository(context: Context) {
|
||||
prefs.edit().putString(KEY_PIPELINE_FILTER_NAME, value).apply()
|
||||
}
|
||||
|
||||
fun setChatOverrides(value: String) {
|
||||
if (value == _chatOverrides.value) return
|
||||
_chatOverrides.value = value
|
||||
prefs.edit().putString(KEY_CHAT_OVERRIDES, value).apply()
|
||||
}
|
||||
|
||||
/** True only when the user has explicitly supplied both required values. */
|
||||
fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank()
|
||||
|
||||
@@ -118,5 +131,6 @@ class SettingsRepository(context: Context) {
|
||||
const val KEY_PIPELINE_FILTER_PRESENCE = "pipeline_filter_presence"
|
||||
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"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,6 +22,11 @@ data class ChatSession(
|
||||
val model: String = "",
|
||||
val directory: String = "",
|
||||
@SerialName("parent_id") val parentId: String = "",
|
||||
// The stored session kind. The only value the server records is "operator"
|
||||
// (a chat the person created); a pipeline stage session is never tagged and
|
||||
// is never listed by chat_sessions. Additive/optional, so an older server
|
||||
// simply omits it and the client shows no kind chip.
|
||||
val tag: String = "",
|
||||
@SerialName("created_at") val createdAt: Long = 0,
|
||||
@SerialName("updated_at") val updatedAt: Long = 0,
|
||||
// Another client holds the session, or the server itself owns it as an active
|
||||
@@ -200,6 +205,13 @@ object ChatProtocol {
|
||||
const val DECISION_ALWAYS = "always"
|
||||
const val DECISION_REJECT = "reject"
|
||||
|
||||
/**
|
||||
* The only stored [ChatSession.tag] value, mirroring `internal/protocol/
|
||||
* chat.go`: a session the operator created. The display label (`Operator`) is
|
||||
* derived from it by the UI rather than carried as a second field.
|
||||
*/
|
||||
const val TAG_OPERATOR = "operator"
|
||||
|
||||
/** A tool call still in flight (no result or error yet). */
|
||||
fun toolRunning(state: ChatToolState?): Boolean = when (state?.status) {
|
||||
TOOL_STREAMING, TOOL_RUNNING -> true
|
||||
|
||||
@@ -65,6 +65,9 @@ object Protocol {
|
||||
const val CHAT_MESSAGES = "chat_messages"
|
||||
const val CHAT_INTERRUPT = "chat_interrupt"
|
||||
const val CHAT_REPLY = "chat_reply"
|
||||
// The operator's directory choices for a new chat (home first, then the
|
||||
// directories of previous operator sessions, most recently used first).
|
||||
const val CHAT_DIRECTORIES = "chat_directories"
|
||||
// Server-pushed frames with no matching request.
|
||||
const val CHAT_EVENT = "chat_event"
|
||||
const val CHAT_PERMISSION = "chat_permission"
|
||||
@@ -635,4 +638,5 @@ data class Message(
|
||||
@SerialName("chat_event") val chatEvent: ChatEventFrame? = null,
|
||||
@SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null,
|
||||
@SerialName("chat_reply") val chatReply: ChatReplyRequest? = null,
|
||||
@SerialName("chat_directories") val chatDirectories: List<String>? = null,
|
||||
)
|
||||
|
||||
@@ -15,6 +15,7 @@ import kotlinx.coroutines.flow.combine
|
||||
import kotlinx.coroutines.flow.distinctUntilChanged
|
||||
import kotlinx.coroutines.flow.filterIsInstance
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withTimeoutOrNull
|
||||
import net.awan.pipelines.PipelinesApplication
|
||||
@@ -35,6 +36,7 @@ import net.awan.pipelines.data.protocol.SessionEvidence
|
||||
import net.awan.pipelines.data.protocol.Template
|
||||
import net.awan.pipelines.data.transport.ConnectionState
|
||||
import net.awan.pipelines.data.transport.ServerUrl
|
||||
import net.awan.pipelines.ui.chat.ChatSessionOverrides
|
||||
import net.awan.pipelines.ui.chat.ChatState
|
||||
import net.awan.pipelines.ui.chat.ChatStore
|
||||
|
||||
@@ -130,7 +132,7 @@ class AppViewModel(
|
||||
private val retryKeys = ConcurrentHashMap<Long, String>()
|
||||
|
||||
/** The multi-chat screen state (sessions, open conversations, drafts, scroll). */
|
||||
private val chatStore = ChatStore()
|
||||
private val chatStore = ChatStore(overrides = ChatSessionOverrides.decode(settings.chatOverrides.value))
|
||||
val chat: StateFlow<ChatState> = chatStore.state
|
||||
|
||||
// The live run subscription: the workspace currently watched, the job that
|
||||
@@ -172,6 +174,7 @@ class AppViewModel(
|
||||
observeChatEvents()
|
||||
observeRunEvents()
|
||||
observeConnection()
|
||||
observeChatOverrides()
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -457,6 +460,19 @@ class AppViewModel(
|
||||
if (subscribedWorkspace != null) _runStream.value = RunStreamState.Connecting
|
||||
}
|
||||
|
||||
/**
|
||||
* Persists the operator's local chat changes (renames and removals) as they
|
||||
* happen, so a managed list survives a restart. Only a real change is written;
|
||||
* the settings repository ignores a repeat, so the initial emission is a no-op.
|
||||
*/
|
||||
private fun observeChatOverrides() {
|
||||
viewModelScope.launch {
|
||||
chatStore.state.map { it.overrides }.distinctUntilChanged().collect {
|
||||
settings.setChatOverrides(it.encode())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun updateServerUrlDraft(value: String) {
|
||||
_serverUrlDraft.value = value
|
||||
_urlError.value = null
|
||||
@@ -766,6 +782,23 @@ class AppViewModel(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Refreshes the directories a new chat can start in (the operator's home first,
|
||||
* then the recents). The server is the only source, so a failed load reports
|
||||
* its error rather than inventing a choice.
|
||||
*/
|
||||
fun refreshChatDirectories() {
|
||||
viewModelScope.launch {
|
||||
chatStore.directoriesLoading()
|
||||
try {
|
||||
chatStore.directoriesLoaded(repository.chatDirectories())
|
||||
} catch (t: Throwable) {
|
||||
if (t is CancellationException) throw t
|
||||
chatStore.directoriesFailed(ErrorMessages.describe(t))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Opens [session] and makes it active. A brand-new chat always loads its
|
||||
* history; a running one re-syncs from the server so a stale copy is never
|
||||
@@ -790,21 +823,63 @@ class AppViewModel(
|
||||
|
||||
fun saveChatScroll(sessionId: String, index: Int, offset: Int) = chatStore.scroll(sessionId, index, offset)
|
||||
|
||||
/** Creates a session on the server and opens it. Reports the server's own error on failure. */
|
||||
fun newChat() {
|
||||
// ---- Directory choices and starting a new chat ---------------------------
|
||||
|
||||
/**
|
||||
* Opens the directory picker for a new chat and refreshes its choices. The
|
||||
* chat is not created until a directory is confirmed, so "New chat" can never
|
||||
* create a session wherever the server happens to be.
|
||||
*/
|
||||
fun startNewChat() {
|
||||
chatStore.createOpened()
|
||||
refreshChatDirectories()
|
||||
}
|
||||
|
||||
/** Picks the directory the new chat will be created in. */
|
||||
fun selectChatDirectory(directory: String) = chatStore.createDirectoryChosen(directory)
|
||||
|
||||
/** Leaves the create flow without creating anything. */
|
||||
fun cancelNewChat() = chatStore.createCancelled()
|
||||
|
||||
/**
|
||||
* Creates the chat in the chosen directory and opens it. The directory is
|
||||
* always sent, so the server resolves it (or rejects it) instead of falling
|
||||
* back to its own working directory.
|
||||
*/
|
||||
fun createNewChat() {
|
||||
val create = chatStore.value.create ?: return
|
||||
if (create.creating) return
|
||||
chatStore.creating()
|
||||
viewModelScope.launch {
|
||||
try {
|
||||
val created = repository.chatCreate(title = "New chat", directory = settings.workspace.value)
|
||||
chatStore.sessionsLoaded(chatStore.value.sessions + created)
|
||||
chatStore.open(created)
|
||||
val created = repository.chatCreate(title = "New chat", directory = create.directory)
|
||||
chatStore.createSucceeded(created)
|
||||
chatStore.history(created.id, emptyList())
|
||||
} catch (t: Throwable) {
|
||||
if (t is CancellationException) throw t
|
||||
chatStore.sessionsFailed(ErrorMessages.describe(t))
|
||||
chatStore.createFailed(ErrorMessages.describe(t))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Managing a session --------------------------------------------------
|
||||
|
||||
/**
|
||||
* Renames a session. The brokered protocol has no rename, so the title is kept
|
||||
* on this device (persisted with the other settings) and shown in place of the
|
||||
* server's own; nothing is sent to the server.
|
||||
*/
|
||||
fun renameChat(sessionId: String, title: String) = chatStore.rename(sessionId, title)
|
||||
|
||||
/**
|
||||
* Removes a session from this device's list. The server is not asked to delete
|
||||
* anything — it exposes no delete for an OpenCode session — so the removal is
|
||||
* local and can be undone from the message that reports it.
|
||||
*/
|
||||
fun removeChat(sessionId: String) = chatStore.remove(sessionId)
|
||||
|
||||
fun undoRemoveChat() = chatStore.undoRemove()
|
||||
|
||||
fun loadChatHistory(sessionId: String) {
|
||||
viewModelScope.launch {
|
||||
chatStore.historyLoading(sessionId)
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
package net.awan.pipelines.ui.chat
|
||||
|
||||
/**
|
||||
* The value chat_create uses for the operator's home directory. It is the one
|
||||
* literal the server documents (`~`, `~/...` and an omitted/empty value all
|
||||
* resolve to the operator's home), so the home choice is sent exactly as the
|
||||
* server defines it instead of relying on a locally known absolute path.
|
||||
*/
|
||||
const val HOME_DIRECTORY = "~"
|
||||
|
||||
/**
|
||||
* One directory the operator can start a new chat in, derived from the server's
|
||||
* `chat_directories` reply (the operator's home first, then the directories of
|
||||
* previous operator sessions, most recently used first).
|
||||
*
|
||||
* [label] is what the row shows; [path] is the full directory, always shown so
|
||||
* the operator can tell two directories apart. [createDirectory] is what
|
||||
* chat_create sends: the home choice goes as [HOME_DIRECTORY] and a recent as
|
||||
* its absolute path.
|
||||
*/
|
||||
data class ChatDirectoryChoice(
|
||||
val label: String,
|
||||
val path: String,
|
||||
val home: Boolean,
|
||||
) {
|
||||
val createDirectory: String get() = if (home) HOME_DIRECTORY else path
|
||||
|
||||
/** The full path shown beneath the home row; a recent's own label is its path. */
|
||||
val secondary: String? get() = if (home) path else null
|
||||
}
|
||||
|
||||
/**
|
||||
* The picker's choices from the server's reported directories. The first entry is
|
||||
* the operator's home — the one entry the server always returns first and never
|
||||
* dedupes away — and the rest keep the server's most-recently-used order. A blank
|
||||
* entry is dropped, and a reply with nothing in it still yields the home choice,
|
||||
* so the picker is never empty.
|
||||
*/
|
||||
fun directoryChoices(directories: List<String>): List<ChatDirectoryChoice> {
|
||||
val cleaned = directories.filter { it.isNotBlank() }
|
||||
val home = cleaned.firstOrNull() ?: HOME_DIRECTORY
|
||||
return buildList {
|
||||
add(ChatDirectoryChoice(label = HOME_TEXT, path = home, home = true))
|
||||
cleaned.drop(1).forEach { add(ChatDirectoryChoice(label = it, path = it, home = false)) }
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The choice a freshly opened picker starts on: the operator's home, first. The
|
||||
* operator has to touch the picker only to change the directory, never to accept
|
||||
* the default.
|
||||
*/
|
||||
fun defaultDirectoryChoice(choices: List<ChatDirectoryChoice>): ChatDirectoryChoice? = choices.firstOrNull()
|
||||
|
||||
/** The home row's label; the `~` the server accepts, named so the flow reads. */
|
||||
private const val HOME_TEXT = "Home ($HOME_DIRECTORY)"
|
||||
@@ -85,6 +85,21 @@ internal fun toolLabel(part: ChatPart): String = part.name.ifBlank { "tool" }
|
||||
internal fun sessionTitle(session: ChatSession): String =
|
||||
session.title.ifBlank { session.id.take(18).ifBlank { "Untitled chat" } }
|
||||
|
||||
/**
|
||||
* The kind chip a session row shows, derived from the server's own tag: a session
|
||||
* the server tagged `operator` reads `Operator`. Any other tag is shown verbatim
|
||||
* (a kind this client does not know is never silently dropped) and an untagged
|
||||
* session shows no chip. This only *labels*; the app never filters on the tag,
|
||||
* because the server already lists operator sessions only.
|
||||
*/
|
||||
internal fun sessionTagLabel(session: ChatSession): String? = when {
|
||||
session.tag.isBlank() -> null
|
||||
session.tag == ChatProtocol.TAG_OPERATOR -> OPERATOR_TAG_LABEL
|
||||
else -> session.tag
|
||||
}
|
||||
|
||||
private const val OPERATOR_TAG_LABEL = "Operator"
|
||||
|
||||
/**
|
||||
* The status a session row shows. A locally-running turn is reported as
|
||||
* `Running`; otherwise the server's `busy` flag is `Busy · read-only` (another
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
package net.awan.pipelines.ui.chat
|
||||
|
||||
import kotlinx.serialization.Serializable
|
||||
import net.awan.pipelines.data.protocol.PipelinesJson
|
||||
|
||||
/**
|
||||
* The operator's own changes to the session list, which the server has no
|
||||
* request for: a chat cannot be renamed or deleted through the brokered
|
||||
* protocol (there is no chat_rename/chat_delete type, and the OpenCode session
|
||||
* endpoint is not exposed), so both are kept here, on the device, and applied
|
||||
* over whatever the server lists.
|
||||
*
|
||||
* - [titles] are local renames, keyed by session id; a renamed chat shows its
|
||||
* local title and the server's title is left untouched.
|
||||
* - [hidden] are sessions the operator removed from the list. Nothing is deleted
|
||||
* on the server, so the removal is honest and reversible ([remove] can be
|
||||
* undone with [restore]).
|
||||
*
|
||||
* Kept as a serializable value so it survives a restart as one preference,
|
||||
* exactly like the app's other stored settings.
|
||||
*/
|
||||
@Serializable
|
||||
data class ChatSessionOverrides(
|
||||
val titles: Map<String, String> = emptyMap(),
|
||||
val hidden: List<String> = emptyList(),
|
||||
) {
|
||||
/** The hidden ids as a set, so membership checks on the list are O(1). */
|
||||
val hiddenIds: Set<String> get() = hidden.toSet()
|
||||
|
||||
/** Records a local rename for [id]; a blank id or title is ignored. */
|
||||
fun renamed(id: String, title: String): ChatSessionOverrides {
|
||||
val trimmed = title.trim()
|
||||
if (id.isBlank() || trimmed.isEmpty()) return this
|
||||
return copy(titles = titles + (id to trimmed))
|
||||
}
|
||||
|
||||
/** Hides [id] from the list; a blank id or an already-hidden one changes nothing. */
|
||||
fun hide(id: String): ChatSessionOverrides =
|
||||
if (id.isBlank() || id in hidden) this else copy(hidden = hidden + id)
|
||||
|
||||
/** Restores a hidden [id] to the list, undoing [hide]. */
|
||||
fun restore(id: String): ChatSessionOverrides =
|
||||
if (id !in hidden) this else copy(hidden = hidden - 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 no overrides. */
|
||||
fun decode(stored: String): ChatSessionOverrides =
|
||||
if (stored.isBlank()) {
|
||||
ChatSessionOverrides()
|
||||
} else {
|
||||
runCatching { PipelinesJson.decodeFromString(serializer(), stored) }
|
||||
.getOrDefault(ChatSessionOverrides())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -38,15 +38,19 @@ import androidx.compose.material.icons.filled.Edit
|
||||
import androidx.compose.material.icons.filled.ErrorOutline
|
||||
import androidx.compose.material.icons.filled.KeyboardArrowDown
|
||||
import androidx.compose.material.icons.filled.KeyboardArrowUp
|
||||
import androidx.compose.material.icons.filled.MoreVert
|
||||
import androidx.compose.material.icons.filled.PanTool
|
||||
import androidx.compose.material.icons.filled.Psychology
|
||||
import androidx.compose.material.icons.filled.Refresh
|
||||
import androidx.compose.material.icons.filled.Stop
|
||||
import androidx.compose.material.icons.outlined.Shield
|
||||
import androidx.compose.material3.AlertDialog
|
||||
import androidx.compose.material3.Button
|
||||
import androidx.compose.material3.Card
|
||||
import androidx.compose.material3.CardDefaults
|
||||
import androidx.compose.material3.CircularProgressIndicator
|
||||
import androidx.compose.material3.DropdownMenu
|
||||
import androidx.compose.material3.DropdownMenuItem
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.HorizontalDivider
|
||||
import androidx.compose.material3.Icon
|
||||
@@ -54,6 +58,10 @@ import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.OutlinedTextField
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.SnackbarDuration
|
||||
import androidx.compose.material3.SnackbarHost
|
||||
import androidx.compose.material3.SnackbarHostState
|
||||
import androidx.compose.material3.SnackbarResult
|
||||
import androidx.compose.material3.Surface
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.material3.TextButton
|
||||
@@ -99,6 +107,7 @@ 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.LabelChip
|
||||
import net.awan.pipelines.ui.components.ListRow
|
||||
import net.awan.pipelines.ui.components.LoadingState
|
||||
import net.awan.pipelines.ui.components.PaneIdentity
|
||||
@@ -113,6 +122,8 @@ import net.awan.pipelines.ui.theme.ICON_BUTTON_SMALL_DP
|
||||
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
|
||||
import net.awan.pipelines.ui.theme.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_XXS
|
||||
import net.awan.pipelines.ui.theme.TOOL_PANEL_MAX_WIDTH_DP
|
||||
import net.awan.pipelines.ui.theme.pipelinesText
|
||||
|
||||
@@ -157,21 +168,25 @@ fun ChatScreen(vm: AppViewModel, wide: Boolean, modifier: Modifier = Modifier) {
|
||||
val state by vm.chat.collectAsStateWithLifecycle()
|
||||
val connection by vm.connectionState.collectAsStateWithLifecycle()
|
||||
val active = state.active
|
||||
val create = state.create
|
||||
|
||||
// Fetch the server's session list once when the Chat destination opens.
|
||||
LaunchedEffect(Unit) { vm.refreshChatSessions() }
|
||||
|
||||
// Back inside a conversation returns to the session list before leaving the
|
||||
// destination, exactly one level (the same rule the other destinations use).
|
||||
PredictiveBackHandler(enabled = active != null) { progress ->
|
||||
// Back leaves the create flow first, then a conversation, before leaving the
|
||||
// destination, exactly one level at a time (the same rule the other
|
||||
// destinations use).
|
||||
PredictiveBackHandler(enabled = create != null || active != null) { progress ->
|
||||
progress.collect { }
|
||||
vm.showChatList()
|
||||
if (create != null) vm.cancelNewChat() else vm.showChatList()
|
||||
}
|
||||
|
||||
SlidingPaneStack(
|
||||
depth = if (active != null) 1 else 0,
|
||||
// The directory picker and the conversation share the second level: they
|
||||
// are mutually exclusive, so a pane is never mounted empty behind either.
|
||||
depth = if (create != null || active != null) 1 else 0,
|
||||
wide = wide,
|
||||
onPopTo = { vm.showChatList() },
|
||||
onPopTo = { if (state.create != null) vm.cancelNewChat() else vm.showChatList() },
|
||||
compactLabel = "Chats",
|
||||
backContentDescription = { "Back to chats" },
|
||||
modifier = modifier,
|
||||
@@ -184,11 +199,14 @@ fun ChatScreen(vm: AppViewModel, wide: Boolean, modifier: Modifier = Modifier) {
|
||||
covered = covered,
|
||||
modifier = paneModifier,
|
||||
)
|
||||
1 -> active?.let { thread ->
|
||||
// Key by session so each conversation gets its own list state and
|
||||
// disposes (saving its scroll) when the operator switches away.
|
||||
key(thread.sessionId) {
|
||||
ChatConversationPane(vm = vm, state = state, thread = thread, modifier = paneModifier)
|
||||
1 -> when {
|
||||
create != null -> NewChatPane(vm = vm, state = state, create = create, modifier = paneModifier)
|
||||
active != null -> {
|
||||
// Key by session so each conversation gets its own list state
|
||||
// and disposes (saving its scroll) when the operator switches away.
|
||||
key(active.sessionId) {
|
||||
ChatConversationPane(vm = vm, state = state, thread = active, modifier = paneModifier)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -206,12 +224,16 @@ private fun ChatListPane(
|
||||
covered: Boolean,
|
||||
modifier: Modifier,
|
||||
) {
|
||||
// A covered pane shows its compact identity only; the server list and the
|
||||
// operator's own local changes are folded into the visible projection only
|
||||
// for the pane actually drawn, never for the sliver behind a conversation.
|
||||
if (covered) {
|
||||
val count = state.visibleSessionCount
|
||||
PaneIdentity(
|
||||
title = "Chat",
|
||||
subtitle = when {
|
||||
state.open.isNotEmpty() -> "${state.open.size} open"
|
||||
state.sessions.isNotEmpty() -> "${state.sessions.size} sessions"
|
||||
count > 0 -> "$count sessions"
|
||||
else -> null
|
||||
},
|
||||
modifier = modifier.fillMaxSize(),
|
||||
@@ -219,8 +241,30 @@ private fun ChatListPane(
|
||||
return
|
||||
}
|
||||
|
||||
// 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
|
||||
|
||||
// A removal is reported for what it is: a local, undoable change, never a
|
||||
// pretend delete — the server is not asked to remove anything.
|
||||
val snackbarHostState = remember { SnackbarHostState() }
|
||||
LaunchedEffect(state.lastRemoved) {
|
||||
if (state.lastRemoved != null &&
|
||||
snackbarHostState.showSnackbar(
|
||||
message = CHAT_REMOVED_MESSAGE,
|
||||
actionLabel = "Undo",
|
||||
duration = SnackbarDuration.Long,
|
||||
) == SnackbarResult.ActionPerformed
|
||||
) {
|
||||
vm.undoRemoveChat()
|
||||
}
|
||||
}
|
||||
var renaming by remember { mutableStateOf<ChatSession?>(null) }
|
||||
|
||||
Scaffold(
|
||||
modifier = modifier,
|
||||
snackbarHost = { SnackbarHost(snackbarHostState) },
|
||||
topBar = {
|
||||
TopAppBar(
|
||||
title = { Text("Chat") },
|
||||
@@ -228,7 +272,7 @@ private fun ChatListPane(
|
||||
IconButton(onClick = vm::refreshChatSessions) {
|
||||
Icon(Icons.Default.Refresh, contentDescription = "Refresh chats")
|
||||
}
|
||||
IconButton(onClick = vm::newChat) {
|
||||
IconButton(onClick = vm::startNewChat) {
|
||||
Icon(Icons.Default.Add, contentDescription = "New chat")
|
||||
}
|
||||
},
|
||||
@@ -247,17 +291,17 @@ private fun ChatListPane(
|
||||
NotConnectedNotice()
|
||||
}
|
||||
when {
|
||||
state.sessionsLoading && state.sessions.isEmpty() -> LoadingState("Loading chats…")
|
||||
state.sessionsError != null && state.sessions.isEmpty() -> {
|
||||
state.sessionsLoading && sessions.isEmpty() -> LoadingState("Loading chats…")
|
||||
state.sessionsError != null && sessions.isEmpty() -> {
|
||||
ErrorState(state.sessionsError, onRetry = vm::refreshChatSessions)
|
||||
}
|
||||
state.sessions.isEmpty() -> EmptyState(
|
||||
sessions.isEmpty() -> EmptyState(
|
||||
message = "No chat sessions on this server yet.",
|
||||
actionLabel = "New chat",
|
||||
onAction = vm::newChat,
|
||||
onAction = vm::startNewChat,
|
||||
)
|
||||
else -> LazyColumn(Modifier.fillMaxSize()) {
|
||||
items(state.sessions, key = { it.id }) { session ->
|
||||
items(sessions, key = { it.id }) { session ->
|
||||
val thread = state.thread(session.id)
|
||||
SessionRow(
|
||||
session = session,
|
||||
@@ -265,6 +309,8 @@ private fun ChatListPane(
|
||||
running = thread?.running == true,
|
||||
active = state.activeId == session.id,
|
||||
onClick = { vm.openChatSession(session) },
|
||||
onRename = { renaming = session },
|
||||
onRemove = { vm.removeChat(session.id) },
|
||||
)
|
||||
}
|
||||
if (state.sessionsError != null) {
|
||||
@@ -281,6 +327,17 @@ private fun ChatListPane(
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
renaming?.let { session ->
|
||||
RenameChatDialog(
|
||||
session = session,
|
||||
onDismiss = { renaming = null },
|
||||
onConfirm = { title ->
|
||||
vm.renameChat(session.id, title)
|
||||
renaming = null
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
@@ -290,18 +347,28 @@ private fun SessionRow(
|
||||
running: Boolean,
|
||||
active: Boolean,
|
||||
onClick: () -> Unit,
|
||||
onRename: () -> Unit,
|
||||
onRemove: () -> Unit,
|
||||
) {
|
||||
val texts = pipelinesText()
|
||||
ListRow(selected = active, onClick = onClick) {
|
||||
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP)) {
|
||||
Row(
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
) {
|
||||
Text(
|
||||
text = sessionTitle(session),
|
||||
style = texts.cardTitle,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
modifier = Modifier.weight(1f, fill = false),
|
||||
modifier = Modifier.weight(1f),
|
||||
)
|
||||
// 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)
|
||||
SessionMenu(onRename = onRename, onRemove = onRemove)
|
||||
}
|
||||
val meta = buildList {
|
||||
add(sessionStatusLabel(session, running))
|
||||
@@ -312,6 +379,208 @@ private fun SessionRow(
|
||||
}
|
||||
}
|
||||
|
||||
/** A session row's management actions: rename and remove from this device's list. */
|
||||
@Composable
|
||||
private fun SessionMenu(onRename: () -> Unit, onRemove: () -> Unit) {
|
||||
var expanded by remember { mutableStateOf(false) }
|
||||
Box {
|
||||
IconButton(onClick = { expanded = true }, modifier = Modifier.size(ICON_BUTTON_SMALL_DP)) {
|
||||
Icon(
|
||||
Icons.Default.MoreVert,
|
||||
contentDescription = "Chat actions",
|
||||
modifier = Modifier.size(ICON_INLINE_DP),
|
||||
)
|
||||
}
|
||||
DropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
|
||||
DropdownMenuItem(
|
||||
text = { Text("Rename…") },
|
||||
onClick = {
|
||||
expanded = false
|
||||
onRename()
|
||||
},
|
||||
)
|
||||
DropdownMenuItem(
|
||||
text = { Text("Remove from list") },
|
||||
onClick = {
|
||||
expanded = false
|
||||
onRemove()
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The rename dialog. The brokered protocol has no rename for a chat session, so
|
||||
* the dialog says plainly that the name is kept on this device rather than
|
||||
* implying the server was told.
|
||||
*/
|
||||
@Composable
|
||||
private fun RenameChatDialog(session: ChatSession, onDismiss: () -> Unit, onConfirm: (String) -> Unit) {
|
||||
var title by remember(session.id) { mutableStateOf(sessionTitle(session)) }
|
||||
AlertDialog(
|
||||
onDismissRequest = onDismiss,
|
||||
title = { Text("Rename chat") },
|
||||
text = {
|
||||
Column(verticalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP)) {
|
||||
OutlinedTextField(
|
||||
value = title,
|
||||
onValueChange = { title = it },
|
||||
singleLine = true,
|
||||
label = { Text("Name") },
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
)
|
||||
Text(
|
||||
text = "The server has no rename for a chat, so this name is kept on this device.",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
},
|
||||
confirmButton = {
|
||||
TextButton(onClick = { onConfirm(title) }, enabled = title.isNotBlank()) { Text("Save") }
|
||||
},
|
||||
dismissButton = { TextButton(onClick = onDismiss) { Text("Cancel") } },
|
||||
)
|
||||
}
|
||||
|
||||
// ---- The create flow: choose the directory, then create ----------------------
|
||||
|
||||
/**
|
||||
* Where the operator starts a new chat: the server's directories, the home first
|
||||
* and the recents after it, each with its full path. It is a normal pane of the
|
||||
* chat stack — Back or its Cancel control leaves without creating anything — so
|
||||
* starting a chat is a step in the flow rather than a modal dead end, and a
|
||||
* session is never created wherever the server happens to run.
|
||||
*
|
||||
* The operator's home is the default; a recent is chosen with one tap, and the
|
||||
* chat is created only when the operator confirms.
|
||||
*/
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
private fun NewChatPane(
|
||||
vm: AppViewModel,
|
||||
state: ChatState,
|
||||
create: ChatCreateState,
|
||||
modifier: Modifier,
|
||||
) {
|
||||
val choices = remember(state.directories) { directoryChoices(state.directories) }
|
||||
val selected = remember(create.directory, choices) {
|
||||
choices.firstOrNull { it.createDirectory == create.directory } ?: defaultDirectoryChoice(choices)
|
||||
}
|
||||
Scaffold(
|
||||
modifier = modifier,
|
||||
topBar = {
|
||||
TopAppBar(
|
||||
title = { Text("Start a chat") },
|
||||
navigationIcon = {
|
||||
IconButton(onClick = vm::cancelNewChat) {
|
||||
Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Cancel new chat")
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
) { padding ->
|
||||
Column(Modifier.fillMaxSize().padding(padding)) {
|
||||
when {
|
||||
state.directoriesError != null && !state.directoriesLoaded ->
|
||||
ErrorState(state.directoriesError, onRetry = vm::refreshChatDirectories)
|
||||
!state.directoriesLoaded -> LoadingState("Loading directories…")
|
||||
else -> {
|
||||
Text(
|
||||
text = "Where should this chat live?",
|
||||
style = MaterialTheme.typography.titleSmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
|
||||
)
|
||||
LazyColumn(Modifier.weight(1f).fillMaxWidth()) {
|
||||
items(choices, key = { it.createDirectory }) { choice ->
|
||||
DirectoryRow(
|
||||
choice = choice,
|
||||
selected = choice.createDirectory == selected?.createDirectory,
|
||||
onClick = { vm.selectChatDirectory(choice.createDirectory) },
|
||||
)
|
||||
}
|
||||
}
|
||||
if (state.directoriesError != null) {
|
||||
Text(
|
||||
text = state.directoriesError,
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.error,
|
||||
modifier = Modifier.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
|
||||
)
|
||||
}
|
||||
create.error?.let { error ->
|
||||
Text(
|
||||
text = error,
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.error,
|
||||
modifier = Modifier.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
|
||||
)
|
||||
}
|
||||
NewChatActions(
|
||||
directory = selected?.createDirectory ?: create.directory,
|
||||
creating = create.creating,
|
||||
onCreate = vm::createNewChat,
|
||||
onCancel = vm::cancelNewChat,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** One directory the new chat can live in: the home first, then the recents. */
|
||||
@Composable
|
||||
private fun DirectoryRow(choice: ChatDirectoryChoice, selected: Boolean, onClick: () -> Unit) {
|
||||
ListRow(selected = selected, onClick = onClick) {
|
||||
Text(
|
||||
text = choice.label,
|
||||
style = pipelinesText().cardTitle,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
)
|
||||
// The home row's label is `~`, so its full path is shown beneath it; a
|
||||
// recent's own label already is its full path.
|
||||
choice.secondary?.let { path ->
|
||||
Text(text = path, style = pipelinesText().meta, maxLines = 1, overflow = TextOverflow.Ellipsis)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The create flow's footer: the chosen directory, its confirm and its cancel. */
|
||||
@Composable
|
||||
private fun NewChatActions(directory: String, creating: Boolean, onCreate: () -> Unit, onCancel: () -> Unit) {
|
||||
Surface(color = MaterialTheme.colorScheme.surfaceContainer) {
|
||||
Row(
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(CHAT_COMPOSER_GAP),
|
||||
modifier = Modifier.fillMaxWidth().padding(CHAT_GUTTER),
|
||||
) {
|
||||
Text(
|
||||
text = "Start in $directory",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
modifier = Modifier.weight(1f),
|
||||
)
|
||||
TextButton(onClick = onCancel, enabled = !creating) { Text("Cancel") }
|
||||
Button(onClick = onCreate, enabled = !creating) {
|
||||
if (creating) {
|
||||
Box(contentAlignment = Alignment.Center) {
|
||||
CircularProgressIndicator(Modifier.size(ICON_INLINE_DP), strokeWidth = 2.dp)
|
||||
}
|
||||
} else {
|
||||
Text("New chat")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The removal report: what happened and how to undo it. */
|
||||
private const val CHAT_REMOVED_MESSAGE = "Removed from this list; the chat stays on the server."
|
||||
|
||||
/** A running/busy/open indicator: a coloured dot plus a word, never colour alone. */
|
||||
@Composable
|
||||
private fun SessionBadge(label: String, running: Boolean = false) {
|
||||
|
||||
@@ -77,9 +77,23 @@ data class ChatThread(
|
||||
}
|
||||
|
||||
/**
|
||||
* The multi-chat screen state. [sessions] is the server's list; [open] is the
|
||||
* ordered set of conversations the operator has opened, each preserved
|
||||
* independently; [activeId] is the one currently on screen.
|
||||
* The directory picker's state while a new chat is being started. It holds only
|
||||
* what the picker needs: the chosen directory (the operator's home until a recent
|
||||
* is picked), whether the create request is in flight, and the server's error when
|
||||
* it fails. The picker is a normal pane of the chat stack, so the operator can go
|
||||
* back out of it at any point.
|
||||
*/
|
||||
data class ChatCreateState(
|
||||
val directory: String = HOME_DIRECTORY,
|
||||
val creating: Boolean = false,
|
||||
val error: String? = null,
|
||||
)
|
||||
|
||||
/**
|
||||
* The multi-chat screen state. [sessions] is the server's list (operator sessions
|
||||
* only — the server does the filtering, never the app); [open] is the ordered set
|
||||
* of conversations the operator has opened, each preserved independently;
|
||||
* [activeId] is the one currently on screen.
|
||||
*/
|
||||
data class ChatState(
|
||||
val sessions: List<ChatSession> = emptyList(),
|
||||
@@ -88,10 +102,53 @@ data class ChatState(
|
||||
val sessionsError: String? = null,
|
||||
val open: List<ChatThread> = emptyList(),
|
||||
val activeId: String? = null,
|
||||
/** The server's directory choices for a new chat, home first. */
|
||||
val directories: List<String> = emptyList(),
|
||||
val directoriesLoading: Boolean = false,
|
||||
val directoriesLoaded: Boolean = false,
|
||||
val directoriesError: String? = null,
|
||||
/** Non-null while the operator is choosing where to start a new chat. */
|
||||
val create: ChatCreateState? = null,
|
||||
/** The operator's own local renames and removals (see [ChatSessionOverrides]). */
|
||||
val overrides: ChatSessionOverrides = ChatSessionOverrides(),
|
||||
/** The id of the session most recently removed, while its removal can be undone. */
|
||||
val lastRemoved: String? = null,
|
||||
) {
|
||||
val active: ChatThread? get() = open.firstOrNull { it.sessionId == activeId }
|
||||
|
||||
fun thread(sessionId: String): ChatThread? = open.firstOrNull { it.sessionId == sessionId }
|
||||
|
||||
/**
|
||||
* 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
|
||||
* local title. This is the only filtering the app does, and it is the
|
||||
* operator's explicit action, never a guess about which session belongs to a
|
||||
* run: the server already returns operator sessions only.
|
||||
*/
|
||||
val visibleSessions: List<ChatSession>
|
||||
get() {
|
||||
val overrides = this.overrides
|
||||
if (overrides.hidden.isEmpty() && overrides.titles.isEmpty()) return sessions
|
||||
// The hidden ids are resolved once for the whole list, so each row's
|
||||
// membership check is O(1) instead of rebuilding the set per element.
|
||||
val hiddenIds = overrides.hiddenIds
|
||||
return sessions
|
||||
.filterNot { it.id in hiddenIds }
|
||||
.map { session -> overrides.titles[session.id]?.let { session.copy(title = it) } ?: session }
|
||||
}
|
||||
|
||||
/**
|
||||
* How many sessions the list shows. The covered pane's identity shows only
|
||||
* this count, so a pane drawn as a sliver never builds the renamed projection
|
||||
* of [visibleSessions]; the same local removals are applied either way.
|
||||
*/
|
||||
val visibleSessionCount: Int
|
||||
get() = if (overrides.hidden.isEmpty()) {
|
||||
sessions.size
|
||||
} else {
|
||||
val hiddenIds = overrides.hiddenIds
|
||||
sessions.count { it.id !in hiddenIds }
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -110,9 +167,12 @@ data class ChatState(
|
||||
* [now] is injectable so the running indicator's elapsed time is testable without
|
||||
* a device clock.
|
||||
*/
|
||||
class ChatStore(private val now: () -> Long = System::currentTimeMillis) {
|
||||
class ChatStore(
|
||||
private val now: () -> Long = System::currentTimeMillis,
|
||||
overrides: ChatSessionOverrides = ChatSessionOverrides(),
|
||||
) {
|
||||
|
||||
private val _state = MutableStateFlow(ChatState())
|
||||
private val _state = MutableStateFlow(ChatState(overrides = overrides))
|
||||
val state: StateFlow<ChatState> = _state.asStateFlow()
|
||||
|
||||
val value: ChatState get() = _state.value
|
||||
@@ -131,14 +191,16 @@ class ChatStore(private val now: () -> Long = System::currentTimeMillis) {
|
||||
* 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
|
||||
* conversation. An open thread the server no longer lists is kept (its
|
||||
* conversation is still the operator's).
|
||||
* conversation is still the operator's). A local rename wins over the server's
|
||||
* title, so refreshing the list never undoes what the operator named it.
|
||||
*/
|
||||
fun sessionsLoaded(sessions: List<ChatSession>) {
|
||||
val byId = sessions.associateBy { it.id }
|
||||
val renamed = _state.value.overrides.titles
|
||||
val open = _state.value.open.map { thread ->
|
||||
val session = byId[thread.sessionId] ?: return@map thread
|
||||
thread.copy(
|
||||
title = session.title.ifBlank { thread.title },
|
||||
title = renamed[thread.sessionId] ?: session.title.ifBlank { thread.title },
|
||||
directory = session.directory.ifBlank { thread.directory },
|
||||
busy = session.busy,
|
||||
)
|
||||
@@ -152,6 +214,107 @@ class ChatStore(private val now: () -> Long = System::currentTimeMillis) {
|
||||
)
|
||||
}
|
||||
|
||||
// ---- Directory choices and starting a chat -------------------------------
|
||||
|
||||
fun directoriesLoading() {
|
||||
_state.value = _state.value.copy(directoriesLoading = true, directoriesError = null)
|
||||
}
|
||||
|
||||
/** Replaces the picker's choices with the server's (home first, recents after). */
|
||||
fun directoriesLoaded(directories: List<String>) {
|
||||
_state.value = _state.value.copy(
|
||||
directories = directories.filter { it.isNotBlank() },
|
||||
directoriesLoading = false,
|
||||
directoriesLoaded = true,
|
||||
directoriesError = null,
|
||||
)
|
||||
}
|
||||
|
||||
fun directoriesFailed(message: String) {
|
||||
_state.value = _state.value.copy(directoriesLoading = false, directoriesError = message)
|
||||
}
|
||||
|
||||
/** Opens the directory picker on its default (the operator's home). */
|
||||
fun createOpened() {
|
||||
_state.value = _state.value.copy(create = ChatCreateState())
|
||||
}
|
||||
|
||||
/** Picks a directory in the picker; the home stays the default until this is called. */
|
||||
fun createDirectoryChosen(directory: String) {
|
||||
val create = _state.value.create ?: return
|
||||
_state.value = _state.value.copy(create = create.copy(directory = directory, error = null))
|
||||
}
|
||||
|
||||
/** Leaves the create flow without creating anything. */
|
||||
fun createCancelled() {
|
||||
if (_state.value.create != null) _state.value = _state.value.copy(create = null)
|
||||
}
|
||||
|
||||
fun creating() {
|
||||
val create = _state.value.create ?: return
|
||||
_state.value = _state.value.copy(create = create.copy(creating = true, error = null))
|
||||
}
|
||||
|
||||
fun createFailed(message: String) {
|
||||
val create = _state.value.create ?: return
|
||||
_state.value = _state.value.copy(create = create.copy(creating = false, error = message))
|
||||
}
|
||||
|
||||
/**
|
||||
* The chat was created in its chosen directory: the picker closes, the new
|
||||
* (most recently used) session goes to the head of the list and becomes the
|
||||
* active conversation. The caller then loads its — empty — history.
|
||||
*/
|
||||
fun createSucceeded(session: ChatSession) {
|
||||
_state.value = _state.value.copy(
|
||||
sessions = listOf(session) + _state.value.sessions.filterNot { it.id == session.id },
|
||||
create = null,
|
||||
)
|
||||
open(session)
|
||||
}
|
||||
|
||||
// ---- Renaming and removing ----------------------------------------------
|
||||
|
||||
/**
|
||||
* Renames a session locally. The server has no rename for a chat session, so
|
||||
* the new title is kept on this device and left to win over the server's own
|
||||
* on every later list load; the server's copy is untouched.
|
||||
*/
|
||||
fun rename(sessionId: String, title: String) {
|
||||
val overrides = _state.value.overrides.renamed(sessionId, title)
|
||||
if (overrides == _state.value.overrides) return
|
||||
val renamed = overrides.titles.getValue(sessionId)
|
||||
_state.value = _state.value.copy(
|
||||
overrides = overrides,
|
||||
open = _state.value.open.map { if (it.sessionId == sessionId) it.copy(title = renamed) else it },
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a session from the device's list and closes its conversation, if
|
||||
* open. Nothing is deleted on the server — the session still exists there — so
|
||||
* the removal is honest and reversible through [undoRemove].
|
||||
*/
|
||||
fun remove(sessionId: String) {
|
||||
if (sessionId.isBlank()) return
|
||||
if (_state.value.sessions.none { it.id == sessionId } && _state.value.thread(sessionId) == null) return
|
||||
_state.value = _state.value.copy(
|
||||
overrides = _state.value.overrides.hide(sessionId),
|
||||
open = _state.value.open.filterNot { it.sessionId == sessionId },
|
||||
activeId = if (_state.value.activeId == sessionId) null else _state.value.activeId,
|
||||
lastRemoved = sessionId,
|
||||
)
|
||||
}
|
||||
|
||||
/** Restores the most recently removed session to the list and forgets it. */
|
||||
fun undoRemove() {
|
||||
val id = _state.value.lastRemoved ?: return
|
||||
_state.value = _state.value.copy(
|
||||
overrides = _state.value.overrides.restore(id),
|
||||
lastRemoved = null,
|
||||
)
|
||||
}
|
||||
|
||||
// ---- Opening / switching -------------------------------------------------
|
||||
|
||||
/**
|
||||
@@ -161,10 +324,13 @@ class ChatStore(private val now: () -> Long = System::currentTimeMillis) {
|
||||
*/
|
||||
fun open(session: ChatSession): Boolean {
|
||||
val existing = _state.value.thread(session.id)
|
||||
// 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
|
||||
if (existing == null) {
|
||||
val thread = ChatThread(
|
||||
sessionId = session.id,
|
||||
title = session.title,
|
||||
title = title,
|
||||
directory = session.directory,
|
||||
model = session.model,
|
||||
agent = session.agent,
|
||||
@@ -175,7 +341,7 @@ class ChatStore(private val now: () -> Long = System::currentTimeMillis) {
|
||||
return true
|
||||
}
|
||||
val merged = existing.copy(
|
||||
title = session.title.ifBlank { existing.title },
|
||||
title = title.ifBlank { existing.title },
|
||||
directory = session.directory.ifBlank { existing.directory },
|
||||
busy = session.busy,
|
||||
)
|
||||
@@ -352,7 +518,7 @@ class ChatStore(private val now: () -> Long = System::currentTimeMillis) {
|
||||
val session = _state.value.sessions.firstOrNull { it.id == sessionId }
|
||||
val placeholder = ChatThread(
|
||||
sessionId = sessionId,
|
||||
title = session?.title ?: "",
|
||||
title = _state.value.overrides.titles[sessionId] ?: session?.title ?: "",
|
||||
directory = session?.directory ?: "",
|
||||
busy = session?.busy ?: false,
|
||||
)
|
||||
|
||||
@@ -239,6 +239,42 @@ class ChatProtocolTest {
|
||||
assertNull(decoded.chatReply)
|
||||
}
|
||||
|
||||
/**
|
||||
* The session list carries the server's own kind tag: an operator session
|
||||
* reads `operator` and an untagged one stays untagged, so the app can label
|
||||
* without ever guessing which session belongs to a run.
|
||||
*/
|
||||
@Test
|
||||
fun chatSessionsCarryTheServersOwnKindTag() {
|
||||
val json = """
|
||||
{"type":"chat_sessions","chat_sessions":[
|
||||
{"id":"ses_op","title":"Mine","directory":"/home/op","tag":"operator"},
|
||||
{"id":"ses_other","title":"Something else"}]}
|
||||
""".trimIndent()
|
||||
val sessions = PipelinesJson.decodeFromString(Message.serializer(), json).chatSessions!!
|
||||
assertEquals(ChatProtocol.TAG_OPERATOR, sessions[0].tag)
|
||||
assertEquals("", sessions[1].tag)
|
||||
}
|
||||
|
||||
/** The create flow's directory request and its reply round-trip the wire shape. */
|
||||
@Test
|
||||
fun chatDirectoriesRequestAndResponseRoundTrip() {
|
||||
val request = Message(type = Protocol.CHAT_DIRECTORIES, id = "android-7")
|
||||
val decodedRequest = PipelinesJson.decodeFromString(
|
||||
Message.serializer(),
|
||||
PipelinesJson.encodeToString(Message.serializer(), request),
|
||||
)
|
||||
assertEquals(Protocol.CHAT_DIRECTORIES, decodedRequest.type)
|
||||
assertNull(decodedRequest.chatDirectories)
|
||||
|
||||
val reply = """
|
||||
{"type":"chat_directories","id":"android-7",
|
||||
"chat_directories":["/home/op","/home/op/work"]}
|
||||
""".trimIndent()
|
||||
val decoded = PipelinesJson.decodeFromString(Message.serializer(), reply)
|
||||
assertEquals(listOf("/home/op", "/home/op/work"), decoded.chatDirectories)
|
||||
}
|
||||
|
||||
/** A non-chat envelope leaves every chat field null, so the two never cross-talk. */
|
||||
@Test
|
||||
fun nonChatEnvelopeHasNoChatPayload() {
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
package net.awan.pipelines.ui.chat
|
||||
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
/**
|
||||
* The create flow's directory choices: the server's home first (the picker's
|
||||
* default), the recents in the server's own order, and the value each choice
|
||||
* sends to chat_create. Pure, so it needs no device or server.
|
||||
*/
|
||||
class ChatDirectoriesTest {
|
||||
|
||||
@Test
|
||||
fun homeIsFirstAndIsTheDefaultChoice() {
|
||||
val choices = directoryChoices(listOf("/home/op", "/home/op/work"))
|
||||
assertEquals(2, choices.size)
|
||||
|
||||
val home = choices.first()
|
||||
assertTrue(home.home)
|
||||
assertEquals(HOME_DIRECTORY, home.createDirectory)
|
||||
assertEquals("/home/op", home.path)
|
||||
// The home row is labelled `~` and its full path is shown beneath it.
|
||||
assertEquals("/home/op", home.secondary)
|
||||
assertEquals(home, defaultDirectoryChoice(choices))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun recentsKeepTheServersOrderAndCreateInTheirFullPath() {
|
||||
val choices = directoryChoices(listOf("/home/op", "/home/op/work", "/home/op/repos/x"))
|
||||
assertEquals(
|
||||
listOf("/home/op/work", "/home/op/repos/x"),
|
||||
choices.drop(1).map { it.createDirectory },
|
||||
)
|
||||
choices.drop(1).forEach { choice ->
|
||||
assertFalse(choice.home)
|
||||
// A recent's own label already is its full path, so nothing is repeated.
|
||||
assertEquals(choice.path, choice.label)
|
||||
assertNull(choice.secondary)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anEmptyOrBlankReplyStillYieldsTheHomeChoice() {
|
||||
assertEquals(HOME_DIRECTORY, directoryChoices(emptyList()).single().createDirectory)
|
||||
assertEquals(HOME_DIRECTORY, directoryChoices(listOf("", " ")).single().createDirectory)
|
||||
// Home only: no recents yet.
|
||||
assertEquals(1, directoryChoices(listOf("/home/op")).size)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,160 @@
|
||||
package net.awan.pipelines.ui.chat
|
||||
|
||||
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||
import net.awan.pipelines.data.protocol.ChatSession
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
/**
|
||||
* Managing the session list: the kind chip comes from the server's tag, the
|
||||
* create flow defaults to the operator's home and creates in the chosen
|
||||
* directory, and rename/removal are local, honest (the server list is untouched)
|
||||
* and reversible. Driven against [ChatStore] with no device or server.
|
||||
*/
|
||||
class ChatSessionManagementTest {
|
||||
|
||||
private fun session(
|
||||
id: String,
|
||||
title: String = id,
|
||||
tag: String = ChatProtocol.TAG_OPERATOR,
|
||||
directory: String = "/home/op",
|
||||
) = ChatSession(id = id, title = title, tag = tag, directory = directory)
|
||||
|
||||
@Test
|
||||
fun theKindChipComesFromTheServersOwnTag() {
|
||||
assertEquals("Operator", sessionTagLabel(session("a")))
|
||||
// An untagged session shows no chip; an unknown tag is shown verbatim.
|
||||
assertNull(sessionTagLabel(session("b", tag = "")))
|
||||
assertEquals("scratch", sessionTagLabel(session("c", tag = "scratch")))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theCreateFlowDefaultsToHomeAndCreatesInTheChosenDirectory() {
|
||||
val store = ChatStore()
|
||||
store.createOpened()
|
||||
assertEquals(HOME_DIRECTORY, store.value.create!!.directory)
|
||||
|
||||
store.createDirectoryChosen("/home/op/work")
|
||||
assertEquals("/home/op/work", store.value.create!!.directory)
|
||||
|
||||
store.createSucceeded(session("new", "New chat", directory = "/home/op/work"))
|
||||
assertNull(store.value.create)
|
||||
assertEquals("new", store.value.activeId)
|
||||
assertEquals(listOf("new"), store.value.visibleSessions.map { it.id })
|
||||
assertEquals("/home/op/work", store.value.active!!.directory)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun cancellingTheCreateFlowLeavesTheListUntouched() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a")))
|
||||
store.createOpened()
|
||||
store.createCancelled()
|
||||
assertNull(store.value.create)
|
||||
assertEquals(listOf("a"), store.value.visibleSessions.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun renameWinsOverTheServersTitleAndSurvivesARefresh() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a", "Server title")))
|
||||
store.rename("a", " My chat ")
|
||||
assertEquals("My chat", store.value.visibleSessions.single().title)
|
||||
|
||||
// A refresh carrying the server's own title does not undo the local rename.
|
||||
store.sessionsLoaded(listOf(session("a", "Server title")))
|
||||
assertEquals("My chat", store.value.visibleSessions.single().title)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun renameAppliesToAnAlreadyOpenConversation() {
|
||||
val store = ChatStore()
|
||||
store.open(session("a"))
|
||||
store.rename("a", "Renamed")
|
||||
assertEquals("Renamed", store.value.thread("a")!!.title)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun removeHidesTheSessionUntilItIsUndone() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a"), session("b")))
|
||||
store.remove("a")
|
||||
assertEquals(listOf("b"), store.value.visibleSessions.map { it.id })
|
||||
assertEquals("a", store.value.lastRemoved)
|
||||
|
||||
// The server still lists it, so a refresh does not bring it back...
|
||||
store.sessionsLoaded(listOf(session("a"), session("b")))
|
||||
assertEquals(listOf("b"), store.value.visibleSessions.map { it.id })
|
||||
|
||||
// ...until the removal is undone.
|
||||
store.undoRemove()
|
||||
assertEquals(listOf("a", "b"), store.value.visibleSessions.map { it.id })
|
||||
assertNull(store.value.lastRemoved)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun removeClosesTheOpenConversationWithoutTouchingTheServerList() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a")))
|
||||
store.open(session("a"))
|
||||
store.remove("a")
|
||||
assertNull(store.value.thread("a"))
|
||||
assertNull(store.value.activeId)
|
||||
// Nothing is deleted: the server's list still holds it, only hidden here.
|
||||
assertEquals(listOf("a"), store.value.sessions.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun removingSomethingThatIsNotListedIsANoOp() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a")))
|
||||
store.remove("ghost")
|
||||
assertNull(store.value.lastRemoved)
|
||||
store.undoRemove()
|
||||
assertEquals(listOf("a"), store.value.visibleSessions.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun overridesSurviveAnEncodeDecodeRoundTrip() {
|
||||
val overrides = ChatSessionOverrides().renamed("a", "Mine").hide("b")
|
||||
assertEquals(overrides, ChatSessionOverrides.decode(overrides.encode()))
|
||||
// Nothing stored, or something unreadable, is simply no overrides.
|
||||
assertEquals(ChatSessionOverrides(), ChatSessionOverrides.decode(""))
|
||||
assertEquals(ChatSessionOverrides(), ChatSessionOverrides.decode("{"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aStoredOverrideSetIsAppliedByAFreshStore() {
|
||||
val stored = ChatSessionOverrides().renamed("a", "Mine").hide("b").encode()
|
||||
val store = ChatStore(overrides = ChatSessionOverrides.decode(stored))
|
||||
store.sessionsLoaded(listOf(session("a", "Server title"), session("b")))
|
||||
assertEquals(listOf("a"), store.value.visibleSessions.map { it.id })
|
||||
assertEquals("Mine", store.value.visibleSessions.single().title)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theListShowsTheServersSessionsVerbatimWhenNothingIsOverridden() {
|
||||
val store = ChatStore()
|
||||
val listed = listOf(session("a"), session("b", "Other"))
|
||||
store.sessionsLoaded(listed)
|
||||
// No app-side filtering or retitling when the operator changed nothing.
|
||||
assertTrue(store.value.visibleSessions == listed)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theCoveredPaneCountMatchesTheVisibleList() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a"), session("b"), session("c")))
|
||||
assertEquals(3, store.value.visibleSessionCount)
|
||||
|
||||
// The covered pane's count tracks the same removals as the list itself.
|
||||
store.remove("b")
|
||||
assertEquals(2, store.value.visibleSessionCount)
|
||||
assertEquals(store.value.visibleSessions.size, store.value.visibleSessionCount)
|
||||
|
||||
store.undoRemove()
|
||||
assertEquals(3, store.value.visibleSessionCount)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user