opencode-ghost 1.0.7 → 1.1.0

package/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2026-10-08
+
+### Added
+
+- **tui:** Add /suggest debug and log diagnostics
+
 ## [1.0.7] - 2026-10-08
 
 ### Fixed
@@ -228,6 +234,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Options for `model`, `acceptKeys`, `maxChars`, `idleDelayMs`,
   `recentMessages` and `system`.
 
+[1.1.0]: https://github.com/ozandogrultan/opencode-ghost/compare/v1.0.7...v1.1.0
 [1.0.7]: https://github.com/ozandogrultan/opencode-ghost/compare/v1.0.6...v1.0.7
 [1.0.6]: https://github.com/ozandogrultan/opencode-ghost/compare/v1.0.5...v1.0.6
 [1.0.5]: https://github.com/ozandogrultan/opencode-ghost/compare/v1.0.4...v1.0.5

package/README.md

@@ -99,6 +99,12 @@ copy, use `/absolute/path/to/config/plugins/opencode-ghost`.
 - `/suggest model openai/gpt-6-luna-fast` — set a persisted runtime model override.
 - `/suggest model clear` — clear the override and use the configured `model`,
   or the OpenCode small default, never the main model.
+- `/suggest debug` — toggle debug mode (persisted). While on, each generation
+  attempt shows a toast with its outcome, resolved model, latency and length, or
+  the error.
+- `/suggest debug on` / `/suggest debug off` — set debug mode explicitly.
+- `/suggest log` — show the last 20 generation attempts (outcome, model,
+  latency, length and error detail) in a dialog, regardless of debug mode.
 
 Model precedence is the persisted `/suggest model` override, then the `model`
 option, then the effective title agent's model from OpenCode's public agent API.
@@ -141,6 +147,17 @@ When enabling, a suggestion is generated immediately for the current session.
   Acceptance, a new turn, session changes, disabling, model changes and unloading
   discard it.
 
+## Debugging
+
+Ghost records every generation attempt to a bounded in-memory history (the last
+20): outcome (`ok`, `empty`, `echo`, `no model`, `error`, `aborted`), the resolved
+model with its variant, latency, suggestion length and error detail. `/suggest log`
+shows it in a dialog at any time; `aborted` covers attempts cancelled by typing,
+a newer turn, leaving the session, disabling or unload, so a missing suggestion can
+be traced to a debounce, an empty or `NONE` reply, an echo filter, or a provider
+error. `/suggest debug` toggles the same data as a toast on each attempt (aborts
+are logged but not toasted). The history is not written to disk.
+
 ## Caveats
 
 - **No inline typing completions.** V1's slash-argument and history ghosts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ghost",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Stateless inline next-prompt ghosts for the empty OpenCode V2 composer, accepted with Tab or Right.",
   "type": "module",
   "license": "MIT",

package/src/diagnostics.ts

@@ -0,0 +1,76 @@
+export type DiagnosticOutcome = "ok" | "empty" | "echo" | "unavailable" | "error" | "aborted"
+
+export type DiagnosticEntry = {
+  readonly at: number
+  readonly sessionID: string
+  readonly outcome: DiagnosticOutcome
+  readonly model?: string
+  readonly durationMs?: number
+  readonly chars?: number
+  readonly detail?: string
+}
+
+export const DIAGNOSTIC_HISTORY_LIMIT = 20
+
+export type Diagnostics = {
+  record(entry: Omit<DiagnosticEntry, "at">): DiagnosticEntry
+  list(): readonly DiagnosticEntry[]
+}
+
+export function createDiagnostics(limit = DIAGNOSTIC_HISTORY_LIMIT, now: () => number = Date.now): Diagnostics {
+  const entries: DiagnosticEntry[] = []
+  return {
+    record(input) {
+      const entry: DiagnosticEntry = { ...input, at: now() }
+      entries.push(entry)
+      if (entries.length > limit) entries.splice(0, entries.length - limit)
+      return entry
+    },
+    list() {
+      return [...entries].reverse()
+    },
+  }
+}
+
+export function modelLabel(model: { providerID: string; modelID: string; variant?: string }): string {
+  return `${model.providerID}/${model.modelID}${model.variant ? `@${model.variant}` : ""}`
+}
+
+export function errorDetail(error: unknown): string {
+  const text = error instanceof Error
+    ? error.message
+    : typeof error === "string"
+      ? error
+      : error === undefined || error === null
+        ? ""
+        : String(error)
+  return text.replace(/\s+/g, " ").trim() || "unknown error"
+}
+
+const OUTCOME_LABELS: Record<DiagnosticOutcome, string> = {
+  ok: "ok",
+  empty: "empty",
+  echo: "echo",
+  unavailable: "no model",
+  error: "error",
+  aborted: "aborted",
+}
+
+function clockTime(at: number): string {
+  const date = new Date(at)
+  const pad = (value: number) => String(value).padStart(2, "0")
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
+}
+
+export function formatDiagnostic(entry: DiagnosticEntry): string {
+  const parts = [clockTime(entry.at), OUTCOME_LABELS[entry.outcome], entry.model ?? "—"]
+  if (entry.durationMs !== undefined) parts.push(`${entry.durationMs}ms`)
+  if (entry.chars !== undefined) parts.push(`${entry.chars} chars`)
+  const line = parts.join(" ")
+  return entry.detail ? `${line}\n  ${entry.detail}` : line
+}
+
+export function formatDiagnostics(entries: readonly DiagnosticEntry[]): string {
+  if (entries.length === 0) return "No generation attempts recorded yet."
+  return entries.map(formatDiagnostic).join("\n")
+}

package/src/options.ts

@@ -81,9 +81,20 @@ export function resolveOptions(options: Readonly<Record<string, unknown>> | unde
   }
 }
 
-export function parseSuggestCommand(input: string | undefined): { type: "toggle" } | { type: "model"; model: string | undefined } | { type: "invalid" } {
+export type SuggestCommand =
+  | { type: "toggle" }
+  | { type: "model"; model: string | undefined }
+  | { type: "debug"; value: boolean | undefined }
+  | { type: "log" }
+  | { type: "invalid" }
+
+export function parseSuggestCommand(input: string | undefined): SuggestCommand {
   const raw = input?.trim() ?? ""
   if (!raw) return { type: "toggle" }
+  if (raw === "log") return { type: "log" }
+  if (raw === "debug") return { type: "debug", value: undefined }
+  const debug = /^debug\s+(on|off)$/.exec(raw)
+  if (debug) return { type: "debug", value: debug[1] === "on" }
   const match = /^model\s+(\S+)$/.exec(raw)
   if (!match || (match[1] !== "clear" && !parseModel(match[1]))) return { type: "invalid" }
   return { type: "model", model: match[1] === "clear" ? undefined : match[1] }

package/src/tui.tsx

@@ -3,12 +3,13 @@ import { Plugin } from "@opencode/plugin/tui"
 import { TextareaRenderable, InputRenderable, type BoxRenderable, type Renderable } from "@opentui/core"
 import { createEffect, createMemo, createRoot, createSignal, on, onCleanup } from "solid-js"
 import { composerAction, findComposerEditor, isEligibleComposer, isEmptyComposer, keyName, observeComposerInput } from "./composer"
+import { createDiagnostics, errorDetail, formatDiagnostic, formatDiagnostics, modelLabel, type DiagnosticEntry } from "./diagnostics"
 import { createLifecycle } from "./lifecycle"
 import { acceptCommand, acceptShortcuts, ghostKeymapLayers } from "./keymap"
 import { parseSuggestCommand, removedOptionKeys, resolveOptions, suggestionModel } from "./options"
 import { createInlinePlaceholder, dimPlaceholderColor } from "./placeholder"
 import { generateSuggestion } from "./stateless"
-import { isEcho, normalize, resolveExplicitModel, resolveSmallModel } from "./text"
+import { isEcho, normalize, resolveExplicitModel, resolveSmallModel, type SuggestionModel } from "./text"
 import { buildTranscript, lastUserText, suggestionPrompt, type TranscriptMessage } from "./transcript"
 
 type Suggestion = { sessionID: string; text: string }
@@ -35,13 +36,22 @@ export default Plugin.define({
     }
 
     const [state, updateState] = context.storage.store("state", {
-      initial: { enabled: opts.enabled, model: undefined as string | undefined },
+      initial: { enabled: opts.enabled, model: undefined as string | undefined, debug: false },
     })
 
     const [suggestion, setSuggestion] = createSignal<Suggestion | undefined>()
     const [composerRevision, setComposerRevision] = createSignal(0)
     const inline = createInlinePlaceholder()
     const ghostColor = createMemo(() => dimPlaceholderColor(context.theme.text.muted))
+    const diagnostics = createDiagnostics()
+
+    const note = (entry: Omit<DiagnosticEntry, "at">) => {
+      const recorded = diagnostics.record(entry)
+      if (state.debug === true && recorded.outcome !== "aborted") {
+        context.ui.toast.show({ title: "Ghost", message: formatDiagnostic(recorded) })
+      }
+      return recorded
+    }
 
     let disposed = false
     const composers = new Map<string, { marker: BoxRenderable; normal: () => boolean }>()
@@ -66,6 +76,10 @@ export default Plugin.define({
 
     const generate = async (sessionID: string, signal: AbortSignal) => {
       if (!canGenerate(sessionID)) return
+      const started = Date.now()
+      const elapsed = () => Date.now() - started
+      let model: SuggestionModel | undefined
+      let failure: unknown
       try {
         await context.data.session.message.sync(sessionID)
         if (signal.aborted || !canGenerate(sessionID)) return
@@ -75,19 +89,58 @@ export default Plugin.define({
         const session = context.data.session.get(sessionID)
         const location = session?.location ?? context.location ?? context.data.location.default()
         const explicit = suggestionModel(state.model, opts.model)
-        const model = explicit
-          ? resolveExplicitModel(context.client, location, signal, explicit)
-          : resolveSmallModel(context.client, location, signal, session)
-        const raw = await generateSuggestion(context.client, suggestionPrompt(opts.system, transcript), model, signal, warnGeneration, () => canGenerate(sessionID))
-        if (signal.aborted || !raw) return
+        model = explicit
+          ? await resolveExplicitModel(context.client, location, signal, explicit)
+          : await resolveSmallModel(context.client, location, signal, session)
+        if (signal.aborted || !canGenerate(sessionID)) return
+        if (!model) {
+          note({ sessionID, outcome: "unavailable", durationMs: elapsed() })
+          return
+        }
+        const raw = await generateSuggestion(
+          context.client,
+          suggestionPrompt(opts.system, transcript),
+          model,
+          signal,
+          (error) => { failure = error; warnGeneration(error) },
+          () => canGenerate(sessionID),
+        )
+        const label = modelLabel(model)
+        if (signal.aborted) {
+          note({ sessionID, outcome: "aborted", model: label, durationMs: elapsed() })
+          return
+        }
+        if (failure) {
+          note({ sessionID, outcome: "error", model: label, durationMs: elapsed(), detail: errorDetail(failure) })
+          return
+        }
+        if (!raw) {
+          note({ sessionID, outcome: "empty", model: label, durationMs: elapsed() })
+          return
+        }
         const clean = normalize(raw, opts.maxChars)
-        if (!clean) return
+        if (!clean) {
+          note({ sessionID, outcome: "empty", model: label, durationMs: elapsed(), chars: raw.length })
+          return
+        }
         const previous = lastUserText(messages)
-        if (previous && isEcho(clean, previous)) return
+        if (previous && isEcho(clean, previous)) {
+          note({ sessionID, outcome: "echo", model: label, durationMs: elapsed(), chars: clean.length })
+          return
+        }
         if (!canGenerate(sessionID)) return
         setSuggestion({ sessionID, text: clean })
+        note({ sessionID, outcome: "ok", model: label, durationMs: elapsed(), chars: clean.length })
       } catch (error) {
-        if (!signal.aborted) warnGeneration(error)
+        if (signal.aborted) return
+        warnGeneration(error)
+        note({
+          sessionID,
+          outcome: "error",
+          ...(model ? { model: modelLabel(model) } : {}),
+          durationMs: elapsed(),
+          detail: errorDetail(error),
+        })
       }
     }
 
@@ -169,8 +222,23 @@ export default Plugin.define({
               context.ui.toast.show({ message: `Suggestion model: ${state.model ?? opts.model ?? "OpenCode small default"}` })
               return
             }
+            if (command.type === "debug") {
+              const next = command.value ?? (state.debug !== true)
+              await updateState((draft) => { draft.debug = next })
+              context.ui.toast.show({ message: `Ghost debug: ${next ? "on" : "off"}` })
+              return
+            }
+            if (command.type === "log") {
+              const override = state.model ?? opts.model
+              const summary = `suggestions ${state.enabled ? "on" : "off"}, debug ${state.debug === true ? "on" : "off"}, model ${override ?? "OpenCode small default"}`
+              void context.ui.dialog.alert({
+                title: "Ghost — recent generations",
+                message: `${summary}\n\n${formatDiagnostics(diagnostics.list())}`,
+              })
+              return
+            }
             if (command.type === "invalid") {
-              context.ui.toast.show({ message: "Use /suggest, /suggest model provider/model, or /suggest model clear", variant: "warning" })
+              context.ui.toast.show({ message: "Use /suggest, /suggest model provider/model, /suggest model clear, /suggest debug [on|off], or /suggest log", variant: "warning" })
               return
             }
             cancelSuggestion()