saeeol 1.4.1 → 1.4.3

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

@@ -1,475 +0,0 @@
-import { createStore } from "solid-js/store"
-import { createSimpleContext } from "../app/helper"
-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 "@saeeol/core/global"
-import { iife } from "@/util/iife"
-import { useToast } from "../../ui/toast"
-import { useArgs } from "../app/args"
-import { useSDK } from "../app/sdk"
-import { useProject } from "../app/project" 
-import { RGBA } from "@opentui/core"
-import { Filesystem } from "@/util/filesystem"
-
-export function parseModel(model: string) {
-  const [providerID, ...rest] = model.split("/")
-  return {
-    providerID: providerID,
-    modelID: rest.join("/"),
-  }
-}
-
-export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
-  name: "Local",
-  init: () => {
-    const sync = useSync()
-    const sdk = useSDK()
-    const project = useProject() 
-    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: undefined as string | undefined,
-      })
-      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() {
-          const found = agents().find((x) => x.name === agentStore.current)
-          if (found) return found
-          const fallback = agents().at(0)
-          if (fallback) setAgentStore("current", fallback.name)
-          return fallback
-        },
-        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(() => {
-            const current = this.current()
-            if (!current) return
-            let next = agents().findIndex((x) => x.name === current.name) + direction
-            if (next < 0) next = agents().length - 1
-            if (next >= agents().length) next = 0
-            const value = agents()[next]
-            if (!value) return 
-            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)
-            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
-            }
-          | undefined
-        >
-        override: Record<
-          string,
-          | {
-              providerID: string
-              modelID: string
-            }
-          | undefined
-        >
-        recent: {
-          providerID: string
-          modelID: string
-        }[]
-        favorite: {
-          providerID: string
-          modelID: string
-        }[]
-        variant: Record<string, string | undefined>
-      }>({
-        ready: false,
-        model: {},
-        override: {}, 
-        recent: [],
-        favorite: [],
-        variant: {},
-      })
-
-      const filePath = path.join(Global.Path.state, "model.json")
-      const state = {
-        pending: false,
-        writer: Promise.resolve() as Promise<unknown>, 
-      }
-      const scope = createMemo(() => project.workspace.current() ?? project.instance.directory())
-
-      function key(name: string) {
-        return [scope(), name].join(":")
-      }
-
-      function clear(name: string) {
-        setModelStore("model", name, undefined)
-      }
-
-      function apply(name: string, value: { providerID: string; modelID: string }, persist: boolean) {
-        setModelStore("override", key(name), { ...value })
-        if (persist) {
-          setModelStore("model", name, { ...value })
-          return
-        }
-        clear(name)
-      }
-
-      function save() {
-        if (!modelStore.ready) {
-          state.pending = true
-          return
-        }
-        state.pending = false
-        const data = {
-          model: modelStore.model,
-          recent: modelStore.recent,
-          favorite: modelStore.favorite,
-          variant: modelStore.variant,
-        }
-        state.writer = state.writer.then(() => Filesystem.writeJson(filePath, data)).catch(() => {})
-      }
-
-      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.model === "object" && x.model !== null) setModelStore("model", x.model) 
-          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 } = parseModel(args.model)
-          if (isModelValid({ providerID, modelID })) {
-            return {
-              providerID,
-              modelID,
-            }
-          }
-        }
-
-        if (sync.data.config.model) {
-          const { providerID, modelID } = 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()
-        if (!a) return fallbackModel() 
-        return (
-          getFirstValidModel(
-            () => a && modelStore.override[key(a.name)],
-            () => a && a.model,
-            () => a && modelStore.model[a.name],
-            fallbackModel,
-          ) ?? undefined
-        )
-      })
-
-      return {
-        current: currentModel,
-        get ready() {
-          return modelStore.ready
-        },
-        saved(name: string) {
-          return modelStore.model[name]
-        },
-        // Used by tests to deterministically await the writer chain instead of sleeping for a fixed
-        // duration, which is too slow on Windows CI where temp-file rename can exceed 50ms under AV.
-        async flush() {
-          const deadline = Date.now() + 5000
-          while (state.pending && Date.now() < deadline) await new Promise((r) => setTimeout(r, 0))
-          await state.writer
-        },
-        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
-          const a = agent.current()
-          if (!a) return
-          apply(a.name, val, !a.model) 
-          save() 
-        },
-        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
-          const a = agent.current()
-          if (!a) return
-          apply(a.name, next, !a.model) 
-          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
-            }
-            const a = agent.current()
-            if (!a) return
-            apply(a.name, model, !a.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: {
-          selected() {
-            const m = currentModel()
-            if (!m) return undefined
-            const key = `${m.providerID}/${m.modelID}`
-            return modelStore.variant[key]
-          },
-          current() {
-            const v = this.selected()
-            if (!v) return undefined
-            if (!this.list().includes(v)) return undefined
-            return v
-          },
-          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 ?? "default")
-            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") {
-          await sdk.client.mcp.disconnect({ name })
-        } else {
-          await sdk.client.mcp.connect({ name })
-        }
-      },
-      async refresh() {
-        const workspace = project.workspace.current()
-        await (sdk.client as any).mcp._client.post({
-          url: "/mcp/refresh",
-          ...(workspace ? { workspace } : {}),
-        })
-      },
-    }
-    createEffect(() => {
-      if (!model.ready) return
-      const value = agent.current()
-      if (!value) return // guard against empty agent list during org switch
-      if (!value.model) return
-      if (isModelValid(value.model)) return
-      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/runtime/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/sdk.tsx

@@ -1 +0,0 @@
-export * from "./app/sdk"

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

@@ -1,18 +0,0 @@
-import { createSimpleContext } from "../app/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/sync.tsx

@@ -1 +0,0 @@
-export * from "./app/sync"

package/src/cli/cmd/tui/context/theme/aura.json

@@ -1,69 +0,0 @@
-{
-  "$schema": "https://saeeol.ai/theme.json",
-  "defs": {
-    "darkBg": "#0f0f0f",
-    "darkBgPanel": "#15141b",
-    "darkBorder": "#2d2d2d",
-    "darkFgMuted": "#6d6d6d",
-    "darkFg": "#edecee",
-    "purple": "#a277ff",
-    "pink": "#f694ff",
-    "blue": "#82e2ff",
-    "red": "#ff6767",
-    "orange": "#ffca85",
-    "cyan": "#61ffca",
-    "green": "#9dff65"
-  },
-  "theme": {
-    "primary": "purple",
-    "secondary": "pink",
-    "accent": "purple",
-    "error": "red",
-    "warning": "orange",
-    "success": "cyan",
-    "info": "purple",
-    "text": "darkFg",
-    "textMuted": "darkFgMuted",
-    "background": "darkBg",
-    "backgroundPanel": "darkBgPanel",
-    "backgroundElement": "darkBgPanel",
-    "border": "darkBorder",
-    "borderActive": "darkFgMuted",
-    "borderSubtle": "darkBorder",
-    "diffAdded": "cyan",
-    "diffRemoved": "red",
-    "diffContext": "darkFgMuted",
-    "diffHunkHeader": "darkFgMuted",
-    "diffHighlightAdded": "cyan",
-    "diffHighlightRemoved": "red",
-    "diffAddedBg": "#354933",
-    "diffRemovedBg": "#3f191a",
-    "diffContextBg": "darkBgPanel",
-    "diffLineNumber": "#898989",
-    "diffAddedLineNumberBg": "#162620",
-    "diffRemovedLineNumberBg": "#26161a",
-    "markdownText": "darkFg",
-    "markdownHeading": "purple",
-    "markdownLink": "pink",
-    "markdownLinkText": "purple",
-    "markdownCode": "cyan",
-    "markdownBlockQuote": "darkFgMuted",
-    "markdownEmph": "orange",
-    "markdownStrong": "purple",
-    "markdownHorizontalRule": "darkFgMuted",
-    "markdownListItem": "purple",
-    "markdownListEnumeration": "purple",
-    "markdownImage": "pink",
-    "markdownImageText": "purple",
-    "markdownCodeBlock": "darkFg",
-    "syntaxComment": "darkFgMuted",
-    "syntaxKeyword": "pink",
-    "syntaxFunction": "purple",
-    "syntaxVariable": "purple",
-    "syntaxString": "cyan",
-    "syntaxNumber": "green",
-    "syntaxType": "purple",
-    "syntaxOperator": "pink",
-    "syntaxPunctuation": "darkFg"
-  }
-}

package/src/cli/cmd/tui/context/theme/ayu.json

@@ -1,80 +0,0 @@
-{
-  "$schema": "https://saeeol.ai/theme.json",
-  "defs": {
-    "darkBg": "#0B0E14",
-    "darkBgAlt": "#0D1017",
-    "darkLine": "#11151C",
-    "darkPanel": "#0F131A",
-    "darkFg": "#BFBDB6",
-    "darkFgMuted": "#565B66",
-    "darkGutter": "#6C7380",
-    "darkTag": "#39BAE6",
-    "darkFunc": "#FFB454",
-    "darkEntity": "#59C2FF",
-    "darkString": "#AAD94C",
-    "darkRegexp": "#95E6CB",
-    "darkMarkup": "#F07178",
-    "darkKeyword": "#FF8F40",
-    "darkSpecial": "#E6B673",
-    "darkComment": "#ACB6BF",
-    "darkConstant": "#D2A6FF",
-    "darkOperator": "#F29668",
-    "darkAdded": "#7FD962",
-    "darkRemoved": "#F26D78",
-    "darkAccent": "#E6B450",
-    "darkError": "#D95757",
-    "darkIndentActive": "#6C7380"
-  },
-  "theme": {
-    "primary": "darkEntity",
-    "secondary": "darkConstant",
-    "accent": "darkAccent",
-    "error": "darkError",
-    "warning": "darkSpecial",
-    "success": "darkAdded",
-    "info": "darkTag",
-    "text": "darkFg",
-    "textMuted": "darkFgMuted",
-    "background": "darkBg",
-    "backgroundPanel": "darkPanel",
-    "backgroundElement": "darkBgAlt",
-    "border": "darkGutter",
-    "borderActive": "darkIndentActive",
-    "borderSubtle": "darkLine",
-    "diffAdded": "darkAdded",
-    "diffRemoved": "darkRemoved",
-    "diffContext": "darkComment",
-    "diffHunkHeader": "darkComment",
-    "diffHighlightAdded": "darkString",
-    "diffHighlightRemoved": "darkMarkup",
-    "diffAddedBg": "#20303b",
-    "diffRemovedBg": "#37222c",
-    "diffContextBg": "darkPanel",
-    "diffLineNumber": "diffContext",
-    "diffAddedLineNumberBg": "#1b2b34",
-    "diffRemovedLineNumberBg": "#2d1f26",
-    "markdownText": "darkFg",
-    "markdownHeading": "darkConstant",
-    "markdownLink": "darkEntity",
-    "markdownLinkText": "darkTag",
-    "markdownCode": "darkString",
-    "markdownBlockQuote": "darkSpecial",
-    "markdownEmph": "darkSpecial",
-    "markdownStrong": "darkFunc",
-    "markdownHorizontalRule": "darkFgMuted",
-    "markdownListItem": "darkEntity",
-    "markdownListEnumeration": "darkTag",
-    "markdownImage": "darkEntity",
-    "markdownImageText": "darkTag",
-    "markdownCodeBlock": "darkFg",
-    "syntaxComment": "darkComment",
-    "syntaxKeyword": "darkKeyword",
-    "syntaxFunction": "darkFunc",
-    "syntaxVariable": "darkEntity",
-    "syntaxString": "darkString",
-    "syntaxNumber": "darkConstant",
-    "syntaxType": "darkSpecial",
-    "syntaxOperator": "darkOperator",
-    "syntaxPunctuation": "darkFg"
-  }
-}