saeeol 1.2.2 → 1.2.3

package/src/cli/cmd/tui/context/app/theme.tsx

@@ -0,0 +1,307 @@
+import { CliRenderEvents, type TerminalColors } from "@opentui/core"
+import path from "path"
+import { createEffect, createMemo, onCleanup, onMount } from "solid-js"
+import { createSimpleContext } from "./helper"
+import { Glob } from "@saeeol/core/util/glob"
+import { useKV } from "../runtime/kv"
+import { useRenderer } from "@opentui/solid"
+import { createStore, produce } from "solid-js/store"
+import { Global } from "@saeeol/core/global"
+import { Filesystem } from "@/util/filesystem"
+import { useTuiConfig } from "./tui-config"
+import { isRecord } from "@/util/record"
+import { selectedForeground, tint } from "../theme/theme-types"
+import type { ThemeJson, Theme } from "../theme/theme-types"
+import { DEFAULT_THEMES, isValidTheme } from "../theme/theme-themes"
+import { resolveTheme } from "../theme/theme-resolve"
+import { generateSystem } from "../theme/theme-system"
+import { generateSyntax, generateSubtleSyntax } from "../theme/theme-syntax"
+
+export { selectedForeground, tint }
+export type { ThemeJson }
+export { DEFAULT_THEMES }
+export { resolveTheme }
+
+type State = {
+  themes: Record<string, ThemeJson>
+  mode: "dark" | "light"
+  lock: "dark" | "light" | undefined
+  active: string
+  ready: boolean
+}
+
+const pluginThemes: Record<string, ThemeJson> = {}
+let customThemes: Record<string, ThemeJson> = {}
+let systemTheme: ThemeJson | undefined
+
+function listThemes() {
+  const themes = {
+    ...DEFAULT_THEMES,
+    ...pluginThemes,
+    ...customThemes,
+  }
+  if (!systemTheme) return themes
+  return {
+    ...themes,
+    system: systemTheme,
+  }
+}
+
+function syncThemes() {
+  setStore("themes", listThemes())
+}
+
+const [store, setStore] = createStore<State>({
+  themes: listThemes(),
+  mode: "dark",
+  lock: undefined,
+  active: "saeeol",
+  ready: false,
+})
+
+export function allThemes() {
+  return store.themes
+}
+
+function isTheme(theme: unknown): theme is ThemeJson {
+  if (!isRecord(theme)) return false
+  if (!isRecord(theme.theme)) return false
+  return true
+}
+
+export function hasTheme(name: string) {
+  if (!name) return false
+  return allThemes()[name] !== undefined
+}
+
+export function addTheme(name: string, theme: unknown) {
+  if (!name) return false
+  if (!isTheme(theme)) return false
+  if (hasTheme(name)) return false
+  pluginThemes[name] = theme
+  syncThemes()
+  return true
+}
+
+export function upsertTheme(name: string, theme: unknown) {
+  if (!name) return false
+  if (!isTheme(theme)) return false
+  if (customThemes[name] !== undefined) {
+    customThemes[name] = theme
+  } else {
+    pluginThemes[name] = theme
+  }
+  syncThemes()
+  return true
+}
+
+export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
+  name: "Theme",
+  init: (props: { mode: "dark" | "light" }) => {
+    const renderer = useRenderer()
+    const config = useTuiConfig()
+    const kv = useKV()
+    const pick = (value: unknown) => {
+      if (value === "dark" || value === "light") return value
+      return
+    }
+
+    setStore(
+      produce((draft) => {
+        const lock = pick(kv.get("theme_mode_lock"))
+        const mode = lock ?? pick(renderer.themeMode) ?? props.mode
+        if (!lock && pick(kv.get("theme_mode")) !== undefined) {
+          kv.set("theme_mode", undefined)
+        }
+        draft.mode = mode
+        draft.lock = lock
+        const active = config.theme ?? kv.get("theme", "saeeol")
+        draft.active = typeof active === "string" ? active : "saeeol"
+        draft.ready = false
+      }),
+    )
+
+    createEffect(() => {
+      const theme = config.theme
+      if (theme) setStore("active", theme)
+    })
+
+    function init() {
+      void Promise.allSettled([
+        resolveSystemTheme(store.mode),
+        getCustomThemes()
+          .then((custom) => {
+            customThemes = custom
+            syncThemes()
+          })
+          .catch(() => {
+            setStore("active", "saeeol")
+          }),
+      ]).finally(() => {
+        setStore("ready", true)
+      })
+    }
+
+    onMount(init)
+
+    function resolveSystemTheme(mode: "dark" | "light" = store.mode) {
+      return renderer
+        .getPalette({
+          size: 16,
+        })
+        .then((colors: TerminalColors) => {
+          if (!colors.palette[0]) {
+            systemTheme = undefined
+            syncThemes()
+            if (store.active === "system") {
+              setStore("active", "saeeol")
+            }
+            return
+          }
+          systemTheme = generateSystem(colors, mode)
+          syncThemes()
+        })
+        .catch(() => {
+          systemTheme = undefined
+          syncThemes()
+          if (store.active === "system") {
+            setStore("active", "saeeol")
+          }
+        })
+    }
+
+    function apply(mode: "dark" | "light") {
+      if (store.lock !== undefined) kv.set("theme_mode", mode)
+      if (store.mode === mode) return
+      setStore("mode", mode)
+      renderer.clearPaletteCache()
+      void resolveSystemTheme(mode)
+    }
+
+    function pin(mode: "dark" | "light" = store.mode) {
+      setStore("lock", mode)
+      kv.set("theme_mode_lock", mode)
+      apply(mode)
+    }
+
+    function free() {
+      setStore("lock", undefined)
+      kv.set("theme_mode_lock", undefined)
+      kv.set("theme_mode", undefined)
+      const mode = renderer.themeMode
+      if (mode) apply(mode)
+    }
+
+    const handle = (mode: "dark" | "light") => {
+      if (store.lock) return
+      apply(mode)
+    }
+    renderer.on(CliRenderEvents.THEME_MODE, handle)
+
+    const refresh = () => {
+      renderer.clearPaletteCache()
+      init()
+    }
+    process.on("SIGUSR2", refresh)
+
+    onCleanup(() => {
+      renderer.off(CliRenderEvents.THEME_MODE, handle)
+      process.off("SIGUSR2", refresh)
+    })
+    const values = createMemo(() => {
+      const active = store.themes[store.active]
+      if (active) {
+        return resolveTheme(active, store.mode)
+      }
+
+      const saved = kv.get("theme")
+      if (typeof saved === "string") {
+        const theme = store.themes[saved]
+        if (theme) {
+          return resolveTheme(theme, store.mode)
+        }
+      }
+
+      return resolveTheme(store.themes.saeeol, store.mode)
+    })
+
+    createEffect(() => {
+      renderer.setBackgroundColor(values().background)
+    })
+
+    const syntax = createMemo(() => generateSyntax(values()))
+    const subtleSyntax = createMemo(() => generateSubtleSyntax(values()))
+    return {
+      theme: new Proxy({} as Theme, {
+        get(_target, prop) {
+          // @ts-expect-error
+          return values()[prop]
+        },
+      }),
+      get selected() {
+        return store.active
+      },
+      all() {
+        return allThemes()
+      },
+      has(name: string) {
+        return hasTheme(name)
+      },
+      syntax,
+      subtleSyntax,
+      mode() {
+        return store.mode
+      },
+      locked() {
+        return store.lock !== undefined
+      },
+      lock() {
+        pin(store.mode)
+      },
+      unlock() {
+        free()
+      },
+      setMode(mode: "dark" | "light") {
+        pin(mode)
+      },
+      set(theme: string) {
+        if (!hasTheme(theme)) return false
+        setStore("active", theme)
+        kv.set("theme", theme)
+        return true
+      },
+      get ready() {
+        return store.ready
+      },
+    }
+  },
+})
+
+async function getCustomThemes() {
+  const directories = [
+    Global.Path.config,
+    ...(await Array.fromAsync(
+      Filesystem.up({
+        targets: [".saeeol", ".saeeol"],
+        start: process.cwd(),
+      }),
+    )),
+  ]
+
+  const result: Record<string, ThemeJson> = {}
+  for (const dir of directories) {
+    for (const item of await Glob.scan("themes/*.json", {
+      cwd: dir,
+      absolute: true,
+      dot: true,
+      symlink: true,
+    })) {
+      const name = path.basename(item, ".json")
+      if (name in DEFAULT_THEMES) continue
+      const json = await Filesystem.readJson(item).catch(() => null)
+      if (!isValidTheme(json)) continue
+      result[name] = json
+    }
+  }
+  return result
+}

package/src/cli/cmd/tui/context/app/tui-config.tsx

@@ -0,0 +1,9 @@
+import { TuiConfig } from "@/cli/cmd/tui/config/tui"
+import { createSimpleContext } from "./helper"
+
+export const { use: useTuiConfig, provider: TuiConfigProvider } = createSimpleContext({
+  name: "TuiConfig",
+  init: (props: { config: TuiConfig.Info }) => {
+    return props.config
+  },
+})

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

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

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

@@ -1,15 +1 @@
-import { createMemo } from "solid-js"
-import { useProject } from "./project"
-import { useSync } from "./sync"
-import { Global } from "@saeeol/core/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
-  })
-}
+export * from "./app/directory"

package/src/cli/cmd/tui/context/editor-zed.ts

@@ -1,281 +1 @@
-import { clamp } from "@saeeol/boxes/clamp"
-import { Database } from "bun:sqlite"
-import os from "node:os"
-import path from "node:path"
-import z from "zod"
-import { Filesystem } from "@/util/filesystem"
-import type { EditorSelection } from "./editor"
-
-const ZedEditorRowSchema = z.object({
-  item_kind: z.string(),
-  editor_id: z.number().nullable(),
-  workspace_id: z.number(),
-  workspace_paths: z.string().nullable(),
-  timestamp: z.string(),
-  buffer_path: z.string().nullable(),
-})
-
-const ZedSelectionRowSchema = z.object({
-  selection_start: z.number().nullable(),
-  selection_end: z.number().nullable(),
-})
-
-const ZedEditorContentsSchema = z.object({
-  contents: z.string().nullable(),
-})
-
-const utf8 = new TextEncoder()
-
-type ZedEditorRow = z.infer<typeof ZedEditorRowSchema>
-type ZedActiveEditorRow = ZedEditorRow & { item_kind: "Editor"; editor_id: number }
-type ZedSelectionRow = z.infer<typeof ZedSelectionRowSchema>
-
-export type ZedSelectionResult =
-  | { type: "selection"; selection: EditorSelection }
-  | { type: "empty" }
-  | { type: "unavailable" }
-
-export async function resolveZedSelection(dbPath: string, cwd = process.cwd()): Promise<ZedSelectionResult> {
-  const active = queryZedActiveEditor(dbPath, cwd)
-  if (active.type !== "row") return active
-
-  const row = active.row
-  if (!row.buffer_path) return { type: "empty" }
-
-  const selections = queryZedEditorSelections(dbPath, row)
-  if (selections.type !== "selections") return selections
-  const byteRanges = selections.selections
-    .flatMap((selection) => {
-      if (selection.selection_start == null || selection.selection_end == null) return []
-      return [
-        {
-          start: Math.min(selection.selection_start, selection.selection_end),
-          end: Math.max(selection.selection_start, selection.selection_end),
-        },
-      ]
-    })
-    .sort((left, right) => left.start - right.start || left.end - right.end)
-  if (byteRanges.length === 0) return { type: "unavailable" }
-
-  const contents = queryZedEditorContents(dbPath, row)
-  const text =
-    contents.type === "contents" && contents.contents != null
-      ? contents.contents
-      : await Bun.file(row.buffer_path)
-          .text()
-          .catch(() => undefined)
-  if (text == null) return { type: "unavailable" }
-
-  const ranges = byteRanges.map((range) => {
-    const startOffset = utf8ByteOffsetToStringIndex(text, range.start)
-    const endOffset = utf8ByteOffsetToStringIndex(text, range.end)
-    return {
-      text: text.slice(startOffset, endOffset),
-      selection: offsetsToSelection(text, startOffset, endOffset),
-    }
-  })
-
-  return {
-    type: "selection",
-    selection: {
-      filePath: row.buffer_path,
-      source: "zed",
-      ranges,
-    },
-  }
-}
-
-function queryZedActiveEditor(dbPath: string, cwd: string) {
-  let db: Database | undefined
-  try {
-    db = new Database(dbPath, { readonly: true })
-    const raw = db
-      .query(
-        `select
-          i.kind as item_kind,
-          e.item_id as editor_id,
-          i.workspace_id as workspace_id,
-          w.paths as workspace_paths,
-          w.timestamp as timestamp,
-          e.buffer_path as buffer_path
-        from items i
-        join panes p on p.pane_id = i.pane_id and p.workspace_id = i.workspace_id
-        join workspaces w on w.workspace_id = i.workspace_id
-        left join editors e on e.item_id = i.item_id and e.workspace_id = i.workspace_id
-        where i.active = 1 and p.active = 1
-        order by w.timestamp desc`,
-      )
-      .all()
-
-    const rows = raw.flatMap((row) => {
-      const parsed = ZedEditorRowSchema.safeParse(row)
-      return parsed.success ? [parsed.data] : []
-    })
-
-    if (raw.length > 0 && rows.length === 0) return { type: "unavailable" as const }
-
-    const row = rows
-      .map((row) => ({ row, score: scoreZedWorkspace(row.workspace_paths, cwd) }))
-      .filter((entry) => entry.score > 0)
-      .sort((left, right) => right.score - left.score || right.row.timestamp.localeCompare(left.row.timestamp))[0]?.row
-    if (!row) return { type: "empty" as const }
-    if (row.item_kind !== "Editor") return { type: "unavailable" as const }
-    if (!isZedActiveEditorRow(row)) return { type: "empty" as const }
-    return { type: "row" as const, row }
-  } catch {
-    return { type: "unavailable" as const }
-  } finally {
-    db?.close()
-  }
-}
-
-function queryZedEditorSelections(dbPath: string, row: ZedActiveEditorRow) {
-  let db: Database | undefined
-  try {
-    db = new Database(dbPath, { readonly: true })
-    const raw = db
-      .query(
-        `select
-          start as selection_start,
-          end as selection_end
-        from editor_selections
-        where editor_id = $editorID and workspace_id = $workspaceID`,
-      )
-      .all({ $editorID: row.editor_id, $workspaceID: row.workspace_id })
-
-    const selections = raw.flatMap((selection) => {
-      const parsed = ZedSelectionRowSchema.safeParse(selection)
-      return parsed.success ? [parsed.data] : []
-    })
-
-    if (raw.length > 0 && selections.length === 0) return { type: "unavailable" as const }
-    return { type: "selections" as const, selections }
-  } catch {
-    return { type: "unavailable" as const }
-  } finally {
-    db?.close()
-  }
-}
-
-function queryZedEditorContents(dbPath: string, row: ZedActiveEditorRow) {
-  let db: Database | undefined
-  try {
-    db = new Database(dbPath, { readonly: true })
-    const parsed = ZedEditorContentsSchema.safeParse(
-      db
-        .query(
-          `select contents
-        from editors
-        where item_id = $editorID and workspace_id = $workspaceID`,
-        )
-        .get({ $editorID: row.editor_id, $workspaceID: row.workspace_id }),
-    )
-    if (!parsed.success) return { type: "unavailable" as const }
-    return { type: "contents" as const, contents: parsed.data.contents }
-  } catch {
-    return { type: "unavailable" as const }
-  } finally {
-    db?.close()
-  }
-}
-
-function isZedActiveEditorRow(row: ZedEditorRow): row is ZedActiveEditorRow {
-  return row.item_kind === "Editor" && row.editor_id != null
-}
-
-export function resolveZedDbPath() {
-  const candidates = [
-    process.env.SAEEOL_ZED_DB,
-    path.join(os.homedir(), "Library", "Application Support", "Zed", "db", "0-stable", "db.sqlite"),
-    path.join(os.homedir(), ".local", "share", "zed", "db", "0-stable", "db.sqlite"),
-  ].filter((item): item is string => Boolean(item))
-
-  return candidates.find((item) => isFile(item))
-}
-
-function isFile(item: string) {
-  try {
-    return Filesystem.stat(item)?.isFile() === true
-  } catch {
-    return false
-  }
-}
-
-function scoreZedWorkspace(workspacePaths: string | null, cwd: string) {
-  return zedWorkspacePaths(workspacePaths).reduce((score, item) => {
-    if (pathContains(item, cwd)) return Math.max(score, path.resolve(item).length)
-    return score
-  }, 0)
-}
-
-function zedWorkspacePaths(value: string | null) {
-  if (!value) return []
-  const parsed = parseJson(value)
-  if (Array.isArray(parsed)) return parsed.filter((item): item is string => typeof item === "string")
-  return value.split(/\r?\n/).filter(Boolean)
-}
-
-export function offsetToPosition(text: string, offset: number) {
-  const stringOffset = utf8ByteOffsetToStringIndex(text, offset)
-  return offsetsToSelection(text, stringOffset, stringOffset).start
-}
-
-function utf8ByteOffsetToStringIndex(text: string, byteOffset: number) {
-  if (byteOffset <= 0) return 0
-
-  let bytes = 0
-  for (let index = 0; index < text.length; ) {
-    const codePoint = text.codePointAt(index)
-    if (codePoint === undefined) return text.length
-
-    const nextIndex = index + (codePoint > 0xffff ? 2 : 1)
-    bytes += utf8.encode(text.slice(index, nextIndex)).length
-    if (bytes >= byteOffset) return nextIndex
-    index = nextIndex
-  }
-
-  return text.length
-}
-
-function offsetsToSelection(text: string, startOffset: number, endOffset: number) {
-  const start = clamp(startOffset, 0, text.length)
-  const end = clamp(endOffset, 0, text.length)
-  let line = 1
-  let lineStart = 0
-  let startPosition = position(line, lineStart, start)
-  let endPosition = position(line, lineStart, end)
-
-  for (let index = 0; index <= end; index++) {
-    if (index === start) startPosition = position(line, lineStart, index)
-    if (index === end) {
-      endPosition = position(line, lineStart, index)
-      break
-    }
-    if (text[index] === "\n") {
-      line += 1
-      lineStart = index + 1
-    }
-  }
-
-  return { start: startPosition, end: endPosition }
-}
-
-function position(line: number, lineStart: number, offset: number) {
-  return {
-    line,
-    character: offset - lineStart + 1,
-  }
-}
-
-function pathContains(parent: string, child: string) {
-  const relative = path.relative(path.resolve(parent), path.resolve(child))
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-}
-
-function parseJson(value: string) {
-  try {
-    return JSON.parse(value) as unknown
-  } catch {
-    return
-  }
-}
+export * from "./app/editor-zed"