@jmoyers/harness 0.1.0

package/src/ui/input-token-router.ts

@@ -0,0 +1,312 @@
+import {
+  classifyPaneAt as classifyPaneAtFrame,
+  type computeDualPaneLayout,
+  type parseMuxInputChunk,
+} from '../mux/dual-pane-core.ts';
+import {
+  hasAltModifier as hasAltModifierFrame,
+  hasShiftModifier as hasShiftModifierFrame,
+  isLeftButtonPress as isLeftButtonPressFrame,
+  isMotionMouseCode as isMotionMouseCodeFrame,
+  type PaneSelection,
+} from '../mux/live-mux/selection.ts';
+import type { TerminalSnapshotFrameCore } from '../terminal/snapshot-oracle.ts';
+
+type MainPaneMode = 'conversation' | 'project' | 'home';
+type DualPaneLayout = ReturnType<typeof computeDualPaneLayout>;
+type MuxInputToken = ReturnType<typeof parseMuxInputChunk>['tokens'][number];
+type PointerTarget = ReturnType<typeof classifyPaneAtFrame>;
+
+interface MouseSelectionEvent {
+  readonly col: number;
+  readonly row: number;
+  readonly code: number;
+  readonly final: 'M' | 'm';
+}
+
+interface ConversationInputLike {
+  readonly oracle: {
+    isMouseTrackingEnabled: () => boolean;
+    scrollViewport: (delta: number) => void;
+    snapshotWithoutHash: () => TerminalSnapshotFrameCore;
+    selectionText: (anchor: PaneSelection['anchor'], focus: PaneSelection['focus']) => string;
+  };
+}
+
+interface PointerRoutingInputLike {
+  handlePaneDividerDrag(event: { code: number; final: 'M' | 'm'; col: number }): boolean;
+  handleHomePaneDragRelease(event: {
+    final: 'M' | 'm';
+    target: PointerTarget;
+    rowIndex: number;
+  }): boolean;
+  handleSeparatorPointerPress(event: {
+    target: PointerTarget;
+    code: number;
+    final: 'M' | 'm';
+    col: number;
+  }): boolean;
+  handleMainPaneWheel(
+    event: { target: PointerTarget; code: number },
+    onConversationWheel: (delta: number) => void,
+  ): boolean;
+  handleHomePaneDragMove(event: {
+    target: PointerTarget;
+    code: number;
+    final: 'M' | 'm';
+    rowIndex: number;
+  }): boolean;
+}
+
+interface MainPanePointerInputLike {
+  handleProjectPanePointerClick(event: {
+    target: PointerTarget;
+    code: number;
+    final: 'M' | 'm';
+    row: number;
+    col: number;
+    rightCols: number;
+    paneRows: number;
+    rightStartCol: number;
+  }): boolean;
+  handleHomePanePointerClick(event: {
+    target: PointerTarget;
+    code: number;
+    final: 'M' | 'm';
+    row: number;
+    col: number;
+    rightCols: number;
+    paneRows: number;
+    rightStartCol: number;
+  }): boolean;
+}
+
+interface LeftRailPointerInputLike {
+  handlePointerClick(input: {
+    clickEligible: boolean;
+    paneRows: number;
+    leftCols: number;
+    pointerRow: number;
+    pointerCol: number;
+  }): boolean;
+}
+
+interface ConversationSelectionInputLike {
+  clearSelectionOnTextToken(textLength: number): boolean;
+  handleMouseSelection(input: {
+    layout: DualPaneLayout;
+    frame: TerminalSnapshotFrameCore;
+    isMainPaneTarget: boolean;
+    resolveSelectionText?: (selection: PaneSelection) => string;
+    event: MouseSelectionEvent;
+  }): boolean;
+}
+
+interface InputTokenRouterOptions {
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly pointerRoutingInput: PointerRoutingInputLike;
+  readonly mainPanePointerInput: MainPanePointerInputLike;
+  readonly leftRailPointerInput: LeftRailPointerInputLike;
+  readonly conversationSelectionInput: ConversationSelectionInputLike;
+}
+
+interface InputTokenRouterDependencies {
+  readonly classifyPaneAt?: typeof classifyPaneAtFrame;
+  readonly isLeftButtonPress?: typeof isLeftButtonPressFrame;
+  readonly hasAltModifier?: typeof hasAltModifierFrame;
+  readonly hasShiftModifier?: typeof hasShiftModifierFrame;
+  readonly isMotionMouseCode?: typeof isMotionMouseCodeFrame;
+}
+
+interface RouteTokensInput {
+  readonly tokens: readonly MuxInputToken[];
+  readonly layout: DualPaneLayout;
+  readonly conversation: ConversationInputLike | null;
+  readonly snapshotForInput: TerminalSnapshotFrameCore | null;
+}
+
+interface RouteTokensResult {
+  readonly routedTokens: MuxInputToken[];
+  readonly snapshotForInput: TerminalSnapshotFrameCore | null;
+}
+
+export class InputTokenRouter {
+  private readonly classifyPaneAt: typeof classifyPaneAtFrame;
+  private readonly isLeftButtonPress: typeof isLeftButtonPressFrame;
+  private readonly hasAltModifier: typeof hasAltModifierFrame;
+  private readonly hasShiftModifier: typeof hasShiftModifierFrame;
+  private readonly isMotionMouseCode: typeof isMotionMouseCodeFrame;
+
+  constructor(
+    private readonly options: InputTokenRouterOptions,
+    dependencies: InputTokenRouterDependencies = {},
+  ) {
+    this.classifyPaneAt = dependencies.classifyPaneAt ?? classifyPaneAtFrame;
+    this.isLeftButtonPress = dependencies.isLeftButtonPress ?? isLeftButtonPressFrame;
+    this.hasAltModifier = dependencies.hasAltModifier ?? hasAltModifierFrame;
+    this.hasShiftModifier = dependencies.hasShiftModifier ?? hasShiftModifierFrame;
+    this.isMotionMouseCode = dependencies.isMotionMouseCode ?? isMotionMouseCodeFrame;
+  }
+
+  routeTokens(input: RouteTokensInput): RouteTokensResult {
+    let snapshotForInput = input.snapshotForInput;
+    const conversation = input.conversation;
+    const resolveSelectionText =
+      conversation === null
+        ? null
+        : (selection: PaneSelection): string =>
+            conversation.oracle.selectionText(selection.anchor, selection.focus);
+    const routedTokens: MuxInputToken[] = [];
+    for (const token of input.tokens) {
+      if (token.kind !== 'mouse') {
+        this.options.conversationSelectionInput.clearSelectionOnTextToken(token.text.length);
+        routedTokens.push(token);
+        continue;
+      }
+
+      if (
+        this.options.pointerRoutingInput.handlePaneDividerDrag({
+          code: token.event.code,
+          final: token.event.final,
+          col: token.event.col,
+        })
+      ) {
+        continue;
+      }
+
+      const target = this.classifyPaneAt(input.layout, token.event.col, token.event.row);
+      const rowIndex = Math.max(0, Math.min(input.layout.paneRows - 1, token.event.row - 1));
+      const passThroughConversationMouse =
+        input.conversation !== null &&
+        this.options.getMainPaneMode() === 'conversation' &&
+        target === 'right' &&
+        snapshotForInput !== null &&
+        snapshotForInput.activeScreen === 'alternate' &&
+        snapshotForInput.viewport.followOutput &&
+        input.conversation.oracle.isMouseTrackingEnabled() &&
+        !this.hasShiftModifier(token.event.code);
+      if (
+        this.options.pointerRoutingInput.handleHomePaneDragRelease({
+          final: token.event.final,
+          target,
+          rowIndex,
+        })
+      ) {
+        continue;
+      }
+      if (
+        this.options.pointerRoutingInput.handleSeparatorPointerPress({
+          target,
+          code: token.event.code,
+          final: token.event.final,
+          col: token.event.col,
+        })
+      ) {
+        continue;
+      }
+      if (passThroughConversationMouse) {
+        routedTokens.push(token);
+        continue;
+      }
+      const isMainPaneTarget = target === 'right';
+      if (
+        this.options.pointerRoutingInput.handleMainPaneWheel(
+          {
+            target,
+            code: token.event.code,
+          },
+          (delta) => {
+            if (input.conversation !== null) {
+              input.conversation.oracle.scrollViewport(delta);
+              snapshotForInput = input.conversation.oracle.snapshotWithoutHash();
+            }
+          },
+        )
+      ) {
+        continue;
+      }
+      if (
+        this.options.pointerRoutingInput.handleHomePaneDragMove({
+          target,
+          code: token.event.code,
+          final: token.event.final,
+          rowIndex,
+        })
+      ) {
+        continue;
+      }
+      if (
+        this.options.mainPanePointerInput.handleProjectPanePointerClick({
+          target,
+          code: token.event.code,
+          final: token.event.final,
+          row: token.event.row,
+          col: token.event.col,
+          rightCols: input.layout.rightCols,
+          paneRows: input.layout.paneRows,
+          rightStartCol: input.layout.rightStartCol,
+        })
+      ) {
+        continue;
+      }
+      if (
+        this.options.mainPanePointerInput.handleHomePanePointerClick({
+          target,
+          code: token.event.code,
+          final: token.event.final,
+          row: token.event.row,
+          col: token.event.col,
+          paneRows: input.layout.paneRows,
+          rightCols: input.layout.rightCols,
+          rightStartCol: input.layout.rightStartCol,
+        })
+      ) {
+        continue;
+      }
+      const leftPaneConversationSelect =
+        target === 'left' &&
+        this.isLeftButtonPress(token.event.code, token.event.final) &&
+        !this.hasAltModifier(token.event.code) &&
+        !this.isMotionMouseCode(token.event.code);
+      if (
+        this.options.leftRailPointerInput.handlePointerClick({
+          clickEligible: leftPaneConversationSelect,
+          paneRows: input.layout.paneRows,
+          leftCols: input.layout.leftCols,
+          pointerRow: token.event.row,
+          pointerCol: token.event.col,
+        })
+      ) {
+        continue;
+      }
+      if (snapshotForInput === null || this.options.getMainPaneMode() !== 'conversation') {
+        routedTokens.push(token);
+        continue;
+      }
+      const mouseSelectionInput =
+        resolveSelectionText === null
+          ? {
+              layout: input.layout,
+              frame: snapshotForInput,
+              isMainPaneTarget,
+              event: token.event,
+            }
+          : {
+              layout: input.layout,
+              frame: snapshotForInput,
+              isMainPaneTarget,
+              resolveSelectionText,
+              event: token.event,
+            };
+      if (this.options.conversationSelectionInput.handleMouseSelection(mouseSelectionInput)) {
+        continue;
+      }
+
+      routedTokens.push(token);
+    }
+    return {
+      routedTokens,
+      snapshotForInput,
+    };
+  }
+}

package/src/ui/input.ts

@@ -0,0 +1,238 @@
+import { handleCommandMenuInput as handleCommandMenuInputFrame } from '../mux/live-mux/modal-command-menu-handler.ts';
+import {
+  handleConversationTitleEditInput as handleConversationTitleEditInputFrame,
+  handleNewThreadPromptInput as handleNewThreadPromptInputFrame,
+} from '../mux/live-mux/modal-conversation-handlers.ts';
+import {
+  handleAddDirectoryPromptInput as handleAddDirectoryPromptInputFrame,
+  handleRepositoryPromptInput as handleRepositoryPromptInputFrame,
+} from '../mux/live-mux/modal-prompt-handlers.ts';
+import { handleTaskEditorPromptInput as handleTaskEditorPromptInputFrame } from '../mux/live-mux/modal-task-editor-handler.ts';
+import type {
+  ConversationTitleEditState,
+  RepositoryPromptState,
+  TaskEditorPromptState,
+} from '../domain/workspace.ts';
+import type {
+  CommandMenuActionDescriptor,
+  CommandMenuState,
+} from '../mux/live-mux/command-menu.ts';
+import type {
+  createNewThreadPromptState,
+  normalizeThreadAgentType,
+} from '../mux/new-thread-prompt.ts';
+
+type NewThreadPromptState = ReturnType<typeof createNewThreadPromptState>;
+type ThreadAgentType = ReturnType<typeof normalizeThreadAgentType>;
+type TaskEditorInputResult = ReturnType<typeof handleTaskEditorPromptInputFrame>;
+type TaskEditorSubmitPayload = NonNullable<TaskEditorInputResult['submitPayload']>;
+
+interface InputRouterOptions {
+  readonly isModalDismissShortcut: (input: Buffer) => boolean;
+  readonly isCommandMenuToggleShortcut: (input: Buffer) => boolean;
+  readonly isArchiveConversationShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  readonly buildConversationTitleModalOverlay: () => { top: number } | null;
+  readonly buildCommandMenuModalOverlay: () => { top: number } | null;
+  readonly buildNewThreadModalOverlay: () => { top: number } | null;
+  readonly resolveNewThreadPromptAgentByRow: (
+    overlayTop: number,
+    row: number,
+  ) => ThreadAgentType | null;
+  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly archiveConversation: (sessionId: string) => Promise<void>;
+  readonly createAndActivateConversationInDirectory: (
+    directoryId: string,
+    agentType: ThreadAgentType,
+  ) => Promise<void>;
+  readonly addDirectoryByPath: (path: string) => Promise<void>;
+  readonly normalizeGitHubRemoteUrl: (remoteUrl: string) => string | null;
+  readonly upsertRepositoryByRemoteUrl: (
+    remoteUrl: string,
+    existingRepositoryId?: string,
+  ) => Promise<void>;
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly markDirty: () => void;
+  readonly conversations: ReadonlyMap<string, { title: string }>;
+  readonly scheduleConversationTitlePersist: () => void;
+  readonly getTaskEditorPrompt: () => TaskEditorPromptState | null;
+  readonly setTaskEditorPrompt: (next: TaskEditorPromptState | null) => void;
+  readonly submitTaskEditorPayload: (payload: TaskEditorSubmitPayload) => void;
+  readonly getConversationTitleEdit: () => ConversationTitleEditState | null;
+  readonly getCommandMenu: () => CommandMenuState | null;
+  readonly setCommandMenu: (menu: CommandMenuState | null) => void;
+  readonly resolveCommandMenuActions: () => readonly CommandMenuActionDescriptor[];
+  readonly executeCommandMenuAction: (actionId: string) => void;
+  readonly getNewThreadPrompt: () => NewThreadPromptState | null;
+  readonly setNewThreadPrompt: (prompt: NewThreadPromptState | null) => void;
+  readonly getAddDirectoryPrompt: () => { value: string; error: string | null } | null;
+  readonly setAddDirectoryPrompt: (
+    next: {
+      value: string;
+      error: string | null;
+    } | null,
+  ) => void;
+  readonly getRepositoryPrompt: () => RepositoryPromptState | null;
+  readonly setRepositoryPrompt: (next: RepositoryPromptState | null) => void;
+}
+
+interface InputRouterDependencies {
+  readonly handleCommandMenuInput?: typeof handleCommandMenuInputFrame;
+  readonly handleTaskEditorPromptInput?: typeof handleTaskEditorPromptInputFrame;
+  readonly handleConversationTitleEditInput?: typeof handleConversationTitleEditInputFrame;
+  readonly handleNewThreadPromptInput?: typeof handleNewThreadPromptInputFrame;
+  readonly handleAddDirectoryPromptInput?: typeof handleAddDirectoryPromptInputFrame;
+  readonly handleRepositoryPromptInput?: typeof handleRepositoryPromptInputFrame;
+}
+
+export class InputRouter {
+  private readonly handleCommandMenuInputFrame: typeof handleCommandMenuInputFrame;
+  private readonly handleTaskEditorPromptInputFrame: typeof handleTaskEditorPromptInputFrame;
+  private readonly handleConversationTitleEditInputFrame: typeof handleConversationTitleEditInputFrame;
+  private readonly handleNewThreadPromptInputFrame: typeof handleNewThreadPromptInputFrame;
+  private readonly handleAddDirectoryPromptInputFrame: typeof handleAddDirectoryPromptInputFrame;
+  private readonly handleRepositoryPromptInputFrame: typeof handleRepositoryPromptInputFrame;
+
+  constructor(
+    private readonly options: InputRouterOptions,
+    dependencies: InputRouterDependencies = {},
+  ) {
+    this.handleCommandMenuInputFrame =
+      dependencies.handleCommandMenuInput ?? handleCommandMenuInputFrame;
+    this.handleTaskEditorPromptInputFrame =
+      dependencies.handleTaskEditorPromptInput ?? handleTaskEditorPromptInputFrame;
+    this.handleConversationTitleEditInputFrame =
+      dependencies.handleConversationTitleEditInput ?? handleConversationTitleEditInputFrame;
+    this.handleNewThreadPromptInputFrame =
+      dependencies.handleNewThreadPromptInput ?? handleNewThreadPromptInputFrame;
+    this.handleAddDirectoryPromptInputFrame =
+      dependencies.handleAddDirectoryPromptInput ?? handleAddDirectoryPromptInputFrame;
+    this.handleRepositoryPromptInputFrame =
+      dependencies.handleRepositoryPromptInput ?? handleRepositoryPromptInputFrame;
+  }
+
+  handleCommandMenuInput(input: Buffer): boolean {
+    return this.handleCommandMenuInputFrame({
+      input,
+      menu: this.options.getCommandMenu(),
+      isQuitShortcut: this.options.isModalDismissShortcut,
+      isToggleShortcut: this.options.isCommandMenuToggleShortcut,
+      dismissOnOutsideClick: this.options.dismissOnOutsideClick,
+      buildCommandMenuModalOverlay: this.options.buildCommandMenuModalOverlay,
+      resolveActions: this.options.resolveCommandMenuActions,
+      executeAction: this.options.executeCommandMenuAction,
+      setMenu: this.options.setCommandMenu,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  handleTaskEditorPromptInput(input: Buffer): boolean {
+    const handled = this.handleTaskEditorPromptInputFrame({
+      input,
+      prompt: this.options.getTaskEditorPrompt(),
+      isQuitShortcut: this.options.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.dismissOnOutsideClick,
+    });
+    if (!handled.handled) {
+      return false;
+    }
+    if (handled.nextPrompt !== undefined) {
+      this.options.setTaskEditorPrompt(handled.nextPrompt);
+    }
+    if (handled.markDirty) {
+      this.options.markDirty();
+    }
+    if (handled.submitPayload !== undefined) {
+      this.options.submitTaskEditorPayload(handled.submitPayload);
+    }
+    return true;
+  }
+
+  handleRepositoryPromptInput(input: Buffer): boolean {
+    return this.handleRepositoryPromptInputFrame({
+      input,
+      prompt: this.options.getRepositoryPrompt(),
+      isQuitShortcut: this.options.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.dismissOnOutsideClick,
+      setPrompt: this.options.setRepositoryPrompt,
+      markDirty: this.options.markDirty,
+      repositoriesHas: this.options.repositoriesHas,
+      normalizeGitHubRemoteUrl: this.options.normalizeGitHubRemoteUrl,
+      queueControlPlaneOp: this.options.queueControlPlaneOp,
+      upsertRepositoryByRemoteUrl: this.options.upsertRepositoryByRemoteUrl,
+    });
+  }
+
+  handleNewThreadPromptInput(input: Buffer): boolean {
+    return this.handleNewThreadPromptInputFrame({
+      input,
+      prompt: this.options.getNewThreadPrompt(),
+      isQuitShortcut: this.options.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.dismissOnOutsideClick,
+      buildNewThreadModalOverlay: this.options.buildNewThreadModalOverlay,
+      resolveNewThreadPromptAgentByRow: this.options.resolveNewThreadPromptAgentByRow,
+      queueControlPlaneOp: this.options.queueControlPlaneOp,
+      createAndActivateConversationInDirectory:
+        this.options.createAndActivateConversationInDirectory,
+      markDirty: this.options.markDirty,
+      setPrompt: this.options.setNewThreadPrompt,
+    });
+  }
+
+  handleConversationTitleEditInput(input: Buffer): boolean {
+    return this.handleConversationTitleEditInputFrame({
+      input,
+      edit: this.options.getConversationTitleEdit(),
+      isQuitShortcut: this.options.isModalDismissShortcut,
+      isArchiveShortcut: this.options.isArchiveConversationShortcut,
+      dismissOnOutsideClick: this.options.dismissOnOutsideClick,
+      buildConversationTitleModalOverlay: this.options.buildConversationTitleModalOverlay,
+      stopConversationTitleEdit: this.options.stopConversationTitleEdit,
+      queueControlPlaneOp: this.options.queueControlPlaneOp,
+      archiveConversation: this.options.archiveConversation,
+      markDirty: this.options.markDirty,
+      conversations: this.options.conversations,
+      scheduleConversationTitlePersist: this.options.scheduleConversationTitlePersist,
+    });
+  }
+
+  handleAddDirectoryPromptInput(input: Buffer): boolean {
+    return this.handleAddDirectoryPromptInputFrame({
+      input,
+      prompt: this.options.getAddDirectoryPrompt(),
+      isQuitShortcut: this.options.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.dismissOnOutsideClick,
+      setPrompt: this.options.setAddDirectoryPrompt,
+      markDirty: this.options.markDirty,
+      queueControlPlaneOp: this.options.queueControlPlaneOp,
+      addDirectoryByPath: this.options.addDirectoryByPath,
+    });
+  }
+
+  routeModalInput(input: Buffer): boolean {
+    if (this.handleCommandMenuInput(input)) {
+      return true;
+    }
+    if (this.handleTaskEditorPromptInput(input)) {
+      return true;
+    }
+    if (this.handleRepositoryPromptInput(input)) {
+      return true;
+    }
+    if (this.handleNewThreadPromptInput(input)) {
+      return true;
+    }
+    if (this.handleConversationTitleEditInput(input)) {
+      return true;
+    }
+    if (this.handleAddDirectoryPromptInput(input)) {
+      return true;
+    }
+    return false;
+  }
+}