@vaibhavgupta0786/opencode-voice 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vaibhavs18
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,12 @@
+NOTICE — third-party binaries in bin/
+
+The recorders in bin/darwin-arm64, bin/darwin-x64 and bin/linux-x64 were
+built from recorder/recorder.c of opencode-dictate
+(https://github.com/rodri45l/opencode-dictate), which is MIT-licensed:
+
+  MIT License, Copyright (c) 2026 Rodrigo
+
+The recorder is a thin wrapper around miniaudio (MIT-0 / public-domain
+style licence, https://github.com/mackron/miniaudio) talking directly to
+CoreAudio (macOS) / ALSA / PulseAudio (Linux). It streams raw 16 kHz mono
+PCM to stdout and stops itself at a deadline; it performs no network I/O.

package/README.md

@@ -1,3 +1,139 @@
-# Temporary Holding Version
+# opencode-voice
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Local-only push-to-talk dictation for [OpenCode](https://opencode.ai) v2.
+Press `f9`, talk (pauses welcome), press `f9` again — the transcript lands
+in a draft you can edit; takes pile up until you send them as one prompt.
+
+No cloud, no temp audio files, no auto-send, no permission answering.
+
+## Install
+
+Requirements: OpenCode v2, a local STT server (see `docs/STT.md`),
+macOS Microphone permission for your terminal.
+
+```sh
+mkdir -p ~/.config/opencode/plugins
+git clone https://github.com/vaibhavgupta0786/opencode-voice ~/.config/opencode/plugins/voice
+# restart the OpenCode TUI, open a session, press f9
+```
+
+Or via npm (after `v0.3.0` is published):
+
+```sh
+opencode plugin add @vaibhavgupta0786/opencode-voice
+```
+
+`f9` may be hijacked by macOS Fn keys — `Ctrl+P` → `dictate` (or
+`/dictate`) works the same.
+
+## Usage
+
+| Input | Action |
+|---|---|
+| `f9` | dictate a take (press to start, press to stop) — appended to the draft |
+| `f9` again | stop → transcribe → draft editor opens with all takes |
+| `f10` | open the draft editor anytime (empty or not — hand-compose works too) |
+| `f12` | wipe the draft (confirmation dialog) |
+| `/dictate`, `/voice-send`, `/voice-clear` | same via slash command / palette |
+
+On MacBooks press F-keys **with Fn**. Plain `F10` is the hardware mic-mute
+key and plain `F11` is Show Desktop (macOS reserves it — which is why wipe
+lives on `F12`).
+
+> **Windows**: not yet supported — the bundled recorders target macOS
+> (CoreAudio) and Linux (ALSA/PulseAudio). PRs welcome; the recorder source
+> is [opencode-dictate](https://github.com/rodri45l/opencode-dictate)'s
+> `recorder.c` (miniaudio supports WASAPI).
+
+**Editor semantics** (one dialog, always the whole draft):
+
+- Opens after every take, with the cursor at the end and the view scrolled
+  to the bottom — long drafts scroll while you type.
+- `Ctrl+Enter` sends everything as one prompt (`Cmd+Enter` also works where
+  the terminal delivers it). `Esc` closes and **keeps your edits** — they
+  are folded back into the draft automatically, whichever way the dialog
+  was closed.
+- A failed send keeps the draft and lets you retry; switching sessions
+  with the editor open refuses to deliver to the wrong chat.
+- The draft is **per session**: dictate in chat A, switch to B, and each
+  keeps its own takes. Switching back shows A's draft intact, take count
+  and all.
+- Switching chats **mid-take discards that take**: the recorder stops
+  within half a second, nothing is transcribed or saved, and a toast says
+  so. The drafts themselves are never touched.
+
+A mic indicator lives in the prompt footer: 🎤 idle, 🔴 recording, 🟡
+transcribing, `🎤·N` = N takes in the draft. With a local STT server the
+mic carries a health dot — `🟢🎤` server up, `🔴🎤` server down (checked
+every 30 s, refreshed on every take; cloud STT endpoints show no dot).
+Takes cap at 60 s (raise via the `maxMs` option). Debug log:
+/tmp/opencode/voice-plugin.log.
+
+## Keeping the STT server alive
+
+Dictation needs the local whisper server on `127.0.0.1:8080`. If it ever
+dies (machine restart, crash), recovery is:
+
+1. **One-time opt-in:** run `/voice-setup` (palette: "Install voice-check
+   recovery skill"). This copies the bundled skill into your global
+   skills directory — nothing is installed silently, ever.
+2. Whenever voice breaks: type `@voice-check` (or just say "voice is
+   dead") and the agent verifies the server, restarts it if needed, and
+   reports back.
+
+Manual recovery is one health check plus a restart — see below.
+
+## How it works
+
+```
+f9 -> bundled mic recorder (16 kHz PCM, stdout, in memory)
+   -> silence/VAD state machine (toggle: pauses never end the take)
+   -> POST WAV to local whisper at 127.0.0.1:8080
+   -> draft (takes accumulate) -> editor -> session.prompt
+```
+
+See `docs/STT.md` (server + model choice) and `docs/TROUBLESHOOTING.md`.
+
+## Development
+
+```sh
+npm ci
+npm test        # 12 unit tests, no mic needed
+npm run typecheck
+```
+
+Pure logic in `logic.ts`, host/IO in `tui.ts`. See `CONTRIBUTING.md`.
+
+## Recorder binaries
+
+`bin/` ships prebuilt mic recorders built from
+[opencode-dictate](https://github.com/rodri45l/opencode-dictate)'s
+`recorder/recorder.c` (miniaudio, MIT) — see NOTICE. SHA256 pinned in
+`bin/SHA256SUMS` and verified in CI. To rebuild from source, fetch
+`recorder.c` + `miniaudio.h` upstream and compile, e.g. on macOS:
+`cc -O2 -o recorder recorder.c -framework CoreAudio -framework AudioToolbox -framework CoreFoundation`.
+
+## Why this instead of X?
+
+| | This | [renjfk/opencode-voice](https://github.com/renjfk/opencode-voice) | [opencode-dictate](https://github.com/rodri45l/opencode-dictate) |
+|---|---|---|---|
+| Input | `F9` press / `F9` press (toggle) | hold `ctrl+r` | hands-free, open mic |
+| Review before send | always (editable draft) | optional | auto-sends in conversation mode |
+| Draft accumulation | per session | single | n/a (immediate send) |
+| LLM cleanup pass | none needed | required (cloud API) | required for voice commands |
+| TTS voice-out | roadmap | yes (Piper) | no |
+| Answers permissions by voice | never | via LLM | yes (opt-out) |
+| External audio deps | none (bundled recorders) | `sox`, `whisper-cli` | none (bundled) |
+
+**Choose this if** you want push-to-talk with edit-before-send, zero
+surprises (no auto-send, no permission answering), and nothing to install
+beyond a local whisper server.
+
+## Roadmap
+
+- 🎤 mic button in the prompt footer
+- Voice-out: spoken digest of long replies (not verbatim readout) + local TTS
+
+## License
+
+MIT — see LICENSE.

package/bin/SHA256SUMS

@@ -0,0 +1,3 @@
+f703bed975f03bbf78fb0f4ba02754722af55aae83edab7df28281dbc1a28117  darwin-arm64/opencode-voice-recorder
+ac164390aa4d208d735dc1389160ab1ea679c4818f385b5a4b69b9f3d7d8bd79  darwin-x64/opencode-voice-recorder
+3b5fa64ff354893f191586ae59ee7e5e693919de7434624678d4ad82053d5148  linux-x64/opencode-voice-recorder

package/docs/STT.md

@@ -0,0 +1,64 @@
+# Local speech-to-text
+
+opencode-voice sends audio to an OpenAI-compatible
+`/audio/transcriptions` endpoint. Default: `http://127.0.0.1:8080/v1`
+(localhost — audio never leaves your machine).
+
+## Install location (canonical)
+
+Keep the server install in one place so the recovery skill can find it:
+
+    ~/.local/share/opencode/voice-stt/
+      mlx_server.py          # Apple Silicon GPU (preferred)
+      mlx-env/               # its virtualenv
+      mlx-server.log         # server log
+
+(A legacy location, `~/.local/share/opencode/opencode-dictate/`, is also
+checked by the skill if the canonical one is missing.)
+
+## Quick health check
+
+    curl -s -m 3 http://127.0.0.1:8080/health   # expect {"status": "ok"}
+
+If it is down, restart it detached:
+
+    cd ~/.local/share/opencode/voice-stt
+    nohup ./mlx-env/bin/python3 mlx_server.py > mlx-server.log 2>&1 &
+
+then re-run the health check every 5 s — the model loads in ~10–25 s on a
+cold start. The `@voice-check` skill automates exactly this.
+
+## mlx-whisper (recommended, Apple Silicon)
+
+Dependency-free server using
+[faster-whisper](https://github.com/SYSTRAN/faster-whisper)
+(CTranslate2 port of OpenAI Whisper, 2–4× faster, CPU-friendly):
+
+```sh
+python3 -m venv stt-env
+stt-env/bin/pip install faster-whisper
+WHISPER_MODEL=small VOICE_STT_PORT=8080 stt-env/bin/python3 server.py
+```
+
+`server.py` sketch (stdlib only, plus `faster-whisper`): serve
+`POST /v1/audio/transcriptions` with multipart `file` + `model` fields,
+return `{"text": ...}`. `GET /health` must return `{"status": "ok"}`.
+
+## Model choice (mac CPU, int8)
+
+| Model | Size | Speed/take | Notes |
+|---|---|---|---|
+| `base` | ~150 MB | fastest | noticeably worse |
+| `small` | ~500 MB | ~1–3 s | good default |
+| `small.en` | ~500 MB | ~1–3 s | English-only, slightly better at English |
+| `medium` | ~1.5 GB | ~5–10 s | big accuracy jump |
+| `large-v3` | ~3 GB | very slow on CPU | best; needs GPU to be practical |
+
+Switch with `WHISPER_MODEL=medium ...` and restart the server.
+The plugin needs no changes — it just POSTs audio to the endpoint.
+
+## Alternatives
+
+Any OpenAI-compatible endpoint works: whisper.cpp server, LM Studio /
+Ollama with STT support, or a cloud API (note: cloud uploads your voice).
+Point the plugin at it via the `stt` option.

package/docs/TROUBLESHOOTING.md

@@ -0,0 +1,82 @@
+# Troubleshooting
+
+Debug log (if enabled): `/tmp/opencode/voice-plugin.log`.
+Every take logs one line:
+
+```
+capture <reason> voiced=700ms loudest=0.058 bytes=96000
+transcript="..."
+```
+
+## `f9` does nothing at all
+
+- The command needs a session view. Dictating on the launch/home view of a
+  brand-new session starts that session automatically; other non-session
+  views refuse with a toast.
+- `f9` may be hijacked by macOS (Fn keys). Use `Ctrl+P` → `dictate`,
+  or `/dictate`, instead.
+
+## `voiced=0ms loudest=0.000` — pure silence
+
+Two causes, same symptom:
+
+1. macOS Microphone permission. **System Settings → Privacy & Security →
+   Microphone** → enable your terminal app, then retry. (CoreAudio feeds
+   zeros when permission is denied — the recorder runs fine, the mic is muted.)
+2. The hardware mic was muted by a **plain `F10` press** (no Fn) — macOS
+   maps it to mic mute, and external monitors display the mute state.
+   Unmute via the keyboard/control-center, then retry.
+
+## `STT failed ... Is the local server up?`
+
+- `curl http://127.0.0.1:8080/health` should return `{"status": "ok"}`.
+- First start downloads the model (small ≈ 500 MB) — watch the server log
+  for `ready` before dictating.
+
+## Takes cut off mid-thought
+
+Toggle mode (default) never ends on silence — only the second `f9` (or the
+60 s cap) ends a take. If takes still split, you are on `toggle: false`;
+either re-enable toggle or raise `silenceMs` (900 → 2500). Very long
+monologues hit the 60 s cap — raise `maxMs` if you want longer takes.
+
+## "Take discarded — you switched chats"
+
+By design: switching sessions mid-take aborts that take (recording stops
+within half a second, nothing is transcribed or saved) so a recording
+started in one chat can never land in another. The drafts themselves are
+untouched — dictate again in the chat you are now viewing.
+
+## Footer mic shows a red dot
+
+The STT server is unreachable: run `@voice-check` (or say "voice is
+dead") to verify and restart it. The dot refreshes every 30 s and on
+every take, so it should flip green on its own once the server is back.
+No dot at all means your `stt` endpoint is not localhost — cloud STT has
+no health route to check, so the mic renders dotless by design.
+
+## F-keys don't reach the app
+
+Press them **with Fn** on MacBooks. Known macOS hardware/system claims:
+plain `F10` = mic mute, plain `F11` = Show Desktop (which is why wipe is
+on `F12`). Leader chords (`Ctrl+X …`) never register from plugin layers —
+that is an OpenCode plugin API limitation, not a bug here.
+
+## Review / wipe do nothing (`f10`, `f12`)
+
+- Slash commands always work: `/voice-send`, `/voice-clear`.
+- If `/voice-send` shows no toast and no editor, check the debug log —
+  an empty draft only toasts; a non-empty one must open the editor.
+
+## Phantom / hallucinated transcripts
+
+Whisper invents phrases ("Thank you.") from noise. The plugin drops takes
+below `minSpeechMs` (default 300 ms) of voiced audio, but in a noisy room
+raise `vadThreshold` (0.03 → 0.06). The log's `loudest=` shows your levels.
+
+## Plugin shows "failed" in the sidebar
+
+- `Cannot find package '@opencode/plugin'` (server): you have a stray
+  server entrypoint importing it — this plugin is TUI-only by design.
+- `Keymap.Provider is missing`: keymap registration must happen inside a
+  component/slot render, not bare in `setup()`.

package/docs/VOICE-MODE.md

@@ -0,0 +1,42 @@
+# Voice mode (PARKED — future separate project)
+
+Goal: full ChatGPT-style voice mode for OpenCode — always-on mic plus
+spoken answers. Parked until voice input (this repo) is solid.
+
+## Background (from OpenAI's realtime/TTS/VAD docs)
+
+Three architectures exist: Realtime API (one audio→audio model), chained
+pipeline (STT → text agent → TTS), GPT-Live (voice frontend + text backend).
+Locally only the **chained pipeline** is viable — and it's the right one:
+we want to see and control the text between stages.
+
+The five moving parts: VAD/turn-taking, STT (✅ done here, mlx GPU),
+brain, streaming TTS, barge-in + audio plumbing.
+
+References: `server_vad` vs `semantic_vad` (OpenAI judges "are they done?"
+from words, not just silence); TTS streams PCM before generation finishes;
+first-audio latency is the metric; `gpt-4o-mini-tts` with 11+ voices.
+
+## Why coding voice mode ≠ ChatGPT voice
+
+1. **Outputs are 1000-word audits, not sentences.** A digest layer
+   (verdict first, 2 things that matter, then ask) is core, not a feature.
+2. **Work takes minutes.** Need status whispers while tools run, and
+   interruption mid-tool-run (`session.interrupt` — verify TUI access).
+3. **Permissions by voice are dangerous.** Never auto-answer; read aloud,
+   require explicit confirm (possibly typed, not spoken).
+
+## Proposed shape
+
+Separate project with three independently toggleable modes: push-to-talk
+(this repo), conversation (open mic, auto-send), voice-out (spoken
+digests). Reuse recorder + mlx STT + session APIs. New: Silero VAD,
+digest LLM prompt, TTS engine + player, barge-in wiring.
+
+## Suggested order
+
+1. TTS bake-off on Apple Silicon (Piper vs Kokoro vs mlx-audio vs `say`):
+   naturalness vs latency, same paragraph.
+2. Digest prompt design (the real product work).
+3. Always-on loop with barge-in.
+4. Permission-safety rules.

package/logic.ts

@@ -0,0 +1,171 @@
+// Pure, host-independent logic for opencode-voice: VAD endpointing, PCM
+// helpers, WAV encoding and STT URL building. No imports — unit-testable
+// with plain node. tui.ts owns all host/IO concerns.
+
+export const RATE = 16_000 // recorder streams 16-bit mono PCM at 16 kHz
+export const TICK_MS = 50 // VAD evaluated in 50 ms windows (1600 bytes)
+
+export interface VoiceOptions {
+  stt?: string // base URL of OpenAI-compatible STT
+  model?: string // STT model name
+  silenceMs?: number // quiet time ending the utterance (auto mode only)
+  maxMs?: number // hard cap per utterance
+  startTimeoutMs?: number // give up if silent this long
+  minSpeechMs?: number // voiced audio required
+  vadThreshold?: number // peak amplitude counting as voice
+  toggle?: boolean // f9 starts, f9 stops; pauses never end the take
+  accumulate?: boolean // takes pile into a draft; send once via /voice-send
+  debug?: boolean
+}
+
+export const DEFAULTS: {
+  stt: string
+  model: string
+  silenceMs: number
+  maxMs: number
+  startTimeoutMs: number
+  minSpeechMs: number
+  vadThreshold: number
+  toggle: boolean
+  accumulate: boolean
+  debug: boolean
+} = {
+  stt: "http://127.0.0.1:8080/v1",
+  model: "whisper-1",
+  silenceMs: 900,
+  maxMs: 60_000,
+  startTimeoutMs: 4_000,
+  minSpeechMs: 300,
+  vadThreshold: 0.03,
+  toggle: true,
+  accumulate: true,
+  debug: false,
+}
+
+export type RequiredVoiceOptions = typeof DEFAULTS
+
+export function mergeOptions(raw: VoiceOptions = {}): RequiredVoiceOptions {
+  return {
+    stt: raw.stt ?? DEFAULTS.stt,
+    model: raw.model ?? DEFAULTS.model,
+    silenceMs: raw.silenceMs ?? DEFAULTS.silenceMs,
+    maxMs: raw.maxMs ?? DEFAULTS.maxMs,
+    startTimeoutMs: raw.startTimeoutMs ?? DEFAULTS.startTimeoutMs,
+    minSpeechMs: raw.minSpeechMs ?? DEFAULTS.minSpeechMs,
+    vadThreshold: raw.vadThreshold ?? DEFAULTS.vadThreshold,
+    toggle: raw.toggle ?? DEFAULTS.toggle,
+    accumulate: raw.accumulate ?? DEFAULTS.accumulate,
+    debug: raw.debug ?? DEFAULTS.debug,
+  }
+}
+
+export function peakOf(chunk: Uint8Array): number {
+  const view = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+  let peak = 0
+  for (let i = 0; i + 1 < chunk.length; i += 2) {
+    const sample = Math.abs(view.getInt16(i, true)) / 32768
+    if (sample > peak) peak = sample
+  }
+  return peak
+}
+
+export function wavFromPcm(pcm: Uint8Array): Buffer<ArrayBuffer> {
+  const header = Buffer.alloc(44)
+  header.write("RIFF", 0)
+  header.writeUInt32LE(36 + pcm.length, 4)
+  header.write("WAVE", 8)
+  header.write("fmt ", 12)
+  header.writeUInt32LE(16, 16)
+  header.writeUInt16LE(1, 20) // PCM
+  header.writeUInt16LE(1, 22) // mono
+  header.writeUInt32LE(RATE, 24)
+  header.writeUInt32LE(RATE * 2, 28)
+  header.writeUInt16LE(2, 32)
+  header.writeUInt16LE(16, 34)
+  header.write("data", 36)
+  header.writeUInt32LE(pcm.length, 40)
+  return Buffer.concat([header, pcm])
+}
+
+export interface Capture {
+  wav: Buffer
+  voicedMs: number
+  loudest: number
+  hadSpeech: boolean
+}
+
+// --- utterance-endpointing state machine (per 50 ms tick) ---
+
+export interface VadState {
+  spoken: boolean
+  voicedMs: number
+  loudest: number
+  quietFor: number
+  elapsed: number
+  done: boolean
+  doneReason: string | null
+}
+
+export function initialVadState(): VadState {
+  return { spoken: false, voicedMs: 0, loudest: 0, quietFor: 0, elapsed: 0, done: false, doneReason: null }
+}
+
+export function vadStep(state: VadState, peak: number, opts: RequiredVoiceOptions): VadState {
+  if (state.done) return state
+  const next: VadState = { ...state, elapsed: state.elapsed + TICK_MS }
+  const finish = (reason: string): VadState => ({ ...next, done: true, doneReason: reason })
+
+  if (peak > opts.vadThreshold) {
+    next.voicedMs += TICK_MS
+    if (peak > next.loudest) next.loudest = peak
+    next.quietFor = 0
+    next.spoken = true
+  } else if (next.spoken) {
+    next.quietFor += TICK_MS
+    // Toggle mode: pauses are thinking time — only manual stop or max cap ends it.
+    if (!opts.toggle && next.quietFor >= opts.silenceMs) return finish("silence")
+  } else if (next.elapsed >= opts.startTimeoutMs) {
+    return finish("start-timeout")
+  }
+
+  if (next.elapsed >= opts.maxMs) return finish("max-length")
+  return next
+}
+
+/** Enough voiced audio to be worth transcribing (noise must not reach Whisper). */
+export function hadSpeech(state: VadState, opts: RequiredVoiceOptions): boolean {
+  return state.spoken && state.voicedMs >= opts.minSpeechMs
+}
+
+export function sttEndpoint(base: string): string {
+  const trimmed = base.replace(/\/+$/, "")
+  return trimmed.includes("/audio/transcriptions") ? trimmed : `${trimmed}/audio/transcriptions`
+}
+
+/** Health-check candidates, root-first: our mlx server answers /health at
+ * the origin; some OpenAI-compatible servers only answer under the API
+ * base (e.g. /v1/health). Duplicates removed, order kept. */
+export function healthEndpoints(base: string): string[] {
+  const trimmed = base.replace(/\/+$/, "")
+  let origin = trimmed
+  try {
+    origin = new URL(trimmed).origin
+  } catch {
+    // not a parseable URL — probe the base only
+  }
+  const candidates = [`${origin}/health`, `${trimmed}/health`]
+  return [...new Set(candidates)]
+}
+
+/** The health dot is a localhost-server feature: cloud STT endpoints expose
+ * no health route, so a red dot there would always lie. */
+export function isLocalEndpoint(base: string): boolean {
+  try {
+    const raw = new URL(base.replace(/\/+$/, "")).hostname.toLowerCase()
+    // URL keeps IPv6 brackets: "[::1]" -> "::1".
+    const host = raw.startsWith("[") && raw.endsWith("]") ? raw.slice(1, -1) : raw
+    return host === "localhost" || host === "127.0.0.1" || host === "::1"
+  } catch {
+    return false
+  }
+}

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@vaibhavgupta0786/opencode-voice",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Local-only push-to-talk dictation for OpenCode v2 \u2014 press F9, speak, press F9.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    "./tui": "./tui.tsx"
+  },
+  "files": [
+    "tui.tsx",
+    "logic.ts",
+    "bin",
+    "servers",
+    "docs",
+    "skills",
+    "NOTICE"
+  ],
+  "scripts": {
+    "test": "node --test 'test/*.test.ts'",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@opencode/plugin": "2.0.12"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.5.0",
+    "@opentui/solid": ">=0.5.0",
+    "solid-js": ">=1.9.0"
+  },
+  "devDependencies": {
+    "@opencode/client": "2.0.12",
+    "@opentui/solid": "^0.5.0",
+    "@types/node": "^22.0.0",
+    "solid-js": "^1.9.0",
+    "typescript": "^5.4.0"
+  }
+}