@brimveyn/aimux 1.21.0 → 1.22.2

package/src/settings/sections/automation.ts

@@ -0,0 +1,105 @@
+import { setAutoCommitEnabled } from '@brimveyn/aimux-config'
+
+import type { SettingSection } from '../types'
+
+/** Ids `src/settings/live.ts` reads back — spelled once, here, next to the rows. */
+export const AUTO_COMMIT_ENABLED = 'autoCommit.enabled'
+export const AUTO_COMMIT_TIMEOUT = 'autoCommit.timeoutMs'
+
+/**
+ * Auto-commit applies live: the driver reads its config through a ref that this
+ * store feeds, and the keymap action reads the module flag `apply` sets.
+ *
+ * Auto-rename does not. Its config is handed to the session backend at bootstrap,
+ * before this screen exists, so a change reaches it on the next launch — which is
+ * what `restart` puts on the row.
+ */
+export const AUTOMATION_SECTION: SettingSection = {
+  id: 'automation',
+  label: 'Automation',
+  rows: [
+    {
+      apply: (value) => setAutoCommitEnabled(value === true),
+      description: 'Offer a generated commit message when you commit from git mode.',
+      fallback: false,
+      fromConfig: (config) => config.autoCommit?.enabled,
+      id: AUTO_COMMIT_ENABLED,
+      kind: 'toggle',
+      label: 'Auto-commit',
+      storage: 'settings',
+    },
+    {
+      description: 'How long the assistant gets to produce one, in milliseconds.',
+      fallback: 60_000,
+      fromConfig: (config) => config.autoCommit?.timeoutMs,
+      id: AUTO_COMMIT_TIMEOUT,
+      kind: 'number',
+      label: 'Auto-commit timeout',
+      max: 300_000,
+      min: 10_000,
+      step: 10_000,
+      storage: 'settings',
+    },
+    {
+      description: 'Name a tab from the first real prompt you send it.',
+      fallback: true,
+      fromConfig: (config) => config.autoRename?.enabled,
+      id: 'autoRename.enabled',
+      kind: 'toggle',
+      label: 'Auto-rename tabs',
+      restart: true,
+      storage: 'settings',
+    },
+    {
+      description: 'Quiet period after a prompt before a title is generated, in milliseconds.',
+      fallback: 2_500,
+      fromConfig: (config) => config.autoRename?.settleMs,
+      id: 'autoRename.settleMs',
+      kind: 'number',
+      label: 'Auto-rename settle',
+      max: 10_000,
+      min: 0,
+      restart: true,
+      step: 500,
+      storage: 'settings',
+    },
+    {
+      description: 'Tries before falling back to a title derived from the prompt itself.',
+      fallback: 3,
+      fromConfig: (config) => config.autoRename?.maxAttempts,
+      id: 'autoRename.maxAttempts',
+      kind: 'number',
+      label: 'Auto-rename attempts',
+      max: 10,
+      min: 1,
+      restart: true,
+      step: 1,
+      storage: 'settings',
+    },
+    {
+      description: 'Shorter prompts are menu answers, not something to name a tab after.',
+      fallback: 3,
+      fromConfig: (config) => config.autoRename?.minPromptWords,
+      id: 'autoRename.minPromptWords',
+      kind: 'number',
+      label: 'Auto-rename minimum words',
+      max: 20,
+      min: 1,
+      restart: true,
+      step: 1,
+      storage: 'settings',
+    },
+    {
+      fallback: 15_000,
+      fromConfig: (config) => config.autoRename?.timeoutMs,
+      id: 'autoRename.timeoutMs',
+      kind: 'number',
+      label: 'Auto-rename timeout',
+      max: 60_000,
+      min: 5_000,
+      restart: true,
+      step: 5_000,
+      storage: 'settings',
+    },
+  ],
+}

package/src/settings/sections/commands.ts

@@ -0,0 +1,72 @@
+import type { SettingRow, SettingSection } from '../types'
+
+import { ASSISTANT_OPTIONS } from '../../pty/command-registry'
+import { dispatchGlobal } from '../../state/dispatch-ref'
+
+export const SNIPPET_TRIGGER_CHAR = 'snippets.triggerChar'
+export const AUTO_COMMIT_MODEL_PREFIX = 'autoCommit.models.'
+
+/**
+ * What each assistant is actually launched with. The value lives in `AppState`
+ * (and is persisted with the rest of it), so these rows delegate — and an empty
+ * value removes the override rather than launching an empty command.
+ */
+function customCommandRow(option: (typeof ASSISTANT_OPTIONS)[number]): SettingRow {
+  return {
+    description: `Default: ${option.command}`,
+    id: `customCommands.${option.id}`,
+    kind: 'text',
+    label: option.label,
+    placeholder: option.command,
+    read: (ctx) => ctx.state.customCommands[option.id] ?? '',
+    storage: 'app',
+    write: (value, ctx) => {
+      const next = { ...ctx.state.customCommands }
+      if (value === '') delete next[option.id]
+      else next[option.id] = String(value)
+      dispatchGlobal({ customCommands: next, type: 'set-custom-commands' })
+    },
+  }
+}
+
+/** The assistants whose auto-commit model the config ships a default for. */
+const MODEL_ASSISTANTS = ['claude', 'codex'] as const
+
+function autoCommitModelRow(assistant: (typeof MODEL_ASSISTANTS)[number]): SettingRow {
+  return {
+    description: `Model that writes the commit message when ${assistant} is the active tab.`,
+    fallback: '',
+    fromConfig: (config) => config.autoCommit?.models?.[assistant],
+    id: `${AUTO_COMMIT_MODEL_PREFIX}${assistant}`,
+    kind: 'text',
+    label: `Auto-commit model (${assistant})`,
+    placeholder: 'the built-in default',
+    storage: 'settings',
+  }
+}
+
+export const COMMANDS_SECTION: SettingSection = {
+  id: 'commands',
+  label: 'Commands',
+  rows: [
+    {
+      description: 'Type this, then a trigger, to expand a snippet. One character.',
+      fallback: ':',
+      fromConfig: (config) => config.snippetTriggerChar,
+      id: SNIPPET_TRIGGER_CHAR,
+      kind: 'text',
+      label: 'Snippet trigger',
+      storage: 'settings',
+    },
+    {
+      description: 'The picker owns them: create, edit, delete, and see the config-pinned ones.',
+      id: 'snippets.manage',
+      kind: 'action',
+      label: 'Snippets',
+      run: () => dispatchGlobal({ returnTo: 'settings', type: 'open-snippet-picker' }),
+      value: (ctx) => `${String(ctx.state.snippets.length)} ›`,
+    },
+    ...MODEL_ASSISTANTS.map(autoCommitModelRow),
+    ...ASSISTANT_OPTIONS.map(customCommandRow),
+  ],
+}

package/src/settings/sections/editor.ts

@@ -0,0 +1,56 @@
+import { getExternalEditorConfig, setExternalEditorConfig } from '@brimveyn/aimux-config'
+
+import type { SettingSection } from '../types'
+
+/** `auto` is the absence of a value, which is not something a row can hold. */
+const AUTO = 'auto'
+
+/**
+ * `args` and `terminal` are absent: both are argv lists, and a list is not a row.
+ * They stay in `aimux.config.ts`, where they are the only two settings here that
+ * really need to be.
+ */
+export const EDITOR_SECTION: SettingSection = {
+  id: 'editor',
+  label: 'Editor',
+  rows: [
+    {
+      apply: (value) => {
+        const command = String(value)
+        setExternalEditorConfig({
+          ...getExternalEditorConfig(),
+          command: command === '' ? undefined : command,
+        })
+      },
+      description: 'Overrides $VISUAL and $EDITOR. Empty falls back to them.',
+      fallback: '',
+      fromConfig: (config) => config.externalEditor?.command,
+      id: 'externalEditor.command',
+      kind: 'text',
+      label: 'Command',
+      placeholder: '$VISUAL / $EDITOR',
+      storage: 'settings',
+    },
+    {
+      apply: (value) => {
+        setExternalEditorConfig({
+          ...getExternalEditorConfig(),
+          kind: value === 'gui' || value === 'tui' ? value : undefined,
+        })
+      },
+      description:
+        'gui spawns detached, tui hands over the terminal. auto decides from the command.',
+      fallback: AUTO,
+      fromConfig: (config) => config.externalEditor?.kind,
+      id: 'externalEditor.kind',
+      kind: 'select',
+      label: 'Window',
+      options: [
+        { label: AUTO, value: AUTO },
+        { label: 'gui', value: 'gui' },
+        { label: 'tui', value: 'tui' },
+      ],
+      storage: 'settings',
+    },
+  ],
+}

package/src/settings/sections/experimental.ts

@@ -0,0 +1,57 @@
+import type { SettingSection } from '../types'
+
+import { userSpriteDir } from '../../ui/terminal-graphics/sprites'
+
+export const HARMONIZE_CLAUDE_THEME = 'theme.beta.harmonizeClaudeTheme'
+export const ACTIVITY_SPRITES = 'theme.beta.experimentalActivitySprites'
+
+/**
+ * The `theme.beta.*` block of the config, under the label its own docstrings use.
+ * Not grouped with the integrations even though both of these touch Claude Code:
+ * what they have in common is that they are unfinished, which is the thing a user
+ * needs to know before turning one on.
+ */
+export const EXPERIMENTAL_SECTION: SettingSection = {
+  description: 'Unfinished. These can change behaviour, or go away, in any release.',
+  id: 'experimental',
+  label: 'Experimental',
+  rows: [
+    {
+      description: 'Write the active aimux theme into ~/.claude and select it there.',
+      fallback: false,
+      fromConfig: (config) => config.theme?.beta?.harmonizeClaudeTheme,
+      id: HARMONIZE_CLAUDE_THEME,
+      kind: 'toggle',
+      label: 'Harmonize the Claude Code theme',
+      storage: 'settings',
+    },
+    {
+      description: "Turn off Claude's own highlighting and re-colour diffs from the aimux theme.",
+      fallback: false,
+      fromConfig: (config) => config.theme?.beta?.experimentalSyntaxHighlight,
+      id: 'theme.beta.experimentalSyntaxHighlight',
+      kind: 'toggle',
+      label: 'Syntax highlight from the theme',
+      restart: true,
+      storage: 'settings',
+    },
+    {
+      description: 'A little animation per agent state, instead of the spinner and the dots.',
+      fallback: false,
+      fromConfig: (config) => config.theme?.beta?.experimentalActivitySprites,
+      id: ACTIVITY_SPRITES,
+      kind: 'toggle',
+      label: 'Activity sprites (Kitty or Ghostty, not tmux)',
+      storage: 'settings',
+    },
+    // The row above is useless without knowing where to put anything, and a path
+    // that has to be looked up in the docs is a path nobody uses.
+    {
+      description: 'Drop a `<state>.gif` here — states: idle, working, waiting, done.',
+      id: 'experimental.spriteFolder',
+      kind: 'info',
+      label: 'Sprite folder',
+      value: () => userSpriteDir(),
+    },
+  ],
+}

package/src/settings/sections/git.ts

@@ -0,0 +1,112 @@
+import { getMultiRepoConfig, setMultiRepoConfig } from '@brimveyn/aimux-config'
+
+import type { GitFileListMode } from '../../state/types'
+import type { SettingSection, SettingValue } from '../types'
+
+import { dispatchGlobal, runSideEffectGlobal } from '../../state/dispatch-ref'
+
+function isFileListMode(value: SettingValue): value is GitFileListMode {
+  return value === 'tree' || value === 'flat'
+}
+
+/**
+ * The file list and diff preferences already live in `AppState` and have their own
+ * persistence, so those rows delegate. The two with no toggle of their own —
+ * prefetch radius and the diff counter — are stored here and pushed into
+ * `AppState` on change; multi-repo is a module singleton, like auto-commit.
+ */
+export const GIT_SECTION: SettingSection = {
+  id: 'git',
+  label: 'Git',
+  rows: [
+    {
+      description: 'Show changed files as a tree, or as one flat list of paths.',
+      id: 'git.fileListMode',
+      kind: 'select',
+      label: 'File list',
+      options: [
+        { label: 'tree', value: 'tree' },
+        { label: 'flat', value: 'flat' },
+      ],
+      read: (ctx) => ctx.state.gitPane.fileListMode,
+      storage: 'app',
+      // Flips rather than sets, because flipping is what also reconciles the git
+      // view's selected entry with the new shape of the list. Safe because
+      // `writeRow` never hands a row the value it already holds — with two
+      // options, flipping and setting agree. A third would need the action to
+      // take a target first; `settings-schema.test.ts` holds that line.
+      write: (value) => {
+        if (!isFileListMode(value)) return
+        dispatchGlobal({ type: 'git-mode-toggle-file-list-mode' })
+        runSideEffectGlobal({ mode: value, type: 'persist-git-file-list-mode' })
+      },
+    },
+    {
+      description: 'Collapse folder chains with a single child into one line.',
+      id: 'git.treeCompaction',
+      kind: 'toggle',
+      label: 'Compact the tree',
+      read: (ctx) => ctx.state.gitPane.treeCompaction,
+      storage: 'app',
+      write: (value) => {
+        dispatchGlobal({ type: 'git-mode-toggle-tree-compaction' })
+        runSideEffectGlobal({ enabled: value === true, type: 'persist-git-tree-compaction' })
+      },
+    },
+    {
+      apply: (value) =>
+        dispatchGlobal({ patch: { diffCount: { enabled: value === true } }, type: 'set-git-pane' }),
+      description: 'Added and removed line counts next to each file.',
+      fallback: true,
+      fromConfig: (config) => config.gitPane?.diffCount?.enabled,
+      id: 'git.diffCount',
+      kind: 'toggle',
+      label: 'Diff counts',
+      storage: 'settings',
+    },
+    {
+      apply: (value) => {
+        if (typeof value === 'number') {
+          dispatchGlobal({ patch: { prefetchRadius: value }, type: 'set-git-pane' })
+        }
+      },
+      description: 'Load this many diffs either side of the cursor ahead of time. 0 disables it.',
+      fallback: 5,
+      fromConfig: (config) => config.gitPane?.prefetchRadius,
+      id: 'git.prefetchRadius',
+      kind: 'number',
+      label: 'Diff prefetch',
+      max: 50,
+      min: 0,
+      step: 1,
+      storage: 'settings',
+    },
+    {
+      apply: (value) => setMultiRepoConfig({ ...getMultiRepoConfig(), enabled: value === true }),
+      description: 'Aggregate the status of git repos nested under the project.',
+      fallback: true,
+      fromConfig: (config) => config.multiRepo?.enabled,
+      id: 'multiRepo.enabled',
+      kind: 'toggle',
+      label: 'Multi-repo',
+      storage: 'settings',
+    },
+    {
+      apply: (value) => {
+        if (typeof value === 'number') {
+          setMultiRepoConfig({ ...getMultiRepoConfig(), maxDepth: value })
+        }
+      },
+      description: 'How far below the project to look for them. 1 = its direct children.',
+      fallback: 1,
+      fromConfig: (config) => config.multiRepo?.maxDepth,
+      id: 'multiRepo.maxDepth',
+      kind: 'number',
+      label: 'Multi-repo depth',
+      max: 5,
+      min: 1,
+      step: 1,
+      storage: 'settings',
+    },
+  ],
+}

package/src/settings/sections/index.ts

@@ -0,0 +1,95 @@
+import type { ProjectRecord } from '../../state/types'
+import type { SettingRow, SettingSection } from '../types'
+
+import { ABOUT_SECTION } from './about'
+import { APPEARANCE_SECTION } from './appearance'
+import { AUTOMATION_SECTION } from './automation'
+import { COMMANDS_SECTION } from './commands'
+import { EDITOR_SECTION } from './editor'
+import { EXPERIMENTAL_SECTION } from './experimental'
+import { GIT_SECTION } from './git'
+import { INTEGRATIONS_SECTION } from './integrations'
+import { LAYOUT_SECTION } from './layout'
+import { NOTIFICATIONS_SECTION } from './notifications'
+import { SETUP_SECTION } from './setup'
+import { STATUS_BAR_SECTION } from './status-bar'
+
+/**
+ * Every section, in the order the screen lists them. Adding a setting is one
+ * entry in one of these files — no component, no reducer branch, no keybind.
+ */
+export const SETTING_SECTIONS: readonly SettingSection[] = [
+  APPEARANCE_SECTION,
+  LAYOUT_SECTION,
+  AUTOMATION_SECTION,
+  NOTIFICATIONS_SECTION,
+  SETUP_SECTION,
+  GIT_SECTION,
+  COMMANDS_SECTION,
+  EDITOR_SECTION,
+  STATUS_BAR_SECTION,
+  INTEGRATIONS_SECTION,
+  EXPERIMENTAL_SECTION,
+  ABOUT_SECTION,
+]
+
+/**
+ * The rows that exist regardless of state, which is what hydration resolves. A
+ * section that builds its rows from state is a view over something that has its
+ * own home — a file, a project record — so it has nothing to hydrate.
+ */
+export const ALL_SETTING_ROWS: readonly SettingRow[] = SETTING_SECTIONS.flatMap((section) =>
+  Array.isArray(section.rows) ? section.rows : []
+)
+
+export const DEFAULT_SECTION_ID = SETTING_SECTIONS[0]?.id ?? 'about'
+
+export function getSection(sectionId: string): SettingSection | undefined {
+  return SETTING_SECTIONS.find((section) => section.id === sectionId)
+}
+
+export function sectionRows(
+  section: SettingSection,
+  projects: readonly ProjectRecord[]
+): readonly SettingRow[] {
+  return Array.isArray(section.rows) ? section.rows : section.rows(projects)
+}
+
+/**
+ * How many rows a section has, without building them. The reducer clamps the
+ * cursor with this, which is why it exists: building a Setup row reads a script
+ * off disk, and a reducer has no business doing that.
+ */
+export function sectionRowCount(
+  section: SettingSection,
+  projects: readonly ProjectRecord[]
+): number {
+  if (section.rowCount) return section.rowCount(projects)
+  return Array.isArray(section.rows) ? section.rows.length : section.rows(projects).length
+}
+
+/** Rows of the given section, or an empty list when the id is unknown. */
+export function getSectionRows(
+  sectionId: string,
+  projects: readonly ProjectRecord[]
+): readonly SettingRow[] {
+  const section = getSection(sectionId)
+  return section ? sectionRows(section, projects) : []
+}
+
+export function getSectionRowCount(sectionId: string, projects: readonly ProjectRecord[]): number {
+  const section = getSection(sectionId)
+  return section ? sectionRowCount(section, projects) : 0
+}
+
+/** The row with this id, dynamic ones included. */
+export function findSettingRow(
+  id: string,
+  projects: readonly ProjectRecord[]
+): SettingRow | undefined {
+  for (const section of SETTING_SECTIONS) {
+    const row = sectionRows(section, projects).find((entry) => entry.id === id)
+    if (row) return row
+  }
+  return undefined
+}

package/src/settings/sections/integrations.ts

@@ -0,0 +1,23 @@
+import type { SettingSection } from '../types'
+
+/**
+ * What aimux writes into other tools' configuration. Installing Claude's hooks is
+ * a one-way write at startup with no uninstall, so it cannot honestly claim to
+ * take effect before the next launch.
+ */
+export const INTEGRATIONS_SECTION: SettingSection = {
+  id: 'integrations',
+  label: 'Integrations',
+  rows: [
+    {
+      description: 'Drive per-tab activity from Claude Code events instead of reading the screen.',
+      fallback: false,
+      fromConfig: (config) => config.integrations?.claudeHooks,
+      id: 'integrations.claudeHooks',
+      kind: 'toggle',
+      label: 'Claude Code hooks',
+      restart: true,
+      storage: 'settings',
+    },
+  ],
+}

package/src/settings/sections/layout.ts

@@ -0,0 +1,72 @@
+import type { SettingSection } from '../types'
+
+import { dispatchGlobal } from '../../state/dispatch-ref'
+
+/**
+ * Bars and their widths. Every row here is a view over something `AppState`
+ * already owns, so each one dispatches the action its keybinding dispatches —
+ * which is also what gets the value persisted on the next autosave. The toggles
+ * flip rather than set, which is safe because `writeRow` never hands a row the
+ * value it already has.
+ */
+export const LAYOUT_SECTION: SettingSection = {
+  id: 'layout',
+  label: 'Layout',
+  rows: [
+    {
+      description: 'The tab strip above the terminal.',
+      id: 'layout.projectBar',
+      kind: 'toggle',
+      label: 'Tab bar',
+      read: (ctx) => ctx.state.projectBar.visible,
+      storage: 'app',
+      write: () => dispatchGlobal({ type: 'toggle-project-bar' }),
+    },
+    {
+      id: 'layout.leftBar',
+      kind: 'toggle',
+      label: 'Left bar',
+      read: (ctx) => ctx.state.bars.left.visible,
+      storage: 'app',
+      write: () => dispatchGlobal({ side: 'left', type: 'toggle-bar' }),
+    },
+    {
+      description: 'Columns. Clamped to what the terminal can spare.',
+      id: 'layout.leftBarWidth',
+      kind: 'number',
+      label: 'Left bar width',
+      max: 80,
+      min: 10,
+      read: (ctx) => ctx.state.bars.left.width,
+      step: 2,
+      storage: 'app',
+      write: (value) => {
+        if (typeof value !== 'number') return
+        dispatchGlobal({ side: 'left', type: 'set-bar-width', width: value })
+      },
+    },
+    {
+      id: 'layout.rightBar',
+      kind: 'toggle',
+      label: 'Right bar',
+      read: (ctx) => ctx.state.bars.right.visible,
+      storage: 'app',
+      write: () => dispatchGlobal({ side: 'right', type: 'toggle-bar' }),
+    },
+    {
+      description: 'Columns. Clamped to what the terminal can spare.',
+      id: 'layout.rightBarWidth',
+      kind: 'number',
+      label: 'Right bar width',
+      max: 80,
+      min: 10,
+      read: (ctx) => ctx.state.bars.right.width,
+      step: 2,
+      storage: 'app',
+      write: (value) => {
+        if (typeof value !== 'number') return
+        dispatchGlobal({ side: 'right', type: 'set-bar-width', width: value })
+      },
+    },
+  ],
+}