@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -0,0 +1,197 @@
+import { $ } from 'bun'
+
+import type { SideEffectContext } from './side-effect-context'
+
+import { toast } from '../state/toast-store'
+import { triggerAutoCommitNow } from './auto-commit-ref'
+
+export async function runGitAction(
+  ctx: SideEffectContext,
+  args: string[],
+  pathToInvalidate?: string
+): Promise<void> {
+  const fallback = ctx.getCurrentProjectProjectPath()
+  const repoPath =
+    pathToInvalidate != null && pathToInvalidate !== ''
+      ? ctx.state.gitPanel.files.find((f) => f.path === pathToInvalidate)?.repoPath
+      : undefined
+  const cwd = repoPath ?? fallback
+  if (!(cwd != null && cwd !== '')) return
+  const result = await $`git -C ${cwd} ${args}`.quiet().nothrow()
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim()
+    ctx.dispatch({ message: stderr || 'git action failed', type: 'git-mode-set-message' })
+    return
+  }
+  ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+  if (pathToInvalidate != null && pathToInvalidate !== '') {
+    ctx.dispatch({ path: pathToInvalidate, type: 'git-mode-clear-diff-cache' })
+  }
+}
+
+export async function runGitActionAll(
+  ctx: SideEffectContext,
+  args: string[],
+  pathsToInvalidate: string[]
+): Promise<void> {
+  const cwd = ctx.getCurrentProjectProjectPath()
+  if (!(cwd != null && cwd !== '')) return
+  const result = await $`git -C ${cwd} ${args}`.quiet().nothrow()
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim()
+    ctx.dispatch({ message: stderr || 'git action failed', type: 'git-mode-set-message' })
+    return
+  }
+  ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+  if (pathsToInvalidate.length > 0) {
+    ctx.dispatch({ paths: pathsToInvalidate, type: 'git-mode-invalidate-diffs' })
+  }
+}
+
+export async function runGitRm(ctx: SideEffectContext, path: string): Promise<void> {
+  const repoPath = ctx.state.gitPanel.files.find((f) => f.path === path)?.repoPath
+  const cwd = repoPath ?? ctx.getCurrentProjectProjectPath()
+  if (!(cwd != null && cwd !== '')) return
+  const absolute = `${cwd}/${path}`
+  try {
+    const stat = await Bun.file(absolute).stat()
+    await (stat.isDirectory()
+      ? Bun.$`rm -rf -- ${absolute}`.quiet().nothrow()
+      : Bun.file(absolute).unlink())
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'failed to delete file'
+    ctx.dispatch({ message, type: 'git-mode-set-message' })
+    return
+  }
+  ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+  ctx.dispatch({ path, type: 'git-mode-clear-diff-cache' })
+}
+
+export async function runGitCommit(
+  ctx: SideEffectContext,
+  title: string,
+  body: string
+): Promise<void> {
+  const cwd = ctx.getCurrentProjectProjectPath()
+  if (!(cwd != null && cwd !== '')) return
+  if (!title) {
+    ctx.dispatch({ message: 'empty commit title', type: 'git-mode-set-message' })
+    return
+  }
+  const result = body
+    ? await $`git -C ${cwd} commit -m ${title} -m ${body}`.quiet().nothrow()
+    : await $`git -C ${cwd} commit -m ${title}`.quiet().nothrow()
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim()
+    ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+    toast.error(stderr || 'Commit failed')
+    return
+  }
+  clearAutoCommitForCurrentProject(ctx)
+  // Match the push flow: clear any inline git-pane message and surface the
+  // result as a toast so it's seen even after leaving git mode.
+  ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+  toast.success(`Committed: ${title}`)
+}
+
+export async function runGitCommitAuto(
+  ctx: SideEffectContext,
+  title: string,
+  body: string
+): Promise<void> {
+  if (!title) {
+    ctx.dispatch({ message: 'empty commit title', type: 'git-mode-set-message' })
+    return
+  }
+  const cwd = ctx.getCurrentProjectProjectPath()
+  if (!(cwd != null && cwd !== '')) return
+
+  // If the user has manually staged files, respect that intent and commit
+  // only the staged set — don't run `git add -A` which would sweep up
+  // unrelated unstaged/untracked changes. With nothing staged, `add -A`
+  // keeps the "commit everything" behaviour the user expects from auto-commit.
+  const hasStaged = ctx.state.gitPanel.files.some((f) => f.section === 'staged')
+  if (!hasStaged) {
+    const addArgs = ['add', '-A']
+    const addResult = await $`git -C ${cwd} ${addArgs}`.quiet().nothrow()
+    if (addResult.exitCode !== 0) {
+      ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+      toast.error(addResult.stderr.toString().trim() || 'Auto-commit: git add failed')
+      return
+    }
+  }
+
+  const commitResult = body
+    ? await $`git -C ${cwd} commit -m ${title} -m ${body}`.quiet().nothrow()
+    : await $`git -C ${cwd} commit -m ${title}`.quiet().nothrow()
+
+  if (commitResult.exitCode !== 0) {
+    ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+    toast.error(commitResult.stderr.toString().trim() || 'Auto-commit: commit failed')
+    return
+  }
+
+  clearAutoCommitForCurrentProject(ctx)
+  ctx.dispatch({ message: `committed: ${title}`, type: 'git-mode-set-message' })
+}
+
+export function clearAutoCommitForCurrentProject(ctx: SideEffectContext): void {
+  const projectId = ctx.state.currentProjectId
+  if (!(projectId != null && projectId !== '')) return
+  ctx.dispatch({ projectId, type: 'auto-commit-clear' })
+}
+
+export async function runGenerateAutoCommitNow(
+  ctx: SideEffectContext,
+  projectId: string
+): Promise<void> {
+  const project = ctx.state.projects.find((s) => s.id === projectId)
+  const panel = ctx.state.gitPanel
+  if (panel.error !== null) {
+    toast.warning('Auto-commit: git panel unavailable')
+    ctx.dispatch({ projectId, type: 'auto-commit-clear' })
+    return
+  }
+  const tab = ctx.activeTab
+  if (!tab) {
+    toast.warning('Auto-commit: no active assistant tab — open a claude/codex tab first')
+    ctx.dispatch({ projectId, type: 'auto-commit-clear' })
+    return
+  }
+  await triggerAutoCommitNow({
+    assistant: tab.assistant,
+    git: {
+      ahead: panel.ahead,
+      behind: panel.behind,
+      branch: panel.branch,
+      files: panel.files,
+    },
+    projectId,
+    projectPath: project?.projectPath,
+    tabId: tab.id,
+  })
+}
+
+export async function runGitPush(ctx: SideEffectContext): Promise<void> {
+  const cwd = ctx.getCurrentProjectProjectPath()
+  if (!(cwd != null && cwd !== '')) return
+  ctx.dispatch({ message: 'pushing…', type: 'git-mode-set-message' })
+
+  const upstream = await $`git -C ${cwd} rev-parse --abbrev-ref --symbolic-full-name @{u}`
+    .quiet()
+    .nothrow()
+  const hasUpstream = upstream.exitCode === 0
+
+  const result = hasUpstream
+    ? await $`git -C ${cwd} push`.quiet().nothrow()
+    : await $`git -C ${cwd} push --set-upstream origin HEAD`.quiet().nothrow()
+
+  // Clear the inline "pushing…" progress; surface the result as a toast so it's
+  // visible even after leaving git mode (and so push failures aren't missed).
+  ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+  if (result.exitCode !== 0) {
+    toast.error(result.stderr.toString().trim() || 'Push failed')
+    return
+  }
+  toast.success('Pushed')
+}

package/src/app-runtime/measure-ref.ts

@@ -0,0 +1,19 @@
+import type { MeasuredPaneRect } from './use-pane-size-report'
+
+// `onMeasure` reaches TerminalPane as a prop chain from app.tsx through
+// root.tsx. A widget hosting its own PTY sits in the bar tree, which that chain
+// never touches — same problem `dispatchGlobal` solves for actions, same shape
+// of answer. Going straight to backend.resizeTab instead would mean
+// re-implementing the PTY_MIN clamps and the per-tab dedupe that handleMeasure
+// owns, and a mismatch there makes the resize loop never settle.
+type MeasureFn = (tabId: string, rect: MeasuredPaneRect) => void
+
+let activeMeasure: MeasureFn | null = null
+
+export function setActiveMeasure(measure: MeasureFn | null): void {
+  activeMeasure = measure
+}
+
+export function measureGlobal(tabId: string, rect: MeasuredPaneRect): void {
+  activeMeasure?.(tabId, rect)
+}

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

@@ -0,0 +1,213 @@
+import type { AppState } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { logInputDebug } from '../debug/input-log'
+import { appStore } from '../state/app-store'
+import { saveProjectCatalog } from '../state/project-catalog'
+import {
+  filterTabsForActiveWorkspace,
+  getPrimaryWorkspace,
+  withActiveWorkspace,
+} from '../state/project-workspaces'
+import { appReducer } from '../state/store'
+import { buildTabEntries } from '../state/tab-entries'
+import { switchProjectRecords } from './project-actions'
+
+export function handleSwitchProjectByIndex(
+  ctx: SideEffectContext,
+  index: number,
+  workspaceId?: string
+): void {
+  const { backend, dispatch } = ctx
+  // Read fresh state. ctx.state is the snapshot from the previous render and
+  // lags behind dispatches that happened in the same JS turn.
+  const state = ctx.getState()
+  const ordered = [...state.projects].sort(
+    (a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER)
+  )
+  const target = ordered[index - 1]
+  if (!target) {
+    logInputDebug('app.projectBar.switchOutOfRange', { index, total: ordered.length })
+    return
+  }
+
+  // Resolve which workspace to land on. If the caller passed an explicit
+  // `workspaceId` (project-row tap → its primary, workspace-row tap → that
+  // workspace), honor it; otherwise let the target project keep its persisted
+  // activeWorkspaceId.
+  const resolvedWorkspaceId =
+    workspaceId != null &&
+    workspaceId !== '' &&
+    (target.workspaces?.some((w) => w.id === workspaceId) ?? false)
+      ? workspaceId
+      : undefined
+  const needsWorkspaceChange =
+    resolvedWorkspaceId != null && resolvedWorkspaceId !== target.activeWorkspaceId
+
+  if (target.id === state.currentProjectId) {
+    if (needsWorkspaceChange) {
+      dispatch({
+        projectId: target.id,
+        type: 'set-active-workspace',
+        workspaceId: resolvedWorkspaceId,
+      })
+    }
+    if (state.focusMode === 'git') {
+      dispatch({ type: 'exit-git-mode' })
+    }
+    return
+  }
+
+  // Cross-project: bundle the workspace change into the project record AND
+  // fold set-projects + load-project into a SINGLE setState call. Otherwise
+  // any subscriber notification (re-render, useEffect, backend re-attach)
+  // between dispatches can re-assert the project's previously-persisted
+  // activeWorkspaceId, dropping the user back on the last-visited workspace.
+  const patchedProject = needsWorkspaceChange
+    ? withActiveWorkspace(target, resolvedWorkspaceId)
+    : target
+  const patchedState: AppState = needsWorkspaceChange
+    ? {
+        ...state,
+        projects: state.projects.map((s) => (s.id === patchedProject.id ? patchedProject : s)),
+      }
+    : state
+  const projects = switchProjectRecords(patchedState, patchedProject)
+  saveProjectCatalog(projects)
+  void backend.destroy(true)
+  appStore.setState((current) => {
+    const afterSet = appReducer(current, { projects, type: 'set-projects' })
+    return appReducer(afterSet, {
+      forceDisconnected: false,
+      projectId: patchedProject.id,
+      projectSnapshot: patchedProject.projectSnapshot,
+      type: 'load-project',
+    })
+  })
+}
+
+/**
+ * One stop for `j`/`k`, and it is always a workspace — the project's own row is
+ * a heading, not a destination. Every project owns a primary (every path into
+ * the catalog runs `ensureProjectWorkspaces`), so no project can be skipped by
+ * having nothing to land on.
+ */
+interface SidebarItem {
+  projectId: string
+  workspaceId: string
+}
+
+function buildSidebarItems(state: AppState): SidebarItem[] {
+  const ordered = [...state.projects].sort(
+    (a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER)
+  )
+  const items: SidebarItem[] = []
+  for (const project of ordered) {
+    for (const workspace of project.workspaces ?? []) {
+      items.push({ projectId: project.id, workspaceId: workspace.id })
+    }
+  }
+  return items
+}
+
+function findCurrentSidebarItem(state: AppState, items: SidebarItem[]): number {
+  const projectId = state.currentProjectId
+  if (projectId == null || projectId === '') return -1
+  const project = state.projects.find((s) => s.id === projectId)
+  // An unset active workspace means the project sits on its checkout, which now
+  // has a row of its own to land on.
+  const activeWorkspaceId =
+    project?.activeWorkspaceId ?? getPrimaryWorkspace(project?.workspaces)?.id
+  if (activeWorkspaceId == null || activeWorkspaceId === '') return -1
+  return items.findIndex(
+    (item) => item.projectId === projectId && item.workspaceId === activeWorkspaceId
+  )
+}
+
+export function handleCycleSidebarItem(ctx: SideEffectContext, direction: 1 | -1): void {
+  const { backend, dispatch } = ctx
+  // Read fresh from the store, not ctx.state (which is a per-render
+  // snapshot). Rapid key presses fire before React re-renders, so ctx.state
+  // can lag the actual store.
+  const state = appStore.getState()
+  const items = buildSidebarItems(state)
+  if (items.length === 0) return
+  const currentIdx = findCurrentSidebarItem(state, items)
+  // If we don't know the current, jump to first/last depending on direction.
+  let startIdx: number
+  if (currentIdx >= 0) {
+    startIdx = currentIdx
+  } else {
+    startIdx = direction === 1 ? -1 : 0
+  }
+  const len = items.length
+  const target = items[(((startIdx + direction) % len) + len) % len]
+  if (!target) return
+
+  const project = state.projects.find((s) => s.id === target.projectId)
+  if (!project) return
+
+  const targetWorkspaceId = target.workspaceId
+  const isCrossProject = project.id !== state.currentProjectId
+  const needsWorkspaceChange = targetWorkspaceId !== project.activeWorkspaceId
+
+  if (isCrossProject) {
+    // Bundle the workspace change into the project record AND fold the
+    // project switch's two dispatches (set-projects + load-project) into a
+    // SINGLE Zustand setState call — otherwise each dispatch fires a
+    // separate subscription notification and the @opentui/react reconciler
+    // paints an intermediate frame where the new project is current but
+    // the old activeWorkspaceId still holds, producing the visible flicker.
+    const patchedProject = needsWorkspaceChange
+      ? withActiveWorkspace(project, targetWorkspaceId)
+      : project
+    const patchedState: AppState = needsWorkspaceChange
+      ? {
+          ...state,
+          projects: state.projects.map((s) => (s.id === patchedProject.id ? patchedProject : s)),
+        }
+      : state
+    const projects = switchProjectRecords(patchedState, patchedProject)
+    saveProjectCatalog(projects)
+    void backend.destroy(true)
+    appStore.setState((current) => {
+      const afterSet = appReducer(current, { projects, type: 'set-projects' })
+      return appReducer(afterSet, {
+        // Daemon is alive and attach() will hydrate real statuses within a
+        // frame, so skip the snapshot's running→disconnected downgrade —
+        // otherwise the "Restored snapshot" hint flashes on every j/k cycle.
+        forceDisconnected: false,
+        projectId: patchedProject.id,
+        projectSnapshot: patchedProject.projectSnapshot,
+        type: 'load-project',
+      })
+    })
+    return
+  }
+
+  if (needsWorkspaceChange) {
+    dispatch({
+      projectId: project.id,
+      type: 'set-active-workspace',
+      workspaceId: targetWorkspaceId,
+    })
+  }
+}
+
+export function handleSwitchTabByIndex(ctx: SideEffectContext, index: number): void {
+  const { dispatch, state } = ctx
+  const currentProject =
+    state.currentProjectId != null && state.currentProjectId !== ''
+      ? state.projects.find((s) => s.id === state.currentProjectId)
+      : undefined
+  const visible = filterTabsForActiveWorkspace(state.tabs, currentProject)
+  const entries = buildTabEntries(visible, state.layoutTrees, state.tabGroupMap, state.activeTabId)
+  const target = entries[index - 1]
+  if (!target) {
+    logInputDebug('app.tabBar.switchOutOfRange', { index, total: entries.length })
+    return
+  }
+  const targetTabId = target.kind === 'single' ? target.tab.id : target.activeLeafId
+  if (targetTabId === state.activeTabId) return
+  dispatch({ tabId: targetTabId, type: 'set-active-tab' })
+}

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

@@ -0,0 +1,188 @@
+import type { SessionBackend } from '../session-backend/types'
+import type { AppAction } from '../state/actions'
+import type { AppState, ProjectRecord, TabSession } from '../state/types'
+
+import { logInputDebug } from '../debug/input-log'
+import { createPrefixedId } from '../platform/id'
+import { saveProjectCatalog } from '../state/project-catalog'
+import { createEmptyProjectSnapshot, serializeProject } from '../state/project-persistence'
+import { buildProjectsWithCurrentSnapshot } from '../state/project-save'
+import { createPrimaryWorkspace, ensureProjectWorkspaces } from '../state/project-workspaces'
+import { toast } from '../state/toast-store'
+
+export function createProjectFromCurrentState(
+  state: AppState,
+  name: string,
+  projectPath?: string
+): { project: ProjectRecord; projects: ProjectRecord[] } {
+  const now = new Date().toISOString()
+  const projectSnapshot =
+    (state.currentProjectId != null && state.currentProjectId !== '') || state.tabs.length === 0
+      ? createEmptyProjectSnapshot()
+      : serializeProject(state)
+  const project: ProjectRecord = {
+    activeWorkspaceId: undefined,
+    createdAt: now,
+    id: createPrefixedId('project'),
+    lastOpenedAt: now,
+    name,
+    projectPath,
+    projectSnapshot,
+    updatedAt: now,
+    workspaces: undefined,
+  }
+  if (projectPath != null && projectPath !== '') {
+    const workspace = createPrimaryWorkspace(projectPath, now)
+    project.activeWorkspaceId = workspace.id
+    project.workspaces = [workspace]
+  }
+
+  let updatedProjects = state.projects
+  if (state.currentProjectId != null && state.currentProjectId !== '') {
+    const currentSnapshot = serializeProject(state)
+    updatedProjects = state.projects.map((entry) =>
+      entry.id === state.currentProjectId
+        ? { ...entry, projectSnapshot: currentSnapshot, updatedAt: now }
+        : entry
+    )
+  }
+
+  return {
+    project,
+    projects: [...updatedProjects, ensureProjectWorkspaces(project)],
+  }
+}
+
+export function renameProjectRecords(
+  projects: ProjectRecord[],
+  projectId: string,
+  name: string
+): ProjectRecord[] {
+  return projects.map((project) =>
+    project.id === projectId ? { ...project, name, updatedAt: new Date().toISOString() } : project
+  )
+}
+
+export function switchProjectRecords(state: AppState, project: ProjectRecord): ProjectRecord[] {
+  const projectsWithSnapshot = buildProjectsWithCurrentSnapshot(
+    state.projects,
+    state.currentProjectId,
+    state
+  )
+  return projectsWithSnapshot.map((entry) =>
+    entry.id === project.id ? { ...entry, lastOpenedAt: new Date().toISOString() } : entry
+  )
+}
+
+export function deleteProjectRecords(
+  projects: ProjectRecord[],
+  projectId: string
+): ProjectRecord[] {
+  return projects.filter((project) => project.id !== projectId)
+}
+
+export function handleCreateProjectEffect(
+  state: AppState,
+  dispatch: (action: AppAction) => void,
+  name: string,
+  projectPath?: string
+): void {
+  const { project, projects } = createProjectFromCurrentState(state, name, projectPath)
+  logInputDebug('app.project.create', {
+    fromCurrentProject:
+      (state.currentProjectId == null || state.currentProjectId === '') && state.tabs.length > 0,
+    name,
+    projectId: project.id,
+    tabCount: project.projectSnapshot?.tabs.length ?? 0,
+  })
+  saveProjectCatalog(projects)
+  dispatch({ projects, type: 'set-projects' })
+  dispatch({
+    projectId: project.id,
+    projectSnapshot: project.projectSnapshot,
+    type: 'load-project',
+  })
+}
+
+export function handleRenameProjectEffect(
+  projects: ProjectRecord[],
+  dispatch: (action: AppAction) => void,
+  projectId: string,
+  name: string
+): void {
+  logInputDebug('app.project.rename', { name, projectId })
+  const renamed = renameProjectRecords(projects, projectId, name)
+  saveProjectCatalog(renamed)
+  dispatch({ name, projectId, type: 'rename-project-record' })
+}
+
+export function handleSwitchProjectEffect(
+  state: AppState,
+  backend: SessionBackend,
+  dispatch: (action: AppAction) => void,
+  project: ProjectRecord
+): void {
+  logInputDebug('app.project.switch.start', {
+    currentTabCount: state.tabs.length,
+    fromProjectId: state.currentProjectId,
+    restoredTabCount: project.projectSnapshot?.tabs.length ?? 0,
+    toName: project.name,
+    toProjectId: project.id,
+  })
+  const projects = switchProjectRecords(state, project)
+  saveProjectCatalog(projects)
+  void backend.destroy(true)
+  dispatch({ projects, type: 'set-projects' })
+  dispatch({
+    projectId: project.id,
+    projectSnapshot: project.projectSnapshot,
+    type: 'load-project',
+  })
+  logInputDebug('app.project.switch.dispatched', { toProjectId: project.id })
+}
+
+export function handleDeleteProjectEffect(
+  state: AppState,
+  backend: SessionBackend,
+  dispatch: (action: AppAction) => void,
+  projectId: string,
+  options?: { openProjectPicker?: boolean }
+): void {
+  const name = state.projects.find((entry) => entry.id === projectId)?.name
+  const remaining = deleteProjectRecords(state.projects, projectId)
+  logInputDebug('app.project.delete', {
+    projectId,
+    remainingCount: remaining.length,
+    wasCurrent: projectId === state.currentProjectId,
+  })
+  saveProjectCatalog(remaining)
+  if (projectId === state.currentProjectId) {
+    void backend.destroy(true)
+  }
+  dispatch({
+    openProjectPicker: options?.openProjectPicker,
+    projectId,
+    type: 'delete-project-record',
+  })
+  toast.success(name != null && name !== '' ? `Deleted project "${name}"` : 'Project deleted')
+}
+
+export function restartTabSession(
+  backend: SessionBackend,
+  dispatch: (action: AppAction) => void,
+  clearIdleTimer: (tabId: string) => void,
+  clearStartupGrace: (tabId: string) => void,
+  startTabSession: (tab: TabSession) => void,
+  tab: TabSession
+): void {
+  logInputDebug('app.restartTab', {
+    command: tab.command,
+    status: tab.status,
+    tabId: tab.id,
+  })
+  clearIdleTimer(tab.id)
+  clearStartupGrace(tab.id)
+  backend.disposeSession(tab.id)
+  dispatch({ tabId: tab.id, type: 'reset-tab-project' })
+  startTabSession(tab)
+}