Merge pull request #9176 from Kilo-Org/detailed-sweater

feat(jetbrains): complete JetBrains chat stack — backend, model, and permission/question RPC

Author: kirillk

packages/kilo-jetbrains/AGENTS.md

@@ -74,6 +74,135 @@
 - Service classes ↔ `<applicationService>`/`<projectService>` entries in the corresponding module XML
 - `script/build.ts` platform list ↔ `backend/build.gradle.kts` `requiredPlatforms` list
 
+## Session Component
+
+The chat session feature uses a three-layer Model / Controller / View architecture. All files live under
+`frontend/src/main/kotlin/ai/kilocode/client/session/`.
+
+### Layers
+
+**`SessionModel`** (`model/SessionModel.kt`)
+
+- Single source of truth for session content and runtime state.
+- **EDT-only access** — no synchronisation. `SessionController` guarantees all reads and writes happen on the EDT.
+- State is mutated only through dedicated methods (`setState`, `upsertMessage`, `setDiff`, etc.), never via direct field assignment from outside the model.
+- Every mutation fires a sealed `SessionModelEvent` that carries the data needed for rendering — UI never needs to read back from the model after receiving an event.
+- Each event overrides `toString()` with a compact, stable label (e.g. `"MessageAdded msg1"`, `"DiffUpdated files=2"`). Tests assert events by comparing joined `toString()` output.
+- `loadHistory()` and `clear()` reset all state fields — diff, todos, compactionCount, messages, and `SessionState.Idle`. Call them when opening or clearing a session.
+
+**`SessionController`** (`SessionController.kt`)
+
+- Owns one `SessionModel`. UIs read from `model` and subscribe to `SessionModelEvent` via `model.addListener()`.
+- Accepts an optional `id` at construction.
+  - `id = null` → lazily creates a new session on the first `prompt()` call. This guarantees events are subscribed before the prompt is sent, eliminating race conditions.
+  - `id != null` → immediately loads history and subscribes to SSE events on construction.
+- After history load, `recoverPending()` seeds state in this priority order: (1) pending permission, (2) pending question, (3) current session status (`busy`/`retry`/`offline` from `KiloSessionService.statuses`), (4) `Idle`.
+- All SSE events are filtered by `sessionID` before being handled. `session.error` events with `null` sessionID are treated as global and pass through.
+- Publishes coarser lifecycle updates (app/workspace changes, view switching) via `SessionControllerEvent` to registered listeners — keep these separate from the fine-grained `SessionModelEvent` stream.
+
+**View** (UI classes under `ui/`)
+
+- Listens to `SessionModelEvent` via `model.addListener(parent) { event -> when(event) { ... } }`.
+- The `when` block must be exhaustive — add `-> Unit` branches for events the view intentionally ignores so new events surface as compile errors.
+- Views call `SessionController` actions (`prompt()`, `replyPermission()`, etc.) on the EDT; the controller dispatches RPC calls to a coroutine scope.
+- Views must never access RPC or services directly — everything goes through the controller.
+
+### Adding a New Event
+
+1. Add a subclass to `SessionModelEvent` with a stable `toString()`.
+2. Add the corresponding state field and mutation method to `SessionModel`. Reset the field in both `loadHistory()` and `clear()`.
+3. Handle the new `ChatEventDto` in `SessionController.handle()` by calling the model mutation method.
+4. Add `-> Unit` stubs for the new event in any existing exhaustive `when` blocks in view code.
+
+### Testing
+
+Controller tests extend `SessionControllerTestBase` (`test/…/session/SessionControllerTestBase.kt`),
+which provides a real IntelliJ Application and EDT via `BasePlatformTestCase`, real frontend services
+wired to `FakeSessionRpcApi`, and a set of shared helpers.
+
+**Two setups:**
+
+| Setup                                                                     | When to use                                                                                                                                                                                                  |
+| ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `val (m, events, modelEvents) = prompted()`                               | New-session flow — sets app/workspace to ready, creates a controller with no ID, sends an initial prompt. `model.showMessages` is `true`. Start all event-driven tests from here.                            |
+| `controller("ses_test")` + manual `appRpc`/`projectRpc` setup + `flush()` | Existing-session flow — opens a specific session, triggers history load and `recoverPending()`. `model.showMessages` is `false`. Use for recovery and history tests. Pass `show = false` to `assertSession`. |
+
+**Core assertion helpers:**
+
+```kotlin
+// Full controller state — includes model transcript + status line.
+// show=true is the default; pass show=false for existing-session tests.
+assertSession("""
+    assistant#msg1
+    text#prt1:
+      hello
+
+    [code] [kilo/gpt-5] [idle]
+""", m)
+
+// Just the model transcript (no status line)
+assertModel("diff: src/A.kt src/B.kt", m)
+
+// Model event stream — one event per line via event.toString()
+assertModelEvents("""
+    MessageAdded msg1
+    ContentAdded msg1/prt1
+""", modelEvents)
+
+// Controller lifecycle events
+assertControllerEvents("WorkspaceReady", events)
+```
+
+**Emitting events and flushing:**
+
+```kotlin
+emit(ChatEventDto.TurnOpen("ses_test"))         // emits + flushes by default
+emit(ChatEventDto.PartDelta(…), flush = false)  // batch without intermediate flush
+flush()                                          // settle coroutines + drain EDT
+```
+
+**`FakeSessionRpcApi` configurable state:**
+
+| Field                                                              | Purpose                                                |
+| ------------------------------------------------------------------ | ------------------------------------------------------ |
+| `rpc.events` (`MutableSharedFlow`)                                 | Emit `ChatEventDto` events the controller will receive |
+| `rpc.statuses` (`MutableStateFlow<Map<String, SessionStatusDto>>`) | Seed the status map read during `recoverPending()`     |
+| `rpc.history`                                                      | Messages returned by `messages()` (history load)       |
+| `rpc.pendingPermissionList`                                        | Permissions returned during recovery                   |
+| `rpc.pendingQuestionList`                                          | Questions returned during recovery                     |
+| `rpc.prompts`, `rpc.permissionReplies`, etc.                       | Call tracking for RPC side-effects                     |
+
+**String format of `model.toString()`** (used by `assertModel` / `assertSession`):
+
+```
+role#msgId
+text#partId:
+  line one
+  line two
+---
+tool#partId toolName [STATE] optional title
+---
+question#id
+tool: msgId/callId
+header: …
+prompt: …
+option: label - description
+multiple: false
+custom: true
+---
+diff: file1 file2
+---
+todo: [status] content
+---
+compacted: N
+```
+
+Sections are separated by `---`. Only non-empty sections appear. The status line appended by `SessionController.toString()` is:
+
+```
+[agentName] [provider/modelId] [idle|busy|retry|offline|error|awaiting-question|awaiting-permission] [optional detail]
+```
+
 ## UI Design Guidelines
 
 Official references:

packages/kilo-jetbrains/backend/src/main/kotlin/ai/kilocode/backend/app/KiloBackendChatManager.kt

@@ -5,7 +5,12 @@ import ai.kilocode.backend.util.KiloLog
 import ai.kilocode.rpc.dto.ChatEventDto
 import ai.kilocode.rpc.dto.ConfigUpdateDto
 import ai.kilocode.rpc.dto.MessageWithPartsDto
+import ai.kilocode.rpc.dto.PermissionAlwaysRulesDto
+import ai.kilocode.rpc.dto.PermissionReplyDto
+import ai.kilocode.rpc.dto.PermissionRequestDto
 import ai.kilocode.rpc.dto.PromptDto
+import ai.kilocode.rpc.dto.QuestionReplyDto
+import ai.kilocode.rpc.dto.QuestionRequestDto
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableSharedFlow
@@ -38,9 +43,20 @@ class KiloBackendChatManager(
             "message.removed",
             "message.part.updated",
             "message.part.delta",
+            "message.part.removed",
             "session.turn.open",
             "session.turn.close",
             "session.error",
+            "session.status",
+            "session.idle",
+            "session.compacted",
+            "session.diff",
+            "permission.asked",
+            "permission.replied",
+            "question.asked",
+            "question.replied",
+            "question.rejected",
+            "todo.updated",
         )
     }
 
@@ -174,8 +190,70 @@ class KiloBackendChatManager(
         }
     }
 
+    // ------ permission / question ------
+
+    fun replyPermission(requestId: String, dir: String, reply: PermissionReplyDto) {
+        val body = KiloCliDataParser.buildPermissionReplyJson(reply)
+        post("/permission/$requestId/reply?directory=${encode(dir)}", body, "replyPermission")
+    }
+
+    fun savePermissionRules(requestId: String, dir: String, rules: PermissionAlwaysRulesDto) {
+        val body = KiloCliDataParser.buildPermissionAlwaysRulesJson(rules)
+        post("/permission/$requestId/always-rules?directory=${encode(dir)}", body, "savePermissionRules")
+    }
+
+    fun replyQuestion(requestId: String, dir: String, answers: QuestionReplyDto) {
+        val body = KiloCliDataParser.buildQuestionReplyJson(answers)
+        post("/question/$requestId/reply?directory=${encode(dir)}", body, "replyQuestion")
+    }
+
+    fun rejectQuestion(requestId: String, dir: String) {
+        post("/question/$requestId/reject?directory=${encode(dir)}", "{}", "rejectQuestion")
+    }
+
+    fun pendingPermissions(dir: String): List<PermissionRequestDto> {
+        val raw = get("/permission?directory=${encode(dir)}", "pendingPermissions") ?: return emptyList()
+        return KiloCliDataParser.parsePermissionRequests(raw)
+    }
+
+    fun pendingQuestions(dir: String): List<QuestionRequestDto> {
+        val raw = get("/question?directory=${encode(dir)}", "pendingQuestions") ?: return emptyList()
+        return KiloCliDataParser.parseQuestionRequests(raw)
+    }
+
     // ------ utilities ------
 
+    private fun post(path: String, body: String, op: String) {
+        val http = requireClient()
+        val url = requireBase()
+        val request = Request.Builder()
+            .url("$url$path")
+            .post(body.toRequestBody(JSON_TYPE))
+            .build()
+        http.newCall(request).execute().use { response ->
+            if (!response.isSuccessful) {
+                log.warn("$op failed: HTTP ${response.code}")
+            }
+        }
+    }
+
+    private fun get(path: String, op: String): String? {
+        val http = requireClient()
+        val url = requireBase()
+        val request = Request.Builder()
+            .url("$url$path")
+            .get()
+            .build()
+        return http.newCall(request).execute().use { response ->
+            if (!response.isSuccessful) {
+                log.warn("$op failed: HTTP ${response.code}")
+                null
+            } else {
+                response.body?.string()
+            }
+        }
+    }
+
     private fun requireClient(): OkHttpClient =
         client ?: throw IllegalStateException("Chat manager not started")