@brimveyn/aimux-config 0.5.3 → 0.5.6

package/src/house-themes.ts

@@ -1,55 +0,0 @@
-// Hand-curated aimux house palettes. The opencode-style semantic palette
-// drives both UI chrome and the runtime-generated Shiki theme — see
-// `palette-to-shiki.ts`.
-/* eslint-disable perfectionist/sort-objects */
-
-import type { AimuxPalette, AimuxTheme } from './types'
-
-const AIMUX_DARK_PALETTE: AimuxPalette = {
-  neutral: '#11151b',
-  ink: '#edf4ff',
-  primary: '#7cd1b8',
-  success: '#8bd5ca',
-  warning: '#f6c177',
-  error: '#f38ba8',
-  info: '#7cb3ff',
-  accent: '#c4a7e7',
-  interactive: '#1f3344',
-  diffAdd: '#1e3d2b',
-  diffDelete: '#3b1e27',
-}
-
-const AIMUX_LIGHT_PALETTE: AimuxPalette = {
-  neutral: '#f7f9fc',
-  ink: '#11151b',
-  primary: '#1f8a72',
-  success: '#2e9a83',
-  warning: '#b8770f',
-  error: '#c43b58',
-  info: '#2e6cc1',
-  accent: '#7d57b8',
-  interactive: '#dbe6f0',
-  diffAdd: '#d4ebd9',
-  diffDelete: '#f0d6dc',
-}
-
-export const HOUSE_THEMES: Record<string, AimuxTheme> = {
-  'aimux-dark': {
-    name: 'aimux',
-    mode: 'dark',
-    displayName: 'Aimux Dark',
-    palette: AIMUX_DARK_PALETTE,
-    fg: AIMUX_DARK_PALETTE.ink,
-    bg: AIMUX_DARK_PALETTE.neutral,
-  },
-  'aimux-light': {
-    name: 'aimux',
-    mode: 'light',
-    displayName: 'Aimux Light',
-    palette: AIMUX_LIGHT_PALETTE,
-    fg: AIMUX_LIGHT_PALETTE.ink,
-    bg: AIMUX_LIGHT_PALETTE.neutral,
-  },
-}
-
-export const HOUSE_THEME_IDS: string[] = ['aimux-dark', 'aimux-light']

package/src/neutral-scale.ts

@@ -1,75 +0,0 @@
-// Port (minimal) of sst/opencode's generateNeutralScale + generateNeutralAlphaScale
-// from packages/ui/src/theme/resolve.ts. Only the `ink`-provided branch of
-// generateNeutralScale is needed — every aimux theme supplies an `ink` seed.
-
-import { blend, hexToOklch, mixColors, oklchToHex } from './oklch'
-
-function clamp(v: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, v))
-}
-
-export type NeutralScale = readonly [
-  string,
-  string,
-  string,
-  string,
-  string,
-  string,
-  string,
-  string,
-  string,
-  string,
-  string,
-  string,
-]
-
-function pickDarkBg(base: { c: number; h: number; l: number }): string {
-  const tone = clamp(0.19 + Math.max(0, base.l - 0.12) * 0.33 + base.c * 1.95, 0.17, 0.27)
-  return oklchToHex({
-    c: base.c * Math.max(0, 1 - tone * 0.12),
-    h: base.h,
-    l: base.l * (1 - tone),
-  })
-}
-
-function pickLightBg(base: { c: number; h: number; l: number }): string {
-  const tone =
-    base.l < 0.82 ? 0.86 : clamp(0.1 + base.c * 3.2 + Math.max(0, 0.95 - base.l) * 0.35, 0.1, 0.28)
-  return oklchToHex({
-    c: base.c * Math.max(0, 1 - tone),
-    h: base.h,
-    l: base.l + (1 - base.l) * tone,
-  })
-}
-
-/**
- * Produce a 12-step neutral scale from a palette seed.
- *
- * Step 0 is the effective app background (`palette.neutral` is treated as a
- * seed, not a direct hex). Step 11 lands close to `ink`. Intermediate steps
- * mix the computed bg toward ink using opencode's fixed lightness stops.
- */
-export function generateNeutralScale(seed: string, isDark: boolean, ink: string): NeutralScale {
-  const base = hexToOklch(seed)
-  const bg = isDark ? pickDarkBg(base) : pickLightBg(base)
-
-  const steps = isDark
-    ? [0, 0.018, 0.039, 0.064, 0.097, 0.143, 0.212, 0.31, 0.46, 0.649, 0.845, 0.984]
-    : [0, 0.022, 0.042, 0.068, 0.102, 0.146, 0.208, 0.296, 0.432, 0.61, 0.81, 0.965]
-
-  return steps.map((step) => mixColors(bg, ink, step)) as unknown as NeutralScale
-}
-
-/**
- * 12-step alpha overlay scale blending ink → bg. Used for surface-base /
- * surface-hover / border-base tokens so they stay consistent with the
- * computed bg above.
- */
-export function generateNeutralAlphaScale(neutral: NeutralScale, isDark: boolean): NeutralScale {
-  const alphas = isDark
-    ? [0.038, 0.066, 0.1, 0.142, 0.19, 0.252, 0.334, 0.446, 0.58, 0.718, 0.854, 0.985]
-    : [0.03, 0.06, 0.1, 0.145, 0.2, 0.265, 0.35, 0.47, 0.61, 0.74, 0.86, 0.97]
-  const ink = neutral[11]
-  const bg = neutral[0]
-  return alphas.map((alpha) => blend(ink, bg, alpha)) as unknown as NeutralScale
-}

package/src/oklch.ts

@@ -1,164 +0,0 @@
-// OKLCH color helpers. Ported (and trimmed) from sst/opencode:
-// packages/ui/src/theme/color.ts — used by neutral-scale.ts to derive
-// aimux surface tokens from a palette seed.
-
-export interface OklchColor {
-  l: number
-  c: number
-  h: number
-}
-
-function clamp(v: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, v))
-}
-
-function hue(v: number): number {
-  return ((v % 360) + 360) % 360
-}
-
-export function hexToRgb(hex: string): { r: number; g: number; b: number } {
-  const h = hex.replace('#', '')
-  const full =
-    h.length === 3 || h.length === 4
-      ? h
-          .split('')
-          .map((c) => c + c)
-          .join('')
-      : h
-  const rgb = full.length === 8 ? full.slice(0, 6) : full
-  const num = parseInt(rgb, 16)
-  return {
-    b: (num & 255) / 255,
-    g: ((num >> 8) & 255) / 255,
-    r: ((num >> 16) & 255) / 255,
-  }
-}
-
-export function rgbToHex(r: number, g: number, b: number): string {
-  const toHex = (v: number): string => {
-    const clamped = clamp(v, 0, 1)
-    const int = Math.round(clamped * 255)
-    return int.toString(16).padStart(2, '0')
-  }
-  return `#${toHex(r)}${toHex(g)}${toHex(b)}`
-}
-
-function srgbToLinear(c: number): number {
-  if (c <= 0.04045) return c / 12.92
-  return Math.pow((c + 0.055) / 1.055, 2.4)
-}
-
-function linearToSrgb(c: number): number {
-  if (c <= 0.0031308) return c * 12.92
-  return 1.055 * Math.pow(c, 1 / 2.4) - 0.055
-}
-
-export function rgbToOklch(r: number, g: number, b: number): OklchColor {
-  const lr = srgbToLinear(r)
-  const lg = srgbToLinear(g)
-  const lb = srgbToLinear(b)
-
-  const lLong = 0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb
-  const mLong = 0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb
-  const sLong = 0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb
-
-  const lCbrt = Math.cbrt(lLong)
-  const mCbrt = Math.cbrt(mLong)
-  const sCbrt = Math.cbrt(sLong)
-
-  const L = 0.2104542553 * lCbrt + 0.793617785 * mCbrt - 0.0040720468 * sCbrt
-  const a = 1.9779984951 * lCbrt - 2.428592205 * mCbrt + 0.4505937099 * sCbrt
-  const bOk = 0.0259040371 * lCbrt + 0.7827717662 * mCbrt - 0.808675766 * sCbrt
-
-  const C = Math.sqrt(a * a + bOk * bOk)
-  let H = Math.atan2(bOk, a) * (180 / Math.PI)
-  if (H < 0) H += 360
-
-  return { c: C, h: H, l: L }
-}
-
-export function oklchToRgb(ok: OklchColor): { r: number; g: number; b: number } {
-  const { c: C, h: H, l: L } = ok
-  const a = C * Math.cos((H * Math.PI) / 180)
-  const b = C * Math.sin((H * Math.PI) / 180)
-
-  const lLin = L + 0.3963377774 * a + 0.2158037573 * b
-  const mLin = L - 0.1055613458 * a - 0.0638541728 * b
-  const sLin = L - 0.0894841775 * a - 1.291485548 * b
-
-  const l3 = lLin * lLin * lLin
-  const m3 = mLin * mLin * mLin
-  const s3 = sLin * sLin * sLin
-
-  const lr = 4.0767416621 * l3 - 3.3077115913 * m3 + 0.2309699292 * s3
-  const lg = -1.2684380046 * l3 + 2.6097574011 * m3 - 0.3413193965 * s3
-  const lb = -0.0041960863 * l3 - 0.7034186147 * m3 + 1.707614701 * s3
-
-  return { b: linearToSrgb(lb), g: linearToSrgb(lg), r: linearToSrgb(lr) }
-}
-
-export function hexToOklch(hex: string): OklchColor {
-  const { b, g, r } = hexToRgb(hex)
-  return rgbToOklch(r, g, b)
-}
-
-// Pull an out-of-gamut OKLCH into sRGB by shrinking chroma.
-export function fitOklch(ok: OklchColor): OklchColor {
-  const base: OklchColor = {
-    c: Math.max(0, ok.c),
-    h: hue(ok.h),
-    l: clamp(ok.l, 0, 1),
-  }
-  const rgb = oklchToRgb(base)
-  if (rgb.r >= 0 && rgb.r <= 1 && rgb.g >= 0 && rgb.g <= 1 && rgb.b >= 0 && rgb.b <= 1) {
-    return base
-  }
-  let c = base.c
-  for (let i = 0; i < 24; i++) {
-    c *= 0.9
-    const next: OklchColor = { ...base, c }
-    const out = oklchToRgb(next)
-    if (out.r >= 0 && out.r <= 1 && out.g >= 0 && out.g <= 1 && out.b >= 0 && out.b <= 1) {
-      return next
-    }
-  }
-  return { ...base, c: 0 }
-}
-
-export function oklchToHex(ok: OklchColor): string {
-  const { b, g, r } = oklchToRgb(fitOklch(ok))
-  return rgbToHex(r, g, b)
-}
-
-/** OKLCH-space mix. t=0 returns `a`, t=1 returns `b`. Uses shortest hue arc. */
-export function mixColors(a: string, b: string, t: number): string {
-  const ca = hexToOklch(a)
-  const cb = hexToOklch(b)
-  const delta = ((((cb.h - ca.h) % 360) + 540) % 360) - 180
-  return oklchToHex({
-    c: ca.c + (cb.c - ca.c) * t,
-    h: ca.h + delta * t,
-    l: ca.l + (cb.l - ca.l) * t,
-  })
-}
-
-/** OKLCH shift: additive L, multiplicative C, additive H (degrees). */
-export function shift(color: string, value: { l?: number; c?: number; h?: number }): string {
-  const base = hexToOklch(color)
-  return oklchToHex({
-    c: base.c * (value.c ?? 1),
-    h: base.h + (value.h ?? 0),
-    l: base.l + (value.l ?? 0),
-  })
-}
-
-/** sRGB alpha blend: `color` over `background` at `alpha` opacity. */
-export function blend(color: string, background: string, alpha: number): string {
-  const fg = hexToRgb(color)
-  const bg = hexToRgb(background)
-  return rgbToHex(
-    fg.r * alpha + bg.r * (1 - alpha),
-    fg.g * alpha + bg.g * (1 - alpha),
-    fg.b * alpha + bg.b * (1 - alpha)
-  )
-}

package/src/palette-to-shiki.ts

@@ -1,134 +0,0 @@
-// Build a Shiki ThemeRegistrationRaw from an AimuxPalette. The same palette
-// powers the UI chrome and the diff syntax highlighter — there's no static
-// theme JSON, so light/dark/overrides stay coherent automatically.
-
-import type { ThemeRegistrationRaw } from 'shiki'
-
-import type { AimuxPalette, ThemeMode } from './types'
-
-import { accent as accentOf, muted } from './palette-utils'
-
-export interface PaletteToShikiOptions {
-  name: string
-  mode: ThemeMode
-  palette: AimuxPalette
-}
-
-export function paletteToShikiTheme(opts: PaletteToShikiOptions): ThemeRegistrationRaw {
-  const { mode, name, palette: p } = opts
-  const m = muted(p)
-  const a = accentOf(p)
-
-  return {
-    bg: p.neutral,
-    colors: {
-      'editor.background': p.neutral,
-      'editor.foreground': p.ink,
-    },
-    fg: p.ink,
-    name,
-    settings: [
-      { settings: { background: p.neutral, foreground: p.ink } },
-      {
-        scope: ['comment', 'punctuation.definition.comment'],
-        settings: { fontStyle: 'italic', foreground: m },
-      },
-      { scope: ['comment.documentation'], settings: { fontStyle: 'italic', foreground: m } },
-      {
-        scope: ['string', 'string.quoted', 'string.template'],
-        settings: { foreground: p.warning },
-      },
-      {
-        scope: ['string.regexp', 'string.escape', 'constant.character.escape'],
-        settings: { foreground: a },
-      },
-      {
-        scope: [
-          'constant.numeric',
-          'constant.language',
-          'constant.language.boolean',
-          'constant.character',
-          'constant.other',
-          'support.constant',
-        ],
-        settings: { foreground: p.error },
-      },
-      {
-        scope: ['keyword', 'keyword.control', 'keyword.operator.new', 'keyword.other'],
-        settings: { fontStyle: 'bold', foreground: a },
-      },
-      {
-        scope: ['storage', 'storage.type', 'storage.modifier'],
-        settings: { fontStyle: 'bold', foreground: a },
-      },
-      {
-        scope: ['keyword.operator', 'punctuation', 'meta.brace', 'punctuation.separator'],
-        settings: { foreground: m },
-      },
-      {
-        scope: [
-          'entity.name.function',
-          'support.function',
-          'meta.function-call',
-          'entity.name.function.member',
-        ],
-        settings: { foreground: p.success },
-      },
-      {
-        scope: [
-          'entity.name.type',
-          'support.type',
-          'support.class',
-          'entity.name.class',
-          'entity.name.interface',
-          'entity.name.namespace',
-          'entity.name.type.enum',
-          'entity.name.type.alias',
-          'entity.name.tag.jsx',
-          'support.class.component',
-        ],
-        settings: { fontStyle: 'italic', foreground: p.primary },
-      },
-      { scope: ['variable', 'meta.variable'], settings: { foreground: p.ink } },
-      {
-        scope: ['variable.parameter', 'meta.function.parameters'],
-        settings: { fontStyle: 'italic', foreground: p.ink },
-      },
-      {
-        scope: ['variable.other.property', 'variable.other.member', 'meta.object-literal.key'],
-        settings: { foreground: p.primary },
-      },
-      {
-        scope: ['variable.language', 'variable.language.this'],
-        settings: { fontStyle: 'italic', foreground: p.error },
-      },
-      { scope: ['entity.name.tag', 'meta.tag'], settings: { foreground: p.error } },
-      {
-        scope: ['entity.other.attribute-name'],
-        settings: { fontStyle: 'italic', foreground: p.warning },
-      },
-      // Markdown
-      { scope: ['markup.heading'], settings: { fontStyle: 'bold', foreground: p.primary } },
-      { scope: ['markup.bold'], settings: { fontStyle: 'bold', foreground: p.ink } },
-      { scope: ['markup.italic'], settings: { fontStyle: 'italic', foreground: p.ink } },
-      {
-        scope: ['markup.underline.link', 'markup.inline.raw', 'markup.raw'],
-        settings: { foreground: p.success },
-      },
-      { scope: ['markup.list'], settings: { foreground: a } },
-      { scope: ['markup.quote'], settings: { fontStyle: 'italic', foreground: m } },
-      // Diff
-      {
-        scope: ['markup.inserted', 'meta.diff.header.to-file'],
-        settings: { foreground: p.success },
-      },
-      {
-        scope: ['markup.deleted', 'meta.diff.header.from-file'],
-        settings: { foreground: p.error },
-      },
-      { scope: ['markup.changed'], settings: { foreground: p.warning } },
-      { scope: ['meta.diff.range'], settings: { foreground: a } },
-    ],
-    type: mode,
-  }
-}

package/src/palette-utils.ts

@@ -1,130 +0,0 @@
-import type { AimuxPalette, ThemeMode } from './types'
-
-import { generateNeutralAlphaScale, generateNeutralScale } from './neutral-scale'
-import { blend } from './oklch'
-
-function stripAlpha(hex: string): string {
-  if (hex.length === 9) return hex.slice(0, 7)
-  if (hex.length === 5) return hex.slice(0, 4)
-  return hex
-}
-
-function expand3(hex: string): string {
-  if (hex.length === 4) return `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}`
-  return hex
-}
-
-function parseHex(hex: string): { b: number; g: number; r: number } {
-  const clean = expand3(stripAlpha(hex))
-  return {
-    b: parseInt(clean.slice(5, 7), 16),
-    g: parseInt(clean.slice(3, 5), 16),
-    r: parseInt(clean.slice(1, 3), 16),
-  }
-}
-
-function toHex({ b, g, r }: { b: number; g: number; r: number }): string {
-  const clamp = (n: number): number => Math.max(0, Math.min(255, Math.round(n)))
-  const h = (n: number): string => clamp(n).toString(16).padStart(2, '0')
-  return `#${h(r)}${h(g)}${h(b)}`
-}
-
-/** Linearly mix two hex colors. `t=0` returns `a`, `t=1` returns `b`. */
-export function mix(a: string, b: string, t: number): string {
-  const ca = parseHex(a)
-  const cb = parseHex(b)
-  return toHex({
-    b: ca.b + (cb.b - ca.b) * t,
-    g: ca.g + (cb.g - ca.g) * t,
-    r: ca.r + (cb.r - ca.r) * t,
-  })
-}
-
-/** Muted foreground — half-way between background and ink. */
-export function muted(p: AimuxPalette): string {
-  return mix(p.neutral, p.ink, 0.55)
-}
-
-/** Slightly recessed foreground for line numbers / placeholders. */
-export function faint(p: AimuxPalette): string {
-  return mix(p.neutral, p.ink, 0.3)
-}
-
-/** A surface tone above the base background — sidebars, headers. */
-export function elevated(p: AimuxPalette): string {
-  return mix(p.neutral, p.ink, 0.04)
-}
-
-/** Hover/highlight surface (line highlight, list hover). */
-export function hover(p: AimuxPalette): string {
-  return mix(p.neutral, p.ink, 0.08)
-}
-
-/** Selected/active row surface. Falls back to a primary-tinted shade. */
-export function selected(p: AimuxPalette): string {
-  return p.interactive ?? mix(p.neutral, p.primary, 0.18)
-}
-
-/** Subtle border between panels. */
-export function border(p: AimuxPalette): string {
-  return mix(p.neutral, p.ink, 0.18)
-}
-
-/** Background tint for inserted diff lines. */
-export function diffAddBg(p: AimuxPalette): string {
-  return p.diffAdd ?? mix(p.neutral, p.success, 0.18)
-}
-
-/** Background tint for removed diff lines. */
-export function diffDeleteBg(p: AimuxPalette): string {
-  return p.diffDelete ?? mix(p.neutral, p.error, 0.18)
-}
-
-/** Resolve `accent`, falling back to `primary`. */
-export function accent(p: AimuxPalette): string {
-  return p.accent ?? p.primary
-}
-
-/** Merge a partial palette onto a base palette. */
-export function extendPalette(
-  base: AimuxPalette,
-  overrides: Partial<AimuxPalette> | undefined
-): AimuxPalette {
-  if (!overrides) return base
-  return { ...base, ...overrides }
-}
-
-/**
- * Resolved surface colors derived from the OKLCH neutral scale. Prefer this
- * over the standalone `muted`/`faint`/`elevated`/… helpers for runtime UI —
- * those still exist for syntax-theme generation and callers that can't
- * provide a mode.
- */
-export interface ResolvedSurfaces {
-  bg: string
-  border: string
-  elevated: string
-  faint: string
-  hover: string
-  muted: string
-  selected: string
-}
-
-/** Compute surface tokens for a palette in a given mode. */
-export function computeSurfaces(palette: AimuxPalette, mode: ThemeMode): ResolvedSurfaces {
-  const isDark = mode === 'dark'
-  const neutral = generateNeutralScale(palette.neutral, isDark, palette.ink)
-  const alpha = generateNeutralAlphaScale(neutral, isDark)
-  // `selected` is a subtle primary-tinted surface, not the raw `palette.interactive`
-  // seed. In opencode themes `interactive` seeds an OKLCH scale we don't port;
-  // using it raw produces eye-bleeding accents (e.g. carbonfox `#0f62fe`).
-  return {
-    bg: neutral[0],
-    border: alpha[6],
-    elevated: alpha[1],
-    faint: neutral[7],
-    hover: alpha[2],
-    muted: neutral[8],
-    selected: blend(palette.primary, neutral[0], 0.18),
-  }
-}