@toolkit-cli/toolkode 1.3.8 → 1.3.10

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

@@ -1,52 +0,0 @@
-import { Global } from "@/global"
-import { Filesystem } from "@/util/filesystem"
-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 [store, setStore] = createStore<Record<string, any>>()
-    const filePath = path.join(Global.Path.state, "kv.json")
-
-    Filesystem.readJson(filePath)
-      .then((x) => {
-        setStore(x)
-      })
-      .catch(() => {})
-      .finally(() => {
-        setReady(true)
-      })
-
-    const result = {
-      get ready() {
-        return ready()
-      },
-      get store() {
-        return store
-      },
-      signal<T>(name: string, defaultValue: T) {
-        if (store[name] === undefined) setStore(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 store[key] ?? defaultValue
-      },
-      set(key: string, value: any) {
-        setStore(key, value)
-        Filesystem.writeJson(filePath, store)
-      },
-    }
-    return result
-  },
-})

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

@@ -1,406 +0,0 @@
-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"
-import { Filesystem } from "@/util/filesystem"
-
-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
-      }
-    }
-
-    const agent = iife(() => {
-      const agents = createMemo(() => sync.data.agent.filter((x) => x.mode !== "subagent" && !x.hidden))
-      const visibleAgents = createMemo(() => sync.data.agent.filter((x) => !x.hidden))
-      const [agentStore, setAgentStore] = createStore<{
-        current: string
-      }>({
-        current: agents()[0].name,
-      })
-      const { theme } = useTheme()
-      const colors = createMemo(() => [
-        theme.secondary,
-        theme.accent,
-        theme.success,
-        theme.warning,
-        theme.primary,
-        theme.error,
-        theme.info,
-      ])
-      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 index = visibleAgents().findIndex((x) => x.name === name)
-          if (index === -1) return colors()[0]
-          const agent = visibleAgents()[index]
-
-          if (agent?.color) {
-            const color = agent.color
-            if (color.startsWith("#")) return RGBA.fromHex(color)
-            // already validated by config, just satisfying TS here
-            return theme[color as keyof typeof theme] as RGBA
-          }
-          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
-        }[]
-        variant: Record<string, string | undefined>
-      }>({
-        ready: false,
-        model: {},
-        recent: [],
-        favorite: [],
-        variant: {},
-      })
-
-      const filePath = path.join(Global.Path.state, "model.json")
-      const state = {
-        pending: false,
-      }
-
-      function save() {
-        if (!modelStore.ready) {
-          state.pending = true
-          return
-        }
-        state.pending = false
-        Filesystem.writeJson(filePath, {
-          recent: modelStore.recent,
-          favorite: modelStore.favorite,
-          variant: modelStore.variant,
-        })
-      }
-
-      Filesystem.readJson(filePath)
-        .then((x: any) => {
-          if (Array.isArray(x.recent)) setModelStore("recent", x.recent)
-          if (Array.isArray(x.favorite)) setModelStore("favorite", x.favorite)
-          if (typeof x.variant === "object" && x.variant !== null) setModelStore("variant", x.variant)
-        })
-        .catch(() => {})
-        .finally(() => {
-          setModelStore("ready", true)
-          if (state.pending) save()
-        })
-
-      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
-          }
-        }
-
-        const provider = sync.data.provider[0]
-        if (!provider) return undefined
-        const defaultModel = sync.data.provider_default[provider.id]
-        const firstModel = Object.values(provider.models)[0]
-        const model = defaultModel ?? firstModel?.id
-        if (!model) return undefined
-        return {
-          providerID: provider.id,
-          modelID: model,
-        }
-      })
-
-      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: "Connect a provider",
-              model: "No provider selected",
-              reasoning: false,
-            }
-          }
-          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,
-            reasoning: info?.capabilities?.reasoning ?? false,
-          }
-        }),
-        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.map((x) => ({ providerID: x.providerID, modelID: x.modelID })),
-          )
-          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.map((x) => ({ providerID: x.providerID, modelID: x.modelID })),
-              )
-              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.map((x) => ({ providerID: x.providerID, modelID: x.modelID })),
-            )
-            save()
-          })
-        },
-        variant: {
-          current() {
-            const m = currentModel()
-            if (!m) return undefined
-            const key = `${m.providerID}/${m.modelID}`
-            return modelStore.variant[key]
-          },
-          list() {
-            const m = currentModel()
-            if (!m) return []
-            const provider = sync.data.provider.find((x) => x.id === m.providerID)
-            const info = provider?.models[m.modelID]
-            if (!info?.variants) return []
-            return Object.keys(info.variants)
-          },
-          set(value: string | undefined) {
-            const m = currentModel()
-            if (!m) return
-            const key = `${m.providerID}/${m.modelID}`
-            setModelStore("variant", key, value)
-            save()
-          },
-          cycle() {
-            const variants = this.list()
-            if (variants.length === 0) return
-            const current = this.current()
-            if (!current) {
-              this.set(variants[0])
-              return
-            }
-            const index = variants.indexOf(current)
-            if (index === -1 || index === variants.length - 1) {
-              this.set(undefined)
-              return
-            }
-            this.set(variants[index + 1])
-          },
-        },
-      }
-    })
-
-    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 })
-        }
-      },
-    }
-
-    // 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 result = {
-      model,
-      agent,
-      mcp,
-    }
-    return result
-  },
-})

package/src/cli/cmd/tui/context/plugin-keybinds.ts

@@ -1,41 +0,0 @@
-import type { ParsedKey } from "@opentui/core"
-
-export type PluginKeybindMap = Record<string, string>
-
-type Base = {
-  match: (key: string, evt: ParsedKey) => boolean
-  print: (key: string) => string
-}
-
-export type PluginKeybind = {
-  readonly all: PluginKeybindMap
-  get: (name: string) => string
-  match: (name: string, evt: ParsedKey) => boolean
-  print: (name: string) => string
-}
-
-const txt = (value: unknown) => {
-  if (typeof value !== "string") return
-  if (!value.trim()) return
-  return value
-}
-
-export function createPluginKeybind(
-  base: Base,
-  defaults: PluginKeybindMap,
-  overrides?: Record<string, unknown>,
-): PluginKeybind {
-  const all = Object.freeze(
-    Object.fromEntries(Object.entries(defaults).map(([name, value]) => [name, txt(overrides?.[name]) ?? value])),
-  )
-  const get = (name: string) => all[name] ?? name
-
-  return {
-    get all() {
-      return all
-    },
-    get,
-    match: (name, evt) => base.match(get(name), evt),
-    print: (name) => base.print(get(name)),
-  }
-}

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

@@ -1,18 +0,0 @@
-import { createSimpleContext } from "./helper"
-import type { PromptRef } from "../component/prompt"
-
-export const { use: usePromptRef, provider: PromptRefProvider } = createSimpleContext({
-  name: "PromptRef",
-  init: () => {
-    let current: PromptRef | undefined
-
-    return {
-      get current() {
-        return current
-      },
-      set(ref: PromptRef | undefined) {
-        current = ref
-      },
-    }
-  },
-})

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

@@ -1,52 +0,0 @@
-import { createStore } from "solid-js/store"
-import { createSimpleContext } from "./helper"
-import type { PromptInfo } from "../component/prompt/history"
-
-export type HomeRoute = {
-  type: "home"
-  initialPrompt?: PromptInfo
-  workspaceID?: string
-}
-
-export type SessionRoute = {
-  type: "session"
-  sessionID: string
-  initialPrompt?: PromptInfo
-}
-
-export type PluginRoute = {
-  type: "plugin"
-  id: string
-  data?: Record<string, unknown>
-}
-
-export type Route = HomeRoute | SessionRoute | PluginRoute
-
-export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
-  name: "Route",
-  init: () => {
-    const [store, setStore] = createStore<Route>(
-      process.env["OPENCODE_ROUTE"]
-        ? JSON.parse(process.env["OPENCODE_ROUTE"])
-        : {
-            type: "home",
-          },
-    )
-
-    return {
-      get data() {
-        return store
-      },
-      navigate(route: Route) {
-        setStore(route)
-      },
-    }
-  },
-})
-
-export type RouteContext = ReturnType<typeof useRoute>
-
-export function useRouteData<T extends Route["type"]>(type: T) {
-  const route = useRoute()
-  return route.data as Extract<Route, { type: typeof type }>
-}

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

@@ -1,128 +0,0 @@
-import { createOpencodeClient, type Event } from "@toolkit-cli/sdk/v2"
-import { createSimpleContext } from "./helper"
-import { createGlobalEmitter } from "@solid-primitives/event-bus"
-import { batch, onCleanup, onMount } from "solid-js"
-
-export type EventSource = {
-  on: (handler: (event: Event) => void) => () => void
-  setWorkspace?: (workspaceID?: string) => void
-}
-
-export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
-  name: "SDK",
-  init: (props: {
-    url: string
-    directory?: string
-    fetch?: typeof fetch
-    headers?: RequestInit["headers"]
-    events?: EventSource
-  }) => {
-    const abort = new AbortController()
-    let workspaceID: string | undefined
-    let sse: AbortController | undefined
-
-    function createSDK() {
-      return createOpencodeClient({
-        baseUrl: props.url,
-        signal: abort.signal,
-        directory: props.directory,
-        fetch: props.fetch,
-        headers: props.headers,
-        experimental_workspaceID: workspaceID,
-      })
-    }
-
-    let sdk = createSDK()
-
-    const emitter = createGlobalEmitter<{
-      [key in Event["type"]]: Extract<Event, { type: key }>
-    }>()
-
-    let queue: Event[] = []
-    let timer: Timer | undefined
-    let last = 0
-
-    const flush = () => {
-      if (queue.length === 0) return
-      const events = queue
-      queue = []
-      timer = undefined
-      last = Date.now()
-      // Batch all event emissions so all store updates result in a single render
-      batch(() => {
-        for (const event of events) {
-          emitter.emit(event.type, event)
-        }
-      })
-    }
-
-    const handleEvent = (event: Event) => {
-      queue.push(event)
-      const elapsed = Date.now() - last
-
-      if (timer) return
-      // If we just flushed recently (within 16ms), batch this with future events
-      // Otherwise, process immediately to avoid latency
-      if (elapsed < 16) {
-        timer = setTimeout(flush, 16)
-        return
-      }
-      flush()
-    }
-
-    function startSSE() {
-      sse?.abort()
-      const ctrl = new AbortController()
-      sse = ctrl
-      ;(async () => {
-        while (true) {
-          if (abort.signal.aborted || ctrl.signal.aborted) break
-          const events = await sdk.event.subscribe({}, { signal: ctrl.signal })
-
-          for await (const event of events.stream) {
-            if (ctrl.signal.aborted) break
-            handleEvent(event)
-          }
-
-          if (timer) clearTimeout(timer)
-          if (queue.length > 0) flush()
-        }
-      })().catch(() => {})
-    }
-
-    onMount(() => {
-      if (props.events) {
-        const unsub = props.events.on(handleEvent)
-        onCleanup(unsub)
-      } else {
-        startSSE()
-      }
-    })
-
-    onCleanup(() => {
-      abort.abort()
-      sse?.abort()
-      if (timer) clearTimeout(timer)
-    })
-
-    return {
-      get client() {
-        return sdk
-      },
-      get workspaceID() {
-        return workspaceID
-      },
-      directory: props.directory,
-      event: emitter,
-      fetch: props.fetch ?? fetch,
-      setWorkspace(next?: string) {
-        if (workspaceID === next) return
-        workspaceID = next
-        sdk = createSDK()
-        props.events?.setWorkspace?.(next)
-        if (!props.events) startSSE()
-      },
-      url: props.url,
-    }
-  },
-})