@brimveyn/aimux 1.12.1 → 1.12.6

package/src/app.tsx

@@ -34,7 +34,7 @@ import { aiUsageStore } from './state/ai-usage-store'
 import { appStore, useAppStore } from './state/app-store'
 import { setActiveDispatch, setActiveSideEffectRunner } from './state/dispatch-ref'
 import { findMostRecentSession, loadSessionCatalog } from './state/session-catalog'
-import { loadSnippetCatalog } from './state/snippet-catalog'
+import { loadSnippetCatalog, mergeConfigSnippets } from './state/snippet-catalog'
 import { createInitialState } from './state/store'
 import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
@@ -137,10 +137,11 @@ export function App({
     }
 
     const sessionCatalog = loadSessionCatalog()
+    const mergedSnippets = mergeConfigSnippets(loadSnippetCatalog(), resolvedConfig.snippets)
     const initial = createInitialState(
       json.customCommands,
       sessionCatalog,
-      loadSnippetCatalog(),
+      mergedSnippets,
       sessionCatalog.length === 0,
       {
         gitPane: gitPaneOverrides,
@@ -259,6 +260,13 @@ export function App({
   const stateRef = useRef(state)
   stateRef.current = state
 
+  const snippetsRef = useRef(state.snippets)
+  snippetsRef.current = state.snippets
+  const branchRef = useRef(state.gitPanel.branch)
+  branchRef.current = state.gitPanel.branch
+  const triggerCharRef = useRef(resolvedConfig.snippetTriggerChar)
+  triggerCharRef.current = resolvedConfig.snippetTriggerChar
+
   const contentOriginRef = useRef<TerminalContentOrigin>({ cols: 0, rows: 0, x: 0, y: 0 })
   const currentSessionWorkspaceSnapshot = currentSession?.workspaceSnapshot
 
@@ -370,11 +378,14 @@ export function App({
     activeTabRef,
     activeTabViewportY: activeTab?.viewport?.viewportY ?? null,
     backend,
+    branchRef,
     dispatch,
     focusMode: state.focusMode,
     focusModeRef,
     handleTerminalShortcut,
     renderer,
+    snippetsRef,
+    triggerCharRef,
   })
 
   const sideEffectCtx: SideEffectContext = {
@@ -478,6 +489,7 @@ export function App({
         onSeparatorDrag={handleSeparatorDrag}
         onSeparatorDragEnd={handleSeparatorDragEnd}
         onSidebarResizeStart={handleSidebarResizeStart}
+        onMeasure={terminalSize.onMeasure}
         terminalCols={terminalSize.cols}
         terminalRows={terminalSize.rows}
       />

package/src/input/modes/types.ts

@@ -26,6 +26,7 @@ export type ModeId =
 export type SideEffect =
   | { type: 'quit'; state: AppState }
   | { type: 'launch-selected-assistant' }
+  | { type: 'edit-selected-assistant' }
   | { type: 'confirm-selected-session' }
   | { type: 'delete-selected-session' }
   | { type: 'open-rename-selected-session' }
@@ -69,6 +70,7 @@ export type SideEffect =
   | { type: 'toggle-transparent' }
   | { type: 'toggle-mode' }
   | { type: 'open-file-in-editor'; path: string }
+  | { type: 'open-selected-snippet-source-in-editor' }
 
 export interface KeyResult {
   actions: AppAction[]

package/src/input/raw-input-handler.ts

@@ -1,4 +1,5 @@
 import type { PtyWriteOptions } from '../app-runtime/pty-write'
+import type { TriggerMatch } from '../snippets/trigger-detector'
 import type { FocusMode } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
@@ -88,6 +89,20 @@ export function createRawInputHandler(deps: {
    * Returns true if the chord was consumed by the keymap, false otherwise.
    */
   handleTerminalShortcut: (chord: KeyChord) => boolean
+  /** True when the active tab is in alternate-screen mode (vim, less, htop, ...). */
+  getIsAlternateBuffer?: () => boolean
+  /** Feed a single char to the per-tab macro trigger detector. */
+  feedTrigger?: (tabId: string, char: string) => TriggerMatch | null
+  /** Expand a matched macro and inject it into the PTY (erase + paste + cursor). */
+  expandMacro?: (tabId: string, match: TriggerMatch) => void
+  /** Reset detector state when input boundaries change (paste start, mode toggle). */
+  resetTrigger?: (tabId: string) => void
+  /**
+   * Called for every keystroke immediately after a macro expansion: if the
+   * keystroke is a backspace, erase the entire expansion and return true.
+   * Any other keystroke clears the pending-undo state and returns false.
+   */
+  tryConsumeMacroUndo?: (tabId: string, sequence: string) => boolean
 }): (sequence: string) => boolean {
   let bracketedPasteBuffer: string | null = null
 
@@ -143,6 +158,7 @@ export function createRawInputHandler(deps: {
         sequencePreview: sequence.slice(0, 120),
         tabId,
       })
+      deps.resetTrigger?.(tabId)
       if (!handleSequence(tabId, sequence.slice(0, startIndex))) {
         return false
       }
@@ -158,6 +174,23 @@ export function createRawInputHandler(deps: {
       return handleSequence(tabId, afterStart.slice(endIndex + BRACKETED_PASTE_END.length))
     }
 
+    if (deps.tryConsumeMacroUndo?.(tabId, sequence) ?? false) {
+      return true
+    }
+
+    if (
+      sequence.length === 1 &&
+      deps.feedTrigger &&
+      deps.expandMacro &&
+      !(deps.getIsAlternateBuffer?.() ?? false)
+    ) {
+      const match = deps.feedTrigger(tabId, sequence)
+      if (match) {
+        deps.expandMacro(tabId, match)
+        return true
+      }
+    }
+
     if (handleTerminalShortcut(sequence)) {
       return true
     }

package/src/platform/clipboard.ts

@@ -11,3 +11,17 @@ export function copyToSystemClipboard(text: string): void {
     })
   }
 }
+
+export async function readFromSystemClipboard(): Promise<string> {
+  try {
+    const proc = Bun.spawn(['pbpaste'], { stdout: 'pipe' })
+    const text = await new Response(proc.stdout).text()
+    await proc.exited
+    return text
+  } catch (error) {
+    logDebug('platform.clipboard.readError', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return ''
+  }
+}

package/src/pty/command-registry.ts

@@ -29,6 +29,12 @@ export const ASSISTANT_OPTIONS: AssistantOption[] = [
     id: 'opencode',
     label: 'OpenCode',
   },
+  {
+    command: 'agy',
+    description: 'Antigravity CLI',
+    id: 'antigravity',
+    label: 'Antigravity',
+  },
   {
     command: DEFAULT_SHELL,
     description: `Plain terminal (${SHELL_NAME})`,

package/src/pty/pty-manager.ts

@@ -24,6 +24,12 @@ interface SessionHandle {
   pendingModeSequence: string
   pendingWrites: number
   pendingExitCode: number | null
+  /** Scroll intent from the most recent resize, re-applied after the
+   *  parser drains the data that was queued across the resize. */
+  lastScrollIntent: ScrollIntent | undefined
+  /** Set when a resize landed while writes were in flight; the viewport is
+   *  re-anchored once pendingWrites reaches 0. */
+  reanchorAfterDrain: boolean
 }
 
 const ESC = '\x1b'
@@ -255,12 +261,14 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         alternateScrollMode: false,
         cursorVisible: true,
         emulator,
+        lastScrollIntent: undefined,
         lastSnapshot: undefined,
         lastTerminalModes: undefined,
         pendingExitCode: null,
         pendingModeSequence: '',
         pendingWrites: 0,
         pty,
+        reanchorAfterDrain: false,
         tabId: options.tabId,
       }
 
@@ -283,6 +291,15 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
         this.scheduleDataRender(session)
         emulator.write(data, () => {
           session.pendingWrites -= 1
+
+          if (session.pendingWrites === 0 && session.reanchorAfterDrain) {
+            // The data queued across a resize has now been parsed into the
+            // reflowed buffer. Re-anchor the viewport before it is snapshotted
+            // so the active screen — not stale scrollback — is what renders.
+            session.reanchorAfterDrain = false
+            this.applyScrollIntent(session, session.lastScrollIntent)
+          }
+
           this.scheduleDataRender(session)
 
           if (session.pendingWrites === 0 && session.pendingExitCode !== null) {
@@ -357,24 +374,46 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     session.emulator.scrollToLine(Math.max(0, intent.absoluteLine))
   }
 
-  resizeAll(
+  private applyResize(
+    session: SessionHandle,
     cols: number,
     rows: number,
-    intents?: Map<string, ScrollIntent>,
-    options?: { sync?: boolean }
+    intent: ScrollIntent | undefined,
+    sync: boolean
   ): void {
     const safeCols = Math.max(20, cols)
     const safeRows = Math.max(8, rows)
+    session.pty.resize(safeCols, safeRows)
+    session.emulator.resize(safeCols, safeRows)
+    session.lastScrollIntent = intent
+    this.applyScrollIntent(session, intent)
+
+    if (session.pendingWrites > 0) {
+      // Output produced by the child for the pre-resize size is still queued
+      // in the xterm parser. Snapshotting now would capture a torn buffer
+      // (reflowed but not yet redrawn); a plain shell never issues a full
+      // repaint, so the shifted content + dead rows would stick. Defer the
+      // snapshot to the drain path, which re-anchors the viewport first.
+      session.reanchorAfterDrain = true
+      this.scheduleDataRender(session)
+      return
+    }
+
+    if (sync) {
+      this.flushRenderNow(session)
+    } else {
+      this.scheduleRender(session)
+    }
+  }
 
+  resizeAll(
+    cols: number,
+    rows: number,
+    intents?: Map<string, ScrollIntent>,
+    options?: { sync?: boolean }
+  ): void {
     for (const session of this.sessions.values()) {
-      session.pty.resize(safeCols, safeRows)
-      session.emulator.resize(safeCols, safeRows)
-      this.applyScrollIntent(session, intents?.get(session.tabId))
-      if (options?.sync) {
-        this.flushRenderNow(session)
-      } else {
-        this.scheduleRender(session)
-      }
+      this.applyResize(session, cols, rows, intents?.get(session.tabId), options?.sync ?? false)
     }
   }
 
@@ -389,16 +428,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     if (!session) {
       return
     }
-    const safeCols = Math.max(20, cols)
-    const safeRows = Math.max(8, rows)
-    session.pty.resize(safeCols, safeRows)
-    session.emulator.resize(safeCols, safeRows)
-    this.applyScrollIntent(session, intent)
-    if (options?.sync) {
-      this.flushRenderNow(session)
-    } else {
-      this.scheduleRender(session)
-    }
+    this.applyResize(session, cols, rows, intent, options?.sync ?? false)
   }
 
   reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {

package/src/pty/terminal-snapshot.ts

@@ -152,9 +152,16 @@ export function snapshotTerminal(terminal: Terminal, cursorVisible = true): Term
   const lines: TerminalLine[] = []
   const tailLines: TerminalLine[] = []
 
+  // The window starts at viewportY, but cursorY is relative to baseY. The
+  // cursor belongs on a rendered row only when its absolute buffer line
+  // (baseY + cursorY) equals that row's buffer line (startLine + row).
+  // Comparing row === cursorY was correct only while scrolled to the bottom
+  // (viewportY === baseY) and misplaced the cursor otherwise.
+  const cursorLine = buffer.baseY + cursorRow
   for (let row = 0; row < terminal.rows; row += 1) {
+    const lineIndex = startLine + row
     lines.push(
-      buildLine(terminal, startLine + row, row === cursorRow ? cursorColumn : null, cursorVisible)
+      buildLine(terminal, lineIndex, lineIndex === cursorLine ? cursorColumn : null, cursorVisible)
     )
   }
 

package/src/snippets/expand-variables.ts

@@ -0,0 +1,112 @@
+import type { SnippetRecord } from '../state/types'
+
+/**
+ * Snippet/macro content expander.
+ *
+ * Supports:
+ *  - Custom (per-snippet) variables resolved upstream and passed via `customVars`.
+ *    These shadow built-ins on name collision.
+ *  - `{{date}}`, `{{date:FORMAT}}` with tokens YYYY MM DD HH mm ss
+ *  - `{{cwd}}` (resolved from context)
+ *  - `{{branch}}` (resolved from context; empty string when null)
+ *  - `{{clipboard}}` (async; only available via `expandSnippet`)
+ *  - `$|` cursor placeholder (first occurrence wins; subsequent are stripped)
+ *  - Unknown `{{...}}` tokens are left literal.
+ */
+
+export interface ExpansionContext {
+  cwd: string
+  branch: string | null
+  now: Date
+  customVars: ReadonlyMap<string, string>
+  clipboard: () => Promise<string>
+}
+
+export type SyncExpansionContext = Omit<ExpansionContext, 'clipboard'>
+
+export interface ExpansionResult {
+  text: string
+  cursorOffset: number
+}
+
+const VAR_RE = /\{\{([^{}]+)\}\}/g
+
+const TWO = (n: number): string => String(n).padStart(2, '0')
+
+function formatDate(date: Date, format?: string): string {
+  if (!format) {
+    return `${date.getFullYear()}-${TWO(date.getMonth() + 1)}-${TWO(date.getDate())}`
+  }
+  return format
+    .replace(/YYYY/g, String(date.getFullYear()))
+    .replace(/MM/g, TWO(date.getMonth() + 1))
+    .replace(/DD/g, TWO(date.getDate()))
+    .replace(/HH/g, TWO(date.getHours()))
+    .replace(/mm/g, TWO(date.getMinutes()))
+    .replace(/ss/g, TWO(date.getSeconds()))
+}
+
+function resolveSyncVariable(name: string, ctx: SyncExpansionContext): string | null {
+  const custom = ctx.customVars.get(name)
+  if (custom !== undefined) return custom
+  if (name === 'date') return formatDate(ctx.now)
+  if (name.startsWith('date:')) return formatDate(ctx.now, name.slice('date:'.length))
+  if (name === 'cwd') return ctx.cwd
+  if (name === 'branch') return ctx.branch ?? ''
+  return null
+}
+
+/**
+ * Replace `$|` with a cursor offset.
+ * First occurrence becomes the offset; additional ones are stripped.
+ * If none present, cursor is placed at the end of the text.
+ */
+function extractCursor(text: string): ExpansionResult {
+  const firstIndex = text.indexOf('$|')
+  if (firstIndex === -1) {
+    return { cursorOffset: text.length, text }
+  }
+  const before = text.slice(0, firstIndex)
+  const after = text
+    .slice(firstIndex + 2)
+    .split('$|')
+    .join('')
+  return { cursorOffset: before.length, text: before + after }
+}
+
+export function contentNeedsClipboard(content: string): boolean {
+  return /\{\{\s*clipboard\s*\}\}/.test(content)
+}
+
+export function requiresAsyncExpansion(snippet: SnippetRecord): boolean {
+  const hasVars = snippet.vars !== undefined && Object.keys(snippet.vars).length > 0
+  return hasVars || contentNeedsClipboard(snippet.content)
+}
+
+export function expandSnippetSync(content: string, ctx: SyncExpansionContext): ExpansionResult {
+  const replaced = content.replace(VAR_RE, (match, rawName: string) => {
+    const name = rawName.trim()
+    if (name === 'clipboard') return match
+    const resolved = resolveSyncVariable(name, ctx)
+    return resolved ?? match
+  })
+  return extractCursor(replaced)
+}
+
+export async function expandSnippet(
+  content: string,
+  ctx: ExpansionContext
+): Promise<ExpansionResult> {
+  let clipboardValue: string | null = null
+  const needsClipboard = contentNeedsClipboard(content) && !ctx.customVars.has('clipboard')
+  if (needsClipboard) {
+    clipboardValue = await ctx.clipboard()
+  }
+  const replaced = content.replace(VAR_RE, (match, rawName: string) => {
+    const name = rawName.trim()
+    if (name === 'clipboard' && clipboardValue !== null) return clipboardValue
+    const resolved = resolveSyncVariable(name, ctx)
+    return resolved ?? match
+  })
+  return extractCursor(replaced)
+}

package/src/snippets/run-shell-var.ts

@@ -0,0 +1,93 @@
+import type { SnippetShellVar } from '@brimveyn/aimux-config'
+
+import { logDebug } from '../debug/input-log'
+
+const DEFAULT_TIMEOUT_MS = 5000
+/** Hard ceiling on any user-supplied timeout to prevent runaway expansions. */
+const MAX_TIMEOUT_MS = 30_000
+
+/**
+ * Build the shell argv. We default to `$SHELL -l -c <cmd>` so the user's
+ * login shell rc files (e.g. /etc/zprofile → path_helper on macOS) populate
+ * PATH and make tools like `gh`, `jira`, `brew` resolvable — matching
+ * Espanso's behavior. Falls back to `/bin/sh -c` if SHELL is unset.
+ */
+function buildShellArgv(cmd: string): string[] {
+  const userShell = process.env.SHELL
+  if (userShell && userShell.length > 0) {
+    return [userShell, '-l', '-c', cmd]
+  }
+  return ['/bin/sh', '-c', cmd]
+}
+
+/**
+ * Run a snippet shell var via the user's login shell, capture stdout.
+ *
+ * Returns the trimmed stdout on success, or '' on error / timeout / non-zero
+ * exit. Stderr is captured for logging but never propagated into the result —
+ * snippet content is for the terminal, not for surfacing failures.
+ */
+export async function runShellVar(name: string, v: SnippetShellVar): Promise<string> {
+  const requested = v.timeout ?? DEFAULT_TIMEOUT_MS
+  const timeoutMs = Math.min(Math.max(requested, 0), MAX_TIMEOUT_MS)
+
+  let proc: Bun.Subprocess<'ignore', 'pipe', 'pipe'>
+  try {
+    proc = Bun.spawn(buildShellArgv(v.sh), {
+      stderr: 'pipe',
+      stdin: 'ignore',
+      stdout: 'pipe',
+    })
+  } catch (error) {
+    logDebug('snippets.shellVar.spawnError', {
+      cmd: v.sh,
+      error: error instanceof Error ? error.message : String(error),
+      name,
+    })
+    return ''
+  }
+
+  let timeoutFired = false
+  const timeoutHandle = setTimeout(() => {
+    timeoutFired = true
+    try {
+      proc.kill()
+    } catch {
+      // process already gone
+    }
+  }, timeoutMs)
+
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ])
+
+    if (timeoutFired) {
+      logDebug('snippets.shellVar.timeout', { cmd: v.sh, name, timeoutMs })
+      return ''
+    }
+
+    if (exitCode !== 0) {
+      logDebug('snippets.shellVar.nonZeroExit', {
+        cmd: v.sh,
+        exitCode,
+        name,
+        stderr: stderr.slice(0, 200),
+      })
+      return ''
+    }
+
+    return v.trim === false ? stdout : stdout.replace(/\s+$/, '')
+  } catch (error) {
+    logDebug('snippets.shellVar.error', {
+      cmd: v.sh,
+      error: error instanceof Error ? error.message : String(error),
+      name,
+    })
+    return ''
+  } finally {
+    clearTimeout(timeoutHandle)
+  }
+}

package/src/snippets/trigger-detector.ts

@@ -0,0 +1,105 @@
+import type { SnippetRecord } from '../state/types'
+
+/**
+ * Inline trigger detector for snippet/macro expansion.
+ *
+ * State machine (per-tab):
+ *   Idle ──(trigger char)──▶ Capturing
+ *   Capturing ──(separator)──▶ try match → return or reset → Idle
+ *   Capturing ──(printable char)──▶ append (max 32 chars)
+ *   Capturing ──(non-printable / control / escape)──▶ reset → Idle
+ *   Capturing ──(trigger char again)──▶ restart Capturing
+ *
+ * Paste heuristic: if two `feed` calls land within 5ms, treat as paste
+ * (sometimes terminals don't enable bracketed paste) and reset.
+ */
+
+const MAX_TRIGGER_BUFFER = 32
+const SEPARATOR_RE = /[\s.,;:!?)\]}]/u
+const PRINTABLE_RE = /^[\x20-\x7e]$/
+const PASTE_WINDOW_MS = 5
+
+export interface TriggerMatch {
+  snippet: SnippetRecord
+  /** Characters typed since trigger char (inclusive), including the closing separator. */
+  triggerText: string
+}
+
+export interface TriggerDetector {
+  feed(char: string): TriggerMatch | null
+  reset(): void
+}
+
+export interface TriggerDetectorOptions {
+  getSnippets: () => readonly SnippetRecord[]
+  getTriggerChar: () => string
+  now?: () => number
+}
+
+export function createTriggerDetector(opts: TriggerDetectorOptions): TriggerDetector {
+  const now = opts.now ?? (() => Date.now())
+  let capturing = false
+  let buffer = ''
+  let lastFeedAt = 0
+
+  function reset(): void {
+    capturing = false
+    buffer = ''
+  }
+
+  function tryMatch(separator: string): TriggerMatch | null {
+    const triggerChar = opts.getTriggerChar()
+    for (const snippet of opts.getSnippets()) {
+      if (snippet.trigger && snippet.trigger === buffer) {
+        const triggerText = `${triggerChar}${buffer}${separator}`
+        reset()
+        return { snippet, triggerText }
+      }
+    }
+    reset()
+    return null
+  }
+
+  return {
+    feed(char: string): TriggerMatch | null {
+      const t = now()
+      const isPaste = capturing && t - lastFeedAt < PASTE_WINDOW_MS && buffer.length > 0
+      lastFeedAt = t
+
+      if (isPaste) {
+        reset()
+        return null
+      }
+
+      const triggerChar = opts.getTriggerChar()
+
+      if (char === triggerChar) {
+        capturing = true
+        buffer = ''
+        return null
+      }
+
+      if (!capturing) return null
+
+      if (SEPARATOR_RE.test(char)) {
+        if (buffer.length === 0) {
+          reset()
+          return null
+        }
+        return tryMatch(char)
+      }
+
+      if (!PRINTABLE_RE.test(char)) {
+        reset()
+        return null
+      }
+
+      buffer += char
+      if (buffer.length > MAX_TRIGGER_BUFFER) {
+        reset()
+      }
+      return null
+    },
+    reset,
+  }
+}

package/src/state/reducers/modal-state.ts

@@ -160,6 +160,7 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         ...state,
         focusMode: 'command-edit',
         modal: {
+          actionMessage: null,
           cursorPos: 0,
           editBuffer: '',
           selectedIndex: 0,
@@ -167,6 +168,11 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           type: 'snippet-picker',
         },
       }
+    case 'snippet-picker-set-message': {
+      if (state.modal.type !== 'snippet-picker') return state
+      if (state.modal.actionMessage === action.message) return state
+      return { ...state, modal: { ...state.modal, actionMessage: action.message } }
+    }
     case 'open-snippet-editor': {
       const snippet = action.snippetId
         ? state.snippets.find((s) => s.id === action.snippetId)
@@ -180,8 +186,10 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           contentBuffer: snippet?.content ?? '',
           cursorPos: initialName.length,
           editBuffer: initialName,
+          nameBuffer: initialName,
           selectedIndex: 0,
           sessionTargetId: snippet?.id ?? null,
+          triggerBuffer: snippet?.trigger ?? '',
           type: 'snippet-editor',
         },
       }
@@ -553,14 +561,33 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         }
       }
       if (state.modal.type === 'snippet-editor') {
-        const nextField = state.modal.activeField === 'name' ? 'content' : 'name'
-        const nextEdit = state.modal.contentBuffer
+        const current = state.modal.editBuffer ?? ''
+        // Save current edit buffer back to the field it belongs to.
+        const updatedBuffers = {
+          contentBuffer:
+            state.modal.activeField === 'content' ? current : state.modal.contentBuffer,
+          nameBuffer: state.modal.activeField === 'name' ? current : state.modal.nameBuffer,
+          triggerBuffer:
+            state.modal.activeField === 'trigger' ? current : state.modal.triggerBuffer,
+        }
+        const cycle: Record<'name' | 'trigger' | 'content', 'name' | 'trigger' | 'content'> = {
+          content: 'name',
+          name: 'trigger',
+          trigger: 'content',
+        }
+        const nextField = cycle[state.modal.activeField]
+        const nextEditByField = {
+          content: updatedBuffers.contentBuffer,
+          name: updatedBuffers.nameBuffer,
+          trigger: updatedBuffers.triggerBuffer,
+        }
+        const nextEdit = nextEditByField[nextField]
         return {
           ...state,
           modal: {
             ...state.modal,
+            ...updatedBuffers,
             activeField: nextField,
-            contentBuffer: state.modal.editBuffer ?? '',
             cursorPos: nextEdit.length,
             editBuffer: nextEdit,
           },