@jmoyers/harness 0.1.0

package/src/ui/conversation-input-forwarder.ts

@@ -0,0 +1,114 @@
+import {
+  classifyPaneAt as classifyPaneAtFrame,
+  parseMuxInputChunk as parseMuxInputChunkFrame,
+  wheelDeltaRowsFromCode,
+  type computeDualPaneLayout,
+} from '../mux/dual-pane-core.ts';
+import { normalizeMuxKeyboardInputForPty as normalizeMuxKeyboardInputForPtyFrame } from '../mux/input-shortcuts.ts';
+import { routeInputTokensForConversation as routeInputTokensForConversationFrame } from '../mux/live-mux/input-forwarding.ts';
+import { hasShiftModifier } from '../mux/live-mux/selection.ts';
+import type { ConversationState } from '../mux/live-mux/conversation-state.ts';
+import type { InputTokenRouter } from './input-token-router.ts';
+
+type MainPaneMode = 'conversation' | 'project' | 'home';
+type DualPaneLayout = ReturnType<typeof computeDualPaneLayout>;
+
+interface ConversationInputForwarderOptions {
+  readonly getInputRemainder: () => string;
+  readonly setInputRemainder: (next: string) => void;
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly getLayout: () => DualPaneLayout;
+  readonly inputTokenRouter: Pick<InputTokenRouter, 'routeTokens'>;
+  readonly getActiveConversation: () => ConversationState | null;
+  readonly markDirty: () => void;
+  readonly isControlledByLocalHuman: (input: {
+    readonly conversation: ConversationState;
+    readonly controllerId: string;
+  }) => boolean;
+  readonly controllerId: string;
+  readonly sendInputToSession: (sessionId: string, chunk: Buffer) => void;
+  readonly noteGitActivity: (directoryId: string | null) => void;
+}
+
+interface ConversationInputForwarderDependencies {
+  readonly parseMuxInputChunk?: typeof parseMuxInputChunkFrame;
+  readonly routeInputTokensForConversation?: typeof routeInputTokensForConversationFrame;
+  readonly classifyPaneAt?: typeof classifyPaneAtFrame;
+  readonly normalizeMuxKeyboardInputForPty?: typeof normalizeMuxKeyboardInputForPtyFrame;
+}
+
+export class ConversationInputForwarder {
+  private readonly parseMuxInputChunk: typeof parseMuxInputChunkFrame;
+  private readonly routeInputTokensForConversation: typeof routeInputTokensForConversationFrame;
+  private readonly classifyPaneAt: typeof classifyPaneAtFrame;
+  private readonly normalizeMuxKeyboardInputForPty: typeof normalizeMuxKeyboardInputForPtyFrame;
+
+  constructor(
+    private readonly options: ConversationInputForwarderOptions,
+    dependencies: ConversationInputForwarderDependencies = {},
+  ) {
+    this.parseMuxInputChunk = dependencies.parseMuxInputChunk ?? parseMuxInputChunkFrame;
+    this.routeInputTokensForConversation =
+      dependencies.routeInputTokensForConversation ?? routeInputTokensForConversationFrame;
+    this.classifyPaneAt = dependencies.classifyPaneAt ?? classifyPaneAtFrame;
+    this.normalizeMuxKeyboardInputForPty =
+      dependencies.normalizeMuxKeyboardInputForPty ?? normalizeMuxKeyboardInputForPtyFrame;
+  }
+
+  handleInput(input: Buffer): void {
+    const parsed = this.parseMuxInputChunk(this.options.getInputRemainder(), input);
+    this.options.setInputRemainder(parsed.remainder);
+
+    const layout = this.options.getLayout();
+    const inputConversation = this.options.getActiveConversation();
+    const { routedTokens, snapshotForInput } = this.options.inputTokenRouter.routeTokens({
+      tokens: parsed.tokens,
+      layout,
+      conversation: inputConversation,
+      snapshotForInput:
+        inputConversation === null ? null : inputConversation.oracle.snapshotWithoutHash(),
+    });
+
+    const { mainPaneScrollRows, forwardToSession } = this.routeInputTokensForConversation({
+      tokens: routedTokens,
+      mainPaneMode: this.options.getMainPaneMode(),
+      normalizeMuxKeyboardInputForPty: this.normalizeMuxKeyboardInputForPty,
+      classifyPaneAt: (col, row) => this.classifyPaneAt(layout, col, row),
+      wheelDeltaRowsFromCode,
+      hasShiftModifier,
+      layout: {
+        paneRows: layout.paneRows,
+        rightCols: layout.rightCols,
+        rightStartCol: layout.rightStartCol,
+      },
+      snapshotForInput,
+      appMouseTrackingEnabled:
+        inputConversation === null ? false : inputConversation.oracle.isMouseTrackingEnabled(),
+    });
+
+    if (mainPaneScrollRows !== 0 && inputConversation !== null) {
+      inputConversation.oracle.scrollViewport(mainPaneScrollRows);
+      this.options.markDirty();
+    }
+
+    if (inputConversation === null) {
+      return;
+    }
+    if (
+      inputConversation.controller !== null &&
+      !this.options.isControlledByLocalHuman({
+        conversation: inputConversation,
+        controllerId: this.options.controllerId,
+      })
+    ) {
+      return;
+    }
+
+    for (const forwardChunk of forwardToSession) {
+      this.options.sendInputToSession(inputConversation.sessionId, forwardChunk);
+    }
+    if (forwardToSession.length > 0) {
+      this.options.noteGitActivity(inputConversation.directoryId);
+    }
+  }
+}

package/src/ui/conversation-selection-input.ts

@@ -0,0 +1,103 @@
+import {
+  hasAltModifier,
+  isLeftButtonPress,
+  isMouseRelease,
+  isSelectionDrag,
+  isWheelMouseCode,
+  pointFromMouseEvent as pointFromMouseEventFrame,
+  reduceConversationMouseSelection as reduceConversationMouseSelectionFrame,
+  selectionText as selectionTextFrame,
+  type PaneSelection,
+  type PaneSelectionDrag,
+  type SelectionLayout,
+} from '../mux/live-mux/selection.ts';
+import type { TerminalSnapshotFrameCore } from '../terminal/snapshot-oracle.ts';
+
+interface ConversationSelectionInputOptions {
+  readonly getSelection: () => PaneSelection | null;
+  readonly setSelection: (next: PaneSelection | null) => void;
+  readonly getSelectionDrag: () => PaneSelectionDrag | null;
+  readonly setSelectionDrag: (next: PaneSelectionDrag | null) => void;
+  readonly pinViewportForSelection: () => void;
+  readonly releaseViewportPinForSelection: () => void;
+  readonly markDirty: () => void;
+}
+
+interface ConversationSelectionInputDependencies {
+  readonly pointFromMouseEvent?: typeof pointFromMouseEventFrame;
+  readonly reduceConversationMouseSelection?: typeof reduceConversationMouseSelectionFrame;
+  readonly selectionText?: typeof selectionTextFrame;
+}
+
+interface MouseSelectionInput {
+  readonly layout: SelectionLayout;
+  readonly frame: TerminalSnapshotFrameCore;
+  readonly isMainPaneTarget: boolean;
+  readonly resolveSelectionText?: (selection: PaneSelection) => string;
+  readonly event: {
+    readonly col: number;
+    readonly row: number;
+    readonly code: number;
+    readonly final: 'M' | 'm';
+  };
+}
+
+export class ConversationSelectionInput {
+  private readonly pointFromMouseEvent: typeof pointFromMouseEventFrame;
+  private readonly reduceConversationMouseSelection: typeof reduceConversationMouseSelectionFrame;
+  private readonly selectionText: typeof selectionTextFrame;
+
+  constructor(
+    private readonly options: ConversationSelectionInputOptions,
+    dependencies: ConversationSelectionInputDependencies = {},
+  ) {
+    this.pointFromMouseEvent = dependencies.pointFromMouseEvent ?? pointFromMouseEventFrame;
+    this.reduceConversationMouseSelection =
+      dependencies.reduceConversationMouseSelection ?? reduceConversationMouseSelectionFrame;
+    this.selectionText = dependencies.selectionText ?? selectionTextFrame;
+  }
+
+  clearSelectionOnTextToken(textLength: number): boolean {
+    const hasSelection =
+      this.options.getSelection() !== null || this.options.getSelectionDrag() !== null;
+    if (textLength <= 0 || !hasSelection) {
+      return false;
+    }
+    this.options.setSelection(null);
+    this.options.setSelectionDrag(null);
+    this.options.releaseViewportPinForSelection();
+    this.options.markDirty();
+    return true;
+  }
+
+  handleMouseSelection(input: MouseSelectionInput): boolean {
+    const reduced = this.reduceConversationMouseSelection({
+      selection: this.options.getSelection(),
+      selectionDrag: this.options.getSelectionDrag(),
+      point: this.pointFromMouseEvent(input.layout, input.frame, input.event),
+      isMainPaneTarget: input.isMainPaneTarget,
+      isLeftButtonPress:
+        isLeftButtonPress(input.event.code, input.event.final) && !hasAltModifier(input.event.code),
+      isSelectionDrag:
+        isSelectionDrag(input.event.code, input.event.final) && !hasAltModifier(input.event.code),
+      isMouseRelease: isMouseRelease(input.event.final),
+      isWheelMouseCode: isWheelMouseCode(input.event.code),
+      selectionTextForPane: (nextSelection) =>
+        input.resolveSelectionText === undefined
+          ? this.selectionText(input.frame, nextSelection)
+          : input.resolveSelectionText(nextSelection),
+    });
+    this.options.setSelection(reduced.selection);
+    this.options.setSelectionDrag(reduced.selectionDrag);
+    if (reduced.pinViewport) {
+      this.options.pinViewportForSelection();
+    }
+    if (reduced.releaseViewportPin) {
+      this.options.releaseViewportPinForSelection();
+    }
+    if (reduced.markDirty) {
+      this.options.markDirty();
+    }
+    return reduced.consumed;
+  }
+}

package/src/ui/debug-footer-notice.ts

@@ -0,0 +1,39 @@
+interface DebugFooterNoticeOptions {
+  readonly ttlMs: number;
+  readonly nowMs?: () => number;
+}
+
+export class DebugFooterNotice {
+  private readonly nowMs: () => number;
+  private currentNotice: {
+    text: string;
+    expiresAtMs: number;
+  } | null = null;
+
+  constructor(private readonly options: DebugFooterNoticeOptions) {
+    this.nowMs = options.nowMs ?? Date.now;
+  }
+
+  set(text: string): void {
+    const normalized = text.trim();
+    if (normalized.length === 0) {
+      this.currentNotice = null;
+      return;
+    }
+    this.currentNotice = {
+      text: normalized,
+      expiresAtMs: this.nowMs() + this.options.ttlMs,
+    };
+  }
+
+  current(): string | null {
+    if (this.currentNotice === null) {
+      return null;
+    }
+    if (this.nowMs() > this.currentNotice.expiresAtMs) {
+      this.currentNotice = null;
+      return null;
+    }
+    return this.currentNotice.text;
+  }
+}

package/src/ui/global-shortcut-input.ts

@@ -0,0 +1,126 @@
+import {
+  detectMuxGlobalShortcut as detectMuxGlobalShortcutFrame,
+  type resolveMuxShortcutBindings,
+} from '../mux/input-shortcuts.ts';
+import { handleGlobalShortcut as handleGlobalShortcutFrame } from '../mux/live-mux/global-shortcut-handlers.ts';
+
+type ResolvedMuxShortcutBindings = ReturnType<typeof resolveMuxShortcutBindings>;
+type ShortcutCycleDirection = 'next' | 'previous';
+type MainPaneMode = 'conversation' | 'project' | 'home';
+const DEFAULT_INTERRUPT_ALL_DOUBLE_TAP_WINDOW_MS = 350;
+
+interface GlobalShortcutInputOptions {
+  readonly shortcutBindings: ResolvedMuxShortcutBindings;
+  readonly requestStop: () => void;
+  readonly resolveDirectoryForAction: () => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly toggleCommandMenu: () => void;
+  readonly openOrCreateCritiqueConversationInDirectory: (directoryId: string) => Promise<void>;
+  readonly toggleGatewayProfile: () => Promise<void>;
+  readonly toggleGatewayStatusTimeline: () => Promise<void>;
+  readonly toggleGatewayRenderTrace: (conversationId: string | null) => Promise<void>;
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly getActiveConversationId: () => string | null;
+  readonly conversationsHas: (sessionId: string) => boolean;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly archiveConversation: (sessionId: string) => Promise<void>;
+  readonly interruptConversation: (sessionId: string) => Promise<void>;
+  readonly takeoverConversation: (sessionId: string) => Promise<void>;
+  readonly openAddDirectoryPrompt: () => void;
+  readonly getActiveDirectoryId: () => string | null;
+  readonly directoryExists: (directoryId: string) => boolean;
+  readonly closeDirectory: (directoryId: string) => Promise<void>;
+  readonly cycleLeftNavSelection: (direction: ShortcutCycleDirection) => void;
+  readonly forwardInterruptAllToActiveConversation?: (input: Buffer) => boolean;
+  readonly interruptAllDoubleTapWindowMs?: number;
+  readonly nowMs?: () => number;
+}
+
+interface GlobalShortcutInputDependencies {
+  readonly detectMuxGlobalShortcut?: typeof detectMuxGlobalShortcutFrame;
+  readonly handleGlobalShortcut?: typeof handleGlobalShortcutFrame;
+}
+
+export class GlobalShortcutInput {
+  private readonly detectMuxGlobalShortcut: typeof detectMuxGlobalShortcutFrame;
+  private readonly handleGlobalShortcut: typeof handleGlobalShortcutFrame;
+  private readonly nowMs: () => number;
+  private readonly interruptAllDoubleTapWindowMs: number | null;
+  private lastInterruptAllAtMs: number | null = null;
+
+  constructor(
+    private readonly options: GlobalShortcutInputOptions,
+    dependencies: GlobalShortcutInputDependencies = {},
+  ) {
+    this.detectMuxGlobalShortcut =
+      dependencies.detectMuxGlobalShortcut ?? detectMuxGlobalShortcutFrame;
+    this.handleGlobalShortcut = dependencies.handleGlobalShortcut ?? handleGlobalShortcutFrame;
+    this.nowMs = this.options.nowMs ?? (() => Date.now());
+    const customInterruptAllBehaviorEnabled =
+      this.options.forwardInterruptAllToActiveConversation !== undefined ||
+      this.options.interruptAllDoubleTapWindowMs !== undefined;
+    this.interruptAllDoubleTapWindowMs = customInterruptAllBehaviorEnabled
+      ? (this.options.interruptAllDoubleTapWindowMs ?? DEFAULT_INTERRUPT_ALL_DOUBLE_TAP_WINDOW_MS)
+      : null;
+  }
+
+  handleInput(input: Buffer): boolean {
+    const shortcut = this.detectMuxGlobalShortcut(input, this.options.shortcutBindings);
+    if (shortcut === 'mux.app.interrupt-all' && this.interruptAllDoubleTapWindowMs !== null) {
+      return this.handleInterruptAllShortcut(input);
+    }
+    if (shortcut !== 'mux.app.interrupt-all') {
+      this.lastInterruptAllAtMs = null;
+    }
+    return this.handleGlobalShortcut({
+      shortcut,
+      requestStop: this.options.requestStop,
+      resolveDirectoryForAction: this.options.resolveDirectoryForAction,
+      openNewThreadPrompt: this.options.openNewThreadPrompt,
+      toggleCommandMenu: this.options.toggleCommandMenu,
+      openOrCreateCritiqueConversationInDirectory:
+        this.options.openOrCreateCritiqueConversationInDirectory,
+      toggleGatewayProfile: this.options.toggleGatewayProfile,
+      toggleGatewayStatusTimeline: this.options.toggleGatewayStatusTimeline,
+      toggleGatewayRenderTrace: this.options.toggleGatewayRenderTrace,
+      resolveConversationForAction: () =>
+        this.options.getMainPaneMode() === 'conversation'
+          ? this.options.getActiveConversationId()
+          : null,
+      conversationsHas: this.options.conversationsHas,
+      queueControlPlaneOp: this.options.queueControlPlaneOp,
+      archiveConversation: this.options.archiveConversation,
+      interruptConversation: this.options.interruptConversation,
+      takeoverConversation: this.options.takeoverConversation,
+      openAddDirectoryPrompt: this.options.openAddDirectoryPrompt,
+      resolveClosableDirectoryId: () => {
+        const activeDirectoryId = this.options.getActiveDirectoryId();
+        if (this.options.getMainPaneMode() !== 'project' || activeDirectoryId === null) {
+          return null;
+        }
+        return this.options.directoryExists(activeDirectoryId) ? activeDirectoryId : null;
+      },
+      closeDirectory: this.options.closeDirectory,
+      cycleLeftNavSelection: this.options.cycleLeftNavSelection,
+    });
+  }
+
+  private handleInterruptAllShortcut(input: Buffer): boolean {
+    const nowMs = this.nowMs();
+    const lastInterruptAllAtMs = this.lastInterruptAllAtMs;
+    const doubleTapWindowMs = this.interruptAllDoubleTapWindowMs;
+    if (
+      doubleTapWindowMs !== null &&
+      lastInterruptAllAtMs !== null &&
+      nowMs >= lastInterruptAllAtMs &&
+      nowMs - lastInterruptAllAtMs <= doubleTapWindowMs
+    ) {
+      this.lastInterruptAllAtMs = null;
+      this.options.requestStop();
+      return true;
+    }
+    this.lastInterruptAllAtMs = nowMs;
+    this.options.forwardInterruptAllToActiveConversation?.(input);
+    return true;
+  }
+}

package/src/ui/input-preflight.ts

@@ -0,0 +1,68 @@
+import { extractFocusEvents as extractFocusEventsFrame } from '../mux/live-mux/startup-utils.ts';
+
+interface InputPreflightOptions {
+  readonly isShuttingDown: () => boolean;
+  readonly routeModalInput: (input: Buffer) => boolean;
+  readonly handleEscapeInput: (input: Buffer) => void;
+  readonly onFocusIn: () => void;
+  readonly onFocusOut: () => void;
+  readonly handleRepositoryFoldInput: (input: Buffer) => boolean;
+  readonly handleGlobalShortcutInput: (input: Buffer) => boolean;
+  readonly handleTaskPaneShortcutInput: (input: Buffer) => boolean;
+  readonly handleCopyShortcutInput: (input: Buffer) => boolean;
+}
+
+interface InputPreflightDependencies {
+  readonly extractFocusEvents?: typeof extractFocusEventsFrame;
+}
+
+export class InputPreflight {
+  private readonly extractFocusEvents: typeof extractFocusEventsFrame;
+
+  constructor(
+    private readonly options: InputPreflightOptions,
+    dependencies: InputPreflightDependencies = {},
+  ) {
+    this.extractFocusEvents = dependencies.extractFocusEvents ?? extractFocusEventsFrame;
+  }
+
+  nextInput(input: Buffer): Buffer | null {
+    if (this.options.isShuttingDown()) {
+      return null;
+    }
+    if (this.options.routeModalInput(input)) {
+      return null;
+    }
+
+    if (input.length === 1 && input[0] === 0x1b) {
+      this.options.handleEscapeInput(input);
+      return null;
+    }
+
+    const focusExtraction = this.extractFocusEvents(input);
+    if (focusExtraction.focusInCount > 0) {
+      this.options.onFocusIn();
+    }
+    if (focusExtraction.focusOutCount > 0) {
+      this.options.onFocusOut();
+    }
+    if (focusExtraction.sanitized.length === 0) {
+      return null;
+    }
+
+    if (this.options.handleRepositoryFoldInput(focusExtraction.sanitized)) {
+      return null;
+    }
+    if (this.options.handleGlobalShortcutInput(focusExtraction.sanitized)) {
+      return null;
+    }
+    if (this.options.handleTaskPaneShortcutInput(focusExtraction.sanitized)) {
+      return null;
+    }
+    if (this.options.handleCopyShortcutInput(focusExtraction.sanitized)) {
+      return null;
+    }
+
+    return focusExtraction.sanitized;
+  }
+}