opencode-ghost 0.5.1 → 1.0.0

package/src/builtins.ts

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,78 +0,0 @@
-/**
- * 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[]
-}
-
-/** 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,
-        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) return undefined
-  const matches = matchOptions(parsed.args, hintList)
-  if (!matches) return undefined
-  const ghost = matches[0].slice(parsed.args.length)
-  const result: Completion = {
-    ghost,
-    insert: `/${parsed.name} ${parsed.args + ghost} `,
-  }
-  // Enumerate the accepted options only while the argument is still empty;
-  // once part of the word is typed, ghost the rest of the matching option.
-  if (parsed.args === "") result.args = matches
-  return result
-}