@brimveyn/aimux 1.20.4 → 1.22.0

package/src/daemon/session-manager.ts

@@ -1,10 +1,10 @@
 import { EventEmitter } from 'node:events'
 
 import type {
+  ProjectSnapshotV1,
   TabSession,
   TerminalModeState,
   TerminalSnapshot,
-  WorkspaceSnapshotV1,
 } from '../state/types'
 
 import { logDebug } from '../debug/input-log'
@@ -12,110 +12,110 @@ import { SessionRegistry } from './session-registry'
 
 interface SessionManagerEvents {
   render: [
-    sessionId: string,
+    projectId: string,
     tabId: string,
     viewport: TerminalSnapshot,
     terminalModes: TerminalModeState,
   ]
-  exit: [sessionId: string, tabId: string, exitCode: number]
-  error: [sessionId: string, tabId: string, message: string]
+  exit: [projectId: string, tabId: string, exitCode: number]
+  error: [projectId: string, tabId: string, message: string]
 }
 
 export class SessionManager extends EventEmitter<SessionManagerEvents> {
   private registries = new Map<string, SessionRegistry>()
 
-  private getOrCreateRegistry(sessionId: string): SessionRegistry {
-    const existing = this.registries.get(sessionId)
+  private getOrCreateRegistry(projectId: string): SessionRegistry {
+    const existing = this.registries.get(projectId)
     if (existing) {
       return existing
     }
 
     const registry = new SessionRegistry()
     registry.on('render', (tabId, viewport, terminalModes) => {
-      this.emit('render', sessionId, tabId, viewport, terminalModes)
+      this.emit('render', projectId, tabId, viewport, terminalModes)
     })
     registry.on('exit', (tabId, exitCode) => {
-      this.emit('exit', sessionId, tabId, exitCode)
+      this.emit('exit', projectId, tabId, exitCode)
     })
     registry.on('error', (tabId, message) => {
-      this.emit('error', sessionId, tabId, message)
+      this.emit('error', projectId, tabId, message)
     })
-    this.registries.set(sessionId, registry)
+    this.registries.set(projectId, registry)
     return registry
   }
 
-  attachSession(sessionId: string, snapshot?: WorkspaceSnapshotV1) {
+  attachSession(projectId: string, snapshot?: ProjectSnapshotV1) {
     logDebug('daemon.sessionManager.attachSession', {
       hasSnapshot: !!snapshot,
-      sessionId,
+      projectId,
       snapshotTabs: snapshot?.tabs.length ?? 0,
     })
-    return this.getOrCreateRegistry(sessionId).attachFromSnapshot(snapshot)
+    return this.getOrCreateRegistry(projectId).attachFromSnapshot(snapshot)
   }
 
-  createTab(sessionId: string, options: Parameters<SessionRegistry['createSession']>[0]): void {
+  createTab(projectId: string, options: Parameters<SessionRegistry['createSession']>[0]): void {
     logDebug('daemon.sessionManager.createTab', {
       command: options.command,
-      sessionId,
+      projectId,
       tabId: options.tabId,
       title: options.title,
     })
-    this.getOrCreateRegistry(sessionId).createSession(options)
+    this.getOrCreateRegistry(projectId).createSession(options)
   }
 
-  write(sessionId: string, tabId: string, data: string): void {
-    this.getOrCreateRegistry(sessionId).write(tabId, data)
+  write(projectId: string, tabId: string, data: string): void {
+    this.getOrCreateRegistry(projectId).write(tabId, data)
   }
 
   updateTabMetadata(
-    sessionId: string,
+    projectId: string,
     tabId: string,
     patch: { title?: string; autoRenameStatus?: 'eligible' | 'attempted' }
   ): void {
-    this.getOrCreateRegistry(sessionId).updateTabMetadata(tabId, patch)
+    this.getOrCreateRegistry(projectId).updateTabMetadata(tabId, patch)
   }
 
-  resize(sessionId: string, cols: number, rows: number, options?: { sync?: boolean }): void {
-    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows, options)
+  resize(projectId: string, cols: number, rows: number, options?: { sync?: boolean }): void {
+    this.getOrCreateRegistry(projectId).resizeAll(cols, rows, options)
   }
 
   resizeTab(
-    sessionId: string,
+    projectId: string,
     tabId: string,
     cols: number,
     rows: number,
     options?: { sync?: boolean }
   ): void {
-    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows, options)
+    this.getOrCreateRegistry(projectId).resizeTab(tabId, cols, rows, options)
   }
 
-  scroll(sessionId: string, tabId: string, deltaLines: number): void {
-    this.getOrCreateRegistry(sessionId).scrollViewport(tabId, deltaLines)
+  scroll(projectId: string, tabId: string, deltaLines: number): void {
+    this.getOrCreateRegistry(projectId).scrollViewport(tabId, deltaLines)
   }
 
-  scrollToBottom(sessionId: string, tabId: string): void {
-    this.getOrCreateRegistry(sessionId).scrollViewportToBottom(tabId)
+  scrollToBottom(projectId: string, tabId: string): void {
+    this.getOrCreateRegistry(projectId).scrollViewportToBottom(tabId)
   }
 
-  setActiveTab(sessionId: string, tabId: string | null): void {
-    this.getOrCreateRegistry(sessionId).setActiveTab(tabId)
+  setActiveTab(projectId: string, tabId: string | null): void {
+    this.getOrCreateRegistry(projectId).setActiveTab(tabId)
   }
 
-  closeTab(sessionId: string, tabId: string): void {
-    this.getOrCreateRegistry(sessionId).closeTab(tabId)
+  closeTab(projectId: string, tabId: string): void {
+    this.getOrCreateRegistry(projectId).closeTab(tabId)
   }
 
-  disposeSession(sessionId: string): void {
+  disposeSession(projectId: string): void {
     logDebug('daemon.sessionManager.disposeSession', {
-      hadRegistry: this.registries.has(sessionId),
-      sessionId,
+      hadRegistry: this.registries.has(projectId),
+      projectId,
     })
-    const registry = this.registries.get(sessionId)
+    const registry = this.registries.get(projectId)
     if (!registry) {
       return
     }
     registry.disposeAll()
-    this.registries.delete(sessionId)
+    this.registries.delete(projectId)
   }
 
   disposeAll(): void {
@@ -143,7 +143,7 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     return [...this.registries.keys()]
   }
 
-  listTabs(sessionId: string): TabSession[] {
-    return this.registries.get(sessionId)?.listTabs() ?? []
+  listTabs(projectId: string): TabSession[] {
+    return this.registries.get(projectId)?.listTabs() ?? []
   }
 }

package/src/daemon/session-registry.ts

@@ -1,10 +1,10 @@
 import { EventEmitter } from 'node:events'
 
 import type {
+  ProjectSnapshotV1,
   TabSession,
   TerminalModeState,
   TerminalSnapshot,
-  WorkspaceSnapshotV1,
 } from '../state/types'
 
 import { logDebug } from '../debug/input-log'
@@ -12,8 +12,8 @@ import { PtyManager } from '../pty/pty-manager'
 import {
   normalizeGroupedTabOrder,
   restoreLayoutTrees,
-  restoreTabsFromWorkspace,
-} from '../state/session-persistence'
+  restoreTabsFromProject,
+} from '../state/project-persistence'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 
 interface SessionRegistryEvents {
@@ -65,7 +65,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     })
   }
 
-  attachFromSnapshot(snapshot: WorkspaceSnapshotV1 | undefined): {
+  attachFromSnapshot(snapshot: ProjectSnapshotV1 | undefined): {
     tabs: TabSession[]
     activeTabId: string | null
   } {
@@ -75,7 +75,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
       snapshotTabs: snapshot?.tabs.length ?? 0,
     })
     if (this.tabs.size === 0 && snapshot) {
-      const restoredTabs = restoreTabsFromWorkspace(snapshot)
+      const restoredTabs = restoreTabsFromProject(snapshot)
       for (const tab of restoredTabs) {
         this.tabs.set(tab.id, tab)
       }
@@ -93,7 +93,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
             existing.title = persisted.title
             existing.autoRenameStatus = persisted.autoRenameStatus
           }
-          existing.worktreeId = persisted.worktreeId
+          existing.workspaceId = persisted.workspaceId
           existing.workerName = persisted.workerName
         }
       }
@@ -116,10 +116,10 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
       .map((persistedTab) => this.tabs.get(persistedTab.id))
       .filter((tab): tab is TabSession => tab !== undefined)
     // The registry — not the snapshot — is the source of truth for *which*
-    // tabs exist. A tab spawned by a sibling CLI after this workspace's
+    // tabs exist. A tab spawned by a sibling CLI after this project's
     // snapshot was last persisted lives in `this.tabs` but is absent from
     // `snapshot.tabs`; ordering by the snapshot alone would silently drop it
-    // from the attach result, so the UI would render an empty/stale workspace
+    // from the attach result, so the UI would render an empty/stale project
     // on switch. Append any live tab the snapshot doesn't mention (in
     // registry order) so membership stays authoritative while the snapshot
     // still supplies ordering + layout for the tabs it captured.
@@ -151,12 +151,12 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
     env?: Record<string, string>
     autoRenameStatus?: 'eligible' | 'attempted'
     /**
-     * Worktree this tab belongs to (for UI grouping). Stored on the
+     * Workspace this tab belongs to (for UI grouping). Stored on the
      * TabSession so an attach-time replay surfaces it inside the right
-     * worktree column. Optional — tabs not bound to a worktree are valid.
+     * workspace column. Optional — tabs not bound to a workspace are valid.
      */
-    worktreeId?: string
-    /** Workspace-scoped orchestration handle; does not affect PTY behavior. */
+    workspaceId?: string
+    /** Project-scoped orchestration handle; does not affect PTY behavior. */
     workerName?: string
   }): void {
     logDebug('daemon.registry.createSession', {
@@ -179,7 +179,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
         terminalModes: createDefaultTerminalModes(),
         title: options.title,
         workerName: options.workerName,
-        worktreeId: options.worktreeId,
+        workspaceId: options.workspaceId,
       })
     } else {
       existing.status = 'starting'
@@ -192,7 +192,7 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
       existing.title = options.title
       existing.command = [options.command, ...(options.args ?? [])].join(' ')
       existing.autoRenameStatus = options.autoRenameStatus
-      if (options.worktreeId !== undefined) existing.worktreeId = options.worktreeId
+      if (options.workspaceId !== undefined) existing.workspaceId = options.workspaceId
       if (options.workerName !== undefined) existing.workerName = options.workerName
     }
 

package/src/git/divergence.ts

@@ -16,7 +16,7 @@ export function parseDivergenceCount(output: string): BranchDivergence | undefin
   }
 }
 
-// Commits a worktree branch is ahead/behind the ref it forked from. Returns
+// Commits a workspace branch is ahead/behind the ref it forked from. Returns
 // undefined when the refs can't be compared (missing ref, not a repo, …) so
 // callers can simply render nothing.
 export async function getBranchDivergence(
@@ -32,8 +32,39 @@ export async function getBranchDivergence(
   return parseDivergenceCount(result.text())
 }
 
+// Parses `git diff --shortstat`, e.g.
+// " 7 files changed, 149 insertions(+), 629 deletions(-)". Either side may be
+// absent (a pure addition reports no deletions line at all).
+export function parseShortstat(output: string): { added: number; removed: number } | undefined {
+  const trimmed = output.trim()
+  if (trimmed === '') return undefined
+  const added = /(\d+) insertions?\(\+\)/.exec(trimmed)
+  const removed = /(\d+) deletions?\(-\)/.exec(trimmed)
+  if (!added && !removed) return undefined
+  return {
+    added: Number.parseInt(added?.[1] ?? '0', 10),
+    removed: Number.parseInt(removed?.[1] ?? '0', 10),
+  }
+}
+
+/**
+ * Lines a workspace has changed since it forked, measured from the merge base
+ * to the *working tree* — so commits, staged and unstaged work all count. That
+ * is the number the sidebar shows, and it is what a squash-move would land.
+ */
+export async function getWorkspaceDiffStat(
+  workspacePath: string,
+  baseRef: string
+): Promise<{ added: number; removed: number } | undefined> {
+  const mergeBase = await getMergeBase(workspacePath, baseRef)
+  if (mergeBase == null) return undefined
+  const result = await $`git -C ${workspacePath} diff --shortstat ${mergeBase}`.quiet().nothrow()
+  if (result.exitCode !== 0) return undefined
+  return parseShortstat(result.text())
+}
+
 // Fork point: the most recent commit shared by baseRef and ref. Diffing the
-// working tree against this shows everything the worktree changed since it
+// working tree against this shows everything the workspace changed since it
 // branched off (commits + staged + unstaged) — i.e. what a squash-move lands.
 export async function getMergeBase(
   repoPath: string,

package/src/git/git-poller.ts

@@ -13,7 +13,7 @@ interface Options {
   enabled: boolean
   projectPath: string | undefined
   headOffset: number
-  // When set, diff the working tree against this ref (worktree fork point for
+  // When set, diff the working tree against this ref (workspace fork point for
   // review-vs-base) instead of HEAD/HEAD~N.
   compareRef?: string
 }

package/src/git/git-status.ts

@@ -199,7 +199,7 @@ async function annotateUntrackedCounts(cwd: string, files: GitFileEntry[]): Prom
 
 interface CollectOptions {
   headOffset?: number
-  // Explicit ref to diff the working tree against (e.g. a worktree's fork
+  // Explicit ref to diff the working tree against (e.g. a workspace's fork
   // point). Takes precedence over headOffset when set.
   compareRef?: string
 }
@@ -266,7 +266,7 @@ async function collectAgainstHistorical(
 }
 
 // Diffs the working tree against an arbitrary ref (a HEAD~N commit, or a
-// worktree's fork point for review-vs-base), surfacing changed files as a
+// workspace's fork point for review-vs-base), surfacing changed files as a
 // single `historical` section plus any untracked files.
 async function collectAgainstRef(cwd: string, ref: string): Promise<GitCollectResult> {
   const [statusResult, nameStatus, numstat, untrackedStatus] = await Promise.all([

package/src/git/{move-worktree.ts → move-workspace.ts}

@@ -1,6 +1,6 @@
 import { $ } from 'bun'
 
-export interface MoveWorktreeOptions {
+export interface MoveWorkspaceOptions {
   sourcePath: string
   sourceBranch: string
   targetPath: string
@@ -10,7 +10,7 @@ export interface MoveWorktreeOptions {
   keepConflicts?: boolean
 }
 
-export type MoveWorktreeResult =
+export type MoveWorkspaceResult =
   | { kind: 'ok'; filesChanged: number; stashedTarget: boolean }
   /** Target dirty/untracked files would be overwritten by the move; nothing was touched. */
   | { kind: 'needs-stash'; files: string[] }
@@ -76,8 +76,8 @@ function parseOverwrittenFiles(output: string): string[] {
   return files
 }
 
-// Squashes everything a source worktree changed since its fork point into the
-// target worktree's working tree (staged, uncommitted) — committed work plus
+// Squashes everything a source workspace changed since its fork point into the
+// target workspace's working tree (staged, uncommitted) — committed work plus
 // any uncommitted/untracked changes. The source is left exactly as it was; the
 // caller decides whether to delete it. The target may be dirty as long as its
 // local changes don't overlap the incoming ones: on overlap the move stops
@@ -85,7 +85,7 @@ function parseOverwrittenFiles(output: string): string[] {
 // conflict nothing is kept — target reset, source restored — unless
 // keepConflicts is set, in which case the conflicted squash state is left in
 // the target for manual resolution.
-export async function moveWorktree(opts: MoveWorktreeOptions): Promise<MoveWorktreeResult> {
+export async function moveWorkspace(opts: MoveWorkspaceOptions): Promise<MoveWorkspaceResult> {
   const { sourceBranch, sourcePath, targetPath } = opts
   try {
     const headResult = await $`git -C ${sourcePath} rev-parse HEAD`.quiet().nothrow()

package/src/git/pr-merge.ts

@@ -0,0 +1,64 @@
+import { logDebug } from '../debug/input-log'
+import { runCli } from '../services/ai-usage/spawn'
+
+export interface RepoMergeMethods {
+  mergeCommitAllowed: boolean
+  squashMergeAllowed: boolean
+  rebaseMergeAllowed: boolean
+}
+
+/**
+ * Mirrors the method GitHub pre-selects on the merge button: a merge commit
+ * when the repo allows one, then squash, then rebase. `gh pr merge` refuses to
+ * guess when several are enabled, so we have to name one explicitly.
+ */
+export function pickMergeFlag(methods: RepoMergeMethods): string | null {
+  if (methods.mergeCommitAllowed) return '--merge'
+  if (methods.squashMergeAllowed) return '--squash'
+  if (methods.rebaseMergeAllowed) return '--rebase'
+  return null
+}
+
+export type MergeResult = { ok: true } | { ok: false; message: string }
+
+async function repoMergeMethods(gh: string, cwd: string): Promise<RepoMergeMethods | null> {
+  const result = await runCli(
+    gh,
+    ['repo', 'view', '--json', 'mergeCommitAllowed,squashMergeAllowed,rebaseMergeAllowed'],
+    15_000,
+    cwd
+  )
+  if (!result.ok) return null
+  try {
+    const raw = JSON.parse(result.stdout) as Record<string, unknown>
+    return {
+      mergeCommitAllowed: raw.mergeCommitAllowed === true,
+      rebaseMergeAllowed: raw.rebaseMergeAllowed === true,
+      squashMergeAllowed: raw.squashMergeAllowed === true,
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function approveAndMergePr(cwd: string): Promise<MergeResult> {
+  const gh = Bun.which('gh')
+  if (gh === null) return { message: 'gh CLI not found', ok: false }
+
+  const methods = await repoMergeMethods(gh, cwd)
+  if (methods === null) return { message: 'could not read repo merge settings', ok: false }
+  const flag = pickMergeFlag(methods)
+  if (flag === null) return { message: 'repo allows no merge method', ok: false }
+
+  // GitHub rejects approving your own PR, and a missing approval is not a
+  // reason to skip the merge — best effort, log it, move on.
+  const approve = await runCli(gh, ['pr', 'review', '--approve'], 15_000, cwd)
+  if (!approve.ok) logDebug('git.pr.approveSkipped', { error: approve.error })
+
+  const merge = await runCli(gh, ['pr', 'merge', flag], 60_000, cwd)
+  if (!merge.ok) {
+    const detail = merge.stderr.trim().split('\n')[0] ?? 'merge failed'
+    return { message: detail.slice(0, 160), ok: false }
+  }
+  return { ok: true }
+}

package/src/git/pr-status-poller.ts

@@ -0,0 +1,57 @@
+import { useEffect } from 'react'
+
+import { prStatusStore } from '../state/pr-status-store'
+import { collectPrStatus } from './pr-status'
+
+/** A run in flight is worth watching closely; a settled one barely changes. */
+const ACTIVE_INTERVAL_MS = 15_000
+const IDLE_INTERVAL_MS = 60_000
+const MAX_INTERVAL_MS = 120_000
+
+interface Options {
+  enabled: boolean
+  projectPath: string | undefined
+}
+
+/** One-shot refetch, for when an action we took just invalidated the state. */
+export async function refreshPrStatus(projectPath: string): Promise<void> {
+  prStatusStore.getState().setResult(await collectPrStatus(projectPath))
+}
+
+export function usePrStatusPolling({ enabled, projectPath }: Options): void {
+  useEffect(() => {
+    if (!enabled || !(projectPath != null && projectPath !== '')) return
+
+    prStatusStore.getState().reset()
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+    let delay = ACTIVE_INTERVAL_MS
+
+    const schedule = () => {
+      if (cancelled) return
+      timer = setTimeout(() => void tick(), delay)
+    }
+
+    const tick = async () => {
+      const result = await collectPrStatus(projectPath)
+      if (cancelled) return
+      prStatusStore.getState().setResult(result)
+      if (result.kind === 'error') {
+        delay = Math.min(delay * 2, MAX_INTERVAL_MS)
+      } else if (result.kind === 'ok' && result.checks.some((c) => c.state === 'pending')) {
+        delay = ACTIVE_INTERVAL_MS
+      } else {
+        delay = IDLE_INTERVAL_MS
+      }
+      schedule()
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer) clearTimeout(timer)
+    }
+  }, [enabled, projectPath])
+}