@neurocode-ai/tui 1.18.8

package/test/cli/tui/inline-tool-wrap-snapshot.test.tsx

@@ -0,0 +1,351 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { createSignal, For, Show } from "solid-js"
+import type { BoxRenderable, ScrollBoxRenderable } from "@opentui/core"
+import { testRender, type JSX } from "@opentui/solid"
+import {
+  formatCompletedSubagentDetail,
+  formatSubagentRetry,
+  formatSubagentTitle,
+  formatSubagentToolcalls,
+  InlineToolRow,
+  parseApplyPatchFiles,
+  parseDiagnostics,
+  parseQuestionAnswers,
+  parseQuestions,
+  parseTodos,
+  alwaysSeparate,
+  toolDisplay,
+} from "../../../src/routes/session"
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined
+
+afterEach(() => {
+  testSetup?.renderer.destroy()
+  testSetup = undefined
+})
+
+type ToolFixture = { icon: string; label: string; error?: string }
+
+const tools: readonly ToolFixture[] = [
+  {
+    icon: "✱",
+    label:
+      'Grep "OPENCODE.*DB|database|sqlite|drizzle|dev.*db|data.*dir|xdg|APPDATA" in packages/opencode/src (151 matches)',
+  },
+  {
+    icon: "✱",
+    label: 'Glob "**/*db*" in packages/opencode (6 matches)',
+  },
+  {
+    icon: "→",
+    label: "Read packages/opencode/src/storage/db.ts [offset=1, limit=130]",
+  },
+  {
+    icon: "→",
+    label: "Read packages/opencode/src/index.ts [offset=1, limit=100]",
+    error: "No LSP server available for this file type.",
+  },
+  {
+    icon: "✱",
+    label:
+      'Grep "export const NEUROCODE_DB|NEUROCODE_DB|NEUROCODE_DEV|Global\\.Path\\.data|data =" in packages/opencode/src (115 matches)',
+  },
+] as const
+
+function ShellOutput() {
+  return (
+    <box
+      ref={(el: BoxRenderable) => alwaysSeparate.add(el)}
+      marginTop={1}
+      paddingTop={1}
+      paddingBottom={1}
+      paddingLeft={2}
+      gap={1}
+    >
+      <box gap={1}>
+        <text>$ ls</text>
+        <text>file.ts</text>
+      </box>
+    </box>
+  )
+}
+
+function UserMessage() {
+  return (
+    <box ref={(el: BoxRenderable) => alwaysSeparate.add(el)}>
+      <box paddingTop={1} paddingBottom={1} paddingLeft={2}>
+        <text>Check whether the next tool remains separated.</text>
+      </box>
+    </box>
+  )
+}
+
+function Fixture(props: { errorExpanded?: boolean; before?: "shell" | "user" }) {
+  return (
+    <box flexDirection="column" width={72}>
+      <box flexDirection="column">
+        {props.before === "shell" && <ShellOutput />}
+        {props.before === "user" && <UserMessage />}
+        <For each={tools}>
+          {(item) => (
+            <InlineToolRow
+              icon={item.icon}
+              complete={true}
+              pending=""
+              failed={Boolean(item.error)}
+              error={item.error}
+              errorExpanded={props.errorExpanded}
+            >
+              {item.label}
+            </InlineToolRow>
+          )}
+        </For>
+      </box>
+    </box>
+  )
+}
+
+function TaskRowsFixture() {
+  return (
+    <box flexDirection="column" width={72}>
+      <InlineToolRow icon="✱" complete={true} pending="">
+        Grep "Task" (2 matches)
+      </InlineToolRow>
+      <InlineToolRow icon="⠙" complete={true} pending="" separate={true}>
+        Explore Task — Inspect active task spacing
+      </InlineToolRow>
+      <InlineToolRow icon="✓" complete={true} pending="" separate={true}>
+        {"General Task — Confirm completed task spacing\n↳ 1 toolcall · 501ms"}
+      </InlineToolRow>
+      <InlineToolRow icon="→" complete={true} pending="">
+        Read src/cli/cmd/tui/routes/session/index.tsx
+      </InlineToolRow>
+    </box>
+  )
+}
+
+function LoadedReadBeforeTaskFixture() {
+  return (
+    <box flexDirection="column" width={72}>
+      <InlineToolRow icon="→" complete={true} pending="">
+        Read src/cli/cmd/tui/routes/session/index.tsx
+      </InlineToolRow>
+      <box paddingLeft={3}>
+        <text paddingLeft={3}>↳ Loaded src/cli/cmd/tui/routes/session/tools.tsx</text>
+      </box>
+      <InlineToolRow icon="✓" complete={true} pending="" separate={true}>
+        {"Explore Task — Inspect active task spacing\n↳ 1 toolcall · 501ms"}
+      </InlineToolRow>
+    </box>
+  )
+}
+
+function AssistantSummaryBeforeInlineFixture() {
+  return (
+    <box flexDirection="column" width={72}>
+      <box ref={(el: BoxRenderable) => alwaysSeparate.add(el)} paddingLeft={3}>
+        <text>▣ Build · Little Frank · 53.1s</text>
+      </box>
+      <InlineToolRow icon="✓" complete={true} pending="">
+        {"Build Task — Review changes\n↳ 48 toolcalls · 1m 40s"}
+      </InlineToolRow>
+    </box>
+  )
+}
+
+function AssistantErrorBeforeInlineFixture() {
+  return (
+    <box flexDirection="column" width={72}>
+      <box
+        ref={(el: BoxRenderable) => alwaysSeparate.add(el)}
+        border={["left"]}
+        paddingTop={1}
+        paddingBottom={1}
+        paddingLeft={2}
+      >
+        <text>Managed inference requires an active Member plan</text>
+      </box>
+      <InlineToolRow icon="✓" complete={true} pending="">
+        {"Build Task — Review changes\n↳ 48 toolcalls · 1m 40s"}
+      </InlineToolRow>
+    </box>
+  )
+}
+
+function StickyScrollFixture(props: { separated: boolean; scroll: (scroll: ScrollBoxRenderable) => void }) {
+  return (
+    <scrollbox ref={props.scroll} stickyScroll={true} stickyStart="bottom" height={3} width={72}>
+      <box height={1}>
+        <text>First row</text>
+      </box>
+      <box height={1}>
+        <text>Second row</text>
+      </box>
+      <Show when={props.separated}>
+        <box ref={(el: BoxRenderable) => alwaysSeparate.add(el)}>
+          <text>Assistant text</text>
+        </box>
+      </Show>
+      <InlineToolRow icon="→" complete={true} pending="">
+        Read src/cli/cmd/tui/routes/session/index.tsx
+      </InlineToolRow>
+    </scrollbox>
+  )
+}
+
+function FailedPendingToolFixture() {
+  return (
+    <InlineToolRow icon="%" complete={false} pending="Preparing patch..." failed={true} failure="Patch failed">
+      Patch
+    </InlineToolRow>
+  )
+}
+
+function FailedCompleteToolFixture() {
+  return (
+    <InlineToolRow icon="→" complete={true} pending="Reading file..." failed={true} failure="Read failed">
+      Read src/index.ts
+    </InlineToolRow>
+  )
+}
+
+async function renderFrame(component: () => JSX.Element, options: { width: number; height: number }) {
+  testSetup = await testRender(component, options)
+  await testSetup.renderOnce()
+  await testSetup.renderOnce()
+
+  return testSetup
+    .captureCharFrame()
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .join("\n")
+    .trimEnd()
+}
+
+describe("TUI inline tool wrapping", () => {
+  test("falls back for unknown tool names", () => {
+    expect(toolDisplay("bash")).toBe("bash")
+    expect(toolDisplay("plugin_tool")).toBe("generic")
+  })
+
+  test("replaces pending copy when a tool fails before completion", async () => {
+    const frame = await renderFrame(() => <FailedPendingToolFixture />, { width: 72, height: 3 })
+    expect(frame).toContain("Patch failed")
+    expect(frame).not.toContain("Preparing patch")
+  })
+
+  test("preserves useful completed copy when a tool fails", async () => {
+    const frame = await renderFrame(() => <FailedCompleteToolFixture />, { width: 72, height: 3 })
+    expect(frame).toContain("Read src/index.ts")
+    expect(frame).not.toContain("Read failed")
+  })
+
+  test("filters malformed nested tool wire data", () => {
+    expect(
+      parseApplyPatchFiles([
+        null,
+        { type: "add" },
+        { type: "add", relativePath: "a.ts", filePath: "a.ts", patch: "diff", deletions: 0 },
+      ]),
+    ).toEqual([
+      { type: "add", relativePath: "a.ts", filePath: "a.ts", patch: "diff", deletions: 0, movePath: undefined },
+    ])
+    expect(parseTodos([null, { status: "pending" }, { status: "pending", content: "Safe" }])).toEqual([
+      { status: "pending", content: "Safe" },
+    ])
+    expect(parseQuestions([{}, { question: 1 }, { question: "Continue?" }])).toEqual([{ question: "Continue?" }])
+    expect(parseQuestionAnswers([null, ["yes", 1], "no"])).toEqual([[], ["yes"], []])
+    expect(parseQuestionAnswers({})).toBeUndefined()
+  })
+
+  test("ignores diagnostics with malformed nested ranges", () => {
+    expect(
+      parseDiagnostics(
+        {
+          "a.ts": [
+            { severity: 1, message: "missing range" },
+            { severity: 1, message: "bad line", range: { start: { line: "0", character: 1 } } },
+            { severity: 1, message: "valid", range: { start: { line: 2, character: 3 } } },
+          ],
+        },
+        "a.ts",
+      ),
+    ).toEqual([{ message: "valid", range: { start: { line: 2, character: 3 } } }])
+  })
+
+  test("formats completed subagent toolcall details", () => {
+    expect(formatCompletedSubagentDetail(0, "501ms")).toBe("501ms")
+    expect(formatCompletedSubagentDetail(1, "501ms")).toBe("1 toolcall · 501ms")
+    expect(formatCompletedSubagentDetail(2, "501ms")).toBe("2 toolcalls · 501ms")
+    expect(formatSubagentToolcalls(0)).toBe("0 toolcalls")
+  })
+
+  test("keeps background state attached to the subagent identity", () => {
+    expect(formatSubagentTitle("Explore", "Inspect renderer", false)).toBe("Explore Task — Inspect renderer")
+    expect(formatSubagentTitle("Explore", "Inspect renderer", true)).toBe(
+      "Explore Task (background) — Inspect renderer",
+    )
+  })
+
+  test("keeps retry status ahead of wrapping messages", () => {
+    expect(formatSubagentRetry(2, "Rate limited by provider")).toBe("Retrying (attempt 2) · Rate limited by provider")
+  })
+
+  test("snapshots consecutive grep, glob, and read rows at a narrow width", async () => {
+    expect(await renderFrame(() => <Fixture />, { width: 72, height: 12 })).toMatchSnapshot()
+  })
+
+  test("snapshots expanded tool errors under the tool text", async () => {
+    expect(await renderFrame(() => <Fixture errorExpanded />, { width: 72, height: 12 })).toMatchSnapshot()
+  })
+
+  test("keeps separation after a shell output block", async () => {
+    expect(await renderFrame(() => <Fixture before="shell" />, { width: 72, height: 16 })).toMatchSnapshot()
+  })
+
+  test("keeps separation after a padded user message", async () => {
+    expect(await renderFrame(() => <Fixture before="user" />, { width: 72, height: 14 })).toMatchSnapshot()
+  })
+
+  test("separates after a multi-line task row", async () => {
+    expect(await renderFrame(() => <TaskRowsFixture />, { width: 72, height: 10 })).toMatchSnapshot()
+  })
+
+  test("separates a task row from a preceding inline detail", async () => {
+    expect(await renderFrame(() => <LoadedReadBeforeTaskFixture />, { width: 72, height: 8 })).toMatchSnapshot()
+  })
+
+  test("separates an inline row from the previous assistant summary", async () => {
+    expect(await renderFrame(() => <AssistantSummaryBeforeInlineFixture />, { width: 72, height: 5 })).toMatchSnapshot()
+  })
+
+  test("separates an inline row from the previous assistant error", async () => {
+    expect(await renderFrame(() => <AssistantErrorBeforeInlineFixture />, { width: 72, height: 7 })).toMatchSnapshot()
+  })
+
+  test("updates sticky-bottom geometry when a text separator mounts and unmounts", async () => {
+    const [separated, setSeparated] = createSignal(false)
+    let scroll: ScrollBoxRenderable | undefined
+    testSetup = await testRender(
+      () => <StickyScrollFixture separated={separated()} scroll={(value) => (scroll = value)} />,
+      {
+        width: 72,
+        height: 3,
+      },
+    )
+
+    await testSetup.renderOnce()
+    expect(scroll?.scrollHeight).toBe(3)
+    expect(scroll?.scrollTop).toBe(Math.max(0, scroll!.scrollHeight - scroll!.viewport.height))
+
+    setSeparated(true)
+    await testSetup.renderOnce()
+    expect(scroll?.scrollHeight).toBe(5)
+    expect(scroll?.scrollTop).toBe(Math.max(0, scroll!.scrollHeight - scroll!.viewport.height))
+
+    setSeparated(false)
+    await testSetup.renderOnce()
+    expect(scroll?.scrollHeight).toBe(3)
+    expect(scroll?.scrollTop).toBe(Math.max(0, scroll!.scrollHeight - scroll!.viewport.height))
+  })
+})

package/test/cli/tui/prompt-submit-race.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test"
+
+// Regression test for the prompt submit race in
+// packages/tui/src/component/prompt/index.tsx (`submit`).
+//
+// Before the fix, two concurrent `submit()` calls (e.g. a double-pressed
+// Enter, or the input's native onSubmit racing another dispatch) each
+// passed the `if (!store.prompt.input) return false` guard, each
+// `await sdk.client.session.create(...)`, and each only captured
+// `inputText = store.prompt.input` AFTER that await. The first invocation
+// finished, sent the prompt, and cleared the store; the second invocation,
+// now past its await, read the cleared store and sent an empty prompt to a
+// second freshly-created session - leaving an orphaned session with the
+// user's actual text and a phantom session visible to the user containing
+// only an assistant reply.
+//
+// `submitMirror` below has the exact shape of the production `submit()`
+// after the fix: an in-flight `submitting` guard wraps the original body.
+// Two concurrent invocations must result in exactly one submission carrying
+// the user's text, with no empty-text submission.
+
+type Store = { input: string }
+
+type SubmitResult = { sessionID: string; text: string }
+
+type Harness = {
+  store: Store
+  submissions: SubmitResult[]
+  createSession(): Promise<string>
+  sendPrompt(sessionID: string, text: string): Promise<void>
+}
+
+function createHarness(opts: { sessionCreateDelayMs: number }): Harness {
+  let sessionCounter = 0
+  const submissions: SubmitResult[] = []
+
+  return {
+    store: { input: "" },
+    submissions,
+    async createSession() {
+      sessionCounter += 1
+      const id = `ses_${sessionCounter}`
+      await Bun.sleep(opts.sessionCreateDelayMs)
+      return id
+    },
+    async sendPrompt(sessionID, text) {
+      submissions.push({ sessionID, text })
+    },
+  }
+}
+
+function createSubmit() {
+  let submitting = false
+  return async function submit(h: Harness) {
+    if (submitting) return false
+    submitting = true
+    try {
+      if (!h.store.input) return false
+      const sessionID = await h.createSession()
+      const inputText = h.store.input
+      await h.sendPrompt(sessionID, inputText)
+      h.store.input = ""
+      return true
+    } finally {
+      submitting = false
+    }
+  }
+}
+
+describe("Prompt.submit race", () => {
+  test("concurrent submits must not lose the user's text", async () => {
+    const submit = createSubmit()
+    const h = createHarness({ sessionCreateDelayMs: 5 })
+    h.store.input = "Hello there."
+
+    // Two invocations back-to-back, mimicking a double-Enter.
+    await Promise.all([submit(h), submit(h)])
+
+    // Every submission that did make it through must carry the actual user
+    // text, and no submission may have an empty text payload.
+    expect(h.submissions.every((s) => s.text === "Hello there.")).toBe(true)
+    expect(h.submissions.some((s) => s.text === "")).toBe(false)
+  })
+
+  test("a sequential second submit after clear is a no-op, not a phantom session", async () => {
+    const submit = createSubmit()
+    const h = createHarness({ sessionCreateDelayMs: 1 })
+    h.store.input = "Hello there."
+
+    await submit(h)
+    // After the first submission completes, the store is cleared; a second
+    // Enter on an empty input must not create a phantom session.
+    await submit(h)
+
+    expect(h.submissions).toHaveLength(1)
+    expect(h.submissions[0].text).toBe("Hello there.")
+  })
+})

package/test/cli/tui/thinking.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+import { reasoningSummary } from "../../../src/context/thinking"
+
+describe("reasoningSummary", () => {
+  test("extracts a leading summary title and leaves markdown body", () => {
+    expect(reasoningSummary("**Continuing Quality Review**\n\nDetails.\n\n**Next section**\n\nMore.")).toEqual({
+      title: "Continuing Quality Review",
+      body: "Details.\n\n**Next section**\n\nMore.",
+    })
+  })
+
+  test("extracts a completed title before its streamed body arrives", () => {
+    expect(reasoningSummary("**Continuing Quality Review**")).toEqual({
+      title: "Continuing Quality Review",
+      body: "",
+    })
+  })
+
+  test("preserves markdown-significant indentation in the extracted body", () => {
+    expect(reasoningSummary("**Continuing Quality Review**\n\n    const value = true\n")).toEqual({
+      title: "Continuing Quality Review",
+      body: "    const value = true",
+    })
+  })
+
+  test("does not consume ordinary leading bold content", () => {
+    expect(reasoningSummary("**Important:** keep this in the body.")).toEqual({
+      title: null,
+      body: "**Important:** keep this in the body.",
+    })
+  })
+
+  test("leaves content without a leading title in its body", () => {
+    expect(reasoningSummary("Details only.")).toEqual({ title: null, body: "Details only." })
+  })
+})

package/test/cli/tui/use-event.test.tsx

@@ -0,0 +1,148 @@
+/** @jsxImportSource @opentui/solid */
+import { describe, expect, test } from "bun:test"
+import { testRender } from "@opentui/solid"
+import type { Event, GlobalEvent } from "@neurocode-ai/sdk/v2"
+import { onMount } from "solid-js"
+import { ProjectProvider, useProject } from "../../../src/context/project"
+import { SDKProvider } from "../../../src/context/sdk"
+import { useEvent } from "../../../src/context/event"
+import { createEventSource, createFetch, directory } from "../../fixture/tui-sdk"
+import { TestTuiContexts } from "../../fixture/tui-environment"
+
+const projectID = "proj_test"
+
+async function wait(fn: () => boolean, timeout = 2000) {
+  const start = Date.now()
+  while (!fn()) {
+    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
+    await Bun.sleep(10)
+  }
+}
+
+function event(payload: Event, input: { directory: string; project?: string; workspace?: string }): GlobalEvent {
+  return {
+    directory: input.directory,
+    project: input.project,
+    workspace: input.workspace,
+    payload,
+  }
+}
+
+function vcs(branch: string): Event {
+  return {
+    id: `evt_vcs_${branch}`,
+    type: "vcs.branch.updated",
+    properties: {
+      branch,
+    },
+  }
+}
+
+function update(version: string): Event {
+  return {
+    id: `evt_update_${version}`,
+    type: "installation.update-available",
+    properties: {
+      version,
+    },
+  }
+}
+
+async function mount() {
+  const events = createEventSource()
+  const calls = createFetch()
+  const seen: Event[] = []
+  const workspaces: Array<string | undefined> = []
+  let project!: ReturnType<typeof useProject>
+  let done!: () => void
+  const ready = new Promise<void>((resolve) => {
+    done = resolve
+  })
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider url="http://test" directory={directory} events={events.source} fetch={calls.fetch}>
+        <ProjectProvider>
+          <Probe
+            onReady={async (ctx) => {
+              project = ctx.project
+              await project.sync()
+              done()
+            }}
+            seen={seen}
+            workspaces={workspaces}
+          />
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  await ready
+  return { app, emit: events.emit, project, seen, workspaces }
+}
+
+function Probe(props: {
+  seen: Event[]
+  workspaces: Array<string | undefined>
+  onReady: (ctx: { project: ReturnType<typeof useProject> }) => void
+}) {
+  const project = useProject()
+  const event = useEvent()
+
+  onMount(() => {
+    event.subscribe((evt, { workspace }) => {
+      props.seen.push(evt)
+      props.workspaces.push(workspace)
+    })
+    props.onReady({ project })
+  })
+
+  return <box />
+}
+
+describe("useEvent", () => {
+  test("delivers events for the current project", async () => {
+    const { app, emit, seen, workspaces } = await mount()
+
+    try {
+      emit(event(vcs("main"), { directory: "/tmp/other", project: projectID, workspace: "ws_a" }))
+
+      await wait(() => seen.length === 1)
+
+      expect(seen).toEqual([vcs("main")])
+      expect(workspaces).toEqual(["ws_a"])
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+
+  test("delivers current project events regardless of active workspace", async () => {
+    const { app, emit, project, seen } = await mount()
+
+    try {
+      project.workspace.set("ws_a")
+      emit(event(vcs("ws"), { directory: "/tmp/other", project: projectID, workspace: "ws_b" }))
+
+      await wait(() => seen.length === 1)
+
+      expect(seen).toEqual([vcs("ws")])
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+
+  test("delivers truly global events even when a workspace is active", async () => {
+    const { app, emit, project, seen } = await mount()
+
+    try {
+      project.workspace.set("ws_a")
+      emit(event(update("1.2.3"), { directory: "global" }))
+
+      await wait(() => seen.length === 1)
+
+      expect(seen).toEqual([update("1.2.3")])
+    } finally {
+      app.renderer.destroy()
+    }
+  })
+})

package/test/clipboard.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test"
+import { copyCommand } from "../src/clipboard"
+
+test("prefers Wayland clipboard when available", () => {
+  expect(copyCommand("linux", true, (name) => name === "wl-copy")).toEqual(["wl-copy"])
+})
+
+test("uses osascript on macOS", () => {
+  expect(copyCommand("darwin", false, (name) => name === "osascript")).toEqual(["osascript"])
+})
+
+test("falls back through X11 clipboard commands", () => {
+  expect(copyCommand("linux", true, (name) => name === "xclip")).toEqual(["xclip", "-selection", "clipboard"])
+  expect(copyCommand("linux", false, (name) => name === "xsel")).toEqual(["xsel", "--clipboard", "--input"])
+})
+
+test("returns undefined when native clipboard is unavailable", () => {
+  expect(copyCommand("linux", false, () => false)).toBeUndefined()
+})