feat(jetbrains): improve shell and markdown rendering

.changeset/highlight-jetbrains-shell-commands.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/kilo-jetbrains": patch
+---
+
+Highlight shell tool commands in JetBrains chat transcripts.

.changeset/improve-jetbrains-markdown.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/kilo-jetbrains": patch
+---
+
+Improve markdown readability in JetBrains chat transcripts.

.changeset/jetbrains-session-icons.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/kilo-jetbrains": patch
+---
+
+Polish session header controls and align session view icons.

.changeset/render-jetbrains-shell-markdown.md

@@ -0,0 +1,5 @@
+---
+"@kilocode/kilo-jetbrains": patch
+---
+
+Render JetBrains shell tool output with markdown code blocks.

.kilo/plans/jetbrains-mdview-editor-theme-colors.md

@@ -0,0 +1,67 @@
+# JetBrains MdView Editor Theme Colors Plan
+
+## Goal
+
+Keep JetBrains markdown layout compact while making markdown colors and backgrounds come from the active editor color scheme, and ensure existing theme/editor-setting listeners refresh all existing `MdView` instances after changes.
+
+## Findings
+
+- `SessionUi` already subscribes to `EditorColorsManager.TOPIC` and `LafManagerListener.TOPIC`, then calls `applyStyle(SessionEditorStyle.current())` on the session tree.
+- Most markdown consumers already propagate that style through `MdView.applyStyle(style)` via `TextView`, `ReasoningView`, message lists, and session panels.
+- `PlanExitView.applyStyle()` sets only font/code font/foreground and does not call `md.applyStyle(style)`, so internal markdown role colors can stay tied to the initial style.
+- `MdViewHybrid.applyStyle()` restyles retained HTML panes and code block containers, but retained `CodeField` editors need explicit reapplication of `SessionEditorStyle.applyToEditor()` after creation so syntax highlighting and editor colors follow scheme changes.
+- `MdCommon.defaults()` currently mixes editor colors, UI theme colors, and one literal inline-code color fallback. The literal fallback should be removed, and markdown roles should derive from `EditorColorsScheme`/syntax attributes wherever possible.
+- `TextView` currently overrides markdown background with `SessionUiStyle.Transcript.bgColor()` (`UiStyle.Colors.bg()`), while prompt markdown already uses `style.editorBackground`. If markdown surfaces should consistently use editor background, normal text views need to use `style.editorBackground` too.
+
+## Implementation Plan
+
+1. Keep compact CSS unchanged.
+   - Do not reintroduce line-height, margin, padding, heading sizing, or other geometry rules.
+   - Keep the current role color/background selectors only.
+
+2. Derive markdown role defaults from editor settings.
+   - Update `MdCommon.defaults(style)` to use `style.editorForeground` and `style.editorBackground` for primary text/background.
+   - Add small local helper functions for editor attributes, for example foreground/background from `style.editorScheme.getAttributes(key)` and color keys from `style.editorScheme.getColor(key)`.
+   - Use public IntelliJ editor keys for role colors:
+     - Links: `CodeInsightColors.HYPERLINK_ATTRIBUTES.foregroundColor`, fallback to platform link color if absent.
+     - Inline code foreground/background: `DefaultLanguageHighlighterColors.DOC_CODE_INLINE`, fallback to `STRING`, then editor foreground/background.
+     - Code block foreground/background: `DefaultLanguageHighlighterColors.DOC_CODE_BLOCK`, fallback to editor foreground/background.
+     - Quote/emphasis/list weak text: comment/doc-comment attributes, fallback to editor foreground or `UIUtil.getContextHelpForeground()` only when the scheme has no useful value.
+     - Borders/HR/table/code border: editor preview/border color keys such as `EditorColors.PREVIEW_BORDER_COLOR`, fallback to `UiStyle.Colors.contentBorder()`.
+   - Remove `JBColor(0x...)` or other literal runtime color fallbacks from `MdCommon`.
+   - Keep public `MdView` API unchanged; role colors stay internal unless a concrete external override need appears.
+
+3. Ensure style propagation reaches every markdown instance.
+   - Update `PlanExitView.applyStyle(style)` to call `md.applyStyle(style)` before applying its explicit font/code-font/foreground overrides.
+   - Audit existing markdown callers after the change; keep using the existing `SessionEditorStyleTarget` propagation path rather than adding per-`MdView` theme listeners.
+   - Keep explicit foreground overrides in `TextView`, `ReasoningView`, and `PlanExitView` where they intentionally set body text role, but let internal markdown role colors refresh from the new style snapshot.
+
+4. Ensure retained hybrid code blocks update after editor setting changes.
+   - In `MdViewHybrid.CodeView.style(opts)`, for retained `CodeField` blocks, reapply `style.applyToEditor(editor)` to the underlying editor if it exists.
+   - Reapply code editor background/scroll pane/viewport backgrounds from `opts.preBg` in the same path.
+   - Preserve retained component/editor reuse: do not rebuild code block panes just to update style.
+
+5. Align markdown backgrounds with editor settings.
+   - Keep `MdCommon` default background as `style.editorBackground`.
+   - Change normal `TextView` markdown background to `style.editorBackground` if the intent is that all markdown surfaces use editor background, matching `PromptView` and session root behavior.
+   - Preserve `transparent` handling: when `md.opaque = false`, background should still be the editor-derived value for child/code surfaces, but the Swing component should remain non-opaque.
+
+6. Update tests.
+   - Extend `MdViewTest` to verify markdown role CSS changes when applying a `SessionEditorStyle` backed by a customized editor scheme, especially inline code, code block, link, and border colors.
+   - Extend `MdViewHybridTest` to assert `applyStyle()` updates retained HTML panes and retained code editors without replacing them, including editor scheme/background changes.
+   - Add or extend `PlanExitViewTest` so `applyStyle()` refreshes the nested markdown style, not just foreground/font overrides.
+   - Keep existing compactness expectations: tests should not assert new spacing, padding, margin, line-height, or size rules.
+
+## Verification
+
+- From `packages/kilo-jetbrains/`, run `./gradlew frontend:test --tests '*MdView*'`.
+- From `packages/kilo-jetbrains/`, run `./gradlew frontend:test --tests '*PlanExitViewTest*'` if the focused test is not covered by the MdView filter.
+- From `packages/kilo-jetbrains/`, run `bun run typecheck`.
+
+## Constraints
+
+- Do not introduce JCEF, Compose, or Kotlin UI DSL.
+- Do not add new theme/editor listeners in `MdView`; use the existing `SessionUi` listener and `SessionEditorStyleTarget` propagation path.
+- Avoid hardcoded runtime colors in markdown styling; prefer editor scheme attributes/color keys, then platform/theme APIs as non-literal fallbacks.
+- Preserve retained Swing behavior and `MdViewHybrid.sync()` component reuse.
+- Keep the public `MdView` override API stable unless implementation proves a new external override is required.

.kilo/plans/jetbrains-mdview-vscode-styling.md

@@ -0,0 +1,69 @@
+# JetBrains MdView VS Code Styling Plan
+
+## Goal
+
+Improve JetBrains markdown output so assistant/user transcript markdown visually matches the VS Code webview markdown style while keeping the existing Swing/JBHtmlPane + editor-backed code block architecture.
+
+## Findings
+
+- VS Code markdown styling is split across `packages/ui/src/components/markdown.css`, `packages/kilo-ui/src/components/markdown.css`, `packages/kilo-ui/src/styles/vscode-bridge.css`, and message-part overrides.
+- Base VS Code markdown uses 14px sans text, 160% line height, tight first/last margins, same-size medium headings, 12px paragraph spacing, link-colored anchors, compact lists, weak list markers, weak blockquotes with a 2px left border, invisible HR spacing, bordered/padded code blocks, green inline code, and lightly bordered tables.
+- The VS Code theme bridge maps markdown roles to editor/theme tokens: heading/link/list/image use `textLinkForeground`, text/strong/code-block use editor foreground, inline code uses charts/syntax green, quote/emphasis use description foreground, HR uses panel border.
+- JetBrains markdown is rendered by `MdViewHybrid` and `MdViewHtmlPane`, with shared CSS from `MdCommon.rules()` and defaults from `MdCommon.defaults()`.
+- JetBrains currently styles only broad tag font/color, links, code/pre colors, blockquote border/text color, and table border. It lacks VS Code-equivalent spacing, heading/strong/emphasis/list marker/table cell rules, inline-code foreground, blockquote geometry, HR spacing, and code block surface polish.
+- JetBrains fenced code blocks are already stronger than VS Code in one respect: they use `EditorTextField` with real IDE syntax highlighting and streaming retention. Preserve this instead of switching to web/JCEF rendering.
+
+## Implementation Plan
+
+1. Expand JetBrains markdown style tokens.
+   - Add internal fields to `MdStyle` for heading, strong, emphasis, inline code foreground, list marker, HR, table/header, and code block border colors.
+   - Keep the public `MdView` override API stable unless a new external override is clearly needed.
+   - Compute defaults in `MdCommon.defaults(style)` from IntelliJ/editor theme sources and centralized Kilo semantic colors where no platform key matches.
+   - Use `JBColor.namedColor("Kilo.Markdown.*", fallback)` for Kilo-specific markdown palette fallbacks, so themes can override them and runtime code avoids scattered hardcoded colors.
+
+2. Mirror VS Code markdown CSS in `MdCommon.rules()`.
+   - Add root/body wrapping rules: max width behavior, break-word wrapping, base line-height, and first/last-child margin trimming where supported by `JBHtmlPane` CSS.
+   - Add heading rules: same base size, medium/bold weight, role-specific color, line height, and bottom spacing.
+   - Add paragraph, list, list item, nested list, and marker rules. If Swing HTML does not support `::marker`, fall back to `li { color: ... }` plus child text color reset only if supported; otherwise keep list text normal and document the limitation in tests.
+   - Add strong/emphasis colors matching VS Code token roles.
+   - Add anchor styling matching VS Code: themed link color, no forced background, and underline behavior where `JBHtmlPane` supports it.
+   - Add blockquote geometry: 2px left border, 24px vertical margin, 8px left padding, weak text, and normal style.
+   - Add table layout rules: collapse borders, full width where possible, 24px vertical margin, 12px cell padding, weak row borders, stronger header text.
+   - Keep HRs visually hidden but spaced consistently with VS Code if the renderer includes them. `MdViewHybrid` currently filters thematic breaks, so this mainly benefits `MdViewHtmlPane` and future reuse.
+   - Add inline-code foreground and medium font weight. Avoid inline code backgrounds unless the current `JBHtmlPane` configuration already draws them acceptably.
+
+3. Polish JetBrains code block containers without losing IDE highlighting.
+   - Keep `EditorTextField` for fenced/indented blocks and `JBTextArea` fallback.
+   - Style `JBScrollPane` code blocks to match VS Code’s `markdown-code` wrapper feel: subtle background, subtle border, rounded-ish platform arc if feasible, 12px-ish padding, and thin horizontal scrollbar behavior.
+   - Use `SessionUiStyle.View.Code` for geometry constants. Add only minimal new constants there if current values cannot represent the VS Code spacing.
+   - Separate code block border color from table border internally so table styling can change without affecting code boxes.
+   - Continue applying `SessionEditorStyle.applyToEditor(ed)` so code blocks follow IDE syntax highlighting and editor font changes.
+
+4. Add file/path affordance parity where safe.
+   - For markdown links whose `href` looks like a relative file path, keep existing link dispatch so the current caller can open files/URLs appropriately.
+   - Consider decorating inline code that looks like a path with a `file-link` class only when an `openFile` callback is available through the existing usage path. If the current `MdView` abstraction only has `openUrl`, do not widen it unless the call sites can pass file opening cleanly.
+   - At minimum, make inline code/path-looking content visually closer to VS Code by using the inline-code foreground and dotted underline for explicit file links where generated HTML contains link/code classes.
+
+5. Preserve retained Swing behavior.
+   - Keep `MdViewHybrid.sync()` prefix reuse logic unchanged unless necessary.
+   - Ensure style updates call `reloadCssStylesheets()` and reassign text only for retained `JBHtmlPane` blocks, not by rebuilding all blocks.
+   - Keep streaming fenced-code fast path and editor disposal behavior intact.
+
+6. Add focused tests.
+   - Extend `MdViewTest` and/or `MdViewHybridTest` to assert `overrideSheet()` contains the new VS Code-equivalent rules for headings, strong/emphasis, links, inline code foreground, list/table/blockquote spacing, HR, and code block/table border separation.
+   - Add component tests for code block pane styling: background, viewport background, border color, padding, scrollbar policy, and retained editor instance after `applyStyle()`.
+   - Keep existing stress/leak tests green. Add a small stress assertion only if the implementation changes style application semantics.
+   - Add a changeset: `@kilocode/kilo-jetbrains` patch with user-facing wording such as `Improve markdown readability in JetBrains chat transcripts.`
+
+## Verification
+
+- Run targeted JetBrains markdown tests first from `packages/kilo-jetbrains/`: `./gradlew frontend:test --tests '*MdView*'` if the Gradle module supports it; otherwise run the closest supported targeted Gradle test command.
+- Run `bun run typecheck` from `packages/kilo-jetbrains/`.
+- If targeted Gradle filtering is unreliable, run `./gradlew test` from `packages/kilo-jetbrains/`.
+
+## Constraints
+
+- Do not introduce JCEF, Compose, or Kotlin UI DSL.
+- Keep changes inside `packages/kilo-jetbrains/` and `.changeset/` unless a shared Kilo UI source of truth is explicitly required.
+- No `kilocode_change` markers are needed for JetBrains or Kilo UI paths.
+- Prefer IntelliJ theme APIs and centralized semantic tokens over scattered literal colors.

.kilo/plans/jetbrains-session-ui-icons-header.md

@@ -0,0 +1,63 @@
+# JetBrains Session UI Icons And Header Layout Plan
+
+## Goal
+Improve JetBrains session UI icon consistency and reduce accidental header interactions:
+- Use Kilo/VS Code-aligned session icons in session views.
+- Fix the reasoning header icon.
+- Normalize session part collapse/expand chevrons so collapsed/expanded states do not jump between differently sized glyphs.
+- Move the session-details toggle away from compaction and place it before the session title.
+
+## Findings
+- Session view icons are centralized in `packages/kilo-jetbrains/frontend/src/main/kotlin/ai/kilocode/client/session/views/SessionViewIcons.kt` and loaded from `frontend/src/main/resources/icons/views/*.svg`.
+- The JetBrains `views` SVGs already mirror the shared VS Code/UI icon paths from `packages/ui/src/components/icon.tsx` for the audited names, including `brain`, `chevron-down`, `chevron-right`, `checklist`, `console`, `warning`, etc.
+- The reasoning view currently renders `SessionViewIcons.eye` in `ReasoningView.kt`; VS Code/shared UI uses the `brain` icon for reasoning/thinking surfaces, and `SessionViewIcons.brain` already exists.
+- Standard collapsible session parts use `SessionViewIcons.chevronDown` when expanded and `SessionViewIcons.chevronRight` when collapsed in `AbstractSessionPartView.kt`; `QuestionResultView.kt` repeats this pattern manually. The down/right SVG paths have different visual extents.
+- The session header currently places the details toggle next to the compact button in the right-side controls in `SessionHeaderPanel.kt`, making the two actions easy to confuse.
+
+## Implementation Steps
+1. **Keep icon sources aligned with VS Code/shared UI**
+   - Treat `packages/ui/src/components/icon.tsx` as the source for Kilo web/session glyph shapes.
+   - Re-check `SessionViewIcons.kt` entries against available JetBrains assets; only update or add SVGs if a session view uses a Kilo icon missing from `frontend/src/main/resources/icons/views/`.
+   - Preserve JetBrains SVG theming rules: no `currentColor`; use literal palette colors and dark variants where assets are added or changed.
+
+2. **Fix reasoning icon**
+   - In `ReasoningView.kt`, change the reasoning header glyph from `SessionViewIcons.eye` to `SessionViewIcons.brain`.
+   - Add or update test coverage in `ReasoningViewTest.kt` by inspecting the rendered Swing label tree and asserting the reasoning icon is `SessionViewIcons.brain`.
+
+3. **Normalize collapse/expand chevrons for session parts**
+   - Stop using the mixed `chevronRight`/`chevronDown` pair for collapsible session content.
+   - Use a single base Kilo chevron glyph for both states, matching the current custom chevron used by the session header (`/icons/chevron-down.svg` / equivalent `SessionViewIcons.chevronDown`).
+   - Add a shared rotated icon for the opposite state instead of switching to a differently sized right-facing asset. Prefer a small reusable helper or centralized icon field rather than importing header-specific UI into session views.
+   - Update `AbstractSessionPartView.kt` and `QuestionResultView.kt` to use the normalized chevron pair.
+   - Leave `QuestionView.kt` navigation chevrons alone unless auditing shows they are being used for collapse/expand; those are previous/next controls, not expand/collapse controls.
+
+4. **Relocate and change header show/hide details toggle**
+   - In `SessionHeaderPanel.kt`, replace the custom header details chevron with platform `AllIcons` arrows/chevrons, e.g. collapsed = `AllIcons.General.ArrowRight`, expanded = `AllIcons.General.ArrowDown`.
+   - Move the details toggle out of the right-side controls and into `BorderLayout.WEST` of the header row.
+   - Rebuild the top header as:
+     - outer border layout
+     - west: details toggle button
+     - center: inner border layout
+     - inner center: session title
+     - inner east: horizontal stack/row with price/context and compact button
+   - Remove the details toggle from the right-side row so compaction remains visually separate from show/hide details.
+   - Keep existing tooltip/accessibility strings and expansion persistence behavior unchanged.
+
+5. **Tests**
+   - Update `SessionHeaderPanelTest.kt` to assert:
+     - collapsed/expanded header details icons use the selected `AllIcons` constants;
+     - the details toggle persists expansion state as before;
+     - the details toggle is parented/laid out separately from the compact button.
+   - Update `AbstractSessionPartViewTest.kt` to assert collapsible parts keep the same icon dimensions across collapsed/expanded states and no longer use the mismatched right/down pair.
+   - Update `QuestionResultViewTest.kt` similarly because it has its own chevron implementation.
+   - Update `ReasoningViewTest.kt` for the brain icon.
+
+6. **Verification**
+   - Run the smallest relevant JetBrains checks from `packages/kilo-jetbrains/`:
+     - `./gradlew test --tests "ai.kilocode.client.session.views.ReasoningViewTest" --tests "ai.kilocode.client.session.views.base.AbstractSessionPartViewTest" --tests "ai.kilocode.client.session.views.QuestionResultViewTest" --tests "ai.kilocode.client.session.ui.header.SessionHeaderPanelTest"`
+     - `./gradlew typecheck`
+   - If the filtered Gradle test syntax is not accepted by the project, run `./gradlew test` from `packages/kilo-jetbrains/` instead.
+
+## Notes
+- No shared upstream `opencode` files are involved; changes stay under `packages/kilo-jetbrains/`.
+- A changeset may be needed because this is user-facing JetBrains UI polish; confirm existing changeset policy for the private JetBrains package during implementation.