opencode-ghost 0.1.1 → 0.2.1

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-09-24
+
+### Changed
+
+- Slash-command completion now stays out of the way of opencode's native slash
+  menu (the plugin only ghosts argument options after a complete `/name `).
+- Typing ghosts (argument options, prompt history) render inside the prompt
+  input box right after the caret instead of the hint row, falling back to the
+  hint row when the prompt's editor renderable cannot be located.
+## [0.2.0] - 2026-09-24
+
+### Added
+
+- Slash-command autocomplete while typing: the remaining command name is
+  ghosted from configured commands, skills, and builtin TUI commands, with
+  known argument options shown as `[a | b]` hints and completed with `Tab`
+  (staged: command name, then arguments). Purely local — no model calls.
+- Prompt-history ghost while typing: if the line being typed is a prefix of a
+  message already sent in the same session, the rest is ghosted and `Tab`
+  pulls the full line back.
+- New option `argHints` (per-command argument option lists for the completion
+  hints).
+
 ## [0.1.1] - 2026-09-24
 
 ### Added
@@ -43,6 +66,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Options for `model`, `acceptKeys`, `maxChars`, `idleDelayMs`,
   `recentMessages` and `system`.
 
-[Unreleased]: https://github.com/ozandogrultan/opencode-ghost/compare/v0.1.1...HEAD
+[Unreleased]: https://github.com/ozandogrultan/opencode-ghost/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/ozandogrultan/opencode-ghost/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/ozandogrultan/opencode-ghost/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/ozandogrultan/opencode-ghost/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/ozandogrultan/opencode-ghost/releases/tag/v0.1.0

package/README.md

@@ -17,6 +17,14 @@ dimmed ghost text you accept with <kbd>Tab</kbd> (or <kbd>→</kbd>).
   default) for one line that sounds like you.
 - **Ghost text, `Tab` to accept.** The suggestion renders under the prompt;
   `Tab` or `→` drops it into the input so you can edit and send.
+- **Slash-command argument ghosts while typing.** After `/name `, argument
+  option hints (from `argHints` or learned from builtins) render inside the
+  prompt input box, right after the caret, like Claude Code's inline ghosts.
+  Tab completes the next argument. While the command name is still being typed,
+  opencode's own slash menu stays in charge. Purely local — no model calls.
+- **History ghost while typing.** If the line you are typing is a prefix of a
+  message you already sent in the same session, the rest of it is ghosted in
+  the box as well; Tab pulls the full line back. Also purely local.
 - **`/suggest` toggles it.** State is stored in the plugin KV.
 
 ## Requirements
@@ -89,6 +97,7 @@ Pass an options object as the second element of the plugin tuple:
 | `system`         | `string`   | built-in              | Override the system prompt sent to the suggestion model.              |
 | `backOnEmptyLeft` | `boolean`  | `false`               | Return to the home screen with Left when the prompt is empty.         |
 | `internalSessionMarkerDir` | `string` | unset       | Optional extra crash-recovery tracking. A configuration-free sweep already reaps leftover hidden sessions, so this is only an additional safety net. |
+| `argHints` | `Record<string, string[]>` | `{}` | Argument option lists per slash command, shown as `[a \| b \| c]` after the command name and completed with Tab, e.g. `"/keepwarm": ["6h", "always", "off", "status"]`. |
 
 ## Commands
 
@@ -116,6 +125,11 @@ When enabling, a suggestion is generated immediately for the current session.
   through that slot, so this plugin replaces the default prompt component. It
   forwards `on_submit`, `ref`, `right`, `visible`, and `disabled`, and cannot be
   combined with another plugin that also renders `session_prompt`.
+- **Ghost placement.** Typing ghosts are drawn directly into the prompt
+  buffer after the caret (opencode exposes no inline-completion API, so the
+  plugin overlays the prompt's editor renderable). When the layout cannot be
+  located, they fall back to the prompt's hint row. The next-prompt
+  suggestion always uses the hint row.
 - **`hint` row.** While a suggestion is showing it occupies the prompt's hint
   row, so the working-directory label is hidden until you accept or type.
 - **Cost.** One small-model call per turn while enabled. Point `model` at a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ghost",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Claude Code-style next-prompt suggestions in the opencode TUI, shown as dimmed ghost text and accepted with Tab. An opencode plugin.",
   "type": "module",
   "license": "MIT",

package/src/builtins.ts

@@ -0,0 +1,28 @@
+/**
+ * Builtin TUI slash commands. The plugin API does not expose the TUI's own
+ * command palette, so the completable subset we observed in the shipped binary
+ * is curated here. Names are fixed; descriptions are ours and only used for the
+ * completion display.
+ */
+export type BuiltinCommand = {
+  name: string
+  description: string
+}
+
+export const BUILTIN_COMMANDS: BuiltinCommand[] = [
+  { name: "new", description: "New session" },
+  { name: "agent", description: "Cycle agent" },
+  { name: "model", description: "Choose model" },
+  { name: "mcp", description: "Toggle MCP servers" },
+  { name: "open", description: "Command palette" },
+  { name: "share", description: "Share session" },
+  { name: "unshare", description: "Unshare session" },
+  { name: "compact", description: "Compact session" },
+  { name: "export", description: "Export session" },
+  { name: "fork", description: "Fork session" },
+  { name: "undo", description: "Undo messages" },
+  { name: "redo", description: "Redo messages" },
+  { name: "terminal", description: "Toggle terminal" },
+  { name: "workspace", description: "Workspace controls" },
+  { name: "suggest", description: "Toggle prompt suggestions" },
+]

package/src/completion.ts

@@ -0,0 +1,83 @@
+/**
+ * Pure slash-command completion: given the current prompt input, the pool of
+ * known command names (configured commands, skills, and builtins) and optional
+ * per-command argument hints, decide what ghost text to render and what Tab
+ * should insert.
+ */
+export type CommandPool = {
+  readonly name: string
+  readonly description?: string
+}
+
+export type Completion = {
+  /** Dimmed text rendered after the input, e.g. `warm` for `/keep`+`warm`. */
+  ghost?: string
+  /** What Tab places into the input when accepting. */
+  insert?: string
+  /** Argument options shown as `[a | b]`, filtered by the word in progress. */
+  args?: string[]
+  /** Non-insertable hint text shown when nothing can be completed. */
+  hint?: string
+}
+
+/** Parse leading `/name args...` from the input; `args` is "" until a space exists. */
+function parseSlash(input: string): { name: string; args: string; nameComplete: boolean } | undefined {
+  if (!input.startsWith("/")) return undefined
+  const line = input.split("\n")[0]
+  const space = line.indexOf(" ")
+  if (space === -1) return { name: line.slice(1), args: "", nameComplete: false }
+  return { name: line.slice(1, space), args: line.slice(space + 1), nameComplete: true }
+}
+
+/** Options that still match the word being typed, excluding an exact hit. */
+function matchOptions(typed: string, options: readonly string[]): string[] | undefined {
+  const lower = typed.toLowerCase()
+  const matches = options.filter(
+    (option) => option.toLowerCase() !== lower && option.toLowerCase().startsWith(lower),
+  )
+  return matches.length > 0 ? matches : undefined
+}
+
+export function completeCommand(
+  input: string,
+  pool: readonly CommandPool[],
+  argHints: Readonly<Record<string, readonly string[]>> = {},
+): Completion | undefined {
+  const parsed = parseSlash(input)
+  if (!parsed) return undefined
+  const lower = parsed.name.toLowerCase()
+  const exact = pool.find((command) => command.name.toLowerCase() === lower)
+
+  // Still typing the command name (no space yet).
+  if (!parsed.nameComplete) {
+    if (exact) {
+      const hints = argHints[lower]
+      return {
+        args: hints ? [...hints] : undefined,
+        hint: hints ? undefined : exact.description,
+        insert: `/${exact.name} `,
+      }
+    }
+    const matches = pool.filter((command) => command.name.toLowerCase().startsWith(lower))
+    if (matches.length === 0) return undefined
+    const next = matches[0]
+    return { ghost: next.name.slice(parsed.name.length), insert: `/${next.name} ` }
+  }
+
+  // `/name args...`: complete the in-progress argument word against hints.
+  const hintList = argHints[lower]
+  if (hintList) {
+    const matches = matchOptions(parsed.args, hintList)
+    if (matches) {
+      const completed = parsed.args + matches[0].slice(parsed.args.length)
+      return {
+        args: matches,
+        ghost: matches[0].slice(parsed.args.length),
+        insert: `/${parsed.name} ${completed} `,
+      }
+    }
+    return undefined
+  }
+  if (exact && parsed.args === "") return { hint: exact.description }
+  return undefined
+}

package/src/options.ts

@@ -8,6 +8,7 @@ export type PromptSuggestOptions = {
   idleDelayMs?: number
   recentMessages?: number
   system?: string
+  argHints?: Record<string, string[]>
 }
 
 export type ResolvedOptions = {
@@ -20,6 +21,7 @@ export type ResolvedOptions = {
   idleDelayMs: number
   recentMessages: number
   system: string
+  argHints: Record<string, readonly string[]>
 }
 
 export const DEFAULT_SYSTEM = [
@@ -77,5 +79,13 @@ export function resolveOptions(options: PromptSuggestOptions | undefined): Resol
         ? recentMessages
         : DEFAULTS.recentMessages,
     system: typeof input.system === "string" && input.system.trim() ? input.system : DEFAULT_SYSTEM,
+    argHints:
+      input.argHints && typeof input.argHints === "object" && !Array.isArray(input.argHints)
+        ? Object.fromEntries(
+            Object.entries(input.argHints)
+              .filter(([, value]) => Array.isArray(value) && value.length > 0)
+              .map(([key, value]) => [key.toLowerCase(), [...value]]),
+          )
+        : {},
   }
 }

package/src/tui.tsx

@@ -5,6 +5,8 @@ import * as fs from "node:fs"
 import * as path from "node:path"
 import { resolveOptions, type PromptSuggestOptions } from "./options"
 import { clip, isEcho, normalize, parseModel } from "./text"
+import { BUILTIN_COMMANDS } from "./builtins"
+import { completeCommand, type CommandPool } from "./completion"
 
 const HIDDEN_TITLE = "ghost-hidden"
 // Survives the server's automatic title generation, which renames the hidden
@@ -259,6 +261,9 @@ const tui: TuiPlugin = async (api, rawOptions) => {
   sweepTimer.unref?.()
 
   const [ghost, setGhost] = createSignal<{ sessionID: string; text: string } | undefined>()
+  const [completion, setCompletion] = createSignal<
+    { sessionID: string; display: string; insert?: string; drawn: boolean } | undefined
+  >()
   let promptRef: TuiPromptRef | undefined
   let timer: ReturnType<typeof setTimeout> | undefined
   let generating = false
@@ -273,6 +278,179 @@ const tui: TuiPlugin = async (api, rawOptions) => {
 
   const currentInput = () => promptRef?.current.input ?? ""
 
+  // Completable commands: configured commands/skills from the server layered
+  // under the builtin TUI slash commands. One config read, refreshed lazily; no
+  // model calls are involved anywhere in completion.
+  let commandPool: CommandPool[] = BUILTIN_COMMANDS
+  let poolFetching = false
+  let poolFetchedAt = 0
+  const refreshPool = async () => {
+    if (poolFetching) return
+    poolFetching = true
+    try {
+      const result = await api.client.command.list()
+      const rows = (result as { data?: unknown }).data
+      if (Array.isArray(rows)) {
+        const configured: CommandPool[] = rows
+          .map((row) => row as { name?: unknown; description?: unknown })
+          .filter((row) => typeof row.name === "string" && row.name.length > 0)
+          .map((row) => ({
+            name: row.name as string,
+            description: typeof row.description === "string" ? row.description : undefined,
+          }))
+        const seen = new Set(configured.map((command) => `${command.name.toLowerCase()}`))
+        const merged = [
+          ...configured,
+          ...BUILTIN_COMMANDS.filter((command) => !seen.has(command.name.toLowerCase())),
+        ]
+        commandPool = merged.length > 0 ? merged : BUILTIN_COMMANDS
+        poolFetchedAt = Date.now()
+      }
+    } catch {
+      // Keep the current pool; the poll loop retries on the next TTL window.
+    } finally {
+      poolFetching = false
+    }
+  }
+  void refreshPool()
+
+  // History ghost while typing: if the input is a prefix of a message the user
+  // already sent in this session, offer the rest of it. No model involved.
+  const historyCandidate = (sessionID: string, input: string) => {
+    const wants = input.replace(/\s+/g, " ").trimEnd()
+    if (wants.length < 2 || /\n/.test(input)) return undefined
+    const collapsed = wants.toLowerCase()
+    const messages = api.state.session.messages(sessionID).filter((m) => m.role === "user")
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const text = api.state
+        .part(messages[i].id)
+        .filter((part) => part.type === "text")
+        .map((part) => (part.type === "text" ? part.text : ""))
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim()
+      if (text.length <= collapsed.length) continue
+      if (!text.toLowerCase().startsWith(collapsed)) continue
+      return { ghost: text.slice(collapsed.length), insert: text }
+    }
+    return undefined
+  }
+
+  // In-box ghost: the suggestion is drawn directly into the prompt's text area
+  // right after the caret, refreshed each frame. When the text area cannot be
+  // located (host layout change), completion falls back to the hint row.
+  let inBoxGhost: { x: number; y: number; text: string } | undefined
+  const drawGhost = (buffer: unknown) => {
+    const target = inBoxGhost
+    if (!target) return
+    try {
+      const drawn = buffer as { drawText?: (text: string, x: number, y: number, fg: unknown) => void }
+      drawn.drawText?.(target.text, target.x, target.y, api.theme.current.textMuted)
+    } catch {
+      // Rendering must never fail because of the overlay.
+    }
+  }
+  const postProcesses = (api.renderer as unknown as { postProcessFns?: unknown[] } | undefined)
+    ?.postProcessFns
+  if (Array.isArray(postProcesses)) postProcesses.push(drawGhost)
+  const removeOverlay = () => {
+    if (!postProcesses) return
+    const index = postProcesses.indexOf(drawGhost)
+    if (index >= 0) postProcesses.splice(index, 1)
+  }
+
+  // Locate the prompt's editor renderable inside the layout tree.
+  const findTextarea = (): unknown => {
+    const root = (api.renderer as unknown as { root?: unknown }).root as
+      | { getChildren?: () => unknown[] }
+      | undefined
+    if (!root) return undefined
+    const stack: unknown[] = [root]
+    while (stack.length) {
+      const node = stack.pop() as
+        | {
+            editBuffer?: unknown
+            editorView?: unknown
+            visualCursor?: { visualRow?: number; visualCol?: number }
+            screenX?: number
+            screenY?: number
+            getChildren?: () => unknown[]
+          }
+        | undefined
+      if (!node) continue
+      if (node.editBuffer && node.editorView && node.visualCursor) return node
+      const children = typeof node.getChildren === "function" ? node.getChildren() : []
+      stack.push(...children)
+    }
+    return undefined
+  }
+
+  const placeInBoxGhost = (text: string): boolean => {
+    inBoxGhost = undefined
+    const textarea = findTextarea() as
+      | { screenX?: unknown; screenY?: unknown; visualCursor?: { visualRow?: number; visualCol?: number } }
+      | undefined
+    if (
+      !textarea ||
+      typeof textarea.screenX !== "number" ||
+      typeof textarea.screenY !== "number"
+    ) {
+      return false
+    }
+    const cursor = textarea.visualCursor ?? {}
+    inBoxGhost = {
+      x: textarea.screenX + (typeof cursor.visualCol === "number" ? cursor.visualCol : 0),
+      y: textarea.screenY + (typeof cursor.visualRow === "number" ? cursor.visualRow : 0),
+      text,
+    }
+    return true
+  }
+
+  const POLL_INTERVAL_MS = 100
+  const POOL_TTL_MS = 60_000
+  let completionKey = ""
+  const pollTimer = setInterval(() => {
+    const sessionID = currentSessionID()
+    if (!sessionID) {
+      inBoxGhost = undefined
+      if (completion()) setCompletion(undefined)
+      return
+    }
+    const input = promptRef?.current.input ?? ""
+    if (poolFetchedAt && Date.now() - poolFetchedAt > POOL_TTL_MS) void refreshPool()
+    // `/name` with no space yet is opencode's native slash menu; the plugin
+    // stays out of its way. Our slash completion only covers `/name args...`.
+    const found = !input.startsWith("/")
+      ? historyCandidate(sessionID, input)
+      : input.includes(" ")
+        ? completeCommand(input, commandPool, opts.argHints)
+        : undefined
+    const key = `${sessionID}\u0000${input}`
+    const insert = found?.insert ?? ""
+    if (completionKey === `${key}\u0000${insert}`) return
+    completionKey = `${key}\u0000${insert}`
+    let display = ""
+    if (found) {
+      const args = "args" in found ? found.args : undefined
+      const hint = "hint" in found ? found.hint : undefined
+      display = args && args.length > 0 ? `[${args.join(" | ")}]` : (found.ghost ?? hint ?? "")
+    }
+    inBoxGhost = undefined
+    const drawn = display ? placeInBoxGhost(display) : false
+    setCompletion(
+      found
+        ? {
+            sessionID,
+            display,
+            insert,
+            drawn,
+          }
+        : undefined,
+    )
+    setAcceptVisible(Boolean(insert) || Boolean(ghost()))
+  }, POLL_INTERVAL_MS)
+  pollTimer.unref?.()
+
   const isEnabled = () => {
     try {
       return api.kv.get<boolean>(ENABLED_KEY, opts.enabled) !== false
@@ -400,11 +578,11 @@ const tui: TuiPlugin = async (api, rawOptions) => {
       priority: 100,
       bindings: opts.acceptKeys.map((key) => ({
         key,
-        desc: "Accept suggested prompt",
+        desc: "Accept suggested prompt or completion",
         preventDefault: true,
         cmd: () => {
-          accept()
-          return true
+          if (completionAccept()) return true
+          return accept()
         },
       })),
     })
@@ -415,12 +593,30 @@ const tui: TuiPlugin = async (api, rawOptions) => {
     acceptLayer = undefined
   }
 
-  const showGhost = (value: { sessionID: string; text: string } | undefined) => {
-    setGhost(value)
+  let acceptVisible = false
+  const setAcceptVisible = (value: boolean) => {
+    if (acceptVisible === value) return
+    acceptVisible = value
     if (value) enableAccept()
     else disableAccept()
   }
 
+  const showGhost = (value: { sessionID: string; text: string } | undefined) => {
+    setGhost(value)
+    setAcceptVisible(Boolean(value) || Boolean(completion()?.insert))
+  }
+
+  const completionAccept = () => {
+    const current = completion()
+    if (!current || currentSessionID() !== current.sessionID) return false
+    if (!promptRef || !current.insert) return false
+    completionKey = ""
+    promptRef.set({ input: current.insert, parts: [] })
+    promptRef.focus()
+    setCompletion(undefined)
+    return true
+  }
+
   const run = async (sessionID: string) => {
     if (generating) return
     if (!isEnabled()) return
@@ -504,6 +700,13 @@ const tui: TuiPlugin = async (api, rawOptions) => {
           const current = ghost()
           return current && current.sessionID === props.session_id ? current.text : ""
         }
+        const completionText = () => {
+          const current = completion()
+          if (!current || current.sessionID !== props.session_id) return ""
+          // In in-box mode `drawGhost` handles the text; the hint row then stays free.
+          if (current.drawn) return ""
+          return current.display
+        }
         return (
           <api.ui.Prompt
             sessionID={props.session_id}
@@ -511,9 +714,11 @@ const tui: TuiPlugin = async (api, rawOptions) => {
             disabled={props.disabled}
             showPlaceholder={false}
             hint={
-              suggestion() ? (
+              suggestion() || completionText() ? (
                 <box marginLeft={1}>
-                  <text fg={api.theme.current.textMuted}>{suggestion()}</text>
+                  <text fg={api.theme.current.textMuted}>
+                    {completionText() || suggestion()}
+                  </text>
                 </box>
               ) : undefined
             }
@@ -563,6 +768,8 @@ const tui: TuiPlugin = async (api, rawOptions) => {
   api.lifecycle.onDispose(() => {
     if (timer) clearTimeout(timer)
     clearInterval(sweepTimer)
+    clearInterval(pollTimer)
+    removeOverlay()
     offIdle()
     offStatus()
     backLayer()