@jmoyers/harness 0.1.0

package/src/ui/left-rail-pointer-input.ts

@@ -0,0 +1,148 @@
+import { handleLeftRailActionClick } from '../mux/live-mux/left-rail-actions.ts';
+import { handleLeftRailConversationClick } from '../mux/live-mux/left-rail-conversation-click.ts';
+import {
+  handleLeftRailPointerClick,
+  type LeftRailPointerContext,
+} from '../mux/live-mux/left-rail-pointer.ts';
+import type { buildWorkspaceRailViewRows } from '../mux/workspace-rail-model.ts';
+
+export interface ConversationTitleClickState {
+  readonly conversationId: string;
+  readonly atMs: number;
+}
+
+interface LeftRailPointerInputOptions {
+  readonly getLatestRailRows: () => ReturnType<typeof buildWorkspaceRailViewRows>;
+  readonly hasConversationTitleEdit: () => boolean;
+  readonly conversationTitleEditConversationId: () => string | null;
+  readonly stopConversationTitleEdit: () => void;
+  readonly hasSelection: () => boolean;
+  readonly clearSelection: () => void;
+  readonly activeConversationId: () => string | null;
+  readonly repositoriesCollapsed: () => boolean;
+  readonly clearConversationTitleEditClickState: () => void;
+  readonly resolveDirectoryForAction: () => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly queueArchiveConversation: (conversationId: string) => void;
+  readonly openAddDirectoryPrompt: () => void;
+  readonly openRepositoryPromptForCreate: () => void;
+  readonly repositoryExists: (repositoryId: string) => boolean;
+  readonly openRepositoryPromptForEdit: (repositoryId: string) => void;
+  readonly queueArchiveRepository: (repositoryId: string) => void;
+  readonly toggleRepositoryGroup: (repositoryGroupId: string) => void;
+  readonly selectLeftNavRepository: (repositoryGroupId: string) => void;
+  readonly expandAllRepositoryGroups: () => void;
+  readonly collapseAllRepositoryGroups: () => void;
+  readonly enterHomePane: () => void;
+  readonly queueCloseDirectory: (directoryId: string) => void;
+  readonly toggleShortcutsCollapsed: () => void;
+  readonly previousConversationClickState: () => ConversationTitleClickState | null;
+  readonly setConversationClickState: (next: ConversationTitleClickState | null) => void;
+  readonly nowMs: () => number;
+  readonly conversationTitleEditDoubleClickWindowMs: number;
+  readonly isConversationPaneActive: () => boolean;
+  readonly ensureConversationPaneActive: (conversationId: string) => void;
+  readonly beginConversationTitleEdit: (conversationId: string) => void;
+  readonly queueActivateConversation: (conversationId: string) => void;
+  readonly queueActivateConversationAndEdit: (conversationId: string) => void;
+  readonly directoriesHas: (directoryId: string) => boolean;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly markDirty: () => void;
+}
+
+interface LeftRailPointerInputDependencies {
+  readonly handleLeftRailPointerClick?: typeof handleLeftRailPointerClick;
+  readonly handleLeftRailActionClick?: typeof handleLeftRailActionClick;
+  readonly handleLeftRailConversationClick?: typeof handleLeftRailConversationClick;
+}
+
+interface HandlePointerClickInput {
+  readonly clickEligible: boolean;
+  readonly paneRows: number;
+  readonly leftCols: number;
+  readonly pointerRow: number;
+  readonly pointerCol: number;
+}
+
+export class LeftRailPointerInput {
+  private readonly pointerClick: typeof handleLeftRailPointerClick;
+  private readonly actionClick: typeof handleLeftRailActionClick;
+  private readonly conversationClick: typeof handleLeftRailConversationClick;
+
+  constructor(
+    private readonly options: LeftRailPointerInputOptions,
+    dependencies: LeftRailPointerInputDependencies = {},
+  ) {
+    this.pointerClick = dependencies.handleLeftRailPointerClick ?? handleLeftRailPointerClick;
+    this.actionClick = dependencies.handleLeftRailActionClick ?? handleLeftRailActionClick;
+    this.conversationClick =
+      dependencies.handleLeftRailConversationClick ?? handleLeftRailConversationClick;
+  }
+
+  handlePointerClick(input: HandlePointerClickInput): boolean {
+    return this.pointerClick({
+      clickEligible: input.clickEligible,
+      rows: this.options.getLatestRailRows(),
+      paneRows: input.paneRows,
+      leftCols: input.leftCols,
+      pointerRow: input.pointerRow,
+      pointerCol: input.pointerCol,
+      hasConversationTitleEdit: this.options.hasConversationTitleEdit(),
+      conversationTitleEditConversationId: this.options.conversationTitleEditConversationId(),
+      stopConversationTitleEdit: this.options.stopConversationTitleEdit,
+      hasSelection: this.options.hasSelection(),
+      clearSelection: this.options.clearSelection,
+      handleAction: (context) => this.handleAction(context),
+      handleConversation: (context) => this.handleConversation(context),
+    });
+  }
+
+  private handleAction(context: LeftRailPointerContext): boolean {
+    return this.actionClick({
+      action: context.selectedAction,
+      selectedProjectId: context.selectedProjectId,
+      selectedRepositoryId: context.selectedRepositoryId,
+      activeConversationId: this.options.activeConversationId(),
+      repositoriesCollapsed: this.options.repositoriesCollapsed(),
+      clearConversationTitleEditClickState: this.options.clearConversationTitleEditClickState,
+      resolveDirectoryForAction: this.options.resolveDirectoryForAction,
+      openNewThreadPrompt: this.options.openNewThreadPrompt,
+      queueArchiveConversation: this.options.queueArchiveConversation,
+      openAddDirectoryPrompt: this.options.openAddDirectoryPrompt,
+      openRepositoryPromptForCreate: this.options.openRepositoryPromptForCreate,
+      repositoryExists: this.options.repositoryExists,
+      openRepositoryPromptForEdit: this.options.openRepositoryPromptForEdit,
+      queueArchiveRepository: this.options.queueArchiveRepository,
+      toggleRepositoryGroup: this.options.toggleRepositoryGroup,
+      selectLeftNavRepository: this.options.selectLeftNavRepository,
+      expandAllRepositoryGroups: this.options.expandAllRepositoryGroups,
+      collapseAllRepositoryGroups: this.options.collapseAllRepositoryGroups,
+      enterHomePane: this.options.enterHomePane,
+      queueCloseDirectory: this.options.queueCloseDirectory,
+      toggleShortcutsCollapsed: this.options.toggleShortcutsCollapsed,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  private handleConversation(context: LeftRailPointerContext): void {
+    this.conversationClick({
+      selectedConversationId: context.selectedConversationId,
+      selectedProjectId: context.selectedProjectId,
+      supportsConversationTitleEditClick: context.supportsConversationTitleEditClick,
+      previousClickState: this.options.previousConversationClickState(),
+      nowMs: this.options.nowMs(),
+      conversationTitleEditDoubleClickWindowMs:
+        this.options.conversationTitleEditDoubleClickWindowMs,
+      activeConversationId: this.options.activeConversationId(),
+      isConversationPaneActive: this.options.isConversationPaneActive(),
+      setConversationClickState: this.options.setConversationClickState,
+      ensureConversationPaneActive: this.options.ensureConversationPaneActive,
+      beginConversationTitleEdit: this.options.beginConversationTitleEdit,
+      queueActivateConversation: this.options.queueActivateConversation,
+      queueActivateConversationAndEdit: this.options.queueActivateConversationAndEdit,
+      directoriesHas: this.options.directoriesHas,
+      enterProjectPane: this.options.enterProjectPane,
+      markDirty: this.options.markDirty,
+    });
+  }
+}

package/src/ui/main-pane-pointer-input.ts

@@ -0,0 +1,150 @@
+import { hasAltModifier, isLeftButtonPress, isMotionMouseCode } from '../mux/live-mux/selection.ts';
+import { handleHomePanePointerClick } from '../mux/live-mux/home-pane-pointer.ts';
+import { handleProjectPaneActionClick } from '../mux/live-mux/project-pane-pointer.ts';
+
+interface EntityDoubleClickState {
+  readonly entityId: string;
+  readonly atMs: number;
+}
+
+interface HomePaneDragState {
+  readonly kind: 'task' | 'repository';
+  readonly itemId: string;
+  readonly startedRowIndex: number;
+  readonly latestRowIndex: number;
+  readonly hasDragged: boolean;
+}
+
+type MainPaneMode = 'conversation' | 'project' | 'home';
+type PointerTarget = 'left' | 'right' | 'separator' | 'status' | 'outside';
+
+interface MainPanePointerInputOptions<TProjectSnapshot extends { directoryId: string }> {
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly getProjectPaneSnapshot: () => TProjectSnapshot | null;
+  readonly getProjectPaneScrollTop: () => number;
+  readonly projectPaneActionAtRow: (
+    snapshot: TProjectSnapshot,
+    rightCols: number,
+    paneRows: number,
+    projectPaneScrollTop: number,
+    rowIndex: number,
+  ) => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly queueCloseDirectory: (directoryId: string) => void;
+  readonly actionAtCell: (rowIndex: number, colIndex: number) => string | null;
+  readonly actionAtRow: (rowIndex: number) => string | null;
+  readonly clearTaskEditClickState: () => void;
+  readonly clearRepositoryEditClickState: () => void;
+  readonly clearHomePaneDragState: () => void;
+  readonly getTaskRepositoryDropdownOpen: () => boolean;
+  readonly setTaskRepositoryDropdownOpen: (open: boolean) => void;
+  readonly taskIdAtRow: (rowIndex: number) => string | null;
+  readonly repositoryIdAtRow: (rowIndex: number) => string | null;
+  readonly selectTaskById: (taskId: string) => void;
+  readonly selectRepositoryById: (repositoryId: string) => void;
+  readonly runTaskPaneAction: (action: 'task.ready' | 'task.draft' | 'task.complete') => void;
+  readonly nowMs: () => number;
+  readonly homePaneEditDoubleClickWindowMs: number;
+  readonly getTaskEditClickState: () => EntityDoubleClickState | null;
+  readonly getRepositoryEditClickState: () => EntityDoubleClickState | null;
+  readonly clearTaskPaneNotice: () => void;
+  readonly setTaskEditClickState: (next: EntityDoubleClickState | null) => void;
+  readonly setRepositoryEditClickState: (next: EntityDoubleClickState | null) => void;
+  readonly setHomePaneDragState: (next: HomePaneDragState | null) => void;
+  readonly openTaskEditPrompt: (taskId: string) => void;
+  readonly openRepositoryPromptForEdit: (repositoryId: string) => void;
+  readonly markDirty: () => void;
+}
+
+interface MainPanePointerInputDependencies {
+  readonly handleProjectPaneActionClick?: typeof handleProjectPaneActionClick;
+  readonly handleHomePanePointerClick?: typeof handleHomePanePointerClick;
+}
+
+interface PointerEventInput {
+  readonly target: PointerTarget;
+  readonly code: number;
+  readonly final: 'M' | 'm';
+  readonly row: number;
+  readonly col: number;
+  readonly paneRows: number;
+  readonly rightCols: number;
+  readonly rightStartCol: number;
+}
+
+export class MainPanePointerInput<TProjectSnapshot extends { directoryId: string }> {
+  private readonly projectPaneActionClick: typeof handleProjectPaneActionClick<TProjectSnapshot>;
+  private readonly homePanePointerClick: typeof handleHomePanePointerClick;
+
+  constructor(
+    private readonly options: MainPanePointerInputOptions<TProjectSnapshot>,
+    dependencies: MainPanePointerInputDependencies = {},
+  ) {
+    this.projectPaneActionClick =
+      dependencies.handleProjectPaneActionClick ?? handleProjectPaneActionClick;
+    this.homePanePointerClick =
+      dependencies.handleHomePanePointerClick ?? handleHomePanePointerClick;
+  }
+
+  handleProjectPanePointerClick(input: PointerEventInput): boolean {
+    const clickEligible =
+      input.target === 'right' &&
+      this.options.getMainPaneMode() === 'project' &&
+      isLeftButtonPress(input.code, input.final) &&
+      !hasAltModifier(input.code) &&
+      !isMotionMouseCode(input.code);
+    const rowIndex = Math.max(0, Math.min(input.paneRows - 1, input.row - 1));
+    return this.projectPaneActionClick({
+      clickEligible,
+      snapshot: this.options.getProjectPaneSnapshot(),
+      rightCols: input.rightCols,
+      paneRows: input.paneRows,
+      projectPaneScrollTop: this.options.getProjectPaneScrollTop(),
+      rowIndex,
+      projectPaneActionAtRow: this.options.projectPaneActionAtRow,
+      openNewThreadPrompt: this.options.openNewThreadPrompt,
+      queueCloseDirectory: this.options.queueCloseDirectory,
+      markDirty: this.options.markDirty,
+    });
+  }
+
+  handleHomePanePointerClick(input: PointerEventInput): boolean {
+    const clickEligible =
+      input.target === 'right' &&
+      this.options.getMainPaneMode() === 'home' &&
+      isLeftButtonPress(input.code, input.final) &&
+      !hasAltModifier(input.code) &&
+      !isMotionMouseCode(input.code);
+    return this.homePanePointerClick({
+      clickEligible,
+      paneRows: input.paneRows,
+      rightCols: input.rightCols,
+      rightStartCol: input.rightStartCol,
+      pointerRow: input.row,
+      pointerCol: input.col,
+      actionAtCell: this.options.actionAtCell,
+      actionAtRow: this.options.actionAtRow,
+      clearTaskEditClickState: this.options.clearTaskEditClickState,
+      clearRepositoryEditClickState: this.options.clearRepositoryEditClickState,
+      clearHomePaneDragState: this.options.clearHomePaneDragState,
+      getTaskRepositoryDropdownOpen: this.options.getTaskRepositoryDropdownOpen,
+      setTaskRepositoryDropdownOpen: this.options.setTaskRepositoryDropdownOpen,
+      taskIdAtRow: this.options.taskIdAtRow,
+      repositoryIdAtRow: this.options.repositoryIdAtRow,
+      selectTaskById: this.options.selectTaskById,
+      selectRepositoryById: this.options.selectRepositoryById,
+      runTaskPaneAction: this.options.runTaskPaneAction,
+      nowMs: this.options.nowMs(),
+      homePaneEditDoubleClickWindowMs: this.options.homePaneEditDoubleClickWindowMs,
+      taskEditClickState: this.options.getTaskEditClickState(),
+      repositoryEditClickState: this.options.getRepositoryEditClickState(),
+      clearTaskPaneNotice: this.options.clearTaskPaneNotice,
+      setTaskEditClickState: this.options.setTaskEditClickState,
+      setRepositoryEditClickState: this.options.setRepositoryEditClickState,
+      setHomePaneDragState: this.options.setHomePaneDragState,
+      openTaskEditPrompt: this.options.openTaskEditPrompt,
+      openRepositoryPromptForEdit: this.options.openRepositoryPromptForEdit,
+      markDirty: this.options.markDirty,
+    });
+  }
+}

package/src/ui/modals/manager.ts

@@ -0,0 +1,192 @@
+import {
+  buildCommandMenuModalOverlay as buildCommandMenuModalOverlayFrame,
+  buildAddDirectoryModalOverlay as buildAddDirectoryModalOverlayFrame,
+  buildConversationTitleModalOverlay as buildConversationTitleModalOverlayFrame,
+  buildNewThreadModalOverlay as buildNewThreadModalOverlayFrame,
+  buildRepositoryModalOverlay as buildRepositoryModalOverlayFrame,
+  buildTaskEditorModalOverlay as buildTaskEditorModalOverlayFrame,
+} from '../../mux/live-mux/modal-overlays.ts';
+import { dismissModalOnOutsideClick as dismissModalOnOutsideClickFrame } from '../../mux/live-mux/modal-pointer.ts';
+import type {
+  CommandMenuActionDescriptor,
+  CommandMenuState,
+} from '../../mux/live-mux/command-menu.ts';
+import type { createNewThreadPromptState } from '../../mux/new-thread-prompt.ts';
+import type {
+  ConversationTitleEditState,
+  RepositoryPromptState,
+  TaskEditorPromptState,
+} from '../../domain/workspace.ts';
+import { isUiModalOverlayHit } from '../kit.ts';
+
+type NewThreadPromptState = ReturnType<typeof createNewThreadPromptState>;
+type AddDirectoryPromptState = { value: string; error: string | null };
+type ModalOverlay = Exclude<ReturnType<typeof buildNewThreadModalOverlayFrame>, null>;
+type ModalTheme = Parameters<typeof buildNewThreadModalOverlayFrame>[3];
+type DismissModalOnOutsideClickInput = Parameters<typeof dismissModalOnOutsideClickFrame>[0];
+
+interface ModalManagerOptions {
+  readonly theme: ModalTheme;
+  readonly resolveRepositoryName: (repositoryId: string) => string | null;
+  readonly getCommandMenu: () => CommandMenuState | null;
+  readonly resolveCommandMenuActions: () => readonly CommandMenuActionDescriptor[];
+  readonly getNewThreadPrompt: () => NewThreadPromptState | null;
+  readonly getAddDirectoryPrompt: () => AddDirectoryPromptState | null;
+  readonly getTaskEditorPrompt: () => TaskEditorPromptState | null;
+  readonly getRepositoryPrompt: () => RepositoryPromptState | null;
+  readonly getConversationTitleEdit: () => ConversationTitleEditState | null;
+}
+
+interface ModalManagerDependencies {
+  readonly buildCommandMenuModalOverlay?: typeof buildCommandMenuModalOverlayFrame;
+  readonly buildNewThreadModalOverlay?: typeof buildNewThreadModalOverlayFrame;
+  readonly buildAddDirectoryModalOverlay?: typeof buildAddDirectoryModalOverlayFrame;
+  readonly buildTaskEditorModalOverlay?: typeof buildTaskEditorModalOverlayFrame;
+  readonly buildRepositoryModalOverlay?: typeof buildRepositoryModalOverlayFrame;
+  readonly buildConversationTitleModalOverlay?: typeof buildConversationTitleModalOverlayFrame;
+  readonly dismissModalOnOutsideClick?: typeof dismissModalOnOutsideClickFrame;
+  readonly isOverlayHit?: typeof isUiModalOverlayHit;
+}
+
+interface ModalDismissInput {
+  readonly input: Buffer;
+  readonly inputRemainder: string;
+  readonly layoutCols: number;
+  readonly viewportRows: number;
+  readonly dismiss: () => void;
+  readonly onInsidePointerPress?: (col: number, row: number) => boolean;
+}
+
+interface ModalDismissResult {
+  readonly handled: boolean;
+  readonly inputRemainder: string;
+}
+
+export class ModalManager {
+  private readonly buildCommandMenuModalOverlay: typeof buildCommandMenuModalOverlayFrame;
+  private readonly buildNewThreadModalOverlay: typeof buildNewThreadModalOverlayFrame;
+  private readonly buildAddDirectoryModalOverlay: typeof buildAddDirectoryModalOverlayFrame;
+  private readonly buildTaskEditorModalOverlay: typeof buildTaskEditorModalOverlayFrame;
+  private readonly buildRepositoryModalOverlay: typeof buildRepositoryModalOverlayFrame;
+  private readonly buildConversationTitleModalOverlay: typeof buildConversationTitleModalOverlayFrame;
+  private readonly dismissModalOnOutsideClick: typeof dismissModalOnOutsideClickFrame;
+  private readonly isOverlayHit: typeof isUiModalOverlayHit;
+
+  constructor(
+    private readonly options: ModalManagerOptions,
+    dependencies: ModalManagerDependencies = {},
+  ) {
+    this.buildCommandMenuModalOverlay =
+      dependencies.buildCommandMenuModalOverlay ?? buildCommandMenuModalOverlayFrame;
+    this.buildNewThreadModalOverlay =
+      dependencies.buildNewThreadModalOverlay ?? buildNewThreadModalOverlayFrame;
+    this.buildAddDirectoryModalOverlay =
+      dependencies.buildAddDirectoryModalOverlay ?? buildAddDirectoryModalOverlayFrame;
+    this.buildTaskEditorModalOverlay =
+      dependencies.buildTaskEditorModalOverlay ?? buildTaskEditorModalOverlayFrame;
+    this.buildRepositoryModalOverlay =
+      dependencies.buildRepositoryModalOverlay ?? buildRepositoryModalOverlayFrame;
+    this.buildConversationTitleModalOverlay =
+      dependencies.buildConversationTitleModalOverlay ?? buildConversationTitleModalOverlayFrame;
+    this.dismissModalOnOutsideClick =
+      dependencies.dismissModalOnOutsideClick ?? dismissModalOnOutsideClickFrame;
+    this.isOverlayHit = dependencies.isOverlayHit ?? isUiModalOverlayHit;
+  }
+
+  buildCommandMenuOverlay(layoutCols: number, viewportRows: number): ModalOverlay | null {
+    return this.buildCommandMenuModalOverlay(
+      layoutCols,
+      viewportRows,
+      this.options.getCommandMenu(),
+      this.options.resolveCommandMenuActions(),
+      this.options.theme,
+    );
+  }
+
+  buildNewThreadOverlay(layoutCols: number, viewportRows: number): ModalOverlay | null {
+    return this.buildNewThreadModalOverlay(
+      layoutCols,
+      viewportRows,
+      this.options.getNewThreadPrompt(),
+      this.options.theme,
+    );
+  }
+
+  buildAddDirectoryOverlay(layoutCols: number, viewportRows: number): ModalOverlay | null {
+    return this.buildAddDirectoryModalOverlay(
+      layoutCols,
+      viewportRows,
+      this.options.getAddDirectoryPrompt(),
+      this.options.theme,
+    );
+  }
+
+  buildTaskEditorOverlay(layoutCols: number, viewportRows: number): ModalOverlay | null {
+    return this.buildTaskEditorModalOverlay(
+      layoutCols,
+      viewportRows,
+      this.options.getTaskEditorPrompt(),
+      this.options.resolveRepositoryName,
+      this.options.theme,
+    );
+  }
+
+  buildRepositoryOverlay(layoutCols: number, viewportRows: number): ModalOverlay | null {
+    return this.buildRepositoryModalOverlay(
+      layoutCols,
+      viewportRows,
+      this.options.getRepositoryPrompt(),
+      this.options.theme,
+    );
+  }
+
+  buildConversationTitleOverlay(layoutCols: number, viewportRows: number): ModalOverlay | null {
+    return this.buildConversationTitleModalOverlay(
+      layoutCols,
+      viewportRows,
+      this.options.getConversationTitleEdit(),
+      this.options.theme,
+    );
+  }
+
+  buildCurrentOverlay(layoutCols: number, viewportRows: number): ModalOverlay | null {
+    const commandMenuOverlay = this.buildCommandMenuOverlay(layoutCols, viewportRows);
+    if (commandMenuOverlay !== null) {
+      return commandMenuOverlay;
+    }
+    const newThreadOverlay = this.buildNewThreadOverlay(layoutCols, viewportRows);
+    if (newThreadOverlay !== null) {
+      return newThreadOverlay;
+    }
+    const addDirectoryOverlay = this.buildAddDirectoryOverlay(layoutCols, viewportRows);
+    if (addDirectoryOverlay !== null) {
+      return addDirectoryOverlay;
+    }
+    const taskEditorOverlay = this.buildTaskEditorOverlay(layoutCols, viewportRows);
+    if (taskEditorOverlay !== null) {
+      return taskEditorOverlay;
+    }
+    const repositoryOverlay = this.buildRepositoryOverlay(layoutCols, viewportRows);
+    if (repositoryOverlay !== null) {
+      return repositoryOverlay;
+    }
+    return this.buildConversationTitleOverlay(layoutCols, viewportRows);
+  }
+
+  dismissOnOutsideClick(input: ModalDismissInput): ModalDismissResult {
+    const dismissInput: DismissModalOnOutsideClickInput = {
+      input: input.input,
+      inputRemainder: input.inputRemainder,
+      dismiss: input.dismiss,
+      buildCurrentModalOverlay: () =>
+        this.buildCurrentOverlay(input.layoutCols, input.viewportRows),
+      isOverlayHit: this.isOverlayHit,
+      ...(input.onInsidePointerPress === undefined
+        ? {}
+        : {
+            onInsidePointerPress: input.onInsidePointerPress,
+          }),
+    };
+    return this.dismissModalOnOutsideClick(dismissInput);
+  }
+}