@brimveyn/aimux-config 0.5.3 → 0.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux-config",
-  "version": "0.5.3",
+  "version": "0.5.6",
   "description": "TypeScript configuration API for aimux — keymaps, themes, and backends with a fluent builder.",
   "keywords": [
     "aimux",

package/src/actions.ts

@@ -547,6 +547,64 @@ export const gitDestructiveSelected: ActionFn = (ctx: ModeContext) => {
   return r([{ path: file.path, type: 'git-mode-set-pending-delete' }])
 }
 
+export const gitToggleFoldAll: ActionFn = (ctx: ModeContext) => {
+  const file = selectedGitFile(ctx)
+  if (!file) return r([])
+  const key = gitFileKey(file.section, file.path)
+  return r([{ key, type: 'git-mode-fold-toggle-all' }])
+}
+
+export const gitStageAll: ActionFn = (ctx: ModeContext) => {
+  if (ctx.state.gitMode.headOffset > 0) {
+    return r([
+      {
+        message: 'disabled while viewing HEAD~N (press 0 or [ to return)',
+        type: 'git-mode-set-message',
+      },
+    ])
+  }
+  const files = ctx.state.gitPanel.files
+  const pending = clearPendingDelete(ctx)
+  if (files.length === 0) return r(pending)
+  const actions: AppAction[] = [...pending]
+  for (const f of files) {
+    if (f.section === 'staged') continue
+    actions.push({
+      fromSection: f.section,
+      path: f.path,
+      toSection: 'staged',
+      type: 'git-mode-optimistic-move',
+    })
+  }
+  return r(actions, [{ type: 'git-stage-all' }])
+}
+
+export const gitUnstageAll: ActionFn = (ctx: ModeContext) => {
+  if (ctx.state.gitMode.headOffset > 0) {
+    return r([
+      {
+        message: 'disabled while viewing HEAD~N (press 0 or [ to return)',
+        type: 'git-mode-set-message',
+      },
+    ])
+  }
+  const files = ctx.state.gitPanel.files
+  const pending = clearPendingDelete(ctx)
+  if (files.length === 0) return r(pending)
+  const actions: AppAction[] = [...pending]
+  for (const f of files) {
+    if (f.section !== 'staged') continue
+    const toSection = f.status === 'A' ? 'untracked' : 'unstaged'
+    actions.push({
+      fromSection: 'staged',
+      path: f.path,
+      toSection,
+      type: 'git-mode-optimistic-move',
+    })
+  }
+  return r(actions, [{ type: 'git-unstage-all' }])
+}
+
 export const gitCommitOpen: ActionFn = (ctx: ModeContext) => {
   if (ctx.state.gitMode.headOffset > 0) {
     return r([

package/src/defaults.ts

@@ -98,7 +98,10 @@ export function getDefaultKeymapConfig(): ResolvedKeymapConfig {
     .mode('git-mode', (m) =>
       m
         .map('a', actions.gitStageSelected, 'Stage')
+        .map('A', actions.gitStageAll, 'Stage all')
         .map('d', actions.gitDestructiveSelected, 'Unstage/delete')
+        .map('D', actions.gitUnstageAll, 'Unstage all')
+        .map('e', actions.gitToggleFoldAll, 'Expand/collapse all folds')
         .map('c', actions.gitCommitOpen, 'Commit')
         .map('p', actions.gitPush, 'Push')
         .map('v', actions.toggleGitDiffView, 'Toggle split/stacked')

package/src/index.ts

@@ -1,26 +1,27 @@
-// Public API — this is what users import from '@brimveyn/aimux-config'
+// Public API — what users import from '@brimveyn/aimux-config'.
 
 export { defineConfig } from './define-config'
 export * as actions from './actions'
-export { isKnownThemeId, migrateThemeId, THEME_IDS, THEMES } from './themes'
-export { HOUSE_THEME_IDS, HOUSE_THEMES } from './house-themes'
-export { OPENCODE_THEME_IDS, OPENCODE_THEMES } from './themes/opencode'
+
+// TUI theme system (1:1 port of opencode TUI).
 export {
-  accent,
-  border,
-  computeSurfaces,
-  diffAddBg,
-  diffDeleteBg,
-  elevated,
-  extendPalette,
-  faint,
-  hover,
-  mix,
-  muted,
-  selected,
-} from './palette-utils'
-export type { ResolvedSurfaces } from './palette-utils'
-export { paletteToShikiTheme } from './palette-to-shiki'
+  isKnownThemeId,
+  migrateThemeId,
+  type ResolvedTuiTheme,
+  resolveTuiTheme,
+  type RGBA,
+  THEME_IDS,
+  type ThemeId,
+  type ThemeMode,
+  TUI_COLOR_TOKENS,
+  TUI_THEMES,
+  type TuiColorToken,
+  type TuiColorValue,
+  type TuiShikiOptions,
+  type TuiThemeJson,
+  tuiThemeToShiki,
+} from './tui'
+
 export { GroupBuilder, KeymapBuilder, ModeBindingBuilder } from './keymap-builder'
 export { getDefaultKeymapConfig } from './defaults'
 export { resolveConfig } from './resolver'
@@ -28,15 +29,11 @@ export { isAutoCommitEnabled, setAutoCommitEnabled } from './auto-commit-runtime
 export { getMultiRepoConfig, setMultiRepoConfig } from './multi-repo-runtime'
 export { DEFAULT_MULTI_REPO_CONFIG } from './defaults'
 
-// Type exports
+// User-facing config types (keymap/backends/sessions/etc.).
 export type {
-  // Action types
   Action,
   ActionFn,
-  AimuxPalette,
-  AimuxTheme,
   AimuxThemeConfig,
-  // User-facing config
   AimuxUserConfig,
   AIUsageTool,
   AIUsageToolConfig,
@@ -57,20 +54,16 @@ export type {
   GroupBuilderApi,
   HooksConfig,
   KeyInput,
-  // Keymap builder API (type surface)
   KeymapBuilderApi,
   KeyResult,
-  // Layout
   LayoutNode,
   ModalState,
   ModeBindingBuilderApi,
   ModeContext,
-  // Mode / state
   ModeId,
   ModeKeymapDef,
   MultiRepoConfig,
   MultiRepoState,
-  // Resolved config (internal, but exported for tooling)
   ResolvedConfig,
   ResolvedKeymapConfig,
   SessionRecord,
@@ -81,7 +74,4 @@ export type {
   SplitDirection,
   StatusBarConfig,
   TabSession,
-  Theme,
-  ThemeId,
-  ThemeMode,
 } from './types'

package/src/resolver.ts

@@ -51,8 +51,8 @@ export function resolveConfig(userConfig: AimuxUserConfig): ResolvedConfig {
 function resolveTheme(userConfig: AimuxUserConfig['theme']): ResolvedConfig['theme'] {
   if (!userConfig) return undefined
   return {
+    initialId: userConfig.initialId,
     initialMode: userConfig.initialMode ?? userConfig.mode,
-    paletteOverrides: userConfig.paletteOverrides,
   }
 }
 

package/src/tui/index.ts

@@ -0,0 +1,5 @@
+export { isKnownThemeId, migrateThemeId, THEME_IDS, type ThemeId, TUI_THEMES } from './registry'
+export { resolveTuiTheme } from './resolve'
+export { type TuiShikiOptions, tuiThemeToShiki } from './shiki'
+export { TUI_COLOR_TOKENS, type TuiColorToken } from './tokens'
+export type { ResolvedTuiTheme, RGBA, ThemeMode, TuiColorValue, TuiThemeJson } from './types'

package/src/tui/registry.ts

@@ -0,0 +1,95 @@
+// Static registry of every TUI theme JSON shipped with aimux. Generated by
+// hand: re-run after `bun scripts/import-opencode-tui-themes.ts` if upstream
+// adds/removes themes.
+
+import type { TuiThemeJson } from './types'
+
+import aimux from './themes/aimux.json'
+import aura from './themes/aura.json'
+import ayu from './themes/ayu.json'
+import carbonfox from './themes/carbonfox.json'
+import catppuccinFrappe from './themes/catppuccin-frappe.json'
+import catppuccinMacchiato from './themes/catppuccin-macchiato.json'
+import catppuccin from './themes/catppuccin.json'
+import cobalt2 from './themes/cobalt2.json'
+import cursor from './themes/cursor.json'
+import dracula from './themes/dracula.json'
+import everforest from './themes/everforest.json'
+import flexoki from './themes/flexoki.json'
+import github from './themes/github.json'
+import gruvbox from './themes/gruvbox.json'
+import kanagawa from './themes/kanagawa.json'
+import lucentOrng from './themes/lucent-orng.json'
+import material from './themes/material.json'
+import matrix from './themes/matrix.json'
+import mercury from './themes/mercury.json'
+import monokai from './themes/monokai.json'
+import nightowl from './themes/nightowl.json'
+import nord from './themes/nord.json'
+import oneDark from './themes/one-dark.json'
+import opencode from './themes/opencode.json'
+import orng from './themes/orng.json'
+import osakaJade from './themes/osaka-jade.json'
+import palenight from './themes/palenight.json'
+import rosepine from './themes/rosepine.json'
+import solarized from './themes/solarized.json'
+import synthwave84 from './themes/synthwave84.json'
+import tokyonight from './themes/tokyonight.json'
+import vercel from './themes/vercel.json'
+import vesper from './themes/vesper.json'
+import zenburn from './themes/zenburn.json'
+
+export const TUI_THEMES: Record<string, TuiThemeJson> = {
+  'aimux': aimux as TuiThemeJson,
+  'aura': aura as TuiThemeJson,
+  'ayu': ayu as TuiThemeJson,
+  'carbonfox': carbonfox as TuiThemeJson,
+  'catppuccin': catppuccin as TuiThemeJson,
+  'catppuccin-frappe': catppuccinFrappe as TuiThemeJson,
+  'catppuccin-macchiato': catppuccinMacchiato as TuiThemeJson,
+  'cobalt2': cobalt2 as TuiThemeJson,
+  'cursor': cursor as TuiThemeJson,
+  'dracula': dracula as TuiThemeJson,
+  'everforest': everforest as TuiThemeJson,
+  'flexoki': flexoki as TuiThemeJson,
+  'github': github as TuiThemeJson,
+  'gruvbox': gruvbox as TuiThemeJson,
+  'kanagawa': kanagawa as TuiThemeJson,
+  'lucent-orng': lucentOrng as TuiThemeJson,
+  'material': material as TuiThemeJson,
+  'matrix': matrix as TuiThemeJson,
+  'mercury': mercury as TuiThemeJson,
+  'monokai': monokai as TuiThemeJson,
+  'nightowl': nightowl as TuiThemeJson,
+  'nord': nord as TuiThemeJson,
+  'one-dark': oneDark as TuiThemeJson,
+  'opencode': opencode as TuiThemeJson,
+  'orng': orng as TuiThemeJson,
+  'osaka-jade': osakaJade as TuiThemeJson,
+  'palenight': palenight as TuiThemeJson,
+  'rosepine': rosepine as TuiThemeJson,
+  'solarized': solarized as TuiThemeJson,
+  'synthwave84': synthwave84 as TuiThemeJson,
+  'tokyonight': tokyonight as TuiThemeJson,
+  'vercel': vercel as TuiThemeJson,
+  'vesper': vesper as TuiThemeJson,
+  'zenburn': zenburn as TuiThemeJson,
+}
+
+export type ThemeId = keyof typeof TUI_THEMES & string
+
+export const THEME_IDS: ThemeId[] = Object.keys(TUI_THEMES).sort() as ThemeId[]
+
+export function isKnownThemeId(id: string): id is ThemeId {
+  return id in TUI_THEMES
+}
+
+const LEGACY_ID_MAP: Record<string, ThemeId> = {
+  'aimux-dark': 'aimux',
+  'aimux-light': 'aimux',
+}
+
+export function migrateThemeId(id: string): ThemeId {
+  if (isKnownThemeId(id)) return id
+  return LEGACY_ID_MAP[id] ?? 'aimux'
+}

package/src/tui/resolve.ts

@@ -0,0 +1,156 @@
+// Port of opencode TUI's resolveTheme + ansiToRgba.
+// Source: opencode/packages/opencode/src/cli/cmd/tui/context/theme.tsx:198-301
+// (pinned reference). Behavior preserved verbatim; output uses CSS-style color
+// strings (hex / rgba) so values flow directly into opentui without conversion.
+
+import type { ResolvedTuiTheme, RGBA, ThemeMode, TuiColorValue, TuiThemeJson } from './types'
+
+import { TUI_COLOR_TOKENS, type TuiColorToken } from './tokens'
+
+const TRANSPARENT: RGBA = { a: 0, b: 0, g: 0, r: 0 }
+
+function rgbaFromHex(hex: string): RGBA {
+  const h = hex.replace('#', '')
+  // expand short forms (#rgb, #rgba)
+  const expanded =
+    h.length === 3 || h.length === 4
+      ? h
+          .split('')
+          .map((c) => c + c)
+          .join('')
+      : h
+  if (expanded.length === 6) {
+    const num = parseInt(expanded, 16)
+    return {
+      a: 255,
+      b: num & 0xff,
+      g: (num >> 8) & 0xff,
+      r: (num >> 16) & 0xff,
+    }
+  }
+  if (expanded.length === 8) {
+    const num = parseInt(expanded, 16) >>> 0
+    return {
+      a: num & 0xff,
+      b: (num >> 8) & 0xff,
+      g: (num >> 16) & 0xff,
+      r: (num >> 24) & 0xff,
+    }
+  }
+  return { a: 255, b: 0, g: 0, r: 0 }
+}
+
+function ansiToRgba(code: number): RGBA {
+  if (code < 16) {
+    const ansiColors = [
+      '#000000', // Black
+      '#800000', // Red
+      '#008000', // Green
+      '#808000', // Yellow
+      '#000080', // Blue
+      '#800080', // Magenta
+      '#008080', // Cyan
+      '#c0c0c0', // White
+      '#808080', // Bright Black
+      '#ff0000', // Bright Red
+      '#00ff00', // Bright Green
+      '#ffff00', // Bright Yellow
+      '#0000ff', // Bright Blue
+      '#ff00ff', // Bright Magenta
+      '#00ffff', // Bright Cyan
+      '#ffffff', // Bright White
+    ]
+    return rgbaFromHex(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 { a: 255, b: val(b), g: val(g), r: val(r) }
+  }
+  if (code < 256) {
+    const gray = (code - 232) * 10 + 8
+    return { a: 255, b: gray, g: gray, r: gray }
+  }
+  return { a: 255, b: 0, g: 0, r: 0 }
+}
+
+/** Recursive color resolver. Mirrors opencode TUI `resolveColor`. */
+function resolveColorRgba(
+  c: TuiColorValue,
+  theme: TuiThemeJson,
+  mode: ThemeMode,
+  chain: string[] = []
+): RGBA {
+  if (typeof c === 'string') {
+    if (c === 'transparent' || c === 'none') return TRANSPARENT
+    if (c.startsWith('#')) return rgbaFromHex(c)
+    if (chain.includes(c)) {
+      throw new Error(`Circular color reference: ${[...chain, c].join(' -> ')}`)
+    }
+    const defs = theme.defs ?? {}
+    const next = defs[c] ?? (theme.theme as Record<string, TuiColorValue>)[c]
+    if (next === undefined) {
+      throw new Error(`Color reference "${c}" not found in defs or theme`)
+    }
+    return resolveColorRgba(next, theme, mode, [...chain, c])
+  }
+  if (typeof c === 'number') return ansiToRgba(c)
+  return resolveColorRgba(c[mode], theme, mode, chain)
+}
+
+function rgbaToCss(c: RGBA): string {
+  const r = Math.max(0, Math.min(255, Math.round(c.r)))
+  const g = Math.max(0, Math.min(255, Math.round(c.g)))
+  const b = Math.max(0, Math.min(255, Math.round(c.b)))
+  const a = Math.max(0, Math.min(255, Math.round(c.a)))
+  if (a === 255) {
+    const hex = (v: number) => v.toString(16).padStart(2, '0')
+    return `#${hex(r)}${hex(g)}${hex(b)}`
+  }
+  return `rgba(${r}, ${g}, ${b}, ${(a / 255).toFixed(3)})`
+}
+
+/**
+ * Resolve a TUI theme JSON to a flat record of CSS color strings.
+ * @param mode "dark" or "light" — selects between {dark, light} branches in token values.
+ */
+export function resolveTuiTheme(theme: TuiThemeJson, mode: ThemeMode): ResolvedTuiTheme {
+  const out: Partial<Record<TuiColorToken, string>> = {}
+
+  // Pass 1: every token defined in the JSON, except optional/derived ones.
+  for (const [key, value] of Object.entries(theme.theme)) {
+    if (key === 'selectedListItemText' || key === 'backgroundMenu' || key === 'thinkingOpacity')
+      continue
+    out[key as TuiColorToken] = rgbaToCss(resolveColorRgba(value as TuiColorValue, theme, mode))
+  }
+
+  // Pass 2: fallbacks (matches opencode behavior).
+  if (theme.theme.selectedListItemText !== undefined) {
+    out.selectedListItemText = rgbaToCss(
+      resolveColorRgba(theme.theme.selectedListItemText, theme, mode)
+    )
+  } else if (out.background !== undefined) {
+    out.selectedListItemText = out.background
+  }
+
+  if (theme.theme.backgroundMenu !== undefined) {
+    out.backgroundMenu = rgbaToCss(resolveColorRgba(theme.theme.backgroundMenu, theme, mode))
+  } else if (out.backgroundElement !== undefined) {
+    out.backgroundMenu = out.backgroundElement
+  }
+
+  // Sanity: every token should be present. Any missing token in a JSON falls
+  // back to text (foreground) so we never hand an `undefined` to opentui.
+  const fallback = out.text ?? out.background ?? '#000000'
+  for (const tok of TUI_COLOR_TOKENS) {
+    if (out[tok] === undefined) out[tok] = fallback
+  }
+
+  return {
+    ...(out as Record<TuiColorToken, string>),
+    thinkingOpacity: theme.theme.thinkingOpacity ?? 0.6,
+  }
+}

package/src/tui/shiki.ts

@@ -0,0 +1,149 @@
+// Build a Shiki ThemeRegistrationRaw from a resolved TUI theme.
+
+import type { ThemeRegistrationRaw } from 'shiki'
+
+import type { ResolvedTuiTheme, ThemeMode } from './types'
+
+export interface TuiShikiOptions {
+  name: string
+  mode: ThemeMode
+  theme: ResolvedTuiTheme
+}
+
+export function tuiThemeToShiki(opts: TuiShikiOptions): ThemeRegistrationRaw {
+  const { mode, name, theme: t } = opts
+  const bg = t.background
+  const fg = t.text
+
+  return {
+    bg,
+    colors: { 'editor.background': bg, 'editor.foreground': fg },
+    fg,
+    name,
+    settings: [
+      { settings: { background: bg, foreground: fg } },
+      {
+        scope: ['comment', 'punctuation.definition.comment', 'comment.documentation'],
+        settings: { fontStyle: 'italic', foreground: t.syntaxComment },
+      },
+      {
+        scope: ['string', 'string.quoted', 'string.template'],
+        settings: { foreground: t.syntaxString },
+      },
+      {
+        scope: ['string.regexp', 'string.escape', 'constant.character.escape'],
+        settings: { foreground: t.syntaxString },
+      },
+      {
+        scope: [
+          'constant.numeric',
+          'constant.language',
+          'constant.language.boolean',
+          'constant.character',
+          'constant.other',
+          'support.constant',
+        ],
+        settings: { foreground: t.syntaxNumber },
+      },
+      {
+        scope: [
+          'keyword',
+          'keyword.control',
+          'keyword.operator.new',
+          'keyword.other',
+          'storage',
+          'storage.type',
+          'storage.modifier',
+        ],
+        settings: { fontStyle: 'bold', foreground: t.syntaxKeyword },
+      },
+      {
+        scope: ['keyword.operator', 'meta.brace', 'punctuation.separator'],
+        settings: { foreground: t.syntaxOperator },
+      },
+      {
+        scope: ['punctuation', 'punctuation.section'],
+        settings: { foreground: t.syntaxPunctuation },
+      },
+      {
+        scope: [
+          'entity.name.function',
+          'support.function',
+          'meta.function-call',
+          'entity.name.function.member',
+        ],
+        settings: { foreground: t.syntaxFunction },
+      },
+      {
+        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: t.syntaxType },
+      },
+      {
+        scope: ['variable', 'meta.variable'],
+        settings: { foreground: t.syntaxVariable },
+      },
+      {
+        scope: ['variable.parameter', 'meta.function.parameters'],
+        settings: { fontStyle: 'italic', foreground: t.syntaxVariable },
+      },
+      {
+        scope: ['variable.other.property', 'variable.other.member', 'meta.object-literal.key'],
+        settings: { foreground: t.syntaxVariable },
+      },
+      {
+        scope: ['variable.language', 'variable.language.this'],
+        settings: { fontStyle: 'italic', foreground: t.syntaxNumber },
+      },
+      { scope: ['entity.name.tag', 'meta.tag'], settings: { foreground: t.error } },
+      {
+        scope: ['entity.other.attribute-name'],
+        settings: { fontStyle: 'italic', foreground: t.warning },
+      },
+      // Markdown
+      {
+        scope: ['markup.heading'],
+        settings: { fontStyle: 'bold', foreground: t.markdownHeading },
+      },
+      {
+        scope: ['markup.bold'],
+        settings: { fontStyle: 'bold', foreground: t.markdownStrong },
+      },
+      {
+        scope: ['markup.italic'],
+        settings: { fontStyle: 'italic', foreground: t.markdownEmph },
+      },
+      {
+        scope: ['markup.underline.link', 'markup.inline.raw', 'markup.raw'],
+        settings: { foreground: t.markdownCode },
+      },
+      { scope: ['markup.list'], settings: { foreground: t.markdownListItem } },
+      {
+        scope: ['markup.quote'],
+        settings: { fontStyle: 'italic', foreground: t.markdownBlockQuote },
+      },
+      // Diff
+      {
+        scope: ['markup.inserted', 'meta.diff.header.to-file'],
+        settings: { foreground: t.diffAdded },
+      },
+      {
+        scope: ['markup.deleted', 'meta.diff.header.from-file'],
+        settings: { foreground: t.diffRemoved },
+      },
+      { scope: ['markup.changed'], settings: { foreground: t.warning } },
+      { scope: ['meta.diff.range'], settings: { foreground: t.diffHunkHeader } },
+    ],
+    type: mode,
+  }
+}