@brimveyn/aimux 1.12.2 → 1.13.0

package/src/state/session-worktrees.ts

@@ -0,0 +1,227 @@
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { basename } from 'node:path'
+
+import type { SessionRecord, TabSession, WorktreeRecord } from './types'
+
+import { createPrefixedId } from '../platform/id'
+import { isInsideAimuxWorktreeRoot } from '../platform/worktree-paths'
+
+const WORKTREE_COLORS = ['#7dd3fc', '#86efac', '#facc15', '#f0abfc', '#fb7185', '#c4b5fd']
+
+export function getWorktreeColor(worktreeId: string): string {
+  let hash = 0
+  for (let i = 0; i < worktreeId.length; i++) {
+    hash = (hash * 31 + worktreeId.charCodeAt(i)) >>> 0
+  }
+  return WORKTREE_COLORS[hash % WORKTREE_COLORS.length] ?? '#7dd3fc'
+}
+
+export function createPrimaryWorktree(projectPath: string, now: string): WorktreeRecord {
+  const id = createPrefixedId('worktree')
+  return {
+    createdAt: now,
+    createdByAimux: false,
+    id,
+    name: basename(projectPath) || projectPath,
+    path: projectPath,
+    repoRoot: projectPath,
+    source: 'primary',
+    updatedAt: now,
+  }
+}
+
+export function ensureSessionWorktrees(
+  session: SessionRecord,
+  now = new Date().toISOString()
+): SessionRecord {
+  if (session.worktrees?.length != null && session.worktrees?.length !== 0) {
+    const worktrees = mergeExistingGitWorktrees(
+      pruneMissingAimuxTempWorktrees(session.worktrees),
+      now
+    )
+    if (worktrees.length === 0 && session.projectPath != null && session.projectPath !== '') {
+      const worktree = createPrimaryWorktree(session.projectPath, now)
+      return { ...session, activeWorktreeId: worktree.id, worktrees: [worktree] }
+    }
+    const activeWorktreeId = worktrees.some((w) => w.id === session.activeWorktreeId)
+      ? session.activeWorktreeId
+      : worktrees[0]?.id
+    const active = worktrees.find((w) => w.id === activeWorktreeId)
+    return {
+      ...session,
+      activeWorktreeId,
+      projectPath: active?.path ?? session.projectPath,
+      worktrees,
+    }
+  }
+
+  if (!(session.projectPath != null && session.projectPath !== '')) {
+    return session
+  }
+
+  const worktree = createPrimaryWorktree(session.projectPath, now)
+  const worktrees = mergeExistingGitWorktrees([worktree], now)
+  return {
+    ...session,
+    activeWorktreeId:
+      worktrees.find((entry) => entry.path === session.projectPath)?.id ?? worktree.id,
+    worktrees,
+  }
+}
+
+function stableWorktreeId(path: string): string {
+  return `worktree-${createHash('sha1').update(path).digest('hex').slice(0, 10)}`
+}
+
+function mergeExistingGitWorktrees(worktrees: WorktreeRecord[], now: string): WorktreeRecord[] {
+  const anchor = worktrees.find((worktree) => existsSync(worktree.path)) ?? worktrees[0]
+  if (!anchor) return worktrees
+  const discovered = listGitWorktreesSync(anchor.path)
+  if (discovered.length === 0) return worktrees
+
+  // Git keeps admin entries for worktrees whose directory is gone (e.g. a temp
+  // dir cleared on reboot). Drop that stale state so the entries stop
+  // resurfacing in `git worktree list`, and ignore them while reconciling.
+  if (discovered.some((entry) => entry.prunable === true)) {
+    pruneGitWorktreesSync(anchor.path)
+  }
+  const live = discovered.filter((entry) => entry.prunable !== true)
+
+  const byPath = new Map(worktrees.map((worktree) => [worktree.path, worktree]))
+  // `git worktree list` reports the main worktree first; prefer the primary
+  // record's repoRoot when it still exists, then git's main worktree.
+  const primaryRepoRoot = worktrees.find((worktree) => worktree.source === 'primary')?.repoRoot
+  const repoRoot =
+    primaryRepoRoot !== undefined && existsSync(primaryRepoRoot)
+      ? primaryRepoRoot
+      : (live[0]?.path ?? anchor.repoRoot)
+  for (const entry of live) {
+    if (byPath.has(entry.path)) continue
+    if (isInsideAimuxWorktreeRoot(entry.path)) continue
+    const worktree: WorktreeRecord = {
+      branch: entry.branch,
+      commitSha: entry.head,
+      createdAt: now,
+      createdByAimux: false,
+      id: stableWorktreeId(entry.path),
+      name: basename(entry.path) || entry.path,
+      path: entry.path,
+      repoRoot,
+      source: 'external',
+      updatedAt: now,
+    }
+    byPath.set(entry.path, worktree)
+  }
+  return (
+    [...byPath.values()]
+      // Drop records whose directory no longer exists (a deleted external
+      // worktree that git already pruned) so they don't reappear on restart.
+      .filter((worktree) => worktree.source === 'primary' || existsSync(worktree.path))
+      // Heal records whose repoRoot points at a since-deleted sibling worktree
+      // so later git operations (e.g. `git -C repoRoot`) don't fail.
+      .map((worktree) =>
+        existsSync(worktree.repoRoot) ? worktree : { ...worktree, repoRoot, updatedAt: now }
+      )
+  )
+}
+
+interface DiscoveredWorktree {
+  path: string
+  head?: string
+  branch?: string
+  prunable?: boolean
+}
+
+function listGitWorktreesSync(cwd: string): DiscoveredWorktree[] {
+  const result = spawnSync('git', ['-C', cwd, 'worktree', 'list', '--porcelain'], {
+    encoding: 'utf8',
+  })
+  if (result.status !== 0 || !result.stdout) return []
+  const worktrees: DiscoveredWorktree[] = []
+  let current: DiscoveredWorktree | null = null
+  for (const line of result.stdout.split('\n')) {
+    if (line.startsWith('worktree ')) {
+      if (current) worktrees.push(current)
+      current = { path: line.slice('worktree '.length) }
+    } else if (current && line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length)
+    } else if (current && line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '')
+    } else if (current && line.startsWith('prunable')) {
+      current.prunable = true
+    }
+  }
+  if (current) worktrees.push(current)
+  return worktrees
+}
+
+function pruneGitWorktreesSync(cwd: string): void {
+  spawnSync('git', ['-C', cwd, 'worktree', 'prune'], { encoding: 'utf8' })
+}
+
+function pruneMissingAimuxTempWorktrees(worktrees: WorktreeRecord[]): WorktreeRecord[] {
+  return worktrees.filter((worktree) => {
+    if (
+      worktree.source !== 'aimux-temp' ||
+      !worktree.createdByAimux ||
+      !isInsideAimuxWorktreeRoot(worktree.path)
+    ) {
+      return true
+    }
+    return existsSync(worktree.path)
+  })
+}
+
+export function getActiveWorktree(session: SessionRecord | undefined): WorktreeRecord | undefined {
+  if (!(session?.worktrees?.length != null && session?.worktrees?.length !== 0)) return undefined
+  return (
+    session.worktrees.find((worktree) => worktree.id === session.activeWorktreeId) ??
+    session.worktrees[0]
+  )
+}
+
+export function getSessionProjectPath(session: SessionRecord | undefined): string | undefined {
+  return getActiveWorktree(session)?.path ?? session?.projectPath
+}
+
+export function withActiveWorktree(session: SessionRecord, worktreeId: string): SessionRecord {
+  const worktree = session.worktrees?.find((entry) => entry.id === worktreeId)
+  if (!worktree) return session
+  return {
+    ...session,
+    activeWorktreeId: worktreeId,
+    projectPath: worktree.path,
+    updatedAt: new Date().toISOString(),
+  }
+}
+
+export function getRenderedTabWorktreeId(
+  tab: { worktreeId?: string },
+  worktrees: { id: string }[]
+): string {
+  return tab.worktreeId ?? worktrees[0]?.id ?? '__main__'
+}
+
+export function orderTabsByWorktree(
+  tabs: TabSession[],
+  session: SessionRecord | undefined
+): TabSession[] {
+  const worktrees = session?.worktrees ?? []
+  const order = new Map<string, number>()
+  for (const [index, worktree] of worktrees.entries()) {
+    order.set(worktree.id, index)
+  }
+  order.set('__main__', order.size)
+
+  return tabs
+    .map((tab, index) => ({ index, tab }))
+    .sort((a, b) => {
+      const aw = order.get(getRenderedTabWorktreeId(a.tab, worktrees)) ?? Number.MAX_SAFE_INTEGER
+      const bw = order.get(getRenderedTabWorktreeId(b.tab, worktrees)) ?? Number.MAX_SAFE_INTEGER
+      if (aw !== bw) return aw - bw
+      return a.index - b.index
+    })
+    .map((entry) => entry.tab)
+}

package/src/state/snippet-catalog.ts

@@ -1,3 +1,5 @@
+import type { SnippetDef, SnippetVar } from '@brimveyn/aimux-config'
+
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 
@@ -9,9 +11,15 @@ export interface SnippetRecord {
   id: string
   name: string
   content: string
+  trigger?: string
+  vars?: Record<string, SnippetVar>
+}
+
+export function getSnippetsCatalogPath(): string {
+  return join(getProfileConfigDir(), 'aimux-snippets.json')
 }
 
-const SNIPPETS_PATH = join(getProfileConfigDir(), 'aimux-snippets.json')
+const SNIPPETS_PATH = getSnippetsCatalogPath()
 
 const DEFAULT_SNIPPETS: SnippetRecord[] = [
   {
@@ -52,7 +60,7 @@ export function loadSnippetCatalog(): SnippetRecord[] {
       version?: unknown
       snippets?: unknown
     }
-    if (parsed.version !== 1 || !Array.isArray(parsed.snippets)) {
+    if ((parsed.version !== 1 && parsed.version !== 2) || !Array.isArray(parsed.snippets)) {
       logDebug('snippets.catalog.loadIssue', {
         issue: 'invalid snippet catalog header',
         path: SNIPPETS_PATH,
@@ -66,7 +74,7 @@ export function loadSnippetCatalog(): SnippetRecord[] {
       })
       return []
     }
-    return parsed.snippets
+    return parsed.snippets.map(stripUserVars)
   } catch (error) {
     logDebug('snippets.catalog.loadIssue', {
       issue: error instanceof Error ? error.message : String(error),
@@ -79,7 +87,16 @@ export function loadSnippetCatalog(): SnippetRecord[] {
 export function saveSnippetCatalog(snippets: SnippetRecord[]): void {
   try {
     mkdirSync(getProfileConfigDir(), { recursive: true })
-    writeFileSync(SNIPPETS_PATH, `${JSON.stringify({ snippets, version: 1 }, null, 2)}\n`)
+    // Persist only user-owned snippets. Config-pinned entries are reapplied
+    // at boot from `aimux.config.ts`.
+    const userSnippets = snippets.filter((s) => !isConfigSnippetId(s.id)).map(stripUserVars)
+    // Schema v2 adds the optional `trigger` and `vars` fields. v1 files are
+    // still accepted on read (they validate as v2 — both fields are optional)
+    // and get rewritten as v2 on the next save.
+    writeFileSync(
+      SNIPPETS_PATH,
+      `${JSON.stringify({ snippets: userSnippets, version: 2 }, null, 2)}\n`
+    )
   } catch (error) {
     logDebug('snippets.catalog.saveError', {
       error: error instanceof Error ? error.message : String(error),
@@ -88,3 +105,47 @@ export function saveSnippetCatalog(snippets: SnippetRecord[]): void {
     })
   }
 }
+
+export const CONFIG_SNIPPET_ID_PREFIX = 'config:'
+
+export function isConfigSnippetId(id: string): boolean {
+  return id.startsWith(CONFIG_SNIPPET_ID_PREFIX)
+}
+
+/**
+ * Shell `vars` are only authorized on config-pinned snippets (those defined in
+ * `aimux.config.ts`). If they ever appear on a user-edited JSON snippet — by
+ * hand edit, restore, or import — strip them. This keeps shell execution
+ * gated by the user's TypeScript config file.
+ *
+ * Exported for testing; called at both load and save time.
+ */
+export function stripUserVars(snippet: SnippetRecord): SnippetRecord {
+  if (snippet.vars === undefined) return snippet
+  if (isConfigSnippetId(snippet.id)) return snippet
+  logDebug('snippets.catalog.strippedVars', { id: snippet.id, name: snippet.name })
+  const { vars, ...clean } = snippet
+  void vars
+  return clean
+}
+
+/**
+ * Merge config-defined snippets with user-edited snippets.
+ * Config-pinned snippets ("sticky") get a stable id `config:${name}` and win
+ * over a user-edited snippet with the same id (they're read-only in the UI).
+ */
+export function mergeConfigSnippets(
+  userSnippets: readonly SnippetRecord[],
+  configSnippets: readonly SnippetDef[]
+): SnippetRecord[] {
+  const fromConfig: SnippetRecord[] = configSnippets.map((s) => ({
+    content: s.text,
+    id: `${CONFIG_SNIPPET_ID_PREFIX}${s.name}`,
+    name: s.name,
+    trigger: s.trigger,
+    vars: s.vars,
+  }))
+  const configIds = new Set(fromConfig.map((s) => s.id))
+  const userKept = userSnippets.filter((s) => !configIds.has(s.id))
+  return [...fromConfig, ...userKept]
+}

package/src/state/store.ts

@@ -117,6 +117,7 @@ export function createInitialState(
     snippets,
     tabGroupMap: {},
     tabs: [],
+    worktreeDivergence: {},
   }
 }
 

package/src/state/toast-store.ts

@@ -0,0 +1,95 @@
+import type { ReactNode } from 'react'
+
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import { createPrefixedId } from '../platform/id'
+
+export type ToastVariant = 'info' | 'success' | 'warning' | 'error'
+export type ToastPosition = `${'top' | 'bottom'}-${'left' | 'center' | 'right'}`
+
+export interface ToastOptions {
+  title?: string
+  message?: string
+  /** Custom body — rendered inside the toast shell instead of title/message. */
+  content?: ReactNode
+  variant?: ToastVariant
+  /** Auto-dismiss after this many ms; 0 keeps it until dismissed. */
+  durationMs?: number
+  position?: ToastPosition
+}
+
+export interface Toast {
+  id: string
+  createdAt: number
+  content?: ReactNode
+  durationMs: number
+  message?: string
+  position: ToastPosition
+  title?: string
+  variant: ToastVariant
+}
+
+export const TOAST_CONFIG = {
+  defaultPosition: 'top-right' as ToastPosition,
+  // Default auto-dismiss per variant when `durationMs` isn't given. Errors (and
+  // warnings) linger longer than confirmations so they're not missed.
+  durations: { error: 7000, info: 3500, success: 3500, warning: 5000 } as Record<
+    ToastVariant,
+    number
+  >,
+  gap: 1,
+  /** Most recent toasts kept visible per position; older ones are evicted. */
+  maxVisible: 4,
+  /** Instant (no slide) — set in tests or for reduced motion. */
+  reduceMotion: false,
+  width: 40,
+}
+
+interface ToastStoreState {
+  toasts: Toast[]
+  show: (opts: ToastOptions) => string
+  dismiss: (id: string) => void
+  clear: () => void
+}
+
+export const toastStore = createStore<ToastStoreState>((set) => ({
+  clear: () => set({ toasts: [] }),
+  dismiss: (id) => set((state) => ({ toasts: state.toasts.filter((entry) => entry.id !== id) })),
+  show: (opts) => {
+    const id = createPrefixedId('toast')
+    const variant = opts.variant ?? 'info'
+    const next: Toast = {
+      content: opts.content,
+      createdAt: Date.now(),
+      durationMs: opts.durationMs ?? TOAST_CONFIG.durations[variant],
+      id,
+      message: opts.message,
+      position: opts.position ?? TOAST_CONFIG.defaultPosition,
+      title: opts.title,
+      variant,
+    }
+    set((state) => ({ toasts: [...state.toasts, next] }))
+    return id
+  },
+  toasts: [],
+}))
+
+export function useToastStore<T>(selector: (state: ToastStoreState) => T): T {
+  return useStore(toastStore, selector)
+}
+
+function variantShortcut(variant: ToastVariant) {
+  return (message: string, opts: Omit<ToastOptions, 'message' | 'variant'> = {}): string =>
+    toastStore.getState().show({ ...opts, message, variant })
+}
+
+// Imperative API usable anywhere (components, side effects) without React.
+export const toast = {
+  dismiss: (id: string) => toastStore.getState().dismiss(id),
+  error: variantShortcut('error'),
+  info: variantShortcut('info'),
+  show: (opts: ToastOptions) => toastStore.getState().show(opts),
+  success: variantShortcut('success'),
+  warning: variantShortcut('warning'),
+}