cerebras-cli 1.0.5 → 1.0.138

package/src/cli/cmd/tui/component/quickstart-onboarding.tsx

@@ -0,0 +1,116 @@
+import { createSignal, onMount, For } from "solid-js"
+import { useTheme } from "../context/theme"
+import { TextAttributes } from "@opentui/core"
+import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
+import { useKV } from "../context/kv"
+
+const STARTER_PROMPTS = [
+  { prompt: "Make a snake game in Python", icon: "" },
+  { prompt: "Organize my downloads folder", icon: "" },
+  { prompt: "Recreate the Google landing page UI", icon: "" },
+] as const
+
+export function QuickStartOnboarding(props: { onSelect: (prompt: string) => void; onSkip: () => void }) {
+  const { theme } = useTheme()
+  const kv = useKV()
+  const dimensions = useTerminalDimensions()
+  const [selected, setSelected] = createSignal(0)
+  const [ready, setReady] = createSignal(false)
+
+  onMount(() => {
+    setTimeout(() => setReady(true), 300)
+  })
+
+  const markSeen = () => {
+    kv.set("hasSeenQuickStart", true)
+  }
+
+  const selectPrompt = (prompt: string) => {
+    markSeen()
+    props.onSelect(prompt)
+  }
+
+  const skip = () => {
+    markSeen()
+    props.onSkip()
+  }
+
+  useKeyboard((evt) => {
+    // Always prevent arrow keys from bubbling
+    if (evt.name === "up" || evt.name === "down") {
+      evt.preventDefault?.()
+    }
+
+    if (!ready()) return
+
+    if (evt.name === "up") {
+      setSelected((s) => (s > 0 ? s - 1 : STARTER_PROMPTS.length - 1))
+    } else if (evt.name === "down") {
+      setSelected((s) => (s < STARTER_PROMPTS.length - 1 ? s + 1 : 0))
+    } else if (evt.name === "return") {
+      evt.preventDefault?.()
+      selectPrompt(STARTER_PROMPTS[selected()].prompt)
+    } else if (evt.name === "escape") {
+      evt.preventDefault?.()
+      skip()
+    }
+  })
+
+  return (
+    <box
+      position="absolute"
+      top={0}
+      left={0}
+      width={dimensions().width}
+      height={dimensions().height}
+      backgroundColor={theme.background}
+      justifyContent="center"
+      alignItems="center"
+      flexDirection="column"
+    >
+      <box
+        width={Math.min(55, dimensions().width - 4)}
+        backgroundColor={theme.backgroundPanel}
+        paddingTop={2}
+        paddingBottom={2}
+        paddingLeft={3}
+        paddingRight={3}
+        gap={1}
+      >
+        <box gap={1}>
+          <text fg={theme.primary} attributes={TextAttributes.BOLD}>
+            ◆ Quick Start
+          </text>
+          <text fg={theme.text}>
+            Try one of these prompts to get started:
+          </text>
+          <box marginTop={1} gap={0}>
+            <For each={STARTER_PROMPTS}>
+              {(item, index) => {
+                const isSelected = () => selected() === index()
+                return (
+                  <box
+                    flexDirection="row"
+                    backgroundColor={isSelected() ? theme.primary : undefined}
+                    paddingLeft={1}
+                    paddingRight={1}
+                  >
+                    <text fg={isSelected() ? theme.backgroundPanel : theme.text}>
+                      {isSelected() ? "▸ " : "  "}{item.icon} {item.prompt}
+                    </text>
+                  </box>
+                )
+              }}
+            </For>
+          </box>
+          <box marginTop={2}>
+            <text fg={theme.textMuted}>
+              ↑↓ navigate • enter select • esc skip
+            </text>
+          </box>
+        </box>
+      </box>
+    </box>
+  )
+}
+

package/src/cli/cmd/tui/context/args.tsx

@@ -0,0 +1,14 @@
+import { createSimpleContext } from "./helper"
+
+export interface Args {
+  model?: string
+  agent?: string
+  prompt?: string
+  continue?: boolean
+  sessionID?: string
+}
+
+export const { use: useArgs, provider: ArgsProvider } = createSimpleContext({
+  name: "Args",
+  init: (props: Args) => props,
+})

package/src/cli/cmd/tui/context/directory.ts

@@ -0,0 +1,12 @@
+import { createMemo } from "solid-js"
+import { useSync } from "./sync"
+import { Global } from "@/global"
+
+export function useDirectory() {
+  const sync = useSync()
+  return createMemo(() => {
+    const result = process.cwd().replace(Global.Path.home, "~")
+    if (sync.data.vcs?.branch) return result + ":" + sync.data.vcs.branch
+    return result
+  })
+}

package/src/cli/cmd/tui/context/exit.tsx

@@ -0,0 +1,23 @@
+import { useRenderer } from "@opentui/solid"
+import { createSimpleContext } from "./helper"
+import { FormatError, FormatUnknownError } from "@/cli/error"
+
+export const { use: useExit, provider: ExitProvider } = createSimpleContext({
+  name: "Exit",
+  init: (input: { onExit?: () => Promise<void> }) => {
+    const renderer = useRenderer()
+    return async (reason?: any) => {
+      // Reset window title before destroying renderer
+      renderer.setTerminalTitle("")
+      renderer.destroy()
+      await input.onExit?.()
+      if (reason) {
+        const formatted = FormatError(reason) ?? FormatUnknownError(reason)
+        if (formatted) {
+          process.stderr.write(formatted + "\n")
+        }
+      }
+      process.exit(0)
+    }
+  },
+})

package/src/cli/cmd/tui/context/helper.tsx

@@ -0,0 +1,25 @@
+import { createContext, Show, useContext, type ParentProps } from "solid-js"
+
+export function createSimpleContext<T, Props extends Record<string, any>>(input: {
+  name: string
+  init: ((input: Props) => T) | (() => T)
+}) {
+  const ctx = createContext<T>()
+
+  return {
+    provider: (props: ParentProps<Props>) => {
+      const init = input.init(props)
+      return (
+        // @ts-expect-error
+        <Show when={init.ready === undefined || init.ready === true}>
+          <ctx.Provider value={init}>{props.children}</ctx.Provider>
+        </Show>
+      )
+    },
+    use() {
+      const value = useContext(ctx)
+      if (!value) throw new Error(`${input.name} context must be used within a context provider`)
+      return value
+    },
+  }
+}

package/src/cli/cmd/tui/context/keybind.tsx

@@ -0,0 +1,111 @@
+import { createMemo } from "solid-js"
+import { useSync } from "@tui/context/sync"
+import { Keybind } from "@/util/keybind"
+import { pipe, mapValues } from "remeda"
+import type { KeybindsConfig } from "@opencode-ai/sdk/v2"
+import type { ParsedKey, Renderable } from "@opentui/core"
+import { createStore } from "solid-js/store"
+import { useKeyboard, useRenderer } from "@opentui/solid"
+import { createSimpleContext } from "./helper"
+
+export const { use: useKeybind, provider: KeybindProvider } = createSimpleContext({
+  name: "Keybind",
+  init: () => {
+    const sync = useSync()
+    const keybinds = createMemo(() => {
+      return pipe(
+        sync.data.config.keybinds ?? {},
+        mapValues((value) => Keybind.parse(value)),
+      )
+    })
+    const [store, setStore] = createStore({
+      leader: false,
+    })
+    const renderer = useRenderer()
+
+    let focus: Renderable | null
+    let timeout: NodeJS.Timeout
+    function leader(active: boolean) {
+      if (active) {
+        setStore("leader", true)
+        focus = renderer.currentFocusedRenderable
+        focus?.blur()
+        if (timeout) clearTimeout(timeout)
+        timeout = setTimeout(() => {
+          if (!store.leader) return
+          leader(false)
+          if (focus) {
+            focus.focus()
+          }
+        }, 2000)
+        return
+      }
+
+      if (!active) {
+        if (focus && !renderer.currentFocusedRenderable) {
+          focus.focus()
+        }
+        setStore("leader", false)
+      }
+    }
+
+    useKeyboard(async (evt) => {
+      if (!store.leader && result.match("leader", evt)) {
+        leader(true)
+        return
+      }
+
+      if (store.leader && evt.name) {
+        setImmediate(() => {
+          if (focus && renderer.currentFocusedRenderable === focus) {
+            focus.focus()
+          }
+          leader(false)
+        })
+      }
+    })
+
+    const result = {
+      get all() {
+        return keybinds()
+      },
+      get leader() {
+        return store.leader
+      },
+      parse(evt: ParsedKey): Keybind.Info {
+        if (evt.name === "\x1F")
+          return {
+            ctrl: true,
+            name: "_",
+            shift: false,
+            leader: false,
+            meta: false,
+          }
+        return {
+          ctrl: evt.ctrl,
+          name: evt.name,
+          shift: evt.shift,
+          leader: store.leader,
+          meta: evt.meta,
+        }
+      },
+      match(key: keyof KeybindsConfig, evt: ParsedKey) {
+        const keybind = keybinds()[key]
+        if (!keybind) return false
+        const parsed: Keybind.Info = result.parse(evt)
+        for (const key of keybind) {
+          if (Keybind.match(key, parsed)) {
+            return true
+          }
+        }
+      },
+      print(key: keyof KeybindsConfig) {
+        const first = keybinds()[key]?.at(0)
+        if (!first) return ""
+        const result = Keybind.toString(first)
+        return result.replace("<leader>", Keybind.toString(keybinds().leader![0]!))
+      },
+    }
+    return result
+  },
+})

package/src/cli/cmd/tui/context/kv.tsx

@@ -0,0 +1,49 @@
+import { Global } from "@/global"
+import { createSignal, type Setter } from "solid-js"
+import { createStore } from "solid-js/store"
+import { createSimpleContext } from "./helper"
+import path from "path"
+
+export const { use: useKV, provider: KVProvider } = createSimpleContext({
+  name: "KV",
+  init: () => {
+    const [ready, setReady] = createSignal(false)
+    const [kvStore, setKvStore] = createStore<Record<string, any>>()
+    const file = Bun.file(path.join(Global.Path.state, "kv.json"))
+
+    file
+      .json()
+      .then((x) => {
+        setKvStore(x)
+      })
+      .catch(() => {})
+      .finally(() => {
+        setReady(true)
+      })
+
+    const result = {
+      get ready() {
+        return ready()
+      },
+      signal<T>(name: string, defaultValue: T) {
+        if (!kvStore[name]) setKvStore(name, defaultValue)
+        return [
+          function () {
+            return result.get(name)
+          },
+          function setter(next: Setter<T>) {
+            result.set(name, next)
+          },
+        ] as const
+      },
+      get(key: string, defaultValue?: any) {
+        return kvStore[key] ?? defaultValue
+      },
+      set(key: string, value: any) {
+        setKvStore(key, value)
+        Bun.write(file, JSON.stringify(kvStore, null, 2))
+      },
+    }
+    return result
+  },
+})

package/src/cli/cmd/tui/context/local.tsx

@@ -0,0 +1,338 @@
+import { createStore } from "solid-js/store"
+import { batch, createEffect, createMemo } from "solid-js"
+import { useSync } from "@tui/context/sync"
+import { useTheme } from "@tui/context/theme"
+import { uniqueBy } from "remeda"
+import path from "path"
+import { Global } from "@/global"
+import { iife } from "@/util/iife"
+import { createSimpleContext } from "./helper"
+import { useToast } from "../ui/toast"
+import { Provider } from "@/provider/provider"
+import { useArgs } from "./args"
+import { useSDK } from "./sdk"
+import { RGBA } from "@opentui/core"
+
+export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
+  name: "Local",
+  init: () => {
+    const sync = useSync()
+    const sdk = useSDK()
+    const toast = useToast()
+
+    function isModelValid(model: { providerID: string; modelID: string }) {
+      const provider = sync.data.provider.find((x) => x.id === model.providerID)
+      return !!provider?.models[model.modelID]
+    }
+
+    function getFirstValidModel(...modelFns: (() => { providerID: string; modelID: string } | undefined)[]) {
+      for (const modelFn of modelFns) {
+        const model = modelFn()
+        if (!model) continue
+        if (isModelValid(model)) return model
+      }
+    }
+
+    // Automatically update model when agent changes
+    createEffect(() => {
+      const value = agent.current()
+      if (value.model) {
+        if (isModelValid(value.model))
+          model.set({
+            providerID: value.model.providerID,
+            modelID: value.model.modelID,
+          })
+        else
+          toast.show({
+            variant: "warning",
+            message: `Agent ${value.name}'s configured model ${value.model.providerID}/${value.model.modelID} is not valid`,
+            duration: 3000,
+          })
+      }
+    })
+
+    const agent = iife(() => {
+      const agents = createMemo(() => sync.data.agent.filter((x) => x.mode !== "subagent"))
+      const [agentStore, setAgentStore] = createStore<{
+        current: string
+      }>({
+        current: agents()[0].name,
+      })
+      const { theme } = useTheme()
+      const colors = createMemo(() => [
+        theme.primary,    // Cerebras orange
+        theme.success,    // Green
+        theme.info,       // Cyan
+        theme.error,      // Red
+        theme.syntaxType, // Yellow
+        theme.syntaxKeyword, // Orange variant
+      ])
+      return {
+        list() {
+          return agents()
+        },
+        current() {
+          return agents().find((x) => x.name === agentStore.current)!
+        },
+        set(name: string) {
+          if (!agents().some((x) => x.name === name))
+            return toast.show({
+              variant: "warning",
+              message: `Agent not found: ${name}`,
+              duration: 3000,
+            })
+          setAgentStore("current", name)
+        },
+        move(direction: 1 | -1) {
+          batch(() => {
+            let next = agents().findIndex((x) => x.name === agentStore.current) + direction
+            if (next < 0) next = agents().length - 1
+            if (next >= agents().length) next = 0
+            const value = agents()[next]
+            setAgentStore("current", value.name)
+          })
+        },
+        color(name: string) {
+          const agent = agents().find((x) => x.name === name)
+          if (agent?.color) return RGBA.fromHex(agent.color)
+          const index = agents().findIndex((x) => x.name === name)
+          if (index === -1) return colors()[0]
+          return colors()[index % colors().length]
+        },
+      }
+    })
+
+    const model = iife(() => {
+      const [modelStore, setModelStore] = createStore<{
+        ready: boolean
+        model: Record<
+          string,
+          {
+            providerID: string
+            modelID: string
+          }
+        >
+        recent: {
+          providerID: string
+          modelID: string
+        }[]
+        favorite: {
+          providerID: string
+          modelID: string
+        }[]
+      }>({
+        ready: false,
+        model: {},
+        recent: [],
+        favorite: [],
+      })
+
+      const file = Bun.file(path.join(Global.Path.state, "model.json"))
+
+      function save() {
+        Bun.write(
+          file,
+          JSON.stringify({
+            recent: modelStore.recent,
+            favorite: modelStore.favorite,
+          }),
+        )
+      }
+
+      file
+        .json()
+        .then((x) => {
+          if (Array.isArray(x.recent)) setModelStore("recent", x.recent)
+          if (Array.isArray(x.favorite)) setModelStore("favorite", x.favorite)
+        })
+        .catch(() => {})
+        .finally(() => {
+          setModelStore("ready", true)
+        })
+
+      const args = useArgs()
+      const fallbackModel = createMemo(() => {
+        if (args.model) {
+          const { providerID, modelID } = Provider.parseModel(args.model)
+          if (isModelValid({ providerID, modelID })) {
+            return {
+              providerID,
+              modelID,
+            }
+          }
+        }
+
+        if (sync.data.config.model) {
+          const { providerID, modelID } = Provider.parseModel(sync.data.config.model)
+          if (isModelValid({ providerID, modelID })) {
+            return {
+              providerID,
+              modelID,
+            }
+          }
+        }
+
+        for (const item of modelStore.recent) {
+          if (isModelValid(item)) {
+            return item
+          }
+        }
+
+        // Default to Cerebras ZAI-GLM-4.7 for Cerebras Code CLI
+        const cerebrasDefault = { providerID: "cerebras", modelID: "zai-glm-4.7" }
+        if (isModelValid(cerebrasDefault)) {
+          return cerebrasDefault
+        }
+
+        // For Cerebras Code CLI, don't fall back to other providers - show nothing until Cerebras is connected
+        // This prevents showing "big pickle" or "gemini 3 pro" on first load
+        return undefined
+      })
+
+      const currentModel = createMemo(() => {
+        const a = agent.current()
+        return (
+          getFirstValidModel(
+            () => modelStore.model[a.name],
+            () => a.model,
+            fallbackModel,
+          ) ?? undefined
+        )
+      })
+
+      return {
+        current: currentModel,
+        get ready() {
+          return modelStore.ready
+        },
+        recent() {
+          return modelStore.recent
+        },
+        favorite() {
+          return modelStore.favorite
+        },
+        parsed: createMemo(() => {
+          const value = currentModel()
+          if (!value) {
+            return {
+              provider: "Cerebras",
+              model: "Loading...",
+            }
+          }
+          const provider = sync.data.provider.find((x) => x.id === value.providerID)
+          const info = provider?.models[value.modelID]
+          return {
+            provider: provider?.name ?? value.providerID,
+            model: info?.name ?? value.modelID,
+          }
+        }),
+        cycle(direction: 1 | -1) {
+          const current = currentModel()
+          if (!current) return
+          const recent = modelStore.recent
+          const index = recent.findIndex((x) => x.providerID === current.providerID && x.modelID === current.modelID)
+          if (index === -1) return
+          let next = index + direction
+          if (next < 0) next = recent.length - 1
+          if (next >= recent.length) next = 0
+          const val = recent[next]
+          if (!val) return
+          setModelStore("model", agent.current().name, { ...val })
+        },
+        cycleFavorite(direction: 1 | -1) {
+          const favorites = modelStore.favorite.filter((item) => isModelValid(item))
+          if (!favorites.length) {
+            toast.show({
+              variant: "info",
+              message: "Add a favorite model to use this shortcut",
+              duration: 3000,
+            })
+            return
+          }
+          const current = currentModel()
+          let index = -1
+          if (current) {
+            index = favorites.findIndex((x) => x.providerID === current.providerID && x.modelID === current.modelID)
+          }
+          if (index === -1) {
+            index = direction === 1 ? 0 : favorites.length - 1
+          } else {
+            index += direction
+            if (index < 0) index = favorites.length - 1
+            if (index >= favorites.length) index = 0
+          }
+          const next = favorites[index]
+          if (!next) return
+          setModelStore("model", agent.current().name, { ...next })
+          const uniq = uniqueBy([next, ...modelStore.recent], (x) => x.providerID + x.modelID)
+          if (uniq.length > 10) uniq.pop()
+          setModelStore("recent", uniq)
+          save()
+        },
+        set(model: { providerID: string; modelID: string }, options?: { recent?: boolean }) {
+          batch(() => {
+            if (!isModelValid(model)) {
+              toast.show({
+                message: `Model ${model.providerID}/${model.modelID} is not valid`,
+                variant: "warning",
+                duration: 3000,
+              })
+              return
+            }
+            setModelStore("model", agent.current().name, model)
+            if (options?.recent) {
+              const uniq = uniqueBy([model, ...modelStore.recent], (x) => x.providerID + x.modelID)
+              if (uniq.length > 10) uniq.pop()
+              setModelStore("recent", uniq)
+              save()
+            }
+          })
+        },
+        toggleFavorite(model: { providerID: string; modelID: string }) {
+          batch(() => {
+            if (!isModelValid(model)) {
+              toast.show({
+                message: `Model ${model.providerID}/${model.modelID} is not valid`,
+                variant: "warning",
+                duration: 3000,
+              })
+              return
+            }
+            const exists = modelStore.favorite.some(
+              (x) => x.providerID === model.providerID && x.modelID === model.modelID,
+            )
+            const next = exists
+              ? modelStore.favorite.filter((x) => x.providerID !== model.providerID || x.modelID !== model.modelID)
+              : [model, ...modelStore.favorite]
+            setModelStore("favorite", next)
+            save()
+          })
+        },
+      }
+    })
+
+    const mcp = {
+      isEnabled(name: string) {
+        const status = sync.data.mcp[name]
+        return status?.status === "connected"
+      },
+      async toggle(name: string) {
+        const status = sync.data.mcp[name]
+        if (status?.status === "connected") {
+          // Disable: disconnect the MCP
+          await sdk.client.mcp.disconnect({ name })
+        } else {
+          // Enable/Retry: connect the MCP (handles disabled, failed, and other states)
+          await sdk.client.mcp.connect({ name })
+        }
+      },
+    }
+
+    const result = {
+      model,
+      agent,
+      mcp,
+    }
+    return result
+  },
+})