saeeol 1.1.0 → 1.1.1

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

@@ -0,0 +1,226 @@
+{
+  "$schema": "https://saeeol.ai/theme.json",
+  "defs": {
+    "background": "#262335",
+    "backgroundAlt": "#1e1a29",
+    "backgroundPanel": "#2a2139",
+    "foreground": "#ffffff",
+    "foregroundMuted": "#848bbd",
+    "pink": "#ff7edb",
+    "pinkBright": "#ff92df",
+    "cyan": "#36f9f6",
+    "cyanBright": "#72f1f8",
+    "yellow": "#fede5d",
+    "yellowBright": "#fff95d",
+    "orange": "#ff8b39",
+    "orangeBright": "#ff9f43",
+    "purple": "#b084eb",
+    "purpleBright": "#c792ea",
+    "red": "#fe4450",
+    "redBright": "#ff5e5b",
+    "green": "#72f1b8",
+    "greenBright": "#97f1d8"
+  },
+  "theme": {
+    "primary": {
+      "dark": "cyan",
+      "light": "#00bcd4"
+    },
+    "secondary": {
+      "dark": "pink",
+      "light": "#e91e63"
+    },
+    "accent": {
+      "dark": "purple",
+      "light": "#9c27b0"
+    },
+    "error": {
+      "dark": "red",
+      "light": "#f44336"
+    },
+    "warning": {
+      "dark": "yellow",
+      "light": "#ff9800"
+    },
+    "success": {
+      "dark": "green",
+      "light": "#4caf50"
+    },
+    "info": {
+      "dark": "orange",
+      "light": "#ff5722"
+    },
+    "text": {
+      "dark": "foreground",
+      "light": "#262335"
+    },
+    "textMuted": {
+      "dark": "foregroundMuted",
+      "light": "#5c5c8a"
+    },
+    "background": {
+      "dark": "#262335",
+      "light": "#fafafa"
+    },
+    "backgroundPanel": {
+      "dark": "#1e1a29",
+      "light": "#f5f5f5"
+    },
+    "backgroundElement": {
+      "dark": "#2a2139",
+      "light": "#eeeeee"
+    },
+    "border": {
+      "dark": "#495495",
+      "light": "#e0e0e0"
+    },
+    "borderActive": {
+      "dark": "cyan",
+      "light": "#00bcd4"
+    },
+    "borderSubtle": {
+      "dark": "#241b2f",
+      "light": "#f0f0f0"
+    },
+    "diffAdded": {
+      "dark": "green",
+      "light": "#4caf50"
+    },
+    "diffRemoved": {
+      "dark": "red",
+      "light": "#f44336"
+    },
+    "diffContext": {
+      "dark": "foregroundMuted",
+      "light": "#5c5c8a"
+    },
+    "diffHunkHeader": {
+      "dark": "purple",
+      "light": "#9c27b0"
+    },
+    "diffHighlightAdded": {
+      "dark": "greenBright",
+      "light": "#4caf50"
+    },
+    "diffHighlightRemoved": {
+      "dark": "redBright",
+      "light": "#f44336"
+    },
+    "diffAddedBg": {
+      "dark": "#1a3a2a",
+      "light": "#e8f5e9"
+    },
+    "diffRemovedBg": {
+      "dark": "#3a1a2a",
+      "light": "#ffebee"
+    },
+    "diffContextBg": {
+      "dark": "#1e1a29",
+      "light": "#f5f5f5"
+    },
+    "diffLineNumber": {
+      "dark": "#959bc1",
+      "light": "textMuted"
+    },
+    "diffAddedLineNumberBg": {
+      "dark": "#1a3a2a",
+      "light": "#e8f5e9"
+    },
+    "diffRemovedLineNumberBg": {
+      "dark": "#3a1a2a",
+      "light": "#ffebee"
+    },
+    "markdownText": {
+      "dark": "foreground",
+      "light": "#262335"
+    },
+    "markdownHeading": {
+      "dark": "pink",
+      "light": "#e91e63"
+    },
+    "markdownLink": {
+      "dark": "cyan",
+      "light": "#00bcd4"
+    },
+    "markdownLinkText": {
+      "dark": "purple",
+      "light": "#9c27b0"
+    },
+    "markdownCode": {
+      "dark": "green",
+      "light": "#4caf50"
+    },
+    "markdownBlockQuote": {
+      "dark": "foregroundMuted",
+      "light": "#5c5c8a"
+    },
+    "markdownEmph": {
+      "dark": "yellow",
+      "light": "#ff9800"
+    },
+    "markdownStrong": {
+      "dark": "orange",
+      "light": "#ff5722"
+    },
+    "markdownHorizontalRule": {
+      "dark": "#495495",
+      "light": "#e0e0e0"
+    },
+    "markdownListItem": {
+      "dark": "cyan",
+      "light": "#00bcd4"
+    },
+    "markdownListEnumeration": {
+      "dark": "purple",
+      "light": "#9c27b0"
+    },
+    "markdownImage": {
+      "dark": "cyan",
+      "light": "#00bcd4"
+    },
+    "markdownImageText": {
+      "dark": "purple",
+      "light": "#9c27b0"
+    },
+    "markdownCodeBlock": {
+      "dark": "foreground",
+      "light": "#262335"
+    },
+    "syntaxComment": {
+      "dark": "foregroundMuted",
+      "light": "#5c5c8a"
+    },
+    "syntaxKeyword": {
+      "dark": "pink",
+      "light": "#e91e63"
+    },
+    "syntaxFunction": {
+      "dark": "orange",
+      "light": "#ff5722"
+    },
+    "syntaxVariable": {
+      "dark": "foreground",
+      "light": "#262335"
+    },
+    "syntaxString": {
+      "dark": "yellow",
+      "light": "#ff9800"
+    },
+    "syntaxNumber": {
+      "dark": "purple",
+      "light": "#9c27b0"
+    },
+    "syntaxType": {
+      "dark": "cyan",
+      "light": "#00bcd4"
+    },
+    "syntaxOperator": {
+      "dark": "pink",
+      "light": "#e91e63"
+    },
+    "syntaxPunctuation": {
+      "dark": "foreground",
+      "light": "#262335"
+    }
+  }
+}

package/src/cli/cmd/tui/context/theme/theme-resolve.ts

@@ -0,0 +1,86 @@
+import { RGBA } from "@opentui/core"
+import type { Theme, ThemeColor, ColorValue, ThemeJson } from "./theme-types"
+
+export function resolveTheme(theme: ThemeJson, mode: "dark" | "light") {
+  const defs = theme.defs ?? {}
+  function resolveColor(c: ColorValue, chain: string[] = []): RGBA {
+    if (c instanceof RGBA) return c
+    if (typeof c === "string") {
+      if (c === "transparent" || c === "none") return RGBA.fromInts(0, 0, 0, 0)
+
+      if (c.startsWith("#")) return RGBA.fromHex(c)
+
+      if (chain.includes(c)) {
+        throw new Error(`Circular color reference: ${[...chain, c].join(" -> ")}`)
+      }
+
+      const next = defs[c] ?? theme.theme[c as ThemeColor]
+      if (next === undefined) {
+        throw new Error(`Color reference "${c}" not found in defs or theme`)
+      }
+      return resolveColor(next, [...chain, c])
+    }
+    if (typeof c === "number") {
+      return ansiToRgba(c)
+    }
+    return resolveColor(c[mode], chain)
+  }
+
+  const resolved = Object.fromEntries(
+    Object.entries(theme.theme)
+      .filter(([key]) => key !== "selectedListItemText" && key !== "backgroundMenu" && key !== "thinkingOpacity")
+      .map(([key, value]) => {
+        return [key, resolveColor(value as ColorValue)]
+      }),
+  ) as Partial<Record<ThemeColor, RGBA>>
+
+  const hasSelectedListItemText = theme.theme.selectedListItemText !== undefined
+  if (hasSelectedListItemText) {
+    resolved.selectedListItemText = resolveColor(theme.theme.selectedListItemText!)
+  } else {
+    resolved.selectedListItemText = resolved.background
+  }
+
+  if (theme.theme.backgroundMenu !== undefined) {
+    resolved.backgroundMenu = resolveColor(theme.theme.backgroundMenu)
+  } else {
+    resolved.backgroundMenu = resolved.backgroundElement
+  }
+
+  const thinkingOpacity = theme.theme.thinkingOpacity ?? 0.6
+
+  return {
+    ...resolved,
+    _hasSelectedListItemText: hasSelectedListItemText,
+    thinkingOpacity,
+  } as Theme
+}
+
+export function ansiToRgba(code: number): RGBA {
+  if (code < 16) {
+    const ansiColors = [
+      "#000000", "#800000", "#008000", "#808000",
+      "#000080", "#800080", "#008080", "#c0c0c0",
+      "#808080", "#ff0000", "#00ff00", "#ffff00",
+      "#0000ff", "#ff00ff", "#00ffff", "#ffffff",
+    ]
+    return RGBA.fromHex(ansiColors[code] ?? "#000000")
+  }
+
+  if (code < 232) {
+    const index = code - 16
+    const b = index % 6
+    const g = Math.floor(index / 6) % 6
+    const r = Math.floor(index / 36)
+
+    const val = (x: number) => (x === 0 ? 0 : x * 40 + 55)
+    return RGBA.fromInts(val(r), val(g), val(b))
+  }
+
+  if (code < 256) {
+    const gray = (code - 232) * 10 + 8
+    return RGBA.fromInts(gray, gray, gray)
+  }
+
+  return RGBA.fromInts(0, 0, 0)
+}

package/src/cli/cmd/tui/context/theme/theme-syntax-code.ts

@@ -0,0 +1,47 @@
+import type { Theme } from "./theme-types"
+
+export function getCodeSyntaxRules(theme: Theme) {
+  return [
+    { scope: ["default"], style: { foreground: theme.text } },
+    { scope: ["prompt"], style: { foreground: theme.accent } },
+    { scope: ["extmark.file"], style: { foreground: theme.warning, bold: true } },
+    { scope: ["extmark.agent"], style: { foreground: theme.secondary, bold: true } },
+    { scope: ["extmark.paste"], style: { foreground: theme.background, background: theme.warning, bold: true } },
+    { scope: ["comment"], style: { foreground: theme.syntaxComment, italic: true } },
+    { scope: ["comment.documentation"], style: { foreground: theme.syntaxComment, italic: true } },
+    { scope: ["string", "symbol"], style: { foreground: theme.syntaxString } },
+    { scope: ["number", "boolean"], style: { foreground: theme.syntaxNumber } },
+    { scope: ["character.special"], style: { foreground: theme.syntaxString } },
+    {
+      scope: ["keyword.return", "keyword.conditional", "keyword.repeat", "keyword.coroutine"],
+      style: { foreground: theme.syntaxKeyword, italic: true },
+    },
+    { scope: ["keyword.type"], style: { foreground: theme.syntaxType, bold: true, italic: true } },
+    { scope: ["keyword.function", "function.method"], style: { foreground: theme.syntaxFunction } },
+    { scope: ["keyword"], style: { foreground: theme.syntaxKeyword, italic: true } },
+    { scope: ["keyword.import"], style: { foreground: theme.syntaxKeyword } },
+    { scope: ["operator", "keyword.operator", "punctuation.delimiter"], style: { foreground: theme.syntaxOperator } },
+    { scope: ["keyword.conditional.ternary"], style: { foreground: theme.syntaxOperator } },
+    {
+      scope: ["variable", "variable.parameter", "function.method.call", "function.call"],
+      style: { foreground: theme.syntaxVariable },
+    },
+    { scope: ["variable.member", "function", "constructor"], style: { foreground: theme.syntaxFunction } },
+    { scope: ["type", "module"], style: { foreground: theme.syntaxType } },
+    { scope: ["constant"], style: { foreground: theme.syntaxNumber } },
+    { scope: ["property"], style: { foreground: theme.syntaxVariable } },
+    { scope: ["class"], style: { foreground: theme.syntaxType } },
+    { scope: ["parameter"], style: { foreground: theme.syntaxVariable } },
+    { scope: ["punctuation", "punctuation.bracket"], style: { foreground: theme.syntaxPunctuation } },
+    {
+      scope: ["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin"],
+      style: { foreground: theme.error },
+    },
+    { scope: ["variable.super"], style: { foreground: theme.error } },
+    { scope: ["string.escape", "string.regexp"], style: { foreground: theme.syntaxKeyword } },
+    { scope: ["keyword.directive"], style: { foreground: theme.syntaxKeyword, italic: true } },
+    { scope: ["punctuation.special"], style: { foreground: theme.syntaxOperator } },
+    { scope: ["keyword.modifier"], style: { foreground: theme.syntaxKeyword, italic: true } },
+    { scope: ["keyword.exception"], style: { foreground: theme.syntaxKeyword, italic: true } },
+  ]
+}

package/src/cli/cmd/tui/context/theme/theme-syntax-markup.ts

@@ -0,0 +1,50 @@
+import type { Theme } from "./theme-types"
+
+export function getMarkupSyntaxRules(theme: Theme) {
+  return [
+    { scope: ["markup.heading"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.heading.1"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.heading.2"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.heading.3"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.heading.4"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.heading.5"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.heading.6"], style: { foreground: theme.markdownHeading, bold: true } },
+    { scope: ["markup.bold", "markup.strong"], style: { foreground: theme.markdownStrong, bold: true } },
+    { scope: ["markup.italic"], style: { foreground: theme.markdownEmph, italic: true } },
+    { scope: ["markup.list"], style: { foreground: theme.markdownListItem } },
+    { scope: ["markup.quote"], style: { foreground: theme.markdownBlockQuote, italic: true } },
+    { scope: ["markup.raw", "markup.raw.block"], style: { foreground: theme.markdownCode } },
+    { scope: ["markup.raw.inline"], style: { foreground: theme.markdownCode, background: theme.background } },
+    { scope: ["markup.link"], style: { foreground: theme.markdownLink, underline: true } },
+    { scope: ["markup.link.label"], style: { foreground: theme.markdownLinkText, underline: true } },
+    { scope: ["markup.link.url"], style: { foreground: theme.markdownLink, underline: true } },
+    { scope: ["label"], style: { foreground: theme.markdownLinkText } },
+    { scope: ["spell", "nospell"], style: { foreground: theme.text } },
+    { scope: ["conceal"], style: { foreground: theme.textMuted } },
+    { scope: ["string.special", "string.special.url"], style: { foreground: theme.markdownLink, underline: true } },
+    { scope: ["character"], style: { foreground: theme.syntaxString } },
+    { scope: ["float"], style: { foreground: theme.syntaxNumber } },
+    { scope: ["comment.error"], style: { foreground: theme.error, italic: true, bold: true } },
+    { scope: ["comment.warning"], style: { foreground: theme.warning, italic: true, bold: true } },
+    { scope: ["comment.todo", "comment.note"], style: { foreground: theme.info, italic: true, bold: true } },
+    { scope: ["namespace"], style: { foreground: theme.syntaxType } },
+    { scope: ["field"], style: { foreground: theme.syntaxVariable } },
+    { scope: ["type.definition"], style: { foreground: theme.syntaxType, bold: true } },
+    { scope: ["keyword.export"], style: { foreground: theme.syntaxKeyword } },
+    { scope: ["attribute", "annotation"], style: { foreground: theme.warning } },
+    { scope: ["tag"], style: { foreground: theme.error } },
+    { scope: ["tag.attribute"], style: { foreground: theme.syntaxKeyword } },
+    { scope: ["tag.delimiter"], style: { foreground: theme.syntaxOperator } },
+    { scope: ["markup.strikethrough"], style: { foreground: theme.textMuted } },
+    { scope: ["markup.underline"], style: { foreground: theme.text, underline: true } },
+    { scope: ["markup.list.checked"], style: { foreground: theme.success } },
+    { scope: ["markup.list.unchecked"], style: { foreground: theme.textMuted } },
+    { scope: ["diff.plus"], style: { foreground: theme.diffAdded, background: theme.diffAddedBg } },
+    { scope: ["diff.minus"], style: { foreground: theme.diffRemoved, background: theme.diffRemovedBg } },
+    { scope: ["diff.delta"], style: { foreground: theme.diffContext, background: theme.diffContextBg } },
+    { scope: ["error"], style: { foreground: theme.error, bold: true } },
+    { scope: ["warning"], style: { foreground: theme.warning, bold: true } },
+    { scope: ["info"], style: { foreground: theme.info } },
+    { scope: ["debug"], style: { foreground: theme.textMuted } },
+  ]
+}

package/src/cli/cmd/tui/context/theme/theme-syntax.ts

@@ -0,0 +1,36 @@
+import { SyntaxStyle, RGBA } from "@opentui/core"
+import type { Theme } from "./theme-types"
+import { getCodeSyntaxRules } from "./theme-syntax-code"
+import { getMarkupSyntaxRules } from "./theme-syntax-markup"
+
+export function getSyntaxRules(theme: Theme) {
+  return [...getCodeSyntaxRules(theme), ...getMarkupSyntaxRules(theme)]
+}
+
+export function generateSyntax(theme: Theme) {
+  return SyntaxStyle.fromTheme(getSyntaxRules(theme))
+}
+
+export function generateSubtleSyntax(theme: Theme) {
+  const rules = getSyntaxRules(theme)
+  return SyntaxStyle.fromTheme(
+    rules.map((rule) => {
+      if (rule.style.foreground) {
+        const fg = rule.style.foreground
+        return {
+          ...rule,
+          style: {
+            ...rule.style,
+            foreground: RGBA.fromInts(
+              Math.round(fg.r * 255),
+              Math.round(fg.g * 255),
+              Math.round(fg.b * 255),
+              Math.round(theme.thinkingOpacity * 255),
+            ),
+          },
+        }
+      }
+      return rule
+    }),
+  )
+}

package/src/cli/cmd/tui/context/theme/theme-system.ts

@@ -0,0 +1,158 @@
+import { RGBA, type TerminalColors } from "@opentui/core"
+import { tint } from "./theme-types"
+import { ansiToRgba } from "./theme-resolve"
+import type { ThemeJson } from "./theme-types"
+
+export function generateSystem(colors: TerminalColors, mode: "dark" | "light"): ThemeJson {
+  const bg = RGBA.fromHex(colors.defaultBackground ?? colors.palette[0]!)
+  const fg = RGBA.fromHex(colors.defaultForeground ?? colors.palette[7]!)
+  const transparent = RGBA.fromValues(bg.r, bg.g, bg.b, 0)
+  const isDark = mode == "dark"
+
+  const col = (i: number) => {
+    const value = colors.palette[i]
+    if (value) return RGBA.fromHex(value)
+    return ansiToRgba(i)
+  }
+
+  const grays = generateGrayScale(bg, isDark)
+  const textMuted = generateMutedTextColor(bg, isDark)
+
+  const ansiColors = {
+    black: col(0),
+    red: col(1),
+    green: col(2),
+    yellow: col(3),
+    blue: col(4),
+    magenta: col(5),
+    cyan: col(6),
+    white: col(7),
+    redBright: col(9),
+    greenBright: col(10),
+  }
+
+  const diffAlpha = isDark ? 0.22 : 0.14
+  const diffAddedBg = tint(bg, ansiColors.green, diffAlpha)
+  const diffRemovedBg = tint(bg, ansiColors.red, diffAlpha)
+  const diffContextBg = grays[2]
+  const diffAddedLineNumberBg = tint(diffContextBg, ansiColors.green, diffAlpha)
+  const diffRemovedLineNumberBg = tint(diffContextBg, ansiColors.red, diffAlpha)
+  const diffLineNumber = textMuted
+
+  return {
+    theme: {
+      primary: ansiColors.cyan,
+      secondary: ansiColors.magenta,
+      accent: ansiColors.cyan,
+      error: ansiColors.red,
+      warning: ansiColors.yellow,
+      success: ansiColors.green,
+      info: ansiColors.cyan,
+      text: fg,
+      textMuted,
+      selectedListItemText: bg,
+      background: transparent,
+      backgroundPanel: grays[2],
+      backgroundElement: grays[3],
+      backgroundMenu: grays[3],
+      borderSubtle: grays[6],
+      border: grays[7],
+      borderActive: grays[8],
+      diffAdded: ansiColors.green,
+      diffRemoved: ansiColors.red,
+      diffContext: grays[7],
+      diffHunkHeader: grays[7],
+      diffHighlightAdded: ansiColors.greenBright,
+      diffHighlightRemoved: ansiColors.redBright,
+      diffAddedBg,
+      diffRemovedBg,
+      diffContextBg,
+      diffLineNumber,
+      diffAddedLineNumberBg,
+      diffRemovedLineNumberBg,
+      markdownText: fg,
+      markdownHeading: fg,
+      markdownLink: ansiColors.blue,
+      markdownLinkText: ansiColors.cyan,
+      markdownCode: ansiColors.green,
+      markdownBlockQuote: ansiColors.yellow,
+      markdownEmph: ansiColors.yellow,
+      markdownStrong: fg,
+      markdownHorizontalRule: grays[7],
+      markdownListItem: ansiColors.blue,
+      markdownListEnumeration: ansiColors.cyan,
+      markdownImage: ansiColors.blue,
+      markdownImageText: ansiColors.cyan,
+      markdownCodeBlock: fg,
+      syntaxComment: textMuted,
+      syntaxKeyword: ansiColors.magenta,
+      syntaxFunction: ansiColors.blue,
+      syntaxVariable: fg,
+      syntaxString: ansiColors.green,
+      syntaxNumber: ansiColors.yellow,
+      syntaxType: ansiColors.cyan,
+      syntaxOperator: ansiColors.cyan,
+      syntaxPunctuation: fg,
+    },
+  }
+}
+
+function generateGrayScale(bg: RGBA, isDark: boolean): Record<number, RGBA> {
+  const grays: Record<number, RGBA> = {}
+  const bgR = bg.r * 255
+  const bgG = bg.g * 255
+  const bgB = bg.b * 255
+  const luminance = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB
+
+  for (let i = 1; i <= 12; i++) {
+    const factor = i / 12.0
+    let newR: number
+    let newG: number
+    let newB: number
+
+    if (isDark) {
+      if (luminance < 10) {
+        const grayValue = Math.floor(factor * 0.4 * 255)
+        newR = grayValue
+        newG = grayValue
+        newB = grayValue
+      } else {
+        const newLum = luminance + (255 - luminance) * factor * 0.4
+        const ratio = newLum / luminance
+        newR = Math.min(bgR * ratio, 255)
+        newG = Math.min(bgG * ratio, 255)
+        newB = Math.min(bgB * ratio, 255)
+      }
+    } else {
+      if (luminance > 245) {
+        const grayValue = Math.floor(255 - factor * 0.4 * 255)
+        newR = grayValue
+        newG = grayValue
+        newB = grayValue
+      } else {
+        const newLum = luminance * (1 - factor * 0.4)
+        const ratio = newLum / luminance
+        newR = Math.max(bgR * ratio, 0)
+        newG = Math.max(bgG * ratio, 0)
+        newB = Math.max(bgB * ratio, 0)
+      }
+    }
+
+    grays[i] = RGBA.fromInts(Math.floor(newR), Math.floor(newG), Math.floor(newB))
+  }
+
+  return grays
+}
+
+function generateMutedTextColor(bg: RGBA, isDark: boolean): RGBA {
+  const bgR = bg.r * 255
+  const bgG = bg.g * 255
+  const bgB = bg.b * 255
+  const bgLum = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB
+
+  const grayValue = isDark
+    ? bgLum < 10 ? 180 : Math.min(Math.floor(160 + bgLum * 0.3), 200)
+    : bgLum > 245 ? 75 : Math.max(Math.floor(100 - (255 - bgLum) * 0.2), 60)
+
+  return RGBA.fromInts(grayValue, grayValue, grayValue)
+}

package/src/cli/cmd/tui/context/theme/theme-themes.ts

@@ -0,0 +1,79 @@
+import aura from "./aura.json" with { type: "json" }
+import ayu from "./ayu.json" with { type: "json" }
+import catppuccin from "./catppuccin.json" with { type: "json" }
+import catppuccinFrappe from "./catppuccin-frappe.json" with { type: "json" }
+import catppuccinMacchiato from "./catppuccin-macchiato.json" with { type: "json" }
+import cobalt2 from "./cobalt2.json" with { type: "json" }
+import cursor from "./cursor.json" with { type: "json" }
+import dracula from "./dracula.json" with { type: "json" }
+import everforest from "./everforest.json" with { type: "json" }
+import flexoki from "./flexoki.json" with { type: "json" }
+import github from "./github.json" with { type: "json" }
+import gruvbox from "./gruvbox.json" with { type: "json" }
+import kanagawa from "./kanagawa.json" with { type: "json" }
+import saeeol from "./saeeol.json" with { type: "json" }
+import material from "./material.json" with { type: "json" }
+import matrix from "./matrix.json" with { type: "json" }
+import mercury from "./mercury.json" with { type: "json" }
+import monokai from "./monokai.json" with { type: "json" }
+import nightowl from "./nightowl.json" with { type: "json" }
+import nord from "./nord.json" with { type: "json" }
+import osakaJade from "./osaka-jade.json" with { type: "json" }
+import onedark from "./one-dark.json" with { type: "json" }
+import orng from "./orng.json" with { type: "json" }
+import lucentOrng from "./lucent-orng.json" with { type: "json" }
+import palenight from "./palenight.json" with { type: "json" }
+import rosepine from "./rosepine.json" with { type: "json" }
+import solarized from "./solarized.json" with { type: "json" }
+import synthwave84 from "./synthwave84.json" with { type: "json" }
+import tokyonight from "./tokyonight.json" with { type: "json" }
+import vercel from "./vercel.json" with { type: "json" }
+import vesper from "./vesper.json" with { type: "json" }
+import zenburn from "./zenburn.json" with { type: "json" }
+import carbonfox from "./carbonfox.json" with { type: "json" }
+import colorblind from "./colorblind.json" with { type: "json" }
+import type { ThemeJson } from "./theme-types"
+
+export const DEFAULT_THEMES: Record<string, ThemeJson> = {
+  aura,
+  ayu,
+  catppuccin,
+  ["catppuccin-frappe"]: catppuccinFrappe,
+  ["catppuccin-macchiato"]: catppuccinMacchiato,
+  cobalt2,
+  cursor,
+  dracula,
+  everforest,
+  flexoki,
+  github,
+  gruvbox,
+  kanagawa,
+  saeeol,
+  material,
+  matrix,
+  mercury,
+  monokai,
+  nightowl,
+  nord,
+  ["one-dark"]: onedark,
+  ["osaka-jade"]: osakaJade,
+  orng,
+  ["lucent-orng"]: lucentOrng,
+  palenight,
+  rosepine,
+  solarized,
+  synthwave84,
+  tokyonight,
+  vesper,
+  vercel,
+  zenburn,
+  carbonfox,
+  colorblind,
+}
+
+export function isValidTheme(t: unknown): t is ThemeJson {
+  if (t == null || typeof t !== "object" || !("theme" in t)) return false
+  const theme = (t as Record<string, unknown>).theme
+  if (theme == null || typeof theme !== "object") return false
+  return "background" in theme && "text" in theme && "primary" in theme
+}