@neurocode-ai/tui 1.18.8

package/test/component/dialog-session-list.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test"
+import { createDialogSessionListQuery, loadDialogSessionList } from "../../src/component/dialog-session-list"
+
+describe("dialog session list", () => {
+  test("requests root sessions for the default browse list", () => {
+    expect(createDialogSessionListQuery({ filter: { path: "packages/tui" } })).toEqual({
+      roots: true,
+      limit: 100,
+      path: "packages/tui",
+    })
+  })
+
+  test("requests root sessions for search results", () => {
+    expect(createDialogSessionListQuery({ search: " deploy ", filter: { scope: "project" } })).toEqual({
+      roots: true,
+      limit: 30,
+      search: "deploy",
+      scope: "project",
+    })
+  })
+
+  test("keeps the cache usable while the root request is pending", async () => {
+    let resolve!: (result: { data: string[] }) => void
+    const pending = loadDialogSessionList<string>({
+      filter: {},
+      list: () => new Promise((done) => (resolve = done)),
+    })
+
+    expect(await Promise.race([pending, Promise.resolve("pending")])).toBe("pending")
+    resolve({ data: ["root"] })
+    expect(await pending).toEqual(["root"])
+  })
+
+  test("falls back when the root request returns an error response", async () => {
+    expect(await loadDialogSessionList({ filter: {}, list: async () => ({}) })).toBeUndefined()
+  })
+
+  test("falls back when the root request rejects", async () => {
+    expect(
+      await loadDialogSessionList({
+        filter: {},
+        list: () => Promise.reject(new Error("offline")),
+      }),
+    ).toBeUndefined()
+  })
+})

package/test/config.test.tsx

@@ -0,0 +1,127 @@
+/** @jsxImportSource @opentui/solid */
+import { testRender } from "@opentui/solid"
+import { expect, test } from "bun:test"
+import { Schema } from "effect"
+import {
+  AttentionSoundName,
+  Info,
+  LeaderTimeoutDefault,
+  PluginSpec,
+  resolve,
+  TuiConfigProvider,
+  type Info as TuiConfigInfo,
+  useTuiConfig,
+} from "../src/config"
+
+const decodeInfo = Schema.decodeUnknownSync(Info)
+const decodePlugin = Schema.decodeUnknownSync(PluginSpec)
+
+test("defines package-owned plugin specs and attention sound names", () => {
+  expect(decodePlugin("example-plugin")).toBe("example-plugin")
+  expect(decodePlugin(["example-plugin", { enabled: true }])).toEqual(["example-plugin", { enabled: true }])
+  expect(() => decodePlugin(["example-plugin"])).toThrow()
+  expect(AttentionSoundName.literals).toEqual(["default", "question", "permission", "error", "done", "subagent_done"])
+})
+
+test("validates config constraints", () => {
+  expect(
+    decodeInfo({
+      leader_timeout: 250,
+      attention: { volume: 1, sounds: { done: "done.wav" } },
+      prompt: { max_height: 10, max_width: "auto" },
+      scroll_speed: 0.001,
+      diff_style: "stacked",
+      plugin: ["example-plugin"],
+    }),
+  ).toMatchObject({ leader_timeout: 250, attention: { volume: 1 }, diff_style: "stacked" })
+  expect(() => decodeInfo({ leader_timeout: 0 })).toThrow()
+  expect(() => decodeInfo({ attention: { volume: 1.1 } })).toThrow()
+  expect(() => decodeInfo({ prompt: { max_width: 0 } })).toThrow()
+  expect(() => decodeInfo({ scroll_speed: 0 })).toThrow()
+  expect(decodeInfo({ attention: { sounds: { unknown: "sound.wav" } } })).toEqual({ attention: { sounds: {} } })
+})
+
+test("resolves host-neutral defaults", () => {
+  const config = resolve({}, { terminalSuspend: true })
+
+  expect(config.attention).toEqual({
+    enabled: false,
+    notifications: true,
+    sound: true,
+    volume: 0.4,
+    sound_pack: "opencode.default",
+    sounds: {},
+  })
+  expect(config.leader_timeout).toBe(LeaderTimeoutDefault)
+  expect(config.mouse).toBe(true)
+  expect(config.keybinds.has("terminal.suspend")).toBe(true)
+  expect(config.keybinds.has("session.list")).toBe(true)
+})
+
+test("resolves overrides without mutating input", () => {
+  const input: TuiConfigInfo = {
+    theme: "custom",
+    mouse: false,
+    leader_timeout: 750,
+    attention: {
+      enabled: true,
+      notifications: false,
+      sound: false,
+      volume: 0.8,
+      sound_pack: "custom.pack",
+      sounds: { question: "/sounds/question.wav" },
+    },
+    keybinds: { session_list: "ctrl+l" },
+  }
+  const config = resolve(input, { terminalSuspend: true })
+
+  expect(config).toMatchObject({ theme: "custom", mouse: false, leader_timeout: 750, attention: input.attention })
+  expect(config.keybinds.get("session.list")).toHaveLength(1)
+  expect(input.keybinds).toEqual({ session_list: "ctrl+l" })
+})
+
+test("resolves a session move keybind", () => {
+  const config = resolve({ keybinds: { session_move: "ctrl+o" } }, { terminalSuspend: true })
+
+  expect(config.keybinds.get("session.move")).toMatchObject([{ key: "ctrl+o" }])
+})
+
+test("disables suspend and assigns ctrl+z to undo when unsupported", () => {
+  const config = resolve({}, { terminalSuspend: false })
+
+  expect(config.keybinds.has("terminal.suspend")).toBe(false)
+  expect(config.keybinds.get("input.undo")).toMatchObject([{ key: "ctrl+z,ctrl+-,super+z" }])
+})
+
+test("preserves an explicit undo binding when suspend is unsupported", () => {
+  const config = resolve({ keybinds: { input_undo: "ctrl+u", terminal_suspend: "ctrl+s" } }, { terminalSuspend: false })
+
+  expect(config.keybinds.has("terminal.suspend")).toBe(false)
+  expect(config.keybinds.get("input.undo")).toHaveLength(1)
+  expect(config.keybinds.get("input.undo")).toMatchObject([{ key: "ctrl+u" }])
+})
+
+test("provides resolved config through Solid context", async () => {
+  const config = resolve({ theme: "custom" }, { terminalSuspend: true })
+
+  function Consumer() {
+    const value = useTuiConfig()
+    return <text>{`${value.theme} ${value.mouse} ${value.leader_timeout}`}</text>
+  }
+
+  const app = await testRender(() => (
+    <TuiConfigProvider config={config}>
+      <Consumer />
+    </TuiConfigProvider>
+  ))
+  try {
+    await app.renderOnce()
+    expect(app.captureCharFrame()).toContain(`custom true ${LeaderTimeoutDefault}`)
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
+test("requires the config provider", () => {
+  expect(() => useTuiConfig()).toThrow("TuiConfigProvider is missing")
+})

package/test/context/local.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "bun:test"
+import { parseModel, recentModels } from "../../src/context/local"
+
+test("parses model IDs containing slashes", () => {
+  expect(parseModel("provider/family/model")).toEqual({
+    providerID: "provider",
+    modelID: "family/model",
+  })
+})
+
+test("moves a model to the front, deduplicates, and limits recents", () => {
+  const recent = Array.from({ length: 12 }, (_, index) => ({
+    providerID: "provider",
+    modelID: `model-${index}`,
+  }))
+
+  expect(recentModels({ providerID: "provider", modelID: "model-5" }, recent)).toEqual([
+    { providerID: "provider", modelID: "model-5" },
+    ...recent.slice(0, 5),
+    ...recent.slice(6, 10),
+  ])
+})

package/test/editor.test.ts

@@ -0,0 +1,32 @@
+import { afterEach, expect, test } from "bun:test"
+import { normalizePromptContent, openEditor } from "../src/editor"
+
+const editor = process.env.EDITOR
+const visual = process.env.VISUAL
+
+afterEach(() => {
+  process.env.EDITOR = editor
+  process.env.VISUAL = visual
+})
+
+test("rejects when the external editor cannot start", async () => {
+  delete process.env.VISUAL
+  process.env.EDITOR = "opencode-editor-that-does-not-exist"
+  const renderer = {
+    suspend() {},
+    resume() {},
+    requestRender() {},
+    currentRenderBuffer: { clear() {} },
+  }
+
+  await expect(openEditor({ value: "original", renderer: renderer as never })).rejects.toThrow()
+})
+
+test("normalizes a single trailing editor newline for one-line prompts", () => {
+  expect(normalizePromptContent("hello\n")).toBe("hello")
+  expect(normalizePromptContent("hello\r\n")).toBe("hello")
+})
+
+test("preserves multiline prompts that end with a newline", () => {
+  expect(normalizePromptContent("hello\nworld\n")).toBe("hello\nworld\n")
+})

package/test/feature-plugins/diff-viewer-file-tree-utils.test.ts

@@ -0,0 +1,323 @@
+import { describe, expect, test } from "bun:test"
+import {
+  allExpandedFileTreeDirectories,
+  buildFileTree,
+  fileTreeFileSelection,
+  flattenFileTree,
+  moveFileTreeSelection,
+  moveFileTreeSelectionToFirstChild,
+  moveFileTreeSelectionToFile,
+  moveFileTreeSelectionToParent,
+  movePatchFileIndex,
+  orderedPatchFileIndexes,
+  setFileTreeDirectoryExpanded,
+  showDiffViewerFileTree,
+  singlePatchFileIndex,
+  toggleFileTreeDirectory,
+} from "../../src/feature-plugins/system/diff-viewer-file-tree-utils"
+
+describe("diff viewer file tree utilities", () => {
+  test("builds a nested tree with deduplicated directories and file indexes", () => {
+    const tree = buildFileTree([
+      { file: "src/config/tui.ts" },
+      { file: "src/config/keybind.ts" },
+      { file: "src/session/index.ts" },
+    ])
+
+    expect(tree.nodes.filter((node) => node.kind === "directory" && node.name === "src")).toHaveLength(1)
+    expect(tree.nodes.filter((node) => node.kind === "directory" && node.name === "config")).toHaveLength(1)
+    expect(tree.nodes.filter((node) => node.kind === "directory" && node.name === "session")).toHaveLength(1)
+    expect(
+      tree.nodes
+        .filter((node) => node.kind === "file")
+        .map((node) => ({ name: node.name, fileIndex: node.fileIndex, depth: node.depth })),
+    ).toEqual([
+      { name: "tui.ts", fileIndex: 0, depth: 2 },
+      { name: "keybind.ts", fileIndex: 1, depth: 2 },
+      { name: "index.ts", fileIndex: 2, depth: 2 },
+    ])
+  })
+
+  test("sorts directories before files and alphabetically within each group", () => {
+    const rows = flattenFileTree(
+      buildFileTree([
+        { file: "z-file.ts" },
+        { file: "b/file.ts" },
+        { file: "a/zeta.ts" },
+        { file: "b/alpha.ts" },
+        { file: "a/alpha.ts" },
+      ]),
+    )
+
+    expect(rows.map((row) => `${"  ".repeat(row.depth)}${row.kind}:${row.name}`)).toEqual([
+      "directory:a",
+      "  file:alpha.ts",
+      "  file:zeta.ts",
+      "directory:b",
+      "  file:alpha.ts",
+      "  file:file.ts",
+      "file:z-file.ts",
+    ])
+  })
+
+  test("sorts root-level files without creating directories", () => {
+    const tree = buildFileTree([{ file: "zeta.ts" }, { file: "alpha.ts" }, { file: "beta.ts" }])
+
+    expect(tree.nodes.every((node) => node.kind === "file")).toBe(true)
+    expect(flattenFileTree(tree).map((row) => row.name)).toEqual(["alpha.ts", "beta.ts", "zeta.ts"])
+  })
+
+  test("collapses unary directory chains while flattening", () => {
+    const rows = flattenFileTree(
+      buildFileTree([{ file: "packages/opencode/src/cli/app.ts" }, { file: "packages/opencode/src/server/server.ts" }]),
+    )
+
+    expect(rows.map((row) => `${"  ".repeat(row.depth)}${row.kind}:${row.name}`)).toEqual([
+      "directory:packages/opencode/src",
+      "  directory:cli",
+      "    file:app.ts",
+      "  directory:server",
+      "    file:server.ts",
+    ])
+  })
+
+  test("does not collapse a directory into a file row", () => {
+    const rows = flattenFileTree(buildFileTree([{ file: "packages/opencode/src/app.ts" }]))
+
+    expect(rows.map((row) => `${"  ".repeat(row.depth)}${row.kind}:${row.name}`)).toEqual([
+      "directory:packages/opencode/src",
+      "  file:app.ts",
+    ])
+  })
+
+  test("stops collapsing at branches", () => {
+    const rows = flattenFileTree(
+      buildFileTree([
+        { file: "packages/opencode/src/cli/app.ts" },
+        { file: "packages/opencode/src/server/server.ts" },
+        { file: "packages/readme.md" },
+      ]),
+    )
+
+    expect(rows.map((row) => `${"  ".repeat(row.depth)}${row.kind}:${row.name}`)).toEqual([
+      "directory:packages",
+      "  directory:opencode/src",
+      "    directory:cli",
+      "      file:app.ts",
+      "    directory:server",
+      "      file:server.ts",
+      "  file:readme.md",
+    ])
+  })
+
+  test("keeps same directory names under different parents separate", () => {
+    const rows = flattenFileTree(
+      buildFileTree([{ file: "components/button.ts" }, { file: "docs/components/usage.md" }]),
+    )
+
+    expect(rows.map((row) => `${"  ".repeat(row.depth)}${row.kind}:${row.name}`)).toEqual([
+      "directory:components",
+      "  file:button.ts",
+      "directory:docs/components",
+      "  file:usage.md",
+    ])
+  })
+
+  test("flattens all-expanded rows depth-first with depths and file references", () => {
+    const rows = flattenFileTree(
+      buildFileTree([{ file: "src/config/tui.ts" }, { file: "src/config/keybind.ts" }, { file: "README.md" }]),
+    )
+
+    expect(rows.map((row) => ({ name: row.name, kind: row.kind, depth: row.depth, fileIndex: row.fileIndex }))).toEqual(
+      [
+        { name: "src/config", kind: "directory", depth: 0, fileIndex: undefined },
+        { name: "keybind.ts", kind: "file", depth: 1, fileIndex: 1 },
+        { name: "tui.ts", kind: "file", depth: 1, fileIndex: 0 },
+        { name: "README.md", kind: "file", depth: 0, fileIndex: 2 },
+      ],
+    )
+  })
+
+  test("collapses expanded unary children under the first visible directory id", () => {
+    const tree = buildFileTree([
+      { file: "packages/opencode/src/cli/app.ts" },
+      { file: "packages/opencode/src/server/server.ts" },
+    ])
+    const packages = tree.nodes.find((node) => node.kind === "directory" && node.name === "packages")!
+
+    expect(flattenFileTree(tree, new Set()).map((row) => row.name)).toEqual(["packages/opencode/src"])
+    expect(flattenFileTree(tree, new Set([packages.id])).map((row) => row.name)).toEqual([
+      "packages/opencode/src",
+      "cli",
+      "server",
+    ])
+  })
+
+  test("flattens only expanded directory descendants when expansion is provided", () => {
+    const tree = buildFileTree([{ file: "src/config/tui.ts" }, { file: "src/session/index.ts" }, { file: "README.md" }])
+    const src = tree.nodes.find((node) => node.kind === "directory" && node.name === "src")!
+    const config = tree.nodes.find((node) => node.kind === "directory" && node.name === "config")!
+
+    expect(flattenFileTree(tree, new Set()).map((row) => row.name)).toEqual(["src", "README.md"])
+    expect(flattenFileTree(tree, new Set([src.id])).map((row) => row.name)).toEqual([
+      "src",
+      "config",
+      "session",
+      "README.md",
+    ])
+    expect(flattenFileTree(tree, new Set([src.id, config.id])).map((row) => row.name)).toEqual([
+      "src",
+      "config",
+      "tui.ts",
+      "session",
+      "README.md",
+    ])
+  })
+
+  test("moves selection across visible rows and clamps to bounds", () => {
+    const rows = flattenFileTree(buildFileTree([{ file: "src/config/tui.ts" }, { file: "README.md" }]))
+
+    expect(moveFileTreeSelection(rows, undefined, 1)).toBe(rows[0]!.id)
+    expect(moveFileTreeSelection(rows, rows[0]!.id, 1)).toBe(rows[1]!.id)
+    expect(moveFileTreeSelection(rows, rows[1]!.id, 99)).toBe(rows[rows.length - 1]!.id)
+    expect(moveFileTreeSelection(rows, rows[1]!.id, -99)).toBe(rows[0]!.id)
+    expect(moveFileTreeSelection([], undefined, 1)).toBeUndefined()
+  })
+
+  test("moves directory selection to first visible child", () => {
+    const rows = flattenFileTree(buildFileTree([{ file: "src/config/tui.ts" }, { file: "src/session/index.ts" }]))
+    const src = rows.find((row) => row.kind === "directory" && row.name === "src")!
+    const config = rows.find((row) => row.kind === "directory" && row.name === "config")!
+    const tui = rows.find((row) => row.name === "tui.ts")!
+
+    expect(moveFileTreeSelectionToFirstChild(rows, src.id)).toBe(config.id)
+    expect(moveFileTreeSelectionToFirstChild(rows, tui.id)).toBe(tui.id)
+    expect(moveFileTreeSelectionToFirstChild(rows, undefined)).toBeUndefined()
+  })
+
+  test("moves collapsed chain selection to first visible child", () => {
+    const rows = flattenFileTree(
+      buildFileTree([{ file: "packages/opencode/src/cli/app.ts" }, { file: "packages/opencode/src/server/server.ts" }]),
+    )
+    const packages = rows.find((row) => row.kind === "directory" && row.name === "packages/opencode/src")!
+    const cli = rows.find((row) => row.kind === "directory" && row.name === "cli")!
+
+    expect(moveFileTreeSelectionToFirstChild(rows, packages.id)).toBe(cli.id)
+  })
+
+  test("moves file and collapsed directory selection to visible parent", () => {
+    const rows = flattenFileTree(
+      buildFileTree([{ file: "packages/opencode/src/cli/app.ts" }, { file: "packages/opencode/src/server/server.ts" }]),
+    )
+    const root = rows.find((row) => row.kind === "directory" && row.name === "packages/opencode/src")!
+    const cli = rows.find((row) => row.kind === "directory" && row.name === "cli")!
+    const app = rows.find((row) => row.name === "app.ts")!
+
+    expect(moveFileTreeSelectionToParent(rows, app.id)).toBe(cli.id)
+    expect(moveFileTreeSelectionToParent(rows, cli.id)).toBe(root.id)
+    expect(moveFileTreeSelectionToParent(rows, root.id)).toBe(root.id)
+    expect(moveFileTreeSelectionToParent(rows, undefined)).toBeUndefined()
+  })
+
+  test("moves file selection relative to the highlighted row", () => {
+    const rows = flattenFileTree(
+      buildFileTree([{ file: "src/config/tui.ts" }, { file: "src/session/index.ts" }, { file: "README.md" }]),
+    )
+    const config = rows.find((row) => row.kind === "directory" && row.name === "config")!
+    const session = rows.find((row) => row.kind === "directory" && row.name === "session")!
+    const tui = rows.find((row) => row.name === "tui.ts")!
+    const index = rows.find((row) => row.name === "index.ts")!
+    const readme = rows.find((row) => row.name === "README.md")!
+
+    expect(moveFileTreeSelectionToFile(rows, undefined, 1)).toBe(tui.id)
+    expect(moveFileTreeSelectionToFile(rows, undefined, -1)).toBe(readme.id)
+    expect(moveFileTreeSelectionToFile(rows, config.id, 1)).toBe(tui.id)
+    expect(moveFileTreeSelectionToFile(rows, session.id, -1)).toBe(tui.id)
+    expect(moveFileTreeSelectionToFile(rows, tui.id, 1)).toBe(index.id)
+    expect(moveFileTreeSelectionToFile(rows, index.id, -1)).toBe(tui.id)
+    expect(moveFileTreeSelectionToFile(rows, readme.id, 1)).toBe(readme.id)
+  })
+
+  test("selects a file tree node and expands its parents for a patch file", () => {
+    const tree = buildFileTree([{ file: "src/config/tui.ts" }, { file: "src/session/index.ts" }, { file: "README.md" }])
+    const selection = fileTreeFileSelection(tree, 1)
+
+    expect(selection?.highlightedNode).toBe(
+      tree.nodes.find((node) => node.kind === "file" && node.name === "index.ts")?.id,
+    )
+    expect([...selection!.expandedNodes].map((id) => tree.nodes[id]!.name)).toEqual(["session", "src"])
+    expect(fileTreeFileSelection(tree, 99)).toBeUndefined()
+  })
+
+  test("prefers the selected file when choosing the single patch file", () => {
+    expect(singlePatchFileIndex(2, 1, 0, 3)).toBe(2)
+    expect(singlePatchFileIndex(undefined, 1, 0, 3)).toBe(1)
+    expect(singlePatchFileIndex(undefined, undefined, 0, 3)).toBe(0)
+    expect(singlePatchFileIndex(undefined, undefined, undefined, 3)).toBe(3)
+  })
+
+  test("orders patches by the flattened file tree order", () => {
+    const rows = flattenFileTree(
+      buildFileTree([
+        { file: "src/dir-8/juniper-4.ts" },
+        { file: "src/dir-8/harbor-94.ts" },
+        { file: "src/dir-8/cedar-16.ts" },
+      ]),
+    )
+
+    expect(orderedPatchFileIndexes(rows)).toEqual([2, 1, 0])
+  })
+
+  test("shows the diff viewer file tree only when enabled and files exist", () => {
+    expect(showDiffViewerFileTree(true, 1)).toBe(true)
+    expect(showDiffViewerFileTree(true, 0)).toBe(false)
+    expect(showDiffViewerFileTree(false, 1)).toBe(false)
+    expect(showDiffViewerFileTree(false, 0)).toBe(false)
+  })
+
+  test("moves patch selection through the ordered patch file indexes", () => {
+    const fileIndexes = [2, 1, 0]
+
+    expect(movePatchFileIndex(fileIndexes, undefined, 1)).toBe(2)
+    expect(movePatchFileIndex(fileIndexes, undefined, -1)).toBe(2)
+    expect(movePatchFileIndex(fileIndexes, 2, 1)).toBe(1)
+    expect(movePatchFileIndex(fileIndexes, 1, -1)).toBe(2)
+    expect(movePatchFileIndex(fileIndexes, 0, 1)).toBe(0)
+    expect(movePatchFileIndex(fileIndexes, 99, 1)).toBe(2)
+    expect(movePatchFileIndex(fileIndexes, 99, -1)).toBe(2)
+    expect(movePatchFileIndex([], undefined, 1)).toBeUndefined()
+  })
+
+  test("toggles only selected directory expansion", () => {
+    const tree = buildFileTree([{ file: "src/config/tui.ts" }, { file: "README.md" }])
+    const src = tree.nodes.find((node) => node.kind === "directory" && node.name === "src")!
+    const readme = tree.nodes.find((node) => node.kind === "file" && node.name === "README.md")!
+    const expanded = allExpandedFileTreeDirectories(tree)
+
+    const collapsed = toggleFileTreeDirectory(tree, expanded, src.id)
+    expect(collapsed.has(src.id)).toBe(false)
+    expect(flattenFileTree(tree, collapsed).map((row) => row.name)).toEqual(["src/config", "README.md"])
+
+    const reopened = toggleFileTreeDirectory(tree, collapsed, src.id)
+    expect(reopened.has(src.id)).toBe(true)
+
+    expect(toggleFileTreeDirectory(tree, reopened, readme.id)).toBe(reopened)
+    expect(toggleFileTreeDirectory(tree, reopened, undefined)).toBe(reopened)
+  })
+
+  test("sets only selected directory expansion", () => {
+    const tree = buildFileTree([{ file: "src/config/tui.ts" }, { file: "README.md" }])
+    const src = tree.nodes.find((node) => node.kind === "directory" && node.name === "src")!
+    const readme = tree.nodes.find((node) => node.kind === "file" && node.name === "README.md")!
+    const expanded = allExpandedFileTreeDirectories(tree)
+
+    const collapsed = setFileTreeDirectoryExpanded(tree, expanded, src.id, false)
+    expect(collapsed.has(src.id)).toBe(false)
+
+    const reopened = setFileTreeDirectoryExpanded(tree, collapsed, src.id, true)
+    expect(reopened.has(src.id)).toBe(true)
+
+    expect(setFileTreeDirectoryExpanded(tree, reopened, readme.id, false)).toBe(reopened)
+    expect(setFileTreeDirectoryExpanded(tree, reopened, undefined, false)).toBe(reopened)
+  })
+})

package/test/fixture/fixture.ts

@@ -0,0 +1,13 @@
+import { mkdtemp, realpath, rm } from "node:fs/promises"
+import path from "node:path"
+import os from "node:os"
+
+export async function tmpdir() {
+  const directory = await realpath(await mkdtemp(path.join(os.tmpdir(), "opencode-tui-test-")))
+  return {
+    path: directory,
+    async [Symbol.asyncDispose]() {
+      await rm(directory, { recursive: true, force: true })
+    },
+  }
+}

package/test/fixture/tui-environment.tsx

@@ -0,0 +1,32 @@
+/** @jsxImportSource @opentui/solid */
+import {
+  TuiPathsProvider,
+  TuiStartupProvider,
+  TuiTerminalEnvironmentProvider,
+  type TuiPaths,
+} from "../../src/context/runtime"
+import type { ParentProps } from "solid-js"
+
+export function TestTuiContexts(
+  props: ParentProps<{
+    cwd?: string
+    directory?: string
+    paths?: Partial<TuiPaths>
+  }>,
+) {
+  return (
+    <TuiPathsProvider
+      value={{
+        cwd: props.cwd ?? props.directory ?? "/tmp/opencode/packages/tui",
+        home: "/tmp/opencode/home",
+        state: "/tmp/opencode/state",
+        worktree: "/tmp/opencode",
+        ...props.paths,
+      }}
+    >
+      <TuiTerminalEnvironmentProvider value={{ platform: "linux" }}>
+        <TuiStartupProvider value={{ skipInitialLoading: false }}>{props.children}</TuiStartupProvider>
+      </TuiTerminalEnvironmentProvider>
+    </TuiPathsProvider>
+  )
+}

package/test/fixture/tui-plugin.ts

@@ -0,0 +1,36 @@
+import type { TuiPluginApi } from "@neurocode-ai/plugin/tui"
+import { RGBA } from "@opentui/core"
+import { createTuiResolvedConfig } from "./tui-runtime"
+
+type Opts = {
+  client?: TuiPluginApi["client"]
+  keymap?: TuiPluginApi["keymap"]
+  attention?: Partial<TuiPluginApi["attention"]>
+  event?: TuiPluginApi["event"]
+  state?: { session?: Partial<TuiPluginApi["state"]["session"]> }
+}
+
+export function createTuiPluginApi(opts: Opts = {}) {
+  const values = new Map<string, unknown>()
+  const color = RGBA.fromInts(200, 200, 200)
+  const dialog = { clear() {}, replace() {}, setSize() {}, size: "medium" as const, depth: 0, open: false }
+  return {
+    attention: { notify: async () => ({ ok: false, notification: false, sound: false }), ...opts.attention },
+    client: opts.client,
+    event: opts.event,
+    keymap: opts.keymap,
+    kv: {
+      get(name: string, fallback?: unknown) {
+        return values.has(name) ? values.get(name) : fallback
+      },
+      set(name: string, value: unknown) {
+        values.set(name, value)
+      },
+      ready: true,
+    },
+    state: { session: { get: () => undefined, ...opts.state?.session } },
+    theme: { current: new Proxy({}, { get: () => color }) },
+    tuiConfig: createTuiResolvedConfig(),
+    ui: { dialog },
+  } as unknown as TuiPluginApi
+}

package/test/fixture/tui-runtime.ts

@@ -0,0 +1,12 @@
+import { resolve, type Info, type Resolved } from "../../src/config"
+import { TuiKeybind } from "../../src/config/keybind"
+
+type ResolvedInput = Omit<Info, "attention" | "keybinds" | "leader_timeout"> & {
+  attention?: Partial<Resolved["attention"]>
+  keybinds?: Partial<TuiKeybind.Keybinds>
+  leader_timeout?: number
+}
+
+export function createTuiResolvedConfig(input: ResolvedInput = {}) {
+  return resolve(input, { terminalSuspend: process.platform !== "win32" })
+}