@brimveyn/aimux-config 0.4.4 → 0.4.5

package/src/themes.ts

@@ -1,100 +1,30 @@
-import type {
-  NamedTheme,
-  NamedThemeDefinition,
-  Theme,
-  ThemeColorMap,
-  ThemeDefinition,
-  ThemeId,
-  UserThemeInput,
-} from './types'
+import type { AimuxTheme, ThemeId } from './types'
 
 import { HOUSE_THEME_IDS, HOUSE_THEMES } from './house-themes'
-import { normalizeTheme } from './normalize-theme'
-import { GENERATED_THEME_IDS, GENERATED_THEMES } from './themes/generated'
+import { OPENCODE_THEME_IDS, OPENCODE_THEMES } from './themes/opencode'
 
-export const THEMES: Record<string, Theme> = { ...GENERATED_THEMES, ...HOUSE_THEMES }
-export const THEME_IDS: ThemeId[] = [...GENERATED_THEME_IDS, ...HOUSE_THEME_IDS]
+export const THEMES: Record<string, AimuxTheme> = { ...HOUSE_THEMES, ...OPENCODE_THEMES }
+export const THEME_IDS: ThemeId[] = [...HOUSE_THEME_IDS, ...OPENCODE_THEME_IDS]
 
-const DEFAULT_THEME_ID: ThemeId = 'aimux'
+const DEFAULT_THEME_ID: ThemeId = 'aimux-dark'
 
-const LEGACY_THEME_ALIASES: Record<string, ThemeId> = {
-  'everforest': 'everforest-dark',
-  'gruvbox-dark': 'gruvbox-dark-hard',
-  'kanagawa': 'kanagawa-wave',
-  'one-dark': 'one-dark-pro',
-}
-
-export function migrateThemeId(id: string | undefined): ThemeId {
-  if (id !== undefined && id in THEMES) return id as ThemeId
-  if (id !== undefined) {
-    const alias = LEGACY_THEME_ALIASES[id]
-    if (alias !== undefined) return alias
-  }
-  return DEFAULT_THEME_ID
-}
-
-export function isKnownThemeId(id: string): boolean {
-  return id in THEMES
-}
-
-function isFullTheme(
-  def: NamedTheme | NamedThemeDefinition | UserThemeInput
-): def is NamedTheme | UserThemeInput {
-  return 'settings' in def || 'fg' in def || 'bg' in def
+const LEGACY_MODE_HINTS: Record<string, ThemeId> = {
+  'aimux': 'aimux-dark',
+  'aimux-dark': 'aimux-dark',
+  'aimux-light': 'aimux-light',
 }
 
 /**
- * Merge user-declared themes into the registry. Both the full and palette
- * shortcut paths run through `normalizeTheme` so every registered theme has
- * all AIMUX_COLOR_KEYS populated — same guarantees as shipped themes.
+ * Migrate a legacy persisted theme id (anything from the old wide registry)
+ * to the new light/dark identifier. Anything we don't recognize lands on the
+ * dark default — modes are the only knob now.
  */
-export function registerUserThemes(
-  defs: Record<string, NamedTheme | NamedThemeDefinition | UserThemeInput> | undefined
-): void {
-  if (!defs) return
-  const fallback = THEMES[DEFAULT_THEME_ID]
-  if (!fallback) return
-  for (const [id, def] of Object.entries(defs)) {
-    if (isFullTheme(def)) {
-      THEMES[id] = normalizeTheme({ ...def, name: def.name ?? id })
-    } else {
-      const base = def.base ? (THEMES[def.base] ?? fallback) : fallback
-      const colors: Record<string, string> = { ...base.colors }
-      for (const [k, v] of Object.entries(def.colors ?? {})) {
-        if (typeof v === 'string') colors[k] = v
-      }
-      THEMES[id] = normalizeTheme({
-        bg: base.bg,
-        colors,
-        displayName: def.name,
-        fg: base.fg,
-        name: id,
-        settings: base.settings,
-        type: base.type,
-      })
-    }
-    if (!THEME_IDS.includes(id)) THEME_IDS.push(id)
-  }
+export function migrateThemeId(id: string | undefined): ThemeId {
+  if (id === undefined) return DEFAULT_THEME_ID
+  if (id in THEMES) return id as ThemeId
+  return LEGACY_MODE_HINTS[id] ?? DEFAULT_THEME_ID
 }
 
-export const themes = {
-  /**
-   * Palette shortcut. Patches VSCode color keys on top of an existing theme;
-   * token settings inherit from the base unchanged.
-   */
-  define(name: string, base: ThemeId, overrides: Partial<ThemeColorMap>): NamedThemeDefinition {
-    return { base, colors: overrides, name }
-  },
-  /** Unnamed variant of `define`. Prefer `define` in config. */
-  extend(base: ThemeId, overrides: Partial<ThemeColorMap>): ThemeDefinition {
-    return { base, colors: overrides }
-  },
-  /**
-   * Passthrough for a raw Shiki / VSCode-shape theme. Missing
-   * `AIMUX_COLOR_KEYS` are filled at registration via the same fallback chain
-   * the shipped themes go through.
-   */
-  full(theme: UserThemeInput): UserThemeInput {
-    return theme
-  },
+export function isKnownThemeId(id: string): id is ThemeId {
+  return id in THEMES
 }

package/src/types.ts

@@ -257,6 +257,7 @@ export interface ModalSessionPicker extends ModalBase {
 }
 export interface ModalSessionName extends ModalBase {
   type: 'session-name'
+  returnToSessionPicker: boolean
 }
 export interface ModalRenameTab extends ModalBase {
   type: 'rename-tab'
@@ -357,7 +358,12 @@ export type ModalAction =
   | { type: 'open-help-modal'; scope?: ModeId }
   | { type: 'open-split-picker'; direction: SplitDirection }
   | { type: 'open-session-picker' }
-  | { type: 'open-session-name-modal'; sessionTargetId?: string; initialName?: string }
+  | {
+      type: 'open-session-name-modal'
+      sessionTargetId?: string
+      initialName?: string
+      returnToSessionPicker?: boolean
+    }
   | { type: 'close-modal' }
   | { type: 'move-modal-selection'; delta: number }
   | { type: 'update-command-edit'; char: string }
@@ -532,7 +538,7 @@ export type SideEffect =
   | { type: 'apply-theme'; action: 'confirm' }
   | { type: 'apply-theme'; action: 'preview'; delta: 1 | -1 }
   | { type: 'rename-session'; sessionId: string; name: string }
-  | { type: 'split-pane'; direction: SplitDirection }
+  | { type: 'split-pane'; direction: SplitDirection; sourceTabId?: string }
   | { type: 'confirm-split' }
   | { type: 'scroll-git-diff'; delta: number }
   | { type: 'persist-git-diff-mode-ratio'; ratio: number }
@@ -546,6 +552,7 @@ export type SideEffect =
   | { type: 'git-push' }
   | { type: 'confirm-update-selection' }
   | { type: 'switch-session-by-index'; index: number }
+  | { type: 'delete-session'; sessionId: string }
   | { type: 'toggle-transparent' }
 
 // ─── Key input / KeyResult / ModeContext ──────────────────────────────────────
@@ -571,138 +578,40 @@ export interface ModeContext {
 
 // ─── Themes ───────────────────────────────────────────────────────────────────
 
-import type { BundledTheme } from 'shiki'
-
-export type ThemeId = BundledTheme | (string & {})
-
 /**
- * VSCode workbench color keys aimux's UI depends on. The build-time normalizer
- * guarantees every `Theme` has all of these populated.
+ * Compact opencode-style semantic palette. Required tokens cover every UI role;
+ * optional tokens fall back via helpers in `palette-utils.ts`.
  */
-export const AIMUX_COLOR_KEYS = [
-  // editor
-  'editor.background',
-  'editor.foreground',
-  'editor.lineHighlightBackground',
-  'editor.selectionBackground',
-  'editorLineNumber.foreground',
-  'editorCursor.foreground',
-  // sidebar / panels
-  'sideBar.background',
-  'sideBar.foreground',
-  'sideBarSectionHeader.background',
-  'sideBarSectionHeader.foreground',
-  'editorGroupHeader.tabsBackground',
-  'editorWidget.background',
-  'panel.background',
-  'panel.border',
-  // borders & focus
-  'focusBorder',
-  'editorGroup.border',
-  'contrastBorder',
-  // lists
-  'list.activeSelectionBackground',
-  'list.activeSelectionForeground',
-  'list.hoverBackground',
-  // text & links
-  'foreground',
-  'descriptionForeground',
-  'textLink.foreground',
-  'textLink.activeForeground',
-  // status
-  'errorForeground',
-  'editorError.foreground',
-  'editorWarning.foreground',
-  // terminal ANSI
-  'terminal.ansiRed',
-  'terminal.ansiGreen',
-  'terminal.ansiYellow',
-  'terminal.ansiBlue',
-  'terminal.ansiMagenta',
-  'terminal.ansiCyan',
-  // git decorations
-  'gitDecoration.addedResourceForeground',
-  'gitDecoration.modifiedResourceForeground',
-  'gitDecoration.deletedResourceForeground',
-  'gitDecoration.untrackedResourceForeground',
-  // diff editor
-  'diffEditor.insertedLineBackground',
-  'diffEditor.removedLineBackground',
-  // input
-  'input.background',
-  'input.foreground',
-  'input.border',
-] as const
-
-export type AimuxColorKey = (typeof AIMUX_COLOR_KEYS)[number]
-
-export type ThemeColorMap = Record<AimuxColorKey, string> & Record<string, string>
-
-export interface ThemeSettings {
-  fontStyle?: string
-  foreground?: string
-  background?: string
-  // Some bundled shiki themes include non-standard keys (e.g. `content`); allow passthrough.
-  [key: string]: string | undefined
-}
-
-export interface ThemeTokenRule {
-  name?: string
-  scope?: string | string[]
-  // `foreground` at the top level is used by a handful of shiki themes as a
-  // shorthand for `settings.foreground` — accept both forms.
-  foreground?: string
-  settings?: ThemeSettings
-}
-
-export interface Theme {
+export interface AimuxPalette {
+  // required
+  neutral: string
+  ink: string
+  primary: string
+  success: string
+  warning: string
+  error: string
+  info: string
+  // optional
+  accent?: string
+  interactive?: string
+  diffAdd?: string
+  diffDelete?: string
+}
+
+export type ThemeMode = 'light' | 'dark'
+// eslint-disable-next-line typescript/no-redundant-type-constituents
+export type ThemeId = 'aimux-light' | 'aimux-dark' | (string & {})
+
+export interface AimuxTheme {
   name: string
+  mode: ThemeMode
   displayName: string
-  type: 'dark' | 'light'
+  palette: AimuxPalette
   fg: string
   bg: string
-  colors: ThemeColorMap
-  settings: ThemeTokenRule[]
-  tokenColors?: ThemeTokenRule[]
-  colorReplacements?: Record<string, string>
-  semanticHighlighting?: boolean
-  semanticTokenColors?: Record<
-    string,
-    | string
-    | {
-        foreground?: string
-        fontStyle?: string
-        bold?: boolean
-        italic?: boolean
-        underline?: boolean
-      }
-  >
-}
-
-/** Partial-override shape for `themes.define(name, base, overrides)`. */
-export interface ThemeDefinition {
-  base?: ThemeId
-  colors: Partial<ThemeColorMap>
-}
-
-export interface NamedThemeDefinition extends ThemeDefinition {
-  name: string
-}
-
-export interface NamedTheme extends Theme {
-  displayName: string
 }
 
-/**
- * Input shape accepted by `themes.full(...)` — lets users paste a shiki /
- * VSCode theme JSON without typing every AIMUX_COLOR_KEY. `registerUserThemes`
- * runs it through `normalizeTheme` to produce a complete `Theme`.
- */
-export interface UserThemeInput extends Partial<Omit<Theme, 'colors' | 'name' | 'displayName'>> {
-  name: string
-  displayName: string
-  colors?: Partial<ThemeColorMap> & Record<string, string | undefined>
-}
+export type Theme = AimuxTheme
 
 // ─── Backend config (stub) ────────────────────────────────────────────────────
 
@@ -816,9 +725,13 @@ export interface GitPanePaneConfig extends GitPaneBaseConfig {
 
 export type GitPaneConfig = GitPaneEmbeddedConfig | GitPanePaneConfig
 
+export interface AimuxThemeConfig {
+  mode?: ThemeMode
+  paletteOverrides?: Partial<AimuxPalette>
+}
+
 export interface AimuxUserConfig {
-  theme?: ThemeId
-  themes?: Record<string, NamedThemeDefinition | UserThemeInput>
+  theme?: AimuxThemeConfig
   keymaps?: (k: KeymapBuilderApi) => KeymapBuilderApi
   backends?: Record<string, BackendConfig>
   sidebar?: SidebarConfig
@@ -851,8 +764,7 @@ export interface ResolvedKeymapConfig {
 }
 
 export interface ResolvedConfig {
-  theme: ThemeId | undefined
-  themes: Record<string, NamedThemeDefinition | UserThemeInput>
+  theme: AimuxThemeConfig | undefined
   keymaps: ResolvedKeymapConfig
   backends: Record<string, BackendConfig>
   sidebar: SidebarConfig

package/src/normalize-theme.ts

@@ -1,260 +0,0 @@
-// Normalize a partial theme input into a full aimux `Theme` where every
-// AIMUX_COLOR_KEY is guaranteed to have a value. Used at build time by the
-// generator script and at runtime by registerUserThemes — same code path, same
-// guarantees.
-
-import {
-  AIMUX_COLOR_KEYS,
-  type AimuxColorKey,
-  type Theme,
-  type ThemeColorMap,
-  type ThemeTokenRule,
-} from './types'
-
-export interface NormalizeInput {
-  name: string
-  displayName?: string
-  type?: 'dark' | 'light'
-  fg?: string
-  bg?: string
-  colors?: Record<string, string | null | undefined>
-  settings?: ThemeTokenRule[]
-  tokenColors?: ThemeTokenRule[]
-  colorReplacements?: Record<string, string>
-  semanticHighlighting?: boolean
-  semanticTokenColors?: Theme['semanticTokenColors']
-}
-
-function stripAlpha(hex: string | null | undefined): string {
-  if (!hex || typeof hex !== 'string') return '#000000'
-  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): { r: number; g: number; b: 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)}`
-}
-
-export function shade(hex: string, amount: number): string {
-  const { b, g, r } = parseHex(hex)
-  const d = amount * 255
-  return toHex({ b: b + d, g: g + d, r: r + d })
-}
-
-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,
-  })
-}
-
-function first(map: Record<string, string | null | undefined>, keys: string[]): string | undefined {
-  for (const k of keys) {
-    const v = map[k]
-    if (v && typeof v === 'string') return stripAlpha(v)
-  }
-  return undefined
-}
-
-const FALLBACKS: Record<AimuxColorKey, string[]> = {
-  'contrastBorder': ['editorGroup.border'],
-  'descriptionForeground': ['editorLineNumber.foreground', 'foreground'],
-  'diffEditor.insertedLineBackground': [],
-  'diffEditor.removedLineBackground': [],
-  'editor.background': [],
-  'editor.foreground': [],
-  'editor.lineHighlightBackground': [],
-  'editor.selectionBackground': ['selection.background'],
-  'editorCursor.foreground': ['editor.foreground'],
-  'editorError.foreground': ['errorForeground', 'terminal.ansiRed'],
-  'editorGroup.border': ['contrastBorder', 'panel.border'],
-  'editorGroupHeader.tabsBackground': ['sideBar.background'],
-  'editorLineNumber.foreground': ['descriptionForeground'],
-  'editorWarning.foreground': ['terminal.ansiYellow'],
-  'editorWidget.background': ['sideBar.background', 'editor.background'],
-  'errorForeground': ['editorError.foreground', 'terminal.ansiRed'],
-  'focusBorder': ['textLink.foreground'],
-  'foreground': ['editor.foreground'],
-  'gitDecoration.addedResourceForeground': ['terminal.ansiGreen'],
-  'gitDecoration.deletedResourceForeground': ['terminal.ansiRed', 'editorError.foreground'],
-  'gitDecoration.modifiedResourceForeground': ['terminal.ansiYellow'],
-  'gitDecoration.untrackedResourceForeground': ['gitDecoration.addedResourceForeground'],
-  'input.background': ['editorWidget.background'],
-  'input.border': ['focusBorder', 'editorGroup.border'],
-  'input.foreground': ['editor.foreground'],
-  'list.activeSelectionBackground': ['editor.selectionBackground'],
-  'list.activeSelectionForeground': ['editor.foreground'],
-  'list.hoverBackground': ['list.activeSelectionBackground'],
-  'panel.background': ['editor.background'],
-  'panel.border': ['editorGroup.border', 'contrastBorder'],
-  'sideBar.background': ['editorGroupHeader.tabsBackground', 'panel.background'],
-  'sideBar.foreground': ['editor.foreground', 'foreground'],
-  'sideBarSectionHeader.background': ['sideBar.background'],
-  'sideBarSectionHeader.foreground': ['sideBar.foreground'],
-  'terminal.ansiBlue': ['textLink.foreground'],
-  'terminal.ansiCyan': [],
-  'terminal.ansiGreen': ['gitDecoration.addedResourceForeground'],
-  'terminal.ansiMagenta': [],
-  'terminal.ansiRed': ['editorError.foreground'],
-  'terminal.ansiYellow': ['editorWarning.foreground'],
-  'textLink.activeForeground': ['textLink.foreground'],
-  'textLink.foreground': ['editorLink.activeForeground', 'terminal.ansiBlue'],
-}
-
-function computeFallback(
-  key: AimuxColorKey,
-  bg: string,
-  fg: string,
-  resolved: ThemeColorMap
-): string {
-  switch (key) {
-    case 'editor.background':
-      return bg
-    case 'editor.foreground':
-      return fg
-    case 'editor.lineHighlightBackground':
-      return shade(bg, 0.03)
-    case 'editor.selectionBackground':
-      return shade(bg, 0.1)
-    case 'editorCursor.foreground':
-      return fg
-    case 'editorLineNumber.foreground':
-      return mix(fg, bg, 0.55)
-    case 'sideBar.background':
-      return shade(bg, -0.04)
-    case 'sideBar.foreground':
-      return fg
-    case 'sideBarSectionHeader.background':
-      return shade(bg, -0.02)
-    case 'sideBarSectionHeader.foreground':
-      return mix(fg, bg, 0.35)
-    case 'editorGroupHeader.tabsBackground':
-      return shade(bg, -0.04)
-    case 'editorWidget.background':
-      return shade(bg, -0.08)
-    case 'panel.background':
-      return bg
-    case 'panel.border':
-      return shade(bg, 0.15)
-    case 'focusBorder':
-      return resolved['textLink.foreground'] ?? fg
-    case 'editorGroup.border':
-      return shade(bg, 0.15)
-    case 'contrastBorder':
-      return shade(bg, 0.2)
-    case 'list.activeSelectionBackground':
-      return shade(bg, 0.1)
-    case 'list.activeSelectionForeground':
-      return fg
-    case 'list.hoverBackground':
-      return shade(bg, 0.05)
-    case 'foreground':
-      return fg
-    case 'descriptionForeground':
-      return mix(fg, bg, 0.55)
-    case 'textLink.foreground':
-    case 'textLink.activeForeground':
-      return resolved['terminal.ansiBlue'] ?? fg
-    case 'errorForeground':
-    case 'editorError.foreground':
-      return '#f38ba8'
-    case 'editorWarning.foreground':
-      return '#f6c177'
-    case 'terminal.ansiRed':
-      return '#f38ba8'
-    case 'terminal.ansiGreen':
-      return '#8bd5ca'
-    case 'terminal.ansiYellow':
-      return '#f6c177'
-    case 'terminal.ansiBlue':
-      return '#7cd1b8'
-    case 'terminal.ansiMagenta':
-      return resolved['textLink.activeForeground'] ?? '#c4a7e7'
-    case 'terminal.ansiCyan':
-      return resolved['terminal.ansiBlue'] ?? '#89dceb'
-    case 'gitDecoration.addedResourceForeground':
-      return resolved['terminal.ansiGreen'] ?? '#8bd5ca'
-    case 'gitDecoration.modifiedResourceForeground':
-      return resolved['terminal.ansiYellow'] ?? '#f6c177'
-    case 'gitDecoration.deletedResourceForeground':
-      return resolved['terminal.ansiRed'] ?? '#f38ba8'
-    case 'gitDecoration.untrackedResourceForeground':
-      return resolved['gitDecoration.addedResourceForeground'] ?? '#8bd5ca'
-    case 'diffEditor.insertedLineBackground':
-      return mix(bg, resolved['gitDecoration.addedResourceForeground'] ?? '#8bd5ca', 0.18)
-    case 'diffEditor.removedLineBackground':
-      return mix(bg, resolved['gitDecoration.deletedResourceForeground'] ?? '#f38ba8', 0.18)
-    case 'input.background':
-      return shade(bg, -0.04)
-    case 'input.foreground':
-      return fg
-    case 'input.border':
-      return shade(bg, 0.15)
-    default:
-      return fg
-  }
-}
-
-export function normalizeTheme(raw: NormalizeInput): Theme {
-  const srcColors = raw.colors ?? {}
-  const bg = stripAlpha(srcColors['editor.background'] ?? raw.bg ?? '#000000')
-  const fg = stripAlpha(srcColors['editor.foreground'] ?? raw.fg ?? '#ffffff')
-
-  const resolved: ThemeColorMap = {} as ThemeColorMap
-  for (const key of AIMUX_COLOR_KEYS) {
-    const direct = srcColors[key]
-    if (direct && typeof direct === 'string') {
-      resolved[key] = stripAlpha(direct)
-      continue
-    }
-    const alt = first(srcColors, FALLBACKS[key])
-    if (alt) resolved[key] = alt
-  }
-  for (const key of AIMUX_COLOR_KEYS) {
-    if (!resolved[key]) resolved[key] = computeFallback(key, bg, fg, resolved)
-  }
-  for (const [k, v] of Object.entries(srcColors)) {
-    if (!resolved[k] && v && typeof v === 'string') resolved[k] = stripAlpha(v)
-  }
-
-  const out: Theme = {
-    bg,
-    colors: resolved,
-    displayName: raw.displayName ?? raw.name,
-    fg,
-    name: raw.name,
-    settings: raw.settings ?? [],
-    type: raw.type ?? 'dark',
-  }
-  if (raw.colorReplacements && Object.keys(raw.colorReplacements).length > 0) {
-    out.colorReplacements = raw.colorReplacements
-  }
-  if (raw.semanticHighlighting) out.semanticHighlighting = raw.semanticHighlighting
-  if (raw.semanticTokenColors && Object.keys(raw.semanticTokenColors).length > 0) {
-    out.semanticTokenColors = raw.semanticTokenColors
-  }
-  if (raw.tokenColors && raw.tokenColors !== raw.settings) out.tokenColors = raw.tokenColors
-  return out
-}