glitch-core

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, PluginOptions, Register } from 'claude-code'
3
4import { THEMES, THEME_NAMES, resolveTheme } from './themes'
5
6export const theme = atom({ plugin: 'glitch-core', key: 'theme' } as const, THEMES.glitch as NonNullable<typeof THEMES.glitch>)
7
8// The `/glitch theme` choice, kept across sessions.
9export const STORE_THEME = 'theme'
10
11// Subcommands other Glitch plugins own. A command.run hook cannot run another command
12// (the host refuses it), so a routed `/glitch <sub> …` passes down the command.run chain
13// to the owner's own hook on `/glitch`; the owner must also register its `/<owner>` command,
14// which is how its presence is told.
15export const ROUTES: Record<string, string> = { hud: 'glitch-hud', budget: 'glitch-hud', warm: 'glitch-hud', demo: 'glitch-hud', pet: 'glitch-pets', crew: 'glitch-pets' }
16
17const str = (v: unknown): string | undefined => (typeof v === 'string' ? v : undefined)
18
19// Resolves the theme from the saved choice, else the `theme` option, and publishes it.
20export async function applyTheme($: EngineInterface, options: PluginOptions): Promise<string[]> {
21  const saved = await $.store.get(STORE_THEME).catch(() => undefined)
22  const { theme: resolved, problems } = resolveTheme(str(saved) ?? str(options.theme), str(options.custom))
23  await update($, theme, () => resolved)
24  return problems
25}
26
27async function installed($: EngineInterface): Promise<Set<string>> {
28  const list = await $.command.list().catch(() => [])
29  return new Set(list.map(c => c.name))
30}
31
32async function themeCommand($: EngineInterface, options: PluginOptions, name: string | undefined): Promise<string> {
33  const current = (await read($, theme)).name
34  if (!name) return `Themes: ${THEME_NAMES.map(n => (n === current ? `${n} (current)` : n)).join(', ')}`
35  // A store that refuses the write leaves the saved choice, so the theme stays as it is.
36  if (name === 'default') {
37    if (!(await $.store.delete(STORE_THEME).then(() => true, () => false))) return `Could not reset the theme; it stays ${current}.`
38    await applyTheme($, options)
39    return `Theme reset to ${(await read($, theme)).name}.`
40  }
41  if (!THEME_NAMES.includes(name)) return `Unknown theme "${name}". Themes: ${THEME_NAMES.join(', ')}`
42  if (!(await $.store.set(STORE_THEME, name).then(() => true, () => false))) return `Could not save the theme; it stays ${current}.`
43  await applyTheme($, options)
44  return `Theme: ${name}.`
45}
46
47async function help($: EngineInterface): Promise<string> {
48  const have = await installed($)
49  const byOwner = new Map<string, string[]>()
50  for (const [sub, owner] of Object.entries(ROUTES)) byOwner.set(owner, [...(byOwner.get(owner) ?? []), sub])
51  const lines = [`Glitch · theme ${(await read($, theme)).name}`, '  /glitch theme [name|default] — list or switch themes']
52  for (const [owner, subs] of byOwner) {
53    lines.push(`  /glitch ${[...subs].sort().join(', ')} — ${owner}${have.has(owner) ? '' : ' (not installed)'}`)
54  }
55  return lines.join('\n')
56}
57
58export const register: Register = (on, options) => {
59  on('session.start', async ($, e, next) => {
60    const started = await next(e)
61    try {
62      const problems = await applyTheme($, options)
63      if (problems.length) $.ui.toast(`Glitch: ${problems.join('; ')}`, { timeoutMs: 8000 })
64    } catch {
65      $.ui.toast('Glitch: could not apply theme', { timeoutMs: 8000 })
66    }
67    try {
68      await $.command.register({ name: 'glitch', description: 'Glitch kit: themes, HUD, budget, cache keep-warm, pets (/glitch for help)' })
69    } catch {
70      $.ui.toast('Glitch: could not register /glitch', { timeoutMs: 8000 })
71    }
72    return started
73  })
74
75  on('command.run', { command: 'glitch' }, async ($, e, next) => {
76    const [sub = '', ...rest] = e.args.trim().split(/\s+/).filter(Boolean)
77    if (sub === 'theme') return { text: await themeCommand($, options, rest[0]) }
78
79    const owner = Object.hasOwn(ROUTES, sub) ? ROUTES[sub] : undefined
80    if (owner) {
81      if (!(await installed($)).has(owner)) return { text: `/glitch ${sub} needs the ${owner} plugin, which is not installed.` }
82      return next(e)
83    }
84    return { text: await help($) }
85  })
86}
87

1import type { Theme } from '../types'
2
3export const THEMES: Record<string, Theme> = {
4  glitch: { name: 'glitch', accent: '#00e5ff', good: '#5af78e', warn: '#f3c969', alert: '#ff5c8a', muted: '#7a7f8c', info: '#c77dff', bar: ['▓', '░'], icons: 'symbols' },
5  neon: { name: 'neon', accent: '#ff2bd6', good: '#39ff14', warn: '#ffd300', alert: '#ff3131', muted: '#8a8aa8', info: '#00f0ff', bar: ['█', '▁'], icons: 'symbols' },
6  mono: { name: 'mono', accent: '#ffffff', good: '#d0d0d0', warn: '#b0b0b0', alert: '#ffffff', muted: '#808080', info: '#c0c0c0', bar: ['■', '□'], icons: 'ascii' },
7  sunset: { name: 'sunset', accent: '#ff8c42', good: '#a3d977', warn: '#ffc857', alert: '#e84855', muted: '#9c8f8a', info: '#c06cde', bar: ['█', '░'], icons: 'emoji' },
8  matrix: { name: 'matrix', accent: '#00ff41', good: '#00ff41', warn: '#c6ff00', alert: '#ff073a', muted: '#008f11', info: '#00d1a0', bar: ['█', '·'], icons: 'symbols' },
9  paper: { name: 'paper', accent: '#3b5bdb', good: '#2b8a3e', warn: '#e67700', alert: '#c92a2a', muted: '#868e96', info: '#7048e8', bar: ['▓', '░'], icons: 'symbols' },
10}
11
12export const THEME_NAMES = Object.keys(THEMES)
13export const DEFAULT_THEME = 'glitch'
14
15const COLOR = /^#[0-9a-fA-F]{6}$/
16const COLOR_TOKENS = ['accent', 'good', 'warn', 'alert', 'muted', 'info'] as const
17
18const copy = (t: Theme): Theme => ({ ...t, bar: [t.bar[0], t.bar[1]] })
19
20// A built-in theme with the `custom` JSON's tokens laid over it. Anything that
21// does not check out is skipped and named in `problems`; nothing throws.
22export function resolveTheme(name: string | undefined, custom: string | undefined): { theme: Theme; problems: string[] } {
23  const problems: string[] = []
24  let base = THEMES[DEFAULT_THEME] as Theme
25  if (name) {
26    const known = Object.hasOwn(THEMES, name) ? THEMES[name] : undefined
27    if (known) base = known
28    else problems.push(`unknown theme "${name}", using ${DEFAULT_THEME}`)
29  }
30  const theme = copy(base)
31  if (!custom || !custom.trim()) return { theme, problems }
32
33  let parsed: unknown
34  try {
35    parsed = JSON.parse(custom)
36  } catch {
37    problems.push('custom theme is not valid JSON, ignored')
38    return { theme, problems }
39  }
40  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
41    problems.push('custom theme must be a JSON object, ignored')
42    return { theme, problems }
43  }
44
45  const tokens = parsed as Record<string, unknown>
46  for (const key of COLOR_TOKENS) {
47    const value = tokens[key]
48    if (value === undefined) continue
49    if (typeof value === 'string' && COLOR.test(value)) theme[key] = value
50    else problems.push(`custom.${key} must be a #rrggbb color`)
51  }
52  if (tokens.bar !== undefined) {
53    const chars = typeof tokens.bar === 'string' ? [...tokens.bar] : []
54    if (chars.length === 2) theme.bar = [chars[0] as string, chars[1] as string]
55    else problems.push('custom.bar must be exactly two characters')
56  }
57  if (tokens.icons !== undefined) {
58    if (tokens.icons === 'emoji' || tokens.icons === 'symbols' || tokens.icons === 'ascii') theme.icons = tokens.icons
59    else problems.push('custom.icons must be emoji, symbols or ascii')
60  }
61  return { theme, problems }
62}
63

1export type ThemeIcons = 'emoji' | 'symbols' | 'ascii'
2
3export type Theme = {
4  name: string
5  accent: string
6  good: string
7  warn: string
8  alert: string
9  muted: string
10  info: string
11  /** Progress-bar characters: [filled, empty]. */
12  bar: [string, string]
13  icons: ThemeIcons
14}
15
16declare module 'claude-code' {
17  interface PluginState {
18    'glitch-core': { theme: Theme }
19  }
20}
21