opencode-ghost 0.6.0 → 1.0.0

package/src/stateless.ts

@@ -1,195 +1,30 @@
-import * as fs from "node:fs"
-import * as os from "node:os"
-import * as path from "node:path"
-import type { ResolvedOptions } from "./options"
-
-const WELL_KNOWN_BASE_URLS: Record<string, string> = {
-  openai: "https://api.openai.com/v1",
-  deepseek: "https://api.deepseek.com",
-  groq: "https://api.groq.com/openai/v1",
-  mistral: "https://api.mistral.com/v1",
-  openrouter: "https://openrouter.ai/api/v1",
-  together: "https://api.together.xyz/v1",
-  ollama: "http://127.0.0.1:11434/v1",
-  perplexity: "https://api.perplexity.ai",
-  xai: "https://api.x.ai/v1",
-  fireworks: "https://api.fireworks.ai/inference/v1",
-  cerebras: "https://api.cerebras.ai/v1",
-}
-
-const WELL_KNOWN_ENV_KEYS: Record<string, string[]> = {
-  openai: ["OPENAI_API_KEY"],
-  deepseek: ["DEEPSEEK_API_KEY"],
-  groq: ["GROQ_API_KEY"],
-  mistral: ["MISTRAL_API_KEY"],
-  openrouter: ["OPENROUTER_API_KEY"],
-  together: ["TOGETHER_API_KEY"],
-  perplexity: ["PERPLEXITY_API_KEY"],
-  xai: ["XAI_API_KEY"],
-  fireworks: ["FIREWORKS_API_KEY"],
-  cerebras: ["CEREBRAS_API_KEY"],
-  anthropic: ["ANTHROPIC_API_KEY"],
-}
-
-export function resolveApiKey(raw: string | undefined): string | undefined {
-  if (!raw) return undefined
-  const trimmed = raw.trim()
-  if (trimmed.startsWith("{file:") && trimmed.endsWith("}")) {
-    const filePath = trimmed.slice(6, -1).trim()
-    try {
-      const resolved = filePath.startsWith("~/")
-        ? path.join(os.homedir(), filePath.slice(2))
-        : filePath
-      return fs.readFileSync(resolved, "utf8").trim()
-    } catch {
-      return undefined
-    }
-  }
-  if (trimmed.startsWith("{env:") && trimmed.endsWith("}")) {
-    const envVar = trimmed.slice(5, -1).trim()
-    return process.env[envVar]
+import type { SuggestionModel } from "./text"
+
+export type GenerateClient = {
+  generate: {
+    text(
+      input: { prompt: string; model: { id: string; providerID: string; variant?: string } },
+      requestOptions?: { signal?: AbortSignal },
+    ): Promise<{ text?: string }>
   }
-  return trimmed
 }
 
-function resolveProviderApiKey(
-  opts: ResolvedOptions,
-  providerID: string | undefined,
-  providerConfig: any,
-  providerState: any,
-): string | undefined {
-  if (opts.apiKey) return resolveApiKey(opts.apiKey)
-
-  const configKey = resolveApiKey(providerConfig?.options?.apiKey)
-  if (configKey) return configKey
-
-  const stateOptionKey = resolveApiKey(providerState?.options?.apiKey)
-  if (stateOptionKey) return stateOptionKey
-
-  const stateKey = resolveApiKey(providerState?.key)
-  if (stateKey) return stateKey
-
-  if (Array.isArray(providerState?.env)) {
-    for (const envName of providerState.env) {
-      if (typeof envName === "string" && process.env[envName]) {
-        return process.env[envName]
-      }
-    }
-  }
-
-  if (providerID && WELL_KNOWN_ENV_KEYS[providerID]) {
-    for (const envName of WELL_KNOWN_ENV_KEYS[providerID]) {
-      if (process.env[envName]) {
-        return process.env[envName]
-      }
-    }
-  }
-
-  if (process.env.LITELLM_API_KEY) return process.env.LITELLM_API_KEY
-  if (!providerID || providerID === "openai" || providerID === "custom") {
-    if (process.env.OPENAI_API_KEY) return process.env.OPENAI_API_KEY
-  }
-
-  return undefined
-}
-
-export async function fetchStatelessSuggestion(
-  transcript: string,
-  opts: ResolvedOptions,
-  modelRef: { providerID: string; modelID: string } | undefined,
-  config: any,
-  providers?: readonly any[],
+export async function generateSuggestion(
+  client: GenerateClient,
+  prompt: string,
+  model: SuggestionModel | undefined,
+  signal: AbortSignal,
+  onError?: (error: unknown) => void,
 ): Promise<string | undefined> {
-  const providerID = modelRef?.providerID
-  const providerConfig = providerID ? config?.provider?.[providerID] : undefined
-  const providerState = providerID && Array.isArray(providers)
-    ? providers.find((p) => p?.id === providerID)
-    : undefined
-
-  const apiKey = resolveProviderApiKey(opts, providerID, providerConfig, providerState)
-  const isAnthropic = providerID === "anthropic"
-
-  const baseURL =
-    opts.endpoint ||
-    providerConfig?.options?.baseURL ||
-    providerState?.options?.baseURL ||
-    (!isAnthropic && providerID ? WELL_KNOWN_BASE_URLS[providerID] : undefined) ||
-    process.env.LITELLM_BASE_URL ||
-    process.env.OPENAI_BASE_URL
-
-  const controller = new AbortController()
-  const timeoutMs = 4000
-  const timer = setTimeout(() => controller.abort(), timeoutMs)
-
+  if (signal.aborted || !model) return undefined
   try {
-    if (baseURL) {
-      const url = baseURL.endsWith("/chat/completions")
-        ? baseURL
-        : `${baseURL.replace(/\/+$/, "")}/chat/completions`
-
-      const rawModel = modelRef?.modelID || "default"
-      const keepSlash = providerID === "openrouter" || providerID === "together"
-      const model = !keepSlash && rawModel.includes("/")
-        ? rawModel.slice(rawModel.lastIndexOf("/") + 1)
-        : rawModel
-
-      const headers: Record<string, string> = { "Content-Type": "application/json" }
-      if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`
-
-      const res = await fetch(url, {
-        method: "POST",
-        headers,
-        signal: controller.signal,
-        body: JSON.stringify({
-          model,
-          messages: [
-            { role: "system", content: opts.system },
-            { role: "user", content: transcript },
-          ],
-          max_tokens: 120,
-          temperature: 0.2,
-        }),
-      })
-
-      if (!res.ok) return undefined
-      const data = (await res.json()) as any
-      return data?.choices?.[0]?.message?.content
-    }
-
-    if (modelRef?.providerID === "anthropic") {
-      const antKey = apiKey || process.env.ANTHROPIC_API_KEY
-      if (!antKey) return undefined
-      const antBase = (
-        providerConfig?.options?.baseURL ||
-        providerState?.options?.baseURL ||
-        "https://api.anthropic.com"
-      ).replace(/\/+$/, "")
-      const url = antBase.endsWith("/v1/messages") ? antBase : `${antBase}/v1/messages`
-      const res = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": antKey,
-          "anthropic-version": "2023-06-01",
-        },
-        signal: controller.signal,
-        body: JSON.stringify({
-          model: modelRef.modelID,
-          max_tokens: 120,
-          system: opts.system,
-          messages: [{ role: "user", content: transcript }],
-        }),
-      })
-
-      if (!res.ok) return undefined
-      const data = (await res.json()) as any
-      return data?.content?.[0]?.text
-    }
-  } catch {
+    const result = await client.generate.text(
+      { prompt, model: { id: model.modelID, providerID: model.providerID, ...(model.variant ? { variant: model.variant } : {}) } },
+      { signal },
+    )
+    return result.text
+  } catch (error) {
+    if (!signal.aborted) onError?.(error)
     return undefined
-  } finally {
-    clearTimeout(timer)
   }
-
-  return undefined
 }

package/src/text.ts

@@ -1,27 +1,51 @@
-export function parseModel(
-  spec: unknown,
-): { providerID: string; modelID: string } | undefined {
-  if (!spec) return undefined
-  if (typeof spec === "object" && spec !== null) {
-    const obj = spec as Record<string, unknown>
-    const providerID =
-      typeof obj.providerID === "string"
-        ? obj.providerID
-        : typeof obj.provider === "string"
-          ? obj.provider
-          : undefined
-    const modelID =
-      typeof obj.modelID === "string"
-        ? obj.modelID
-        : typeof obj.id === "string"
-          ? obj.id
-          : typeof obj.model === "string"
-            ? obj.model
-            : undefined
-    if (providerID && modelID) return { providerID, modelID }
-    return undefined
+import type { LocationRef, ModelInfo, OpenCodeClient } from "@opencode/client"
+
+export type SuggestionModel = { providerID: string; modelID: string; variant?: string }
+
+export const NO_SMALL_MODEL = "No default small model available; set /suggest model provider/model"
+
+export type SmallModelClient = {
+  agent: Pick<OpenCodeClient["agent"], "list">
+  model: Pick<OpenCodeClient["model"], "default" | "list">
+}
+
+export function selectSmallModel(models: readonly ModelInfo[], providerID: string): SuggestionModel | undefined {
+  const available = models.filter((model) => model.providerID === providerID && model.enabled &&
+    model.status === "active" && model.capabilities.input.some((item) => item.startsWith("text")) &&
+    model.capabilities.output.some((item) => item.startsWith("text")))
+  for (const family of ["gpt-luna", "gemini-flash-lite", "gemini-flash", "claude-haiku"]) {
+    const model = available.find((model) => model.family === family)
+    if (model) return { providerID: model.providerID, modelID: model.id }
   }
-  if (typeof spec !== "string") return undefined
+  return undefined
+}
+
+export async function resolveSmallModel(
+  client: SmallModelClient,
+  location: LocationRef,
+  signal: AbortSignal,
+  providerID?: string,
+): Promise<SuggestionModel | undefined> {
+  if (signal.aborted) return undefined
+  const agents = await client.agent.list({ location }, { signal })
+  if (signal.aborted) return undefined
+  const configured = agents.data.find((agent) => agent.id === "title")?.model
+  if (configured) return { providerID: configured.providerID, modelID: configured.id, ...(configured.variant ? { variant: configured.variant } : {}) }
+  if (!providerID) {
+    const primary = await client.model.default({ location }, { signal })
+    if (signal.aborted) return undefined
+    providerID = primary.data?.providerID
+  }
+  if (!providerID) throw new Error(NO_SMALL_MODEL)
+  const catalog = await client.model.list({ location }, { signal })
+  if (signal.aborted) return undefined
+  const model = selectSmallModel(catalog.data, providerID)
+  if (!model) throw new Error(NO_SMALL_MODEL)
+  return model
+}
+
+export function parseModel(spec: string | undefined): { providerID: string; modelID: string } | undefined {
+  if (!spec || /\s/.test(spec)) return undefined
   const index = spec.indexOf("/")
   if (index <= 0 || index === spec.length - 1) return undefined
   return { providerID: spec.slice(0, index), modelID: spec.slice(index + 1) }
@@ -53,34 +77,6 @@ export function normalize(raw: string, maxChars: number): string | undefined {
   return cleaned.slice(0, maxChars - 1).trimEnd() + "…"
 }
 
-/**
- * Number of visual rows `text` occupies when word-wrapped to `width` columns.
- * Mirrors the greedy word wrap the prompt renderer uses, so a ghost can reserve
- * exactly as many rows as it needs. Long words break at the column boundary.
- */
-export function wrapCount(text: string, width: number): number {
-  if (width <= 0) return 1
-  let lines = 1
-  let col = 0
-  for (const word of text.split(/\s+/).filter(Boolean)) {
-    let length = word.length
-    if (col > 0) {
-      if (col + 1 + length <= width) {
-        col += 1 + length
-        continue
-      }
-      lines += 1
-      col = 0
-    }
-    while (length > width) {
-      lines += 1
-      length -= width
-    }
-    col = length
-  }
-  return lines
-}
-
 export function isEcho(suggestion: string, previous: string): boolean {
   const strip = (value: string) =>
     value

package/src/transcript.ts

@@ -0,0 +1,44 @@
+import { clip } from "./text"
+
+const MAX_MESSAGE_CHARS = 800
+const MAX_TRANSCRIPT_CHARS = 6000
+
+export type TranscriptMessage =
+  | { readonly type: "user"; readonly text: string }
+  | { readonly type: "assistant"; readonly content: ReadonlyArray<{ readonly type: string; readonly text?: string }> }
+  | { readonly type: string }
+
+function messageText(message: TranscriptMessage): { role: "User" | "Assistant"; text: string } | undefined {
+  if (message.type === "user" && "text" in message) return { role: "User", text: message.text }
+  if (message.type === "assistant" && "content" in message) {
+    const text = message.content
+      .filter((part) => part.type === "text")
+      .map((part) => part.text ?? "")
+      .join(" ")
+    return { role: "Assistant", text }
+  }
+  return undefined
+}
+
+export function buildTranscript(messages: readonly TranscriptMessage[], recentMessages: number): string {
+  const lines: string[] = []
+  const entries = messages.map(messageText).filter((entry) => entry && entry.text.trim())
+  for (const entry of entries.slice(-recentMessages)) {
+    if (!entry) continue
+    lines.push(`${entry.role}: ${clip(entry.text, MAX_MESSAGE_CHARS)}`)
+  }
+  if (lines.length === 0) return ""
+  return `${lines.join("\n").slice(-MAX_TRANSCRIPT_CHARS)}\n\nTask: write the user's next message.`
+}
+
+export function lastUserText(messages: readonly TranscriptMessage[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i]
+    if (message.type === "user") return (message as { text: string }).text
+  }
+  return ""
+}
+
+export function suggestionPrompt(system: string, transcript: string): string {
+  return `${system}\n\n${transcript}`
+}