@neurocode-ai/tui 1.18.8

package/src/util/provider-origin.ts

@@ -0,0 +1,7 @@
+const contains = (consoleManagedProviders: string[] | ReadonlySet<string>, providerID: string) =>
+  Array.isArray(consoleManagedProviders)
+    ? consoleManagedProviders.includes(providerID)
+    : consoleManagedProviders.has(providerID)
+
+export const isConsoleManagedProvider = (consoleManagedProviders: string[] | ReadonlySet<string>, providerID: string) =>
+  contains(consoleManagedProviders, providerID)

package/src/util/record.ts

@@ -0,0 +1,3 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+}

package/src/util/renderer.ts

@@ -0,0 +1,7 @@
+import type { CliRenderer } from "@opentui/core"
+
+export function destroyRenderer(renderer: Pick<CliRenderer, "isDestroyed" | "setTerminalTitle" | "destroy">) {
+  renderer.setTerminalTitle("")
+  if (renderer.isDestroyed) return
+  renderer.destroy()
+}

package/src/util/revert-diff.ts

@@ -0,0 +1,18 @@
+import { parsePatch } from "diff"
+
+export function getRevertDiffFiles(diffText: string) {
+  if (!diffText) return []
+
+  try {
+    return parsePatch(diffText).map((patch) => {
+      const filename = [patch.newFileName, patch.oldFileName].find((item) => item && item !== "/dev/null") ?? "unknown"
+      return {
+        filename: filename.replace(/^[ab]\//, ""),
+        additions: patch.hunks.reduce((sum, hunk) => sum + hunk.lines.filter((line) => line.startsWith("+")).length, 0),
+        deletions: patch.hunks.reduce((sum, hunk) => sum + hunk.lines.filter((line) => line.startsWith("-")).length, 0),
+      }
+    })
+  } catch {
+    return []
+  }
+}

package/src/util/scroll.ts

@@ -0,0 +1,27 @@
+import { MacOSScrollAccel, type ScrollAcceleration } from "@opentui/core"
+
+export type ScrollConfig = {
+  scroll_acceleration?: { enabled?: boolean }
+  scroll_speed?: number
+}
+
+export class CustomSpeedScroll implements ScrollAcceleration {
+  constructor(private speed: number) {}
+
+  tick(_now?: number): number {
+    return this.speed
+  }
+
+  reset(): void {}
+}
+
+export function getScrollAcceleration(tuiConfig?: ScrollConfig): ScrollAcceleration {
+  if (tuiConfig?.scroll_acceleration?.enabled) {
+    return new MacOSScrollAccel()
+  }
+  if (tuiConfig?.scroll_speed !== undefined) {
+    return new CustomSpeedScroll(tuiConfig.scroll_speed)
+  }
+
+  return new CustomSpeedScroll(3)
+}

package/src/util/selection.ts

@@ -0,0 +1,79 @@
+import type { ClipboardService } from "../context/clipboard"
+
+type Toast = {
+  show: (input: { message: string; variant: "info" | "success" | "warning" | "error" }) => void
+  error: (err: unknown) => void
+}
+
+type FocusableSelectionTarget = {
+  hasSelection: () => boolean
+  getClipboardText?: (text: string) => string
+}
+
+type Renderer = {
+  getSelection: () => { getSelectedText: () => string; selectedRenderables: FocusableSelectionTarget[] } | null
+  clearSelection: () => void
+  currentFocusedRenderable?: FocusableSelectionTarget | null
+}
+
+type SelectionKeyEvent = {
+  ctrl?: boolean
+  name: string
+  preventDefault: () => void
+  stopPropagation: () => void
+}
+
+export function copy(renderer: Renderer, toast: Toast, clipboard: ClipboardService): boolean {
+  const selection = renderer.getSelection()
+  if (!selection) return false
+
+  const text = selection.getSelectedText()
+  if (!text) return false
+
+  const focus = renderer.currentFocusedRenderable
+  const clipboardText =
+    focus?.getClipboardText && selection.selectedRenderables.includes(focus) ? focus.getClipboardText(text) : text
+
+  clipboard
+    ?.write?.(clipboardText)
+    .then(() => toast.show({ message: "Copied to clipboard", variant: "info" }))
+    .catch(toast.error)
+
+  renderer.clearSelection()
+  return true
+}
+
+export function handleSelectionKey(
+  renderer: Renderer,
+  toast: Toast,
+  event: SelectionKeyEvent,
+  clipboard: ClipboardService,
+) {
+  const selection = renderer.getSelection()
+  if (!selection) return
+
+  if (event.ctrl && event.name === "c") {
+    if (!copy(renderer, toast, clipboard)) {
+      renderer.clearSelection()
+      return
+    }
+
+    event.preventDefault()
+    event.stopPropagation()
+    return
+  }
+
+  if (event.name === "escape") {
+    renderer.clearSelection()
+    event.preventDefault()
+    event.stopPropagation()
+    return
+  }
+
+  const focus = renderer.currentFocusedRenderable
+  if (focus?.hasSelection() && selection.selectedRenderables.includes(focus)) return
+
+  renderer.clearSelection()
+}
+
+export * as Selection from "./selection"

package/src/util/session.ts

@@ -0,0 +1,3 @@
+export function isDefaultTitle(title: string) {
+  return /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(title)
+}

package/src/util/signal.ts

@@ -0,0 +1,51 @@
+import { createEffect, createSignal, on, onCleanup, type Accessor } from "solid-js"
+
+export function createDebouncedSignal<T>(value: T, ms: number): [Accessor<T>, (value: T) => void] {
+  const [get, set] = createSignal(value)
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const debounced = (next: T) => {
+    if (timer) clearTimeout(timer)
+    timer = setTimeout(() => {
+      timer = undefined
+      set(() => next)
+    }, ms)
+  }
+  onCleanup(() => {
+    if (timer) clearTimeout(timer)
+  })
+  return [get, debounced]
+}
+
+export function createFadeIn(show: Accessor<boolean>, enabled: Accessor<boolean>) {
+  const [alpha, setAlpha] = createSignal(show() ? 1 : 0)
+  let revealed = show()
+
+  createEffect(
+    on([show, enabled], ([visible, animate]) => {
+      if (!visible) {
+        setAlpha(0)
+        return
+      }
+
+      if (!animate || revealed) {
+        revealed = true
+        setAlpha(1)
+        return
+      }
+
+      const start = performance.now()
+      revealed = true
+      setAlpha(0)
+
+      const timer = setInterval(() => {
+        const progress = Math.min((performance.now() - start) / 160, 1)
+        setAlpha(progress * progress * (3 - 2 * progress))
+        if (progress >= 1) clearInterval(timer)
+      }, 16)
+
+      onCleanup(() => clearInterval(timer))
+    }),
+  )
+
+  return alpha
+}

package/src/util/system.ts

@@ -0,0 +1,20 @@
+import { release } from "node:os"
+
+export function describeOS() {
+  const name =
+    process.platform === "darwin"
+      ? "macOS"
+      : process.platform === "win32"
+        ? "Windows"
+        : process.platform === "linux"
+          ? "Linux"
+          : process.platform
+  return `${name} ${release()} (${process.arch})`
+}
+
+export function describeTerminal() {
+  const program = process.env.TERM_PROGRAM || process.env.TERM || "unknown"
+  const version = process.env.TERM_PROGRAM_VERSION ? ` ${process.env.TERM_PROGRAM_VERSION}` : ""
+  const multiplexer = process.env.TMUX ? " in tmux" : process.env.STY ? " in screen" : ""
+  return `${program}${version}${multiplexer}`
+}

package/src/util/tool-display.ts

@@ -0,0 +1,13 @@
+export function webSearchProviderLabel(provider: unknown) {
+  if (provider === "parallel") return "Parallel Web Search"
+  if (provider === "exa") return "Exa Web Search"
+  return "Web Search"
+}
+
+export function toolDisplayMetadata(state: unknown): Record<string, unknown> {
+  if (!state || typeof state !== "object" || Array.isArray(state)) return {}
+  if (!("status" in state) || state.status === "pending") return {}
+  if (!("structured" in state) || !state.structured || typeof state.structured !== "object") return {}
+  if (Array.isArray(state.structured)) return {}
+  return state.structured as Record<string, unknown>
+}

package/src/util/transcript.ts

@@ -0,0 +1,112 @@
+import type { AssistantMessage, Part, Provider, UserMessage } from "@neurocode-ai/sdk/v2"
+import { Locale } from "./locale"
+import * as Model from "./model"
+
+export type TranscriptOptions = {
+  thinking: boolean
+  toolDetails: boolean
+  assistantMetadata: boolean
+  providers?: Provider[]
+}
+
+export type SessionInfo = {
+  id: string
+  title: string
+  time: {
+    created: number
+    updated: number
+  }
+}
+
+export type MessageWithParts = {
+  info: UserMessage | AssistantMessage
+  parts: Part[]
+}
+
+export function formatTranscript(
+  session: SessionInfo,
+  messages: MessageWithParts[],
+  options: TranscriptOptions,
+): string {
+  const providers = Model.index(options.providers)
+  let transcript = `# ${session.title}\n\n`
+  transcript += `**Session ID:** ${session.id}\n`
+  transcript += `**Created:** ${new Date(session.time.created).toLocaleString()}\n`
+  transcript += `**Updated:** ${new Date(session.time.updated).toLocaleString()}\n\n`
+  transcript += `---\n\n`
+
+  for (const msg of messages) {
+    transcript += formatMessage(msg.info, msg.parts, options, providers)
+    transcript += `---\n\n`
+  }
+
+  return transcript
+}
+
+export function formatMessage(
+  msg: UserMessage | AssistantMessage,
+  parts: Part[],
+  options: TranscriptOptions,
+  providers?: Provider[] | ReadonlyMap<string, Provider>,
+): string {
+  let result = ""
+
+  if (msg.role === "user") {
+    result += `## User\n\n`
+  } else {
+    result += formatAssistantHeader(msg, options.assistantMetadata, providers ?? options.providers)
+  }
+
+  for (const part of parts) {
+    result += formatPart(part, options)
+  }
+
+  return result
+}
+
+export function formatAssistantHeader(
+  msg: AssistantMessage,
+  includeMetadata: boolean,
+  providers?: Provider[] | ReadonlyMap<string, Provider>,
+): string {
+  if (!includeMetadata) {
+    return `## Assistant\n\n`
+  }
+
+  const duration =
+    msg.time.completed && msg.time.created ? ((msg.time.completed - msg.time.created) / 1000).toFixed(1) + "s" : ""
+
+  const modelName = Model.name(providers, msg.providerID, msg.modelID)
+
+  return `## Assistant (${Locale.titlecase(msg.agent)} · ${modelName}${duration ? ` · ${duration}` : ""})\n\n`
+}
+
+export function formatPart(part: Part, options: TranscriptOptions): string {
+  if (part.type === "text" && !part.synthetic) {
+    return `${part.text}\n\n`
+  }
+
+  if (part.type === "reasoning") {
+    if (options.thinking) {
+      return `_Thinking:_\n\n${part.text}\n\n`
+    }
+    return ""
+  }
+
+  if (part.type === "tool") {
+    let result = `**Tool: ${part.tool}**\n`
+    if (options.toolDetails && part.state.input) {
+      result += `\n**Input:**\n\`\`\`json\n${JSON.stringify(part.state.input, null, 2)}\n\`\`\`\n`
+    }
+    if (options.toolDetails && part.state.status === "completed" && part.state.output) {
+      result += `\n**Output:**\n\`\`\`\n${part.state.output}\n\`\`\`\n`
+    }
+    if (options.toolDetails && part.state.status === "error" && part.state.error) {
+      result += `\n**Error:**\n\`\`\`\n${part.state.error}\n\`\`\`\n`
+    }
+    result += `\n`
+    return result
+  }
+
+  return ""
+}

package/sst-env.d.ts

@@ -0,0 +1,10 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+/* biome-ignore-all lint: auto-generated */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import "sst"
+export {}

package/test/app-lifecycle.test.tsx

@@ -0,0 +1,128 @@
+import { expect, mock, test } from "bun:test"
+import type { TuiPluginApi } from "@neurocode-ai/plugin/tui"
+import { createTestRenderer } from "@opentui/core/testing"
+import { Effect } from "effect"
+import { AppNodeBuilder } from "@neurocode-ai/core/effect/app-node-builder"
+import { Global } from "@neurocode-ai/core/global"
+import { createTuiResolvedConfig } from "./fixture/tui-runtime"
+import { createEventSource, createFetch, directory, json } from "./fixture/tui-sdk"
+
+test("SIGHUP clears title and disposes scoped resources once", async () => {
+  const setup = await createTestRenderer({ width: 80, height: 24, useThread: false })
+  const core = await import("@opentui/core")
+  mock.module("@opentui/core", () => ({ ...core, createCliRenderer: async () => setup.renderer }))
+  const titles: string[] = []
+  const setTitle = setup.renderer.setTerminalTitle.bind(setup.renderer)
+  setup.renderer.setTerminalTitle = (title) => {
+    titles.push(title)
+    setTitle(title)
+  }
+  const listeners = new Set(process.listeners("SIGHUP"))
+  const events = createEventSource()
+  const calls = createFetch()
+  let started!: () => void
+  const ready = new Promise<void>((resolve) => {
+    started = resolve
+  })
+  let disposes = 0
+
+  try {
+    const { run } = await import("../src/app")
+    const task = Effect.runPromise(
+      run({
+        url: "http://test",
+        directory,
+        config: createTuiResolvedConfig({ plugin_enabled: {} }),
+        fetch: calls.fetch,
+        events: events.source,
+        args: {},
+        pluginHost: {
+          async start() {
+            started()
+          },
+          async dispose() {
+            disposes++
+          },
+        },
+      }).pipe(Effect.provide(AppNodeBuilder.build(Global.node))),
+    )
+    await ready
+    process.emit("SIGHUP")
+    await task
+
+    expect(setup.renderer.isDestroyed).toBe(true)
+    expect(titles.at(-1)).toBe("")
+    expect(disposes).toBe(1)
+    expect(process.listeners("SIGHUP").every((listener) => listeners.has(listener))).toBe(true)
+  } finally {
+    if (!setup.renderer.isDestroyed) setup.renderer.destroy()
+    mock.restore()
+  }
+})
+
+test("app.exit prints the session epilogue after scoped cleanup", async () => {
+  const setup = await createTestRenderer({ width: 80, height: 24, useThread: false })
+  const core = await import("@opentui/core")
+  mock.module("@opentui/core", () => ({ ...core, createCliRenderer: async () => setup.renderer }))
+  const events = createEventSource()
+  const calls = createFetch((url) => {
+    if (url.pathname === "/session")
+      return json([
+        {
+          id: "dummy",
+          title: "Demo session",
+          slug: "dummy",
+          projectID: "project",
+          directory,
+          version: "0.0.0-test",
+          time: { created: 0, updated: 0 },
+        },
+      ])
+  })
+  const originalWrite = process.stdout.write.bind(process.stdout)
+  let stdout = ""
+  let api: TuiPluginApi | undefined
+  let started!: () => void
+  const ready = new Promise<void>((resolve) => {
+    started = resolve
+  })
+
+  process.stdout.write = ((chunk: string | Uint8Array) => {
+    stdout += String(chunk)
+    return true
+  }) as typeof process.stdout.write
+
+  try {
+    const { run } = await import("../src/app")
+    const task = Effect.runPromise(
+      run({
+        url: "http://test",
+        directory,
+        config: createTuiResolvedConfig({ plugin_enabled: {} }),
+        fetch: calls.fetch,
+        events: events.source,
+        args: { continue: true },
+        pluginHost: {
+          async start(input) {
+            api = input.api
+            started()
+          },
+          async dispose() {},
+        },
+      }).pipe(Effect.provide(AppNodeBuilder.build(Global.node))),
+    )
+
+    await ready
+    await setup.renderOnce()
+    await setup.renderOnce()
+    api?.keymap.dispatchCommand("app.exit")
+    await task
+
+    expect(stdout).toContain("Demo session")
+    expect(stdout).toContain("opencode -s dummy")
+  } finally {
+    process.stdout.write = originalWrite
+    if (!setup.renderer.isDestroyed) setup.renderer.destroy()
+    mock.restore()
+  }
+})

package/test/cli/cmd/tui/dialog-workspace-create.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test"
+import { recentConnectedWorkspaces } from "../../../../src/component/dialog-workspace-create"
+
+describe("recentConnectedWorkspaces", () => {
+  test("returns connected workspaces sorted by time used", () => {
+    const workspaces = [
+      { id: "wrk_a", name: "alpha", timeUsed: 700 },
+      { id: "wrk_b", name: "beta", timeUsed: 800 },
+      { id: "wrk_c", name: "gamma", timeUsed: 400 },
+      { id: "wrk_d", name: "delta", timeUsed: 300 },
+      { id: "wrk_e", name: "epsilon", timeUsed: 200 },
+    ]
+    const status = {
+      wrk_a: "connected",
+      wrk_b: "disconnected",
+      wrk_c: "error",
+      wrk_d: "connected",
+      wrk_e: "connected",
+    } as const
+
+    const { recent } = recentConnectedWorkspaces({
+      workspaces,
+      status: (workspaceID) => status[workspaceID as keyof typeof status],
+    })
+
+    expect(recent.map((workspace) => workspace.id)).toEqual(["wrk_a", "wrk_d", "wrk_e"])
+  })
+})

package/test/cli/cmd/tui/model-options.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test"
+import { sortModelOptions } from "../../../../src/component/dialog-model"
+
+describe("sortModelOptions", () => {
+  test("orders provider-scoped model choices by newest release first", () => {
+    const sorted = sortModelOptions(
+      [
+        { title: "GPT 5.2", releaseDate: "2025-12-11" },
+        { title: "GPT 5.4", releaseDate: "2026-03-05" },
+        { title: "GPT 5.1", releaseDate: "2025-11-13" },
+      ],
+      true,
+    )
+
+    expect(sorted.map((model) => model.title)).toEqual(["GPT 5.4", "GPT 5.2", "GPT 5.1"])
+  })
+
+  test("orders regular model choices free-first and then newest-first", () => {
+    const sorted = sortModelOptions(
+      [
+        { title: "GLM 5", releaseDate: "2025-07-28" },
+        { title: "GLM 5.1", releaseDate: "2025-12-09" },
+        { title: "GLM 5.2", releaseDate: "2026-02-16" },
+        { title: "Free old", releaseDate: "2024-01-01", footer: "Free" },
+        { title: "Free new", releaseDate: "2025-01-01", footer: "Free" },
+      ],
+      false,
+    )
+
+    expect(sorted.map((model) => model.title)).toEqual(["Free new", "Free old", "GLM 5.2", "GLM 5.1", "GLM 5"])
+  })
+})