feat(opencode): lightweight TUI (oclite) and subagent directory fix

packages/opencode/package.json

@@ -9,6 +9,7 @@
  "typecheck": "tsgo --noEmit",
  "test": "bun test",
  "build": "bun run script/build.ts",
+ "build:lite": "bun run script/build-lite.ts",
  "dev": "bun run --conditions=browser ./src/index.ts",
  "random": "echo 'Random script updated at $(date)' && echo 'Change queued successfully' && echo 'Another change made' && echo 'Yet another change' && echo 'One more change' && echo 'Final change' && echo 'Another final change' && echo 'Yet another final change'",
  "clean": "echo 'Cleaning up...' && rm -rf node_modules dist",

packages/opencode/script/build-lite.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env bun
+import path from "path"
+import fs from "fs"
+import { $ } from "bun"
+
+const ROOT = path.resolve(import.meta.dirname, "..")
+const DIST = path.join(ROOT, "dist", "oclite-darwin-arm64")
+const BIN = path.join(DIST, "bin")
+const HOME_BIN = path.join(process.env.HOME!, "bin")
+
+async function build() {
+ console.log("Building oclite...")
+
+ // Clean
+ await fs.promises.rm(DIST, { recursive: true, force: true })
+ await fs.promises.mkdir(BIN, { recursive: true })
+
+ // Build
+ const result = await Bun.build({
+ entrypoints: [path.join(ROOT, "src/cli/lite/index.ts")],
+ outdir: BIN,
+ target: "bun",
+ minify: true,
+ sourcemap: "none",
+ naming: "oclite",
+ })
+
+ if (!result.success) {
+ console.error("Build failed:")
+ for (const log of result.logs) {
+ console.error(log)
+ }
+ process.exit(1)
+ }
+
+ // Make executable
+ await $`chmod +x ${path.join(BIN, "oclite")}`
+
+ // Copy to ~/bin
+ await fs.promises.mkdir(HOME_BIN, { recursive: true })
+ await fs.promises.copyFile(path.join(BIN, "oclite"), path.join(HOME_BIN, "oclite"))
+
+ // Sign for macOS
+ await $`codesign --force --deep --sign - ${path.join(HOME_BIN, "oclite")}`.quiet().nothrow()
+ await $`xattr -cr ${path.join(HOME_BIN, "oclite")}`.quiet().nothrow()
+
+ // Get size
+ const stat = await fs.promises.stat(path.join(HOME_BIN, "oclite"))
+ const sizeMB = (stat.size / 1024 / 1024).toFixed(2)
+
+ console.log(`✓ Built oclite (${sizeMB} MB)`)
+ console.log(`✓ Installed to ~/bin/oclite`)
+ console.log("\nRun with: ~/bin/oclite")
+}
+
+build().catch((err) => {
+ console.error(err)
+ process.exit(1)
+})

packages/opencode/src/agent/agent.ts

@@ -324,8 +324,11 @@ export namespace Agent {
  for await (const part of result.fullStream) {
  if (part.type === "error") throw part.error
  }
- } catch (e: any) {
- if (e?.name === "AbortError" || (e instanceof DOMException && e.name === "AbortError")) {
+ } catch (e) {
+ if (typeof e === "object" && e !== null && "name" in e && e.name === "AbortError") {
+ throw e
+ }
+ if (e instanceof DOMException && e.name === "AbortError") {
  throw e
  }
  throw e

packages/opencode/src/cli/cmd/tui/util/icons.ts

@@ -0,0 +1,83 @@
+/**
+ * Task state icons and color system for terminal UI.
+ * Provides visual feedback for task status, agent roles, and UI elements.
+ */
+
+export namespace Icons {
+ /**
+ * ANSI color codes for terminal output
+ */
+ export const colors = {
+ green: "\x1b[32m",
+ yellow: "\x1b[33m",
+ cyan: "\x1b[36m",
+ dim: "\x1b[2m",
+ red: "\x1b[31m",
+ magenta: "\x1b[35m",
+ reset: "\x1b[0m",
+ }
+
+ /**
+ * Task status icons with their default colors
+ */
+ export const icons = {
+ taskComplete: "✓",
+ taskPending: "□",
+ taskRunning: "●",
+ taskProgress: "◇",
+ agentRole: "🟪",
+ }
+
+ /**
+ * Status colors lookup table (module-level for performance)
+ */
+ const statusColors: Record<string, string> = {
+ completed: colors.green,
+ pending: colors.dim,
+ running: colors.green,
+ progress: colors.yellow,
+ }
+
+ /**
+ * Status icons lookup table (module-level for performance)
+ */
+ const statusIcons: Record<string, string> = {
+ completed: icons.taskComplete,
+ pending: icons.taskPending,
+ running: icons.taskRunning,
+ progress: icons.taskProgress,
+ }
+
+ /**
+ * Returns a colored task status icon based on the given status
+ * @param status - The task status: 'completed', 'pending', 'running', or 'progress'
+ * @returns The colored icon as a string, or pending icon as safe fallback
+ */
+ export function taskIcon(status: "completed" | "pending" | "running" | "progress"): string {
+ const color = statusColors[status]
+ const icon = statusIcons[status]
+
+ if (!color || !icon) return `${colors.dim}${icons.taskPending}${colors.reset}`
+ return `${color}${icon}${colors.reset}`
+ }
+
+ /**
+ * Returns a colored agent name badge in cyan
+ * @param name - The agent name
+ * @returns The colored agent name badge, or empty string if name is empty
+ */
+ export function agentBadge(name: string): string {
+ if (!name) return ""
+ return `${colors.cyan}${name}${colors.reset}`
+ }
+
+ /**
+ * Returns a colored role badge with a purple icon prefix
+ * @param role - The role name
+ * @returns The colored role badge with icon, or empty string if role is empty
+ */
+ export function roleBadge(role: string): string {
+ if (!role) return ""
+ return `${colors.magenta}${icons.agentRole}${colors.reset} ${role}`
+ }
+}

packages/opencode/src/cli/lite/index.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env bun
+import { cursor, clear, fg, style, write, screen } from "./terminal"
+import { parseKey, LineEditor } from "./input"
+import { Spinner } from "./spinner"
+import { chat } from "./session"
+
+const PROMPT = `${fg.cyan}>${style.reset} `
+
+async function main() {
+ // Check TTY
+ if (!process.stdin.isTTY) {
+ console.error("oclite requires a TTY")
+ process.exit(1)
+ }
+
+ // Setup
+ write(screen.alt)
+ write(clear.screen)
+ write(cursor.home)
+
+ // Header
+ write(`${fg.brightCyan}${style.bold}oclite${style.reset} ${fg.gray}v0.1.0${style.reset}\n`)
+ write(`${fg.gray}Type /help for commands, Ctrl+C to exit${style.reset}\n\n`)
+
+ // Input setup
+ const editor = new LineEditor()
+ process.stdin.setRawMode(true)
+ process.stdin.resume()
+
+ // Render prompt
+ editor.render(PROMPT)
+
+ // Handle input
+ process.stdin.on("data", async (data: Buffer) => {
+ const key = parseKey(data)
+
+ // Ctrl+C to exit
+ if (key.ctrl && key.name === "c") {
+ cleanup()
+ process.exit(0)
+ }
+
+ const result = editor.handle(key)
+
+ if (result !== null) {
+ write("\n")
+
+ if (result.startsWith("/")) {
+ handleCommand(result)
+ } else if (result.trim()) {
+ await handleMessage(result)
+ }
+
+ editor.render(PROMPT)
+ } else {
+ editor.render(PROMPT)
+ }
+ })
+
+ // Cleanup on exit
+ function cleanup() {
+ write(cursor.show)
+ write(screen.main)
+ process.stdin.setRawMode(false)
+ }
+
+ process.on("exit", cleanup)
+ process.on("SIGINT", () => {
+ cleanup()
+ process.exit(0)
+ })
+}
+
+function handleCommand(cmd: string) {
+ const command = cmd.slice(1).toLowerCase().trim()
+
+ if (command === "help") {
+ write(`${fg.yellow}Commands:${style.reset}\n`)
+ write(` /help - Show this help\n`)
+ write(` /clear - Clear screen\n`)
+ write(` /quit - Exit oclite\n`)
+ write("\n")
+ return
+ }
+
+ if (command === "clear") {
+ write(clear.screen)
+ write(cursor.home)
+ write(`${fg.brightCyan}${style.bold}oclite${style.reset} ${fg.gray}v0.1.0${style.reset}\n\n`)
+ return
+ }
+
+ if (command === "quit" || command === "exit") {
+ process.exit(0)
+ }
+
+ write(`${fg.red}Unknown command: ${cmd}${style.reset}\n\n`)
+}
+
+async function handleMessage(message: string) {
+ const spinner = new Spinner("Thinking")
+ spinner.start()
+
+ let first = true
+ try {
+ for await (const chunk of chat(message)) {
+ if (first) {
+ spinner.stop(true)
+ first = false
+ }
+
+ if (chunk.type === "text" && chunk.content) {
+ write(chunk.content)
+ }
+
+ if (chunk.type === "tool_start" && chunk.tool) {
+ write(`\n${fg.yellow}▶ ${chunk.tool}${style.reset}\n`)
+ }
+
+ if (chunk.type === "tool_end" && chunk.tool) {
+ write(`${fg.green}✓ ${chunk.tool}${style.reset}\n`)
+ }
+
+ if (chunk.type === "error" && chunk.content) {
+ write(`\n${fg.red}Error: ${chunk.content}${style.reset}\n`)
+ }
+ }
+ } catch (err) {
+ if (first) spinner.stop(false)
+ const msg = err instanceof Error ? err.message : String(err)
+ write(`\n${fg.red}Error: ${msg}${style.reset}\n`)
+ }
+
+ write("\n")
+}
+
+main().catch(console.error)