opencode-ghost 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 +56,7 @@ 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.0...HEAD
+[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 autocomplete while typing.** When the input starts with `/`,
+  the remaining command name is ghosted from configured commands, skills, and
+  the builtin TUI commands; known argument options render as `[a | b]` hints.
+  Tab completes in stages (command name, then each argument). 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 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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ghost",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "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; ghost?: string; insert?: string; args?: string[]; hint?: string } | undefined
+  >()
   let promptRef: TuiPromptRef | undefined
   let timer: ReturnType<typeof setTimeout> | undefined
   let generating = false
@@ -273,6 +278,96 @@ 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
+  }
+
+  const POLL_INTERVAL_MS = 100
+  const POOL_TTL_MS = 60_000
+  let completionKey = ""
+  const pollTimer = setInterval(() => {
+    const sessionID = currentSessionID()
+    if (!sessionID) {
+      if (completion()) setCompletion(undefined)
+      return
+    }
+    const input = promptRef?.current.input ?? ""
+    if (poolFetchedAt && Date.now() - poolFetchedAt > POOL_TTL_MS) void refreshPool()
+    const key = `${sessionID}\u0000${input}`
+    const found = input.startsWith("/")
+      ? completeCommand(input, commandPool, opts.argHints)
+      : historyCandidate(sessionID, input)
+    if (completionKey === `${key}\u0000${found?.insert ?? ""}`) return
+    completionKey = `${key}\u0000${found?.insert ?? ""}`
+    setCompletion(
+      found
+        ? {
+            sessionID,
+            ghost: found.ghost,
+            insert: found.insert,
+            args: "args" in found ? found.args : undefined,
+            hint: "hint" in found ? found.hint : undefined,
+          }
+        : undefined,
+    )
+    setAcceptVisible(Boolean(found?.insert) || Boolean(ghost()))
+  }, POLL_INTERVAL_MS)
+  pollTimer.unref?.()
+
   const isEnabled = () => {
     try {
       return api.kv.get<boolean>(ENABLED_KEY, opts.enabled) !== false
@@ -400,11 +495,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 +510,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 +617,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 ""
+          if (current.args && current.args.length > 0) return `[${current.args.join(" | ")}]`
+          if (current.hint) return current.hint
+          return current.ghost ?? ""
+        }
         return (
           <api.ui.Prompt
             sessionID={props.session_id}
@@ -511,9 +631,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 +685,7 @@ const tui: TuiPlugin = async (api, rawOptions) => {
   api.lifecycle.onDispose(() => {
     if (timer) clearTimeout(timer)
     clearInterval(sweepTimer)
+    clearInterval(pollTimer)
     offIdle()
     offStatus()
     backLayer()