@sleepy-ai/cli 0.1.5 → 0.1.7

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

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

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

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

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

@@ -1,45 +0,0 @@
-import type { Event } from "@sleepy-ai/sdk/v2"
-import { useProject } from "./project"
-import { useSDK } from "./sdk"
-
-export function useEvent() {
-  const project = useProject()
-  const sdk = useSDK()
-
-  function subscribe(handler: (event: Event) => void) {
-    return sdk.event.on("event", (event) => {
-      if (event.payload.type === "sync") {
-        return
-      }
-
-      // Special hack for truly global events
-      if (event.directory === "global") {
-        handler(event.payload)
-      }
-
-      if (project.workspace.current()) {
-        if (event.workspace === project.workspace.current()) {
-          handler(event.payload)
-        }
-
-        return
-      }
-
-      if (event.directory === project.instance.directory()) {
-        handler(event.payload)
-      }
-    })
-  }
-
-  function on<T extends Event["type"]>(type: T, handler: (event: Extract<Event, { type: T }>) => void) {
-    return subscribe((event) => {
-      if (event.type !== type) return
-      handler(event as Extract<Event, { type: T }>)
-    })
-  }
-
-  return {
-    subscribe,
-    on,
-  }
-}

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

@@ -1,65 +0,0 @@
-import { useRenderer } from "@opentui/solid"
-import { createSimpleContext } from "./helper"
-import { FormatError, FormatUnknownError } from "@/cli/error"
-import { win32FlushInputBuffer } from "../win32"
-type Exit = ((reason?: unknown) => Promise<void>) & {
-  message: {
-    set: (value?: string) => () => void
-    clear: () => void
-    get: () => string | undefined
-  }
-}
-
-export const { use: useExit, provider: ExitProvider } = createSimpleContext({
-  name: "Exit",
-  init: (input: { onBeforeExit?: () => Promise<void>; onExit?: () => Promise<void> }) => {
-    const renderer = useRenderer()
-    let message: string | undefined
-    let task: Promise<void> | undefined
-    const store = {
-      set: (value?: string) => {
-        const prev = message
-        message = value
-        return () => {
-          message = prev
-        }
-      },
-      clear: () => {
-        message = undefined
-      },
-      get: () => message,
-    }
-    const exit: Exit = Object.assign(
-      (reason?: unknown) => {
-        if (task) return task
-        task = (async () => {
-          await input.onBeforeExit?.()
-          // Reset window title before destroying renderer
-          renderer.setTerminalTitle("")
-          renderer.destroy()
-          // SGR reset + show cursor + OSC 110/111/112 reset terminal fg/bg/cursor color.
-          // Without the OSC resets, whatever fg/bg the active sleepycode theme pushed
-          // via OSC 10/11/12 would persist in the terminal session, leaving the
-          // shell prompt unreadable (e.g. white-on-white).
-          process.stdout.write("\x1b[0m\x1b[?25h\x1b]110\x07\x1b]111\x07\x1b]112\x07")
-          win32FlushInputBuffer()
-          if (reason) {
-            const formatted = FormatError(reason) ?? FormatUnknownError(reason)
-            if (formatted) {
-              process.stderr.write(formatted + "\n")
-            }
-          }
-          const text = store.get()
-          if (text) process.stdout.write(text + "\n")
-          await input.onExit?.()
-        })()
-        return task
-      },
-      {
-        message: store,
-      },
-    )
-    process.on("SIGHUP", () => exit())
-    return exit
-  },
-})

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

@@ -1,25 +0,0 @@
-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

@@ -1,105 +0,0 @@
-import { createMemo } from "solid-js"
-import { Keybind } from "@/util"
-import { pipe, mapValues } from "remeda"
-import type { TuiConfig } from "@/cli/cmd/tui/config/tui"
-import type { ParsedKey, Renderable } from "@opentui/core"
-import { createStore } from "solid-js/store"
-import { useKeyboard, useRenderer } from "@opentui/solid"
-import { createSimpleContext } from "./helper"
-import { useTuiConfig } from "./tui-config"
-
-export type KeybindKey = keyof NonNullable<TuiConfig.Info["keybinds"]> & string
-
-export const { use: useKeybind, provider: KeybindProvider } = createSimpleContext({
-  name: "Keybind",
-  init: () => {
-    const config = useTuiConfig()
-    const keybinds = createMemo<Record<string, Keybind.Info[]>>(() => {
-      return pipe(
-        (config.keybinds ?? {}) as Record<string, string>,
-        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.isDestroyed) return
-          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 {
-        // Handle special case for Ctrl+Underscore (represented as \x1F)
-        if (evt.name === "\x1F") {
-          return Keybind.fromParsedKey({ ...evt, name: "_", ctrl: true }, store.leader)
-        }
-        return Keybind.fromParsedKey(evt, store.leader)
-      },
-      match(key: string, evt: ParsedKey) {
-        const list = keybinds()[key] ?? Keybind.parse(key)
-        if (!list.length) return false
-        const parsed: Keybind.Info = result.parse(evt)
-        for (const item of list) {
-          if (Keybind.match(item, parsed)) {
-            return true
-          }
-        }
-        return false
-      },
-      print(key: string) {
-        const first = keybinds()[key]?.at(0) ?? Keybind.parse(key).at(0)
-        if (!first) return ""
-        const text = Keybind.toString(first)
-        const lead = keybinds().leader?.[0]
-        if (!lead) return text
-        return text.replace("<leader>", Keybind.toString(lead))
-      },
-    }
-    return result
-  },
-})

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

@@ -1,86 +0,0 @@
-import { Global } from "@/global"
-import { Filesystem } from "@/util"
-import { Flock } from "@sleepy-ai/shared/util/flock"
-import { rename, rm } from "fs/promises"
-import { createSignal, type Setter } from "solid-js"
-import { createStore, unwrap } 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")
-    const lock = `tui-kv:${filePath}`
-    // Queue same-process writes so rapid updates persist in order.
-    let write = Promise.resolve()
-
-    // Write to a temp file first so kv.json is only replaced once the JSON is complete, avoiding partial writes if shutdown interrupts persistence.
-    function writeSnapshot(snapshot: Record<string, any>) {
-      const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`
-      return Filesystem.writeJson(tempPath, snapshot)
-        .then(() => rename(tempPath, filePath))
-        .catch(async (error) => {
-          await rm(tempPath, { force: true }).catch(() => undefined)
-          throw error
-        })
-    }
-
-    // Read under the same lock used for writes because kv.json is shared across processes.
-    Flock.withLock(lock, () => Filesystem.readJson<Record<string, any>>(filePath))
-      .then((x) => {
-        setStore(x)
-      })
-      .catch((error) => {
-        console.error("Failed to read KV state", { filePath, error })
-      })
-      .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)
-        const snapshot = structuredClone(unwrap(store))
-        write = write
-          .then(() => Flock.withLock(lock, () => writeSnapshot(snapshot)))
-          .catch((error) => {
-            console.error("Failed to write KV state", { filePath, error })
-          })
-      },
-      delete(key: string) {
-        setStore(key, undefined)
-        const snapshot = structuredClone(unwrap(store))
-        delete snapshot[key]
-        write = write
-          .then(() => Flock.withLock(lock, () => writeSnapshot(snapshot)))
-          .catch((error) => {
-            console.error("Failed to write KV state", { filePath, error })
-          })
-      },
-    }
-    return result
-  },
-})

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

@@ -1,91 +0,0 @@
-import * as i18n from "@solid-primitives/i18n"
-import { createMemo, createResource, type ParentProps } from "solid-js"
-import { I18nProvider } from "@sleepy-ai/ui/context/i18n"
-import { dict as tuiEn } from "../i18n/en"
-import { dict as uiEn } from "@sleepy-ai/ui/i18n/en"
-import { LOCALES, INTL, LABEL_KEY, normalizeLocale, type Locale } from "../i18n/locales"
-import { useKV } from "./kv"
-import { detectSystemLocale } from "../util/system-locale"
-import { createSimpleContext } from "./helper"
-
-type Source = { dict: Record<string, string> }
-const base = i18n.flatten({ ...tuiEn, ...uiEn })
-type Dictionary = typeof base
-
-const merge = async (ui: Promise<Source>, tui?: Promise<Source>) => {
-  const [u, t] = await Promise.all([ui, tui])
-  const tuiDict = t?.dict ?? {}
-  return { ...base, ...i18n.flatten({ ...tuiDict, ...u.dict }) } as Dictionary
-}
-
-const loaders: Record<Exclude<Locale, "en">, () => Promise<Dictionary>> = {
-  zh: () => merge(import("@sleepy-ai/ui/i18n/zh"), import("../i18n/zh")),
-  zht: () => merge(import("@sleepy-ai/ui/i18n/zht"), import("../i18n/zht")),
-  ko: () => merge(import("@sleepy-ai/ui/i18n/ko")),
-  de: () => merge(import("@sleepy-ai/ui/i18n/de")),
-  es: () => merge(import("@sleepy-ai/ui/i18n/es"), import("../i18n/es")),
-  fr: () => merge(import("@sleepy-ai/ui/i18n/fr"), import("../i18n/fr")),
-  da: () => merge(import("@sleepy-ai/ui/i18n/da")),
-  ja: () => merge(import("@sleepy-ai/ui/i18n/ja"), import("../i18n/ja")),
-  pl: () => merge(import("@sleepy-ai/ui/i18n/pl")),
-  ru: () => merge(import("@sleepy-ai/ui/i18n/ru"), import("../i18n/ru")),
-  ar: () => merge(import("@sleepy-ai/ui/i18n/ar")),
-  no: () => merge(import("@sleepy-ai/ui/i18n/no")),
-  br: () => merge(import("@sleepy-ai/ui/i18n/br")),
-  th: () => merge(import("@sleepy-ai/ui/i18n/th")),
-  bs: () => merge(import("@sleepy-ai/ui/i18n/bs")),
-  tr: () => merge(import("@sleepy-ai/ui/i18n/tr")),
-}
-
-const cache = new Map<Locale, Dictionary>([["en", base]])
-async function loadDict(locale: Locale): Promise<Dictionary> {
-  const hit = cache.get(locale)
-  if (hit) return hit
-  if (locale === "en") return base
-  const next = await loaders[locale]()
-  cache.set(locale, next)
-  return next
-}
-
-export const { use: useLanguage, provider: LanguageProvider } = createSimpleContext({
-  name: "Language",
-  init: () => {
-    const kv = useKV()
-    const [preference, setPreference] = kv.signal<Locale | "auto">("locale", "auto")
-
-    const effective = createMemo<Locale>(() => {
-      if (!kv.ready) return "en"
-      const pref = preference()
-      if (pref !== "auto") return normalizeLocale(pref)
-      return detectSystemLocale()
-    })
-
-    const [dict] = createResource(effective, loadDict, { initialValue: base })
-    const t = i18n.translator(() => dict() ?? base, i18n.resolveTemplate) as (
-      key: string,
-      params?: Record<string, string | number | boolean>,
-    ) => string
-    const intl = createMemo(() => INTL[effective()])
-    const label = (locale: Locale) => t(LABEL_KEY[locale])
-
-    function setLocale(next: Locale | "auto") {
-      const value: Locale | "auto" = next === "auto" ? "auto" : normalizeLocale(next)
-      setPreference(() => value)
-    }
-
-    return {
-      preference,
-      effective,
-      intl,
-      locales: LOCALES,
-      label,
-      t,
-      setLocale,
-    }
-  },
-})
-
-export function UiI18nBridge(props: ParentProps) {
-  const lang = useLanguage()
-  return <I18nProvider value={{ locale: lang.intl, t: (key: any, params: any) => lang.t(key, params) }}>{props.children}</I18nProvider>
-}