@brimveyn/aimux 1.1.0

package/src/app-runtime/selection-clipboard.ts

@@ -0,0 +1,69 @@
+import type { TabSession } from '../state/types'
+
+import { extractStreamText } from '../input/terminal-text-extraction'
+
+interface PositionedNode {
+  parent?: unknown
+  x: number
+  y: number
+}
+
+export interface OtuiSelection {
+  isDragging?: boolean
+  anchor: { x: number; y: number }
+  focus: { x: number; y: number }
+  touchedRenderables?: unknown[]
+  getSelectedText(): string
+}
+
+function isPositionedNode(value: unknown): value is PositionedNode {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof Reflect.get(value, 'x') === 'number' &&
+    typeof Reflect.get(value, 'y') === 'number'
+  )
+}
+
+export function computeStreamSelectedText(
+  selection: OtuiSelection,
+  lines: { spans: { text: string }[] }[]
+): string | null {
+  const touched = selection.touchedRenderables
+  if (!touched || touched.length === 0) return null
+
+  const viewportText = touched[0]
+  if (!isPositionedNode(viewportText)) return null
+
+  const originX = viewportText.x
+  const originY = viewportText.y
+
+  const anchorRow = selection.anchor.y - originY
+  const anchorCol = selection.anchor.x - originX
+  const focusRow = selection.focus.y - originY
+  const focusCol = selection.focus.x - originX
+
+  return extractStreamText(
+    lines as Parameters<typeof extractStreamText>[0],
+    anchorRow,
+    anchorCol,
+    focusRow,
+    focusCol
+  )
+}
+
+export function resolveSelectionClipboardText(
+  selection: OtuiSelection,
+  tab: TabSession | undefined
+): { selectedText: string; streamLength: number | null; fallbackLength: number } {
+  const fallback = selection.getSelectedText()
+  const streamText =
+    tab?.viewport && tab.viewport.lines.length > 0
+      ? computeStreamSelectedText(selection, tab.viewport.lines)
+      : null
+  return {
+    fallbackLength: fallback.length,
+    selectedText: streamText ?? fallback,
+    streamLength: streamText?.length ?? null,
+  }
+}

package/src/app-runtime/selection-scroll.ts

@@ -0,0 +1,143 @@
+interface SelectableLike {
+  selectable?: boolean
+  isDestroyed?: boolean
+}
+
+function isUsableTarget(target: SelectableLike | null | undefined): target is SelectableLike {
+  return Boolean(target?.selectable) && !target?.isDestroyed
+}
+
+interface SelectionLike {
+  isActive: boolean
+  isDragging: boolean
+  anchor: { x: number; y: number }
+  focus: { x: number; y: number }
+  selectedRenderables: SelectableLike[]
+  touchedRenderables: SelectableLike[]
+}
+
+export interface RendererSelectionApi {
+  getSelection(): SelectionLike | null
+  startSelection(target: unknown, x: number, y: number): void
+  updateSelection(target: unknown, x: number, y: number, opts: { finishDragging: boolean }): void
+  clearSelection(): void
+}
+
+interface ShiftState {
+  target: SelectableLike | null
+  anchor: { x: number; y: number } | null
+  focus: { x: number; y: number } | null
+}
+
+const states = new WeakMap<object, ShiftState>()
+
+function getState(renderer: object): ShiftState {
+  let s = states.get(renderer)
+  if (!s) {
+    s = { anchor: null, focus: null, target: null }
+    states.set(renderer, s)
+  }
+  return s
+}
+
+export function resetSelectionShiftState(renderer: object): void {
+  states.set(renderer, { anchor: null, focus: null, target: null })
+}
+
+function pickSelectionTarget(selection: SelectionLike): SelectableLike | null {
+  for (const r of selection.selectedRenderables) {
+    if (isUsableTarget(r)) return r
+  }
+  for (const r of selection.touchedRenderables) {
+    if (isUsableTarget(r)) return r
+  }
+  return null
+}
+
+function liveDiffersFromCache(live: SelectionLike, state: ShiftState): boolean {
+  if (!state.anchor || !state.focus) return true
+  return (
+    live.anchor.x !== state.anchor.x ||
+    live.anchor.y !== state.anchor.y ||
+    live.focus.x !== state.focus.x ||
+    live.focus.y !== state.focus.y
+  )
+}
+
+export function shiftSelectionByScroll(renderer: RendererSelectionApi, deltaLines: number): void {
+  if (deltaLines === 0) return
+
+  const live = renderer.getSelection()
+
+  if (!live?.isActive) {
+    resetSelectionShiftState(renderer)
+    return
+  }
+
+  if (live.isDragging) {
+    // Mid-drag (e.g. user holds the mouse and scrolls past the viewport edge to
+    // extend the selection): only the anchor needs to follow the content. The
+    // focus is owned by opentui's live pointer tracking, which keeps it pinned
+    // to the cursor in screen-space — leave it alone.
+    const target = pickSelectionTarget(live)
+    if (!isUsableTarget(target)) return
+    const anchorY = live.anchor.y - deltaLines
+    renderer.startSelection(target, live.anchor.x, anchorY)
+    renderer.updateSelection(target, live.focus.x, live.focus.y, { finishDragging: false })
+    resetSelectionShiftState(renderer)
+    return
+  }
+
+  const state = getState(renderer)
+
+  if (liveDiffersFromCache(live, state)) {
+    const target = pickSelectionTarget(live) ?? (isUsableTarget(state.target) ? state.target : null)
+    if (target) {
+      state.target = target
+      state.anchor = { x: live.anchor.x, y: live.anchor.y }
+      state.focus = { x: live.focus.x, y: live.focus.y }
+    }
+  }
+
+  if (!isUsableTarget(state.target) || !state.anchor || !state.focus) {
+    if (!isUsableTarget(state.target)) {
+      resetSelectionShiftState(renderer)
+    }
+    return
+  }
+
+  const anchor = { x: state.anchor.x, y: state.anchor.y - deltaLines }
+  const focus = { x: state.focus.x, y: state.focus.y - deltaLines }
+  state.anchor = anchor
+  state.focus = focus
+
+  renderer.startSelection(state.target, anchor.x, anchor.y)
+  renderer.updateSelection(state.target, focus.x, focus.y, { finishDragging: true })
+}
+
+export interface ViewportObservation {
+  tabId: string
+  y: number
+}
+
+export function applyViewportObservation(
+  renderer: RendererSelectionApi,
+  prior: ViewportObservation | null,
+  next: ViewportObservation | null
+): ViewportObservation | null {
+  if (!next) {
+    if (prior !== null) resetSelectionShiftState(renderer)
+    return null
+  }
+
+  if (!prior || prior.tabId !== next.tabId) {
+    resetSelectionShiftState(renderer)
+    return next
+  }
+
+  const delta = next.y - prior.y
+  if (delta !== 0) {
+    shiftSelectionByScroll(renderer, delta)
+  }
+  return next
+}

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

@@ -0,0 +1,170 @@
+import type { SessionBackend } from '../session-backend/types'
+import type { AppAction, AppState, SessionRecord, TabSession } from '../state/types'
+
+import { logInputDebug } from '../debug/input-log'
+import { createPrefixedId } from '../platform/id'
+import { saveSessionCatalog } from '../state/session-catalog'
+import { createEmptyWorkspaceSnapshot, serializeWorkspace } from '../state/session-persistence'
+import { buildSessionsWithCurrentSnapshot } from '../state/workspace-save'
+
+export function createSessionFromCurrentState(
+  state: AppState,
+  name: string,
+  projectPath?: string
+): { session: SessionRecord; sessions: SessionRecord[] } {
+  const now = new Date().toISOString()
+  const workspaceSnapshot =
+    state.currentSessionId || state.tabs.length === 0
+      ? createEmptyWorkspaceSnapshot()
+      : serializeWorkspace(state)
+  const session: SessionRecord = {
+    createdAt: now,
+    id: createPrefixedId('session'),
+    lastOpenedAt: now,
+    name,
+    projectPath,
+    updatedAt: now,
+    workspaceSnapshot,
+  }
+
+  let updatedSessions = state.sessions
+  if (state.currentSessionId) {
+    const currentSnapshot = serializeWorkspace(state)
+    updatedSessions = state.sessions.map((entry) =>
+      entry.id === state.currentSessionId
+        ? { ...entry, updatedAt: now, workspaceSnapshot: currentSnapshot }
+        : entry
+    )
+  }
+
+  return {
+    session,
+    sessions: [...updatedSessions, session],
+  }
+}
+
+export function renameSessionRecords(
+  sessions: SessionRecord[],
+  sessionId: string,
+  name: string
+): SessionRecord[] {
+  return sessions.map((session) =>
+    session.id === sessionId ? { ...session, name, updatedAt: new Date().toISOString() } : session
+  )
+}
+
+export function switchSessionRecords(state: AppState, session: SessionRecord): SessionRecord[] {
+  const sessionsWithSnapshot = buildSessionsWithCurrentSnapshot(
+    state.sessions,
+    state.currentSessionId,
+    state
+  )
+  return sessionsWithSnapshot.map((entry) =>
+    entry.id === session.id ? { ...entry, lastOpenedAt: new Date().toISOString() } : entry
+  )
+}
+
+export function deleteSessionRecords(
+  sessions: SessionRecord[],
+  sessionId: string
+): SessionRecord[] {
+  return sessions.filter((session) => session.id !== sessionId)
+}
+
+export function handleCreateSessionEffect(
+  state: AppState,
+  dispatch: (action: AppAction) => void,
+  name: string,
+  projectPath?: string
+): void {
+  const { session, sessions } = createSessionFromCurrentState(state, name, projectPath)
+  logInputDebug('app.session.create', {
+    fromCurrentWorkspace: !state.currentSessionId && state.tabs.length > 0,
+    name,
+    sessionId: session.id,
+    tabCount: session.workspaceSnapshot?.tabs.length ?? 0,
+  })
+  saveSessionCatalog(sessions)
+  dispatch({ sessions, type: 'set-sessions' })
+  dispatch({
+    sessionId: session.id,
+    type: 'load-session',
+    workspaceSnapshot: session.workspaceSnapshot,
+  })
+}
+
+export function handleRenameSessionEffect(
+  sessions: SessionRecord[],
+  dispatch: (action: AppAction) => void,
+  sessionId: string,
+  name: string
+): void {
+  logInputDebug('app.session.rename', { name, sessionId })
+  const renamed = renameSessionRecords(sessions, sessionId, name)
+  saveSessionCatalog(renamed)
+  dispatch({ name, sessionId, type: 'rename-session-record' })
+}
+
+export function handleSwitchSessionEffect(
+  state: AppState,
+  backend: SessionBackend,
+  dispatch: (action: AppAction) => void,
+  session: SessionRecord
+): void {
+  logInputDebug('app.session.switch.start', {
+    currentTabCount: state.tabs.length,
+    fromSessionId: state.currentSessionId,
+    restoredTabCount: session.workspaceSnapshot?.tabs.length ?? 0,
+    toName: session.name,
+    toSessionId: session.id,
+  })
+  const sessions = switchSessionRecords(state, session)
+  saveSessionCatalog(sessions)
+  void backend.destroy(true)
+  dispatch({ sessions, type: 'set-sessions' })
+  dispatch({
+    sessionId: session.id,
+    type: 'load-session',
+    workspaceSnapshot: session.workspaceSnapshot,
+  })
+  logInputDebug('app.session.switch.dispatched', { toSessionId: session.id })
+}
+
+export function handleDeleteSessionEffect(
+  state: AppState,
+  backend: SessionBackend,
+  dispatch: (action: AppAction) => void,
+  sessionId: string
+): void {
+  const remaining = deleteSessionRecords(state.sessions, sessionId)
+  logInputDebug('app.session.delete', {
+    remainingCount: remaining.length,
+    sessionId,
+    wasCurrent: sessionId === state.currentSessionId,
+  })
+  saveSessionCatalog(remaining)
+  if (sessionId === state.currentSessionId) {
+    void backend.destroy(true)
+  }
+  dispatch({ sessionId, type: 'delete-session-record' })
+}
+
+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-session' })
+  startTabSession(tab)
+}