@brimveyn/aimux 1.20.4 → 1.22.0

package/src/app-runtime/snippet-actions.ts

@@ -1,5 +1,6 @@
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, AppState, SnippetRecord, TabSession } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { AppState, SnippetRecord, TabSession } from '../state/types'
 
 import { createPrefixedId } from '../platform/id'
 import { isConfigSnippetId, saveSnippetCatalog } from '../state/snippet-catalog'
@@ -40,7 +41,7 @@ export function saveSnippetEditorState(state: AppState): SnippetRecord[] | null
     return null
   }
 
-  const snippetId = state.modal.sessionTargetId
+  const snippetId = state.modal.projectTargetId
   // Config-pinned snippets are sticky and read-only in the UI.
   if (snippetId != null && snippetId !== '' && isConfigSnippetId(snippetId)) {
     return null

package/src/app-runtime/split-drag-controller.ts

@@ -16,8 +16,7 @@ export interface AxisDragState {
   screenStart: number
 }
 
-export interface AnchoredRatioDragState {
-  anchor: 'start' | 'end'
+export interface RatioDragState {
   axis: ScreenAxis
   screenStart: number
   totalSize: number
@@ -38,10 +37,7 @@ export function getAxisDeltaFromDrag(event: OtuiMouseEvent, drag: AxisDragState)
   return getScreenPosition(event, drag.axis) - drag.screenStart
 }
 
-export function getAnchoredRatioFromDrag(
-  event: OtuiMouseEvent,
-  drag: AnchoredRatioDragState
-): number {
-  const offset = getScreenPosition(event, drag.axis) - drag.screenStart
-  return drag.anchor === 'start' ? offset / drag.totalSize : 1 - offset / drag.totalSize
+/** Cursor position as a 0..1 fraction of the dragged container. */
+export function getRatioFromDrag(event: OtuiMouseEvent, drag: RatioDragState): number {
+  return (getScreenPosition(event, drag.axis) - drag.screenStart) / drag.totalSize
 }

package/src/app-runtime/tab-actions.ts

@@ -0,0 +1,218 @@
+import type { AssistantId, TabSession } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { logInputDebug } from '../debug/input-log'
+import { createPrefixedId } from '../platform/id'
+import {
+  getAllAssistantOptions,
+  getAssistantOption,
+  isCommandAvailable,
+  parseCommand,
+} from '../pty/command-registry'
+import { createTerminalBounds } from '../state/layout-resize'
+import {
+  computePaneRects,
+  createLeaf,
+  getTreeForTab,
+  PANE_BORDER,
+  type SplitDirection,
+  splitNode,
+} from '../state/layout-tree'
+import { getActiveWorkspace, getCurrentProject } from '../state/project-workspaces'
+import { createDefaultTerminalModes } from '../state/terminal-modes'
+import { getSelectedAssistantOption } from './selection'
+
+/**
+ * How long a freshly spawned assistant is given to draw something before the
+ * tab stops being treated as "still starting up".
+ */
+const STARTUP_GRACE_MS = 5_000
+
+export function confirmSplitSelection(ctx: SideEffectContext): void {
+  const { dispatch, state } = ctx
+  const option = getSelectedAssistantOption(state)
+  const direction = state.modal.type === 'split-picker' ? state.modal.splitDirection : 'vertical'
+  const customCommand = state.customCommands[option.id]
+  const tab = createTabSession(
+    option.id,
+    customCommand,
+    state.customCommands,
+    getActiveWorkspace(getCurrentProject(state))?.id
+  )
+  dispatch({ type: 'close-modal' })
+  executeSplitPane(ctx, direction, tab)
+  dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
+}
+
+function createTabId(): string {
+  return createPrefixedId('tab')
+}
+
+export function createTabSession(
+  assistant: AssistantId,
+  customCommand?: string,
+  customCommands?: Record<string, string>,
+  workspaceId?: string
+): TabSession {
+  const allOptions = getAllAssistantOptions(customCommands ?? {})
+  const option = allOptions.find((o) => o.id === assistant) ?? getAssistantOption(0)
+
+  return {
+    activity: 'idle',
+    assistant,
+    buffer: '',
+    command: customCommand ?? option.command,
+    id: createTabId(),
+    status: 'starting',
+    terminalModes: createDefaultTerminalModes(),
+    title: option.label,
+    workspaceId,
+  }
+}
+
+/** Everything `startTabSession` needs from the side-effect context. */
+type StartTabSessionContext = Pick<
+  SideEffectContext,
+  'backend' | 'clearStartupGrace' | 'dispatch' | 'startStartupGrace'
+>
+
+export interface StartTabSessionOptions {
+  cols: number
+  rows: number
+  cwd?: string
+  /** Default true: only a tab the user did not just ask for opts out. */
+  autoRenameCandidate?: boolean
+  /**
+   * Appended after the command's own args. Kept out of `tab.command` on purpose:
+   * an initial prompt is up to a few thousand characters, and `command` is what
+   * the UI shows, what the snapshot persists, and what the custom-command editor
+   * round-trips.
+   */
+  extraArgs?: string[]
+}
+
+export function startTabSession(
+  ctx: StartTabSessionContext,
+  tab: Pick<TabSession, 'id' | 'assistant' | 'title' | 'command' | 'workspaceId'>,
+  { autoRenameCandidate = true, cols, cwd, extraArgs, rows }: StartTabSessionOptions
+): void {
+  const { backend, clearStartupGrace, dispatch } = ctx
+  logInputDebug('app.tab.start.request', {
+    cols,
+    command: tab.command,
+    cwd: cwd ?? null,
+    rows,
+    tabId: tab.id,
+    title: tab.title,
+    workspaceId: tab.workspaceId ?? null,
+  })
+  ctx.startStartupGrace(tab.id, STARTUP_GRACE_MS)
+
+  const { args, executable } = parseCommand(tab.command)
+
+  if (!isCommandAvailable(executable)) {
+    clearStartupGrace(tab.id)
+    dispatch({
+      message: `[command not found] ${executable} is not available in PATH.`,
+      tabId: tab.id,
+      type: 'set-tab-error',
+    })
+    return
+  }
+
+  backend.createSession({
+    args: extraArgs ? [...args, ...extraArgs] : args,
+    assistant: tab.assistant,
+    autoRenameCandidate,
+    cols,
+    command: executable,
+    cwd,
+    rows,
+    tabId: tab.id,
+    title: tab.title,
+    workspaceId: tab.workspaceId,
+  })
+}
+
+/**
+ * Returns the id of the tab it created, so a caller can write into it.
+ *
+ * `initialPromptArgs` hands the prompt to the CLI at spawn — see
+ * `assistantAcceptsPromptArg`. Callers pass it only for assistants that support
+ * it, and fall back to `injectPromptWhenReady` otherwise.
+ */
+export function launchAssistant(
+  ctx: SideEffectContext,
+  assistant: AssistantId,
+  workspaceId?: string,
+  initialPromptArgs?: string[]
+): string {
+  const { dispatch, state } = ctx
+  const customCommand = state.customCommands[assistant]
+  const tab = createTabSession(
+    assistant,
+    customCommand,
+    state.customCommands,
+    workspaceId ?? getActiveWorkspace(getCurrentProject(state))?.id
+  )
+  logInputDebug('app.launchAssistant', {
+    assistant,
+    command: tab.command,
+    tabId: tab.id,
+  })
+  dispatch({ tab, type: 'add-tab' })
+  dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
+  startTabSession(ctx, tab, {
+    cols: state.layout.terminalCols,
+    cwd: getTabProjectPath(ctx, tab),
+    extraArgs: initialPromptArgs,
+    rows: state.layout.terminalRows,
+  })
+  return tab.id
+}
+
+export function getTabProjectPath(
+  ctx: SideEffectContext,
+  tab: Pick<TabSession, 'workspaceId'>
+): string | undefined {
+  // Scoped to the current project on purpose: a tab pinned to a workspace of
+  // some other project gets the current project's path, not that project's.
+  const project = getCurrentProject(ctx.state)
+  const workspace = project?.workspaces?.find((entry) => entry.id === tab.workspaceId)
+  if (workspace) return workspace.path
+  return ctx.getCurrentProjectProjectPath()
+}
+
+export function startExistingTab(ctx: SideEffectContext, tab: TabSession): void {
+  startTabSession(ctx, tab, {
+    autoRenameCandidate: false,
+    cols: ctx.state.layout.terminalCols,
+    cwd: getTabProjectPath(ctx, tab),
+    rows: ctx.state.layout.terminalRows,
+  })
+}
+
+export function executeSplitPane(
+  ctx: SideEffectContext,
+  direction: SplitDirection,
+  tab: TabSession
+): void {
+  const { dispatch, state } = ctx
+  const activeTabId = state.activeTabId
+  if (!(activeTabId != null && activeTabId !== '')) {
+    return
+  }
+
+  const existingTree = getTreeForTab(state.layoutTrees, state.tabGroupMap, activeTabId)
+  const baseTree = existingTree ?? createLeaf(activeTabId)
+  const newTree = splitNode(baseTree, activeTabId, direction, tab.id)
+  const bounds = createTerminalBounds(state.layout.terminalCols, state.layout.terminalRows)
+  const paneRect = computePaneRects(newTree, bounds).get(tab.id)
+
+  dispatch({ direction, newTab: tab, type: 'split-pane' })
+  startTabSession(ctx, tab, {
+    cols: Math.max(1, (paneRect?.cols ?? state.layout.terminalCols) - PANE_BORDER * 2),
+    cwd: getTabProjectPath(ctx, tab),
+    rows: Math.max(1, (paneRect?.rows ?? state.layout.terminalRows) - PANE_BORDER * 2),
+  })
+}

package/src/app-runtime/tab-runtime-timeouts.ts

@@ -1,6 +1,6 @@
 import { useCallback, useRef } from 'react'
 
-import type { AppAction } from '../state/types'
+import type { AppAction } from '../state/actions'
 
 export interface TabRuntimeTimeouts {
   clearIdleTimer: (tabId: string) => void

package/src/app-runtime/use-auto-commit-driver.ts

@@ -1,6 +1,7 @@
 import { type MutableRefObject, useEffect, useRef } from 'react'
 
-import type { AppAction, AppState, GitRefreshPayload, TabActivity } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { AppState, GitRefreshPayload, TabActivity } from '../state/types'
 
 import {
   type AutoCommitConfigSnapshot,
@@ -61,7 +62,7 @@ export function useAutoCommitDriver({
   const prevActivityRef = useRef<Map<string, TabActivity | undefined>>(new Map())
 
   useEffect(() => {
-    // Always refresh the activity map so re-enabling mid-session doesn't fire
+    // Always refresh the activity map so re-enabling mid-project doesn't fire
     // a stale "became idle" transition. Skip only the dispatch work.
     const prev = prevActivityRef.current
     const next = new Map<string, TabActivity | undefined>()
@@ -73,15 +74,15 @@ export function useAutoCommitDriver({
       const becameIdle =
         (before === 'working' || before === 'waiting-input') && tab.activity === 'idle'
       if (becameIdle) {
-        const sessionId = state.currentSessionId
-        if (!(sessionId != null && sessionId !== '')) continue
-        const session = state.sessions.find((s) => s.id === sessionId)
+        const projectId = state.currentProjectId
+        if (!(projectId != null && projectId !== '')) continue
+        const project = state.projects.find((s) => s.id === projectId)
         const git = gitPayloadFromState(state)
         void onActivityTransition(depsRef.current, {
           assistant: tab.assistant,
           git,
-          projectPath: session?.projectPath,
-          sessionId,
+          projectId,
+          projectPath: project?.projectPath,
           tabId: tab.id,
         })
       }
@@ -94,14 +95,14 @@ export function useAutoCommitDriver({
 
   useEffect(() => {
     if (!configRef.current.enabled) return
-    const sessionId = state.currentSessionId
-    if (!(sessionId != null && sessionId !== '')) return
+    const projectId = state.currentProjectId
+    if (!(projectId != null && projectId !== '')) return
     const payload = gitPayloadFromState(state)
     if (!payload) return
     const cacheKey = JSON.stringify(payload)
     if (lastGitHashRef.current === cacheKey) return
     lastGitHashRef.current = cacheKey
-    onGitRefresh(depsRef.current, sessionId, payload)
+    onGitRefresh(depsRef.current, projectId, payload)
 
     // Debounced trigger: when the working tree stays stable for
     // GIT_STABILIZATION_DEBOUNCE_MS, try to start generation. Covers cases
@@ -114,14 +115,14 @@ export function useAutoCommitDriver({
         ? state.tabs.find((tab) => tab.id === activeTabId)
         : undefined
     if (!activeTab) return
-    const session = state.sessions.find((s) => s.id === sessionId)
+    const project = state.projects.find((s) => s.id === projectId)
     gitStabilizeTimerRef.current = setTimeout(() => {
       gitStabilizeTimerRef.current = null
       void onActivityTransition(depsRef.current, {
         assistant: activeTab.assistant,
         git: payload,
-        projectPath: session?.projectPath,
-        sessionId,
+        projectId,
+        projectPath: project?.projectPath,
         tabId: activeTab.id,
       })
     }, GIT_STABILIZATION_DEBOUNCE_MS)

package/src/app-runtime/use-backend-runtime.ts

@@ -1,7 +1,8 @@
 import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, LayoutState } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { LayoutState } from '../state/types'
 
 import { attachCurrentSession } from './backend-attach-runtime'
 import { bindBackendRuntimeEvents } from './backend-runtime-events'
@@ -11,10 +12,10 @@ interface BackendRuntimeOptions {
   backend: SessionBackend
   dispatch: (action: AppAction) => void
   activeTabId: string | null
-  currentSessionId: string | null
+  currentProjectId: string | null
   layoutRef: MutableRefObject<LayoutState>
   resizingRef: MutableRefObject<boolean>
-  currentSessionWorkspaceSnapshot: Parameters<SessionBackend['attach']>[0]['workspaceSnapshot']
+  currentProjectProjectSnapshot: Parameters<SessionBackend['attach']>[0]['projectSnapshot']
   syntaxOverlayEnabled: () => boolean
 }
 
@@ -27,8 +28,8 @@ export interface TabRuntimeControls {
 export function useBackendRuntime({
   activeTabId,
   backend,
-  currentSessionId,
-  currentSessionWorkspaceSnapshot,
+  currentProjectId,
+  currentProjectProjectSnapshot,
   dispatch,
   layoutRef,
   resizingRef,
@@ -39,7 +40,7 @@ export function useBackendRuntime({
   const { clearAllTimers, clearIdleTimer, clearStartupGrace, startStartupGrace } = timeouts
 
   useEffect(() => {
-    if (!(currentSessionId != null && currentSessionId !== '')) {
+    if (!(currentProjectId != null && currentProjectId !== '')) {
       attachRequestIdRef.current += 1
       return
     }
@@ -47,22 +48,22 @@ export function useBackendRuntime({
     return attachCurrentSession({
       attachRequestIdRef,
       backend,
-      currentSessionId,
-      currentSessionWorkspaceSnapshot,
+      currentProjectId,
+      currentProjectProjectSnapshot,
       dispatch,
       layoutRef,
     })
-  }, [backend, currentSessionId, currentSessionWorkspaceSnapshot, dispatch, layoutRef])
+  }, [backend, currentProjectId, currentProjectProjectSnapshot, dispatch, layoutRef])
 
   useEffect(() => {
-    if (!(currentSessionId != null && currentSessionId !== '')) {
+    if (!(currentProjectId != null && currentProjectId !== '')) {
       return
     }
 
     // The backend owns each tab's scroll position; a backgrounded tab keeps it
     // in its own emulator, so switching back needs no re-anchor from here.
     backend.setActiveTab(activeTabId)
-  }, [activeTabId, backend, currentSessionId])
+  }, [activeTabId, backend, currentProjectId])
 
   useEffect(() => {
     return bindBackendRuntimeEvents({

package/src/app-runtime/use-directory-search.ts

@@ -1,13 +1,14 @@
 import { useEffect } from 'react'
 
-import type { AppAction, ModalState } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { ModalState } from '../state/types'
 
 import { searchProjectDirectories, warmDirectoryCache } from '../platform/project-search'
 
 const DEFAULT_DIRECTORY_SEARCH_DEBOUNCE_MS = 200
 
 function getDirectoryQuery(modal: ModalState): string {
-  if (modal.type !== 'create-session') {
+  if (modal.type !== 'create-project') {
     return ''
   }
 
@@ -26,12 +27,12 @@ export function useDirectorySearch(
   const directoryQuery = getDirectoryQuery(modal)
 
   useEffect(() => {
-    if (modal.type !== 'create-session') return
+    if (modal.type !== 'create-project') return
     void warmDirectoryCache()
   }, [modal.type])
 
   useEffect(() => {
-    if (modal.type !== 'create-session') {
+    if (modal.type !== 'create-project') {
       return
     }
 

package/src/app-runtime/use-mouse-handlers.ts

@@ -4,8 +4,9 @@ import { useEffect, useRef } from 'react'
 
 import type { TerminalContentOrigin } from '../input/raw-input-handler'
 import type { SessionBackend } from '../session-backend/types'
+import type { AppAction } from '../state/actions'
 import type { SplitDirection } from '../state/layout-tree'
-import type { AppAction, AppState, TabSession, TerminalLine } from '../state/types'
+import type { AppState, BarSide, TabSession, TerminalLine } from '../state/types'
 
 import { logInputDebug } from '../debug/input-log'
 import { MultiClickDetector } from '../input/multi-click-detector'
@@ -23,20 +24,19 @@ import { recordMultiClickClipboardWrite } from './multi-click-clipboard-guard'
 import { requestRenderUpTree } from './render-invalidation'
 import { shouldWriteSelectionToClipboard } from './selection-clipboard-dedup'
 import {
-  type AnchoredRatioDragState,
   type AxisDragState,
-  getAnchoredRatioFromDrag,
   getAxisDeltaFromDrag,
+  getRatioFromDrag,
   getSplitRatioFromDrag,
+  type RatioDragState,
   type SplitDragState,
 } from './split-drag-controller'
 import { getForwardedMouseSequence, getScrollViewportDelta } from './terminal-mouse-adapter'
 
 type ResizeDragState =
   | ({ kind: 'split' } & SplitDragState)
-  | ({ initialWidth: number; kind: 'sidebar' } & AxisDragState)
-  | ({ initialWidth: number; kind: 'git-pane'; side: 'left' | 'right' } & AxisDragState)
-  | ({ kind: 'embedded-git'; position: 'top' | 'bottom' } & AnchoredRatioDragState)
+  | ({ initialWidth: number; kind: 'bar'; side: BarSide } & AxisDragState)
+  | ({ index: number; kind: 'bar-boundary'; side: BarSide } & RatioDragState)
 
 interface MultiClickDragState {
   mode: MultiClickMode
@@ -322,40 +322,32 @@ export function useMouseHandlers({
     separatorDragRef.current = { kind: 'split', ...info }
   }
 
-  const handleSidebarResizeStart = (info: { initialWidth: number; screenStart: number }) => {
-    separatorDragRef.current = {
-      axis: 'x',
-      initialWidth: info.initialWidth,
-      kind: 'sidebar',
-      screenStart: info.screenStart,
-    }
-  }
-
-  const handleGitPaneResizeStart = (info: {
+  const handleBarResizeStart = (info: {
     initialWidth: number
     screenStart: number
-    side: 'left' | 'right'
+    side: BarSide
   }) => {
     separatorDragRef.current = {
       axis: 'x',
       initialWidth: info.initialWidth,
-      kind: 'git-pane',
+      kind: 'bar',
       screenStart: info.screenStart,
       side: info.side,
     }
   }
 
-  const handleEmbeddedGitResizeStart = (info: {
+  const handleBarBoundaryResizeStart = (info: {
     containerStart: number
-    position: 'top' | 'bottom'
+    index: number
+    side: BarSide
     totalSize: number
   }) => {
     separatorDragRef.current = {
-      anchor: info.position === 'top' ? 'start' : 'end',
       axis: 'y',
-      kind: 'embedded-git',
-      position: info.position,
+      index: info.index,
+      kind: 'bar-boundary',
       screenStart: info.containerStart,
+      side: info.side,
       totalSize: info.totalSize,
     }
   }
@@ -377,27 +369,22 @@ export function useMouseHandlers({
         })
         break
       }
-      case 'sidebar': {
-        const nextWidth = Math.round(drag.initialWidth + getAxisDeltaFromDrag(event, drag))
-        dispatch({ type: 'set-sidebar-width', width: nextWidth })
-        break
-      }
-      case 'git-pane': {
-        const delta = getAxisDeltaFromDrag(event, drag)
-        const direction = drag.side === 'left' ? 1 : -1
-        const nextWidth = drag.initialWidth + delta * direction
+      case 'bar': {
+        // The right bar grows as the cursor moves left, hence the flipped sign.
+        const delta = getAxisDeltaFromDrag(event, drag) * (drag.side === 'left' ? 1 : -1)
         dispatch({
-          ratio: nextWidth / 80,
-          target: 'pane',
-          type: 'set-git-pane-ratio',
+          side: drag.side,
+          type: 'set-bar-width',
+          width: Math.round(drag.initialWidth + delta),
         })
         break
       }
-      case 'embedded-git': {
+      case 'bar-boundary': {
         dispatch({
-          ratio: getAnchoredRatioFromDrag(event, drag),
-          target: 'embedded',
-          type: 'set-git-pane-ratio',
+          index: drag.index,
+          ratio: getRatioFromDrag(event, drag),
+          side: drag.side,
+          type: 'set-bar-boundary',
         })
         break
       }
@@ -586,13 +573,12 @@ export function useMouseHandlers({
   }
 
   return {
-    handleEmbeddedGitResizeStart,
-    handleGitPaneResizeStart,
+    handleBarBoundaryResizeStart,
+    handleBarResizeStart,
     handlePaneActivate,
     handleSeparatorDrag,
     handleSeparatorDragEnd,
     handleSeparatorDragStart,
-    handleSidebarResizeStart,
     handleSplitResize,
     handleTerminalClick,
     handleTerminalDrag,

package/src/app-runtime/{use-workspace-autosave.ts → use-project-autosave.ts}

@@ -2,9 +2,9 @@ import { useEffect, useRef } from 'react'
 
 import type { AppState } from '../state/types'
 
-import { saveCurrentWorkspace } from '../state/workspace-save'
+import { saveCurrentProject } from '../state/project-save'
 
-export function useWorkspaceAutosave(state: AppState, debounceMs: number): void {
+export function useProjectAutosave(state: AppState, debounceMs: number): void {
   const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const latestStateRef = useRef(state)
   latestStateRef.current = state
@@ -15,7 +15,7 @@ export function useWorkspaceAutosave(state: AppState, debounceMs: number): void
     }
 
     timeoutRef.current = setTimeout(() => {
-      saveCurrentWorkspace(latestStateRef.current)
+      saveCurrentProject(latestStateRef.current)
       timeoutRef.current = null
     }, debounceMs)
 
@@ -33,7 +33,7 @@ export function useWorkspaceAutosave(state: AppState, debounceMs: number): void
         clearTimeout(timeoutRef.current)
         timeoutRef.current = null
       }
-      saveCurrentWorkspace(latestStateRef.current)
+      saveCurrentProject(latestStateRef.current)
     }
   }, [])
 }

package/src/app-runtime/use-renderer-bindings.ts

@@ -4,7 +4,8 @@ import { type MutableRefObject, useEffect, useRef } from 'react'
 
 import type { KeyChord } from '../input/keymap/key-chord'
 import type { SessionBackend } from '../session-backend/types'
-import type { AppAction, FocusMode, SnippetRecord, TabSession } from '../state/types'
+import type { AppAction } from '../state/actions'
+import type { FocusMode, SnippetRecord, TabSession } from '../state/types'
 
 import { INPUT_DEBUG_LOG_PATH, logInputDebug } from '../debug/input-log'
 import { createRawInputHandler } from '../input/raw-input-handler'