@jmoyers/harness 0.1.0

package/src/mux/live-mux/left-nav.ts

@@ -0,0 +1,85 @@
+import type { buildWorkspaceRailViewRows } from '../workspace-rail-model.ts';
+
+export type LeftNavSelection =
+  | {
+      readonly kind: 'home';
+    }
+  | {
+      readonly kind: 'repository';
+      readonly repositoryId: string;
+    }
+  | {
+      readonly kind: 'project';
+      readonly directoryId: string;
+    }
+  | {
+      readonly kind: 'conversation';
+      readonly sessionId: string;
+    };
+
+export function leftNavTargetKey(target: LeftNavSelection): string {
+  if (target.kind === 'home') {
+    return 'home';
+  }
+  if (target.kind === 'repository') {
+    return `repository:${target.repositoryId}`;
+  }
+  if (target.kind === 'project') {
+    return `directory:${target.directoryId}`;
+  }
+  return `conversation:${target.sessionId}`;
+}
+
+function leftNavTargetFromRow(
+  rows: ReturnType<typeof buildWorkspaceRailViewRows>,
+  rowIndex: number,
+): LeftNavSelection | null {
+  const row = rows[rowIndex];
+  if (row === undefined) {
+    return null;
+  }
+  if (row.railAction === 'home.open') {
+    return {
+      kind: 'home',
+    };
+  }
+  if (row.kind === 'repository-header' && row.repositoryId !== null) {
+    return {
+      kind: 'repository',
+      repositoryId: row.repositoryId,
+    };
+  }
+  if (row.kind === 'dir-header' && row.directoryKey !== null) {
+    return {
+      kind: 'project',
+      directoryId: row.directoryKey,
+    };
+  }
+  if (row.kind === 'conversation-title' && row.conversationSessionId !== null) {
+    return {
+      kind: 'conversation',
+      sessionId: row.conversationSessionId,
+    };
+  }
+  return null;
+}
+
+export function visibleLeftNavTargets(
+  rows: ReturnType<typeof buildWorkspaceRailViewRows>,
+): readonly LeftNavSelection[] {
+  const entries: LeftNavSelection[] = [];
+  const seen = new Set<string>();
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+    const target = leftNavTargetFromRow(rows, rowIndex);
+    if (target === null) {
+      continue;
+    }
+    const key = leftNavTargetKey(target);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    entries.push(target);
+  }
+  return entries;
+}

package/src/mux/live-mux/left-rail-actions.ts

@@ -0,0 +1,118 @@
+interface HandleLeftRailActionClickOptions {
+  action: string | null;
+  selectedProjectId: string | null;
+  selectedRepositoryId: string | null;
+  activeConversationId: string | null;
+  repositoriesCollapsed: boolean;
+  clearConversationTitleEditClickState: () => void;
+  resolveDirectoryForAction: () => string | null;
+  openNewThreadPrompt: (directoryId: string) => void;
+  queueArchiveConversation: (conversationId: string) => void;
+  openAddDirectoryPrompt: () => void;
+  openRepositoryPromptForCreate: () => void;
+  repositoryExists: (repositoryId: string) => boolean;
+  openRepositoryPromptForEdit: (repositoryId: string) => void;
+  queueArchiveRepository: (repositoryId: string) => void;
+  toggleRepositoryGroup: (repositoryId: string) => void;
+  selectLeftNavRepository: (repositoryId: string) => void;
+  expandAllRepositoryGroups: () => void;
+  collapseAllRepositoryGroups: () => void;
+  enterHomePane: () => void;
+  queueCloseDirectory: (directoryId: string) => void;
+  toggleShortcutsCollapsed: () => void;
+  markDirty: () => void;
+}
+
+export function handleLeftRailActionClick(options: HandleLeftRailActionClickOptions): boolean {
+  if (options.action === 'conversation.new') {
+    options.clearConversationTitleEditClickState();
+    const targetDirectoryId = options.selectedProjectId ?? options.resolveDirectoryForAction();
+    if (targetDirectoryId !== null) {
+      options.openNewThreadPrompt(targetDirectoryId);
+    }
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'conversation.delete') {
+    options.clearConversationTitleEditClickState();
+    if (options.activeConversationId !== null) {
+      options.queueArchiveConversation(options.activeConversationId);
+    }
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'project.add') {
+    options.clearConversationTitleEditClickState();
+    options.openAddDirectoryPrompt();
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'repository.add') {
+    options.clearConversationTitleEditClickState();
+    options.openRepositoryPromptForCreate();
+    return true;
+  }
+  if (options.action === 'repository.edit') {
+    options.clearConversationTitleEditClickState();
+    if (
+      options.selectedRepositoryId !== null &&
+      options.repositoryExists(options.selectedRepositoryId)
+    ) {
+      options.openRepositoryPromptForEdit(options.selectedRepositoryId);
+    }
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'repository.archive') {
+    options.clearConversationTitleEditClickState();
+    if (
+      options.selectedRepositoryId !== null &&
+      options.repositoryExists(options.selectedRepositoryId)
+    ) {
+      options.queueArchiveRepository(options.selectedRepositoryId);
+    }
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'repository.toggle') {
+    options.clearConversationTitleEditClickState();
+    if (options.selectedRepositoryId !== null) {
+      options.toggleRepositoryGroup(options.selectedRepositoryId);
+      options.selectLeftNavRepository(options.selectedRepositoryId);
+    }
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'repositories.toggle') {
+    options.clearConversationTitleEditClickState();
+    if (options.repositoriesCollapsed) {
+      options.expandAllRepositoryGroups();
+    } else {
+      options.collapseAllRepositoryGroups();
+    }
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'home.open') {
+    options.clearConversationTitleEditClickState();
+    options.enterHomePane();
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'project.close') {
+    options.clearConversationTitleEditClickState();
+    const targetDirectoryId = options.selectedProjectId ?? options.resolveDirectoryForAction();
+    if (targetDirectoryId !== null) {
+      options.queueCloseDirectory(targetDirectoryId);
+    }
+    options.markDirty();
+    return true;
+  }
+  if (options.action === 'shortcuts.toggle') {
+    options.clearConversationTitleEditClickState();
+    options.toggleShortcutsCollapsed();
+    options.markDirty();
+    return true;
+  }
+  return false;
+}

package/src/mux/live-mux/left-rail-conversation-click.ts

@@ -0,0 +1,82 @@
+import { detectConversationDoubleClick } from '../double-click.ts';
+
+interface ConversationTitleEditClickState {
+  readonly conversationId: string;
+  readonly atMs: number;
+}
+
+interface HandleLeftRailConversationClickOptions {
+  selectedConversationId: string | null;
+  selectedProjectId: string | null;
+  supportsConversationTitleEditClick: boolean;
+  previousClickState: ConversationTitleEditClickState | null;
+  nowMs: number;
+  conversationTitleEditDoubleClickWindowMs: number;
+  activeConversationId: string | null;
+  isConversationPaneActive: boolean;
+  setConversationClickState: (next: ConversationTitleEditClickState | null) => void;
+  ensureConversationPaneActive: (conversationId: string) => void;
+  beginConversationTitleEdit: (conversationId: string) => void;
+  queueActivateConversation: (conversationId: string) => void;
+  queueActivateConversationAndEdit: (conversationId: string) => void;
+  directoriesHas: (directoryId: string) => boolean;
+  enterProjectPane: (directoryId: string) => void;
+  markDirty: () => void;
+}
+
+export function handleLeftRailConversationClick(
+  options: HandleLeftRailConversationClickOptions,
+): boolean {
+  const conversationClick =
+    options.selectedConversationId !== null && options.supportsConversationTitleEditClick
+      ? detectConversationDoubleClick(
+          options.previousClickState,
+          options.selectedConversationId,
+          options.nowMs,
+          options.conversationTitleEditDoubleClickWindowMs,
+        )
+      : {
+          doubleClick: false,
+          nextState: null,
+        };
+  options.setConversationClickState(conversationClick.nextState);
+
+  if (
+    options.selectedConversationId !== null &&
+    options.selectedConversationId === options.activeConversationId
+  ) {
+    if (!options.isConversationPaneActive) {
+      options.ensureConversationPaneActive(options.selectedConversationId);
+    }
+    if (conversationClick.doubleClick) {
+      options.beginConversationTitleEdit(options.selectedConversationId);
+    }
+    options.markDirty();
+    return true;
+  }
+
+  if (options.selectedConversationId !== null) {
+    if (conversationClick.doubleClick) {
+      options.queueActivateConversationAndEdit(options.selectedConversationId);
+    } else {
+      options.queueActivateConversation(options.selectedConversationId);
+    }
+    options.markDirty();
+    return true;
+  }
+
+  if (
+    options.selectedConversationId === null &&
+    options.selectedProjectId !== null &&
+    options.directoriesHas(options.selectedProjectId)
+  ) {
+    options.setConversationClickState(null);
+    options.enterProjectPane(options.selectedProjectId);
+    options.markDirty();
+    return true;
+  }
+
+  options.setConversationClickState(null);
+  options.markDirty();
+  return true;
+}

package/src/mux/live-mux/left-rail-pointer.ts

@@ -0,0 +1,74 @@
+import {
+  actionAtWorkspaceRailCell,
+  conversationIdAtWorkspaceRailRow,
+  kindAtWorkspaceRailRow,
+  projectIdAtWorkspaceRailRow,
+  repositoryIdAtWorkspaceRailRow,
+} from '../workspace-rail-model.ts';
+import type { buildWorkspaceRailViewRows } from '../workspace-rail-model.ts';
+
+export interface LeftRailPointerContext {
+  readonly selectedConversationId: string | null;
+  readonly selectedProjectId: string | null;
+  readonly selectedRepositoryId: string | null;
+  readonly selectedAction: string | null;
+  readonly supportsConversationTitleEditClick: boolean;
+}
+
+interface HandleLeftRailPointerClickOptions {
+  clickEligible: boolean;
+  rows: ReturnType<typeof buildWorkspaceRailViewRows>;
+  paneRows: number;
+  leftCols: number;
+  pointerRow: number;
+  pointerCol: number;
+  hasConversationTitleEdit: boolean;
+  conversationTitleEditConversationId: string | null;
+  stopConversationTitleEdit: () => void;
+  hasSelection: boolean;
+  clearSelection: () => void;
+  handleAction: (context: LeftRailPointerContext) => boolean;
+  handleConversation: (context: LeftRailPointerContext) => void;
+}
+
+export function handleLeftRailPointerClick(options: HandleLeftRailPointerClickOptions): boolean {
+  if (!options.clickEligible) {
+    return false;
+  }
+  const rowIndex = Math.max(0, Math.min(options.paneRows - 1, options.pointerRow - 1));
+  const colIndex = Math.max(0, Math.min(options.leftCols - 1, options.pointerCol - 1));
+  const selectedConversationId = conversationIdAtWorkspaceRailRow(options.rows, rowIndex);
+  const selectedProjectId = projectIdAtWorkspaceRailRow(options.rows, rowIndex);
+  const selectedRepositoryId = repositoryIdAtWorkspaceRailRow(options.rows, rowIndex);
+  const selectedAction = actionAtWorkspaceRailCell(
+    options.rows,
+    rowIndex,
+    colIndex,
+    options.leftCols,
+  );
+  const selectedRowKind = kindAtWorkspaceRailRow(options.rows, rowIndex);
+  const supportsConversationTitleEditClick =
+    selectedRowKind === 'conversation-title' || selectedRowKind === 'conversation-body';
+  const keepTitleEditActive =
+    options.hasConversationTitleEdit &&
+    selectedConversationId === options.conversationTitleEditConversationId &&
+    supportsConversationTitleEditClick;
+  if (!keepTitleEditActive && options.hasConversationTitleEdit) {
+    options.stopConversationTitleEdit();
+  }
+  if (options.hasSelection) {
+    options.clearSelection();
+  }
+  const context: LeftRailPointerContext = {
+    selectedConversationId,
+    selectedProjectId,
+    selectedRepositoryId,
+    selectedAction,
+    supportsConversationTitleEditClick,
+  };
+  if (options.handleAction(context)) {
+    return true;
+  }
+  options.handleConversation(context);
+  return true;
+}

package/src/mux/live-mux/modal-command-menu-handler.ts

@@ -0,0 +1,101 @@
+import {
+  clampCommandMenuState,
+  COMMAND_MENU_MAX_RESULTS,
+  reduceCommandMenuInput,
+  resolveCommandMenuMatches,
+  type CommandMenuActionDescriptor,
+  type CommandMenuState,
+} from './command-menu.ts';
+
+interface HandleCommandMenuInputOptions {
+  readonly input: Buffer;
+  readonly menu: CommandMenuState | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly isToggleShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  readonly buildCommandMenuModalOverlay: () => { top: number } | null;
+  readonly resolveActions: () => readonly CommandMenuActionDescriptor[];
+  readonly executeAction: (actionId: string) => void;
+  readonly setMenu: (next: CommandMenuState | null) => void;
+  readonly markDirty: () => void;
+}
+
+export function handleCommandMenuInput(options: HandleCommandMenuInputOptions): boolean {
+  const {
+    input,
+    menu,
+    isQuitShortcut,
+    isToggleShortcut,
+    dismissOnOutsideClick,
+    buildCommandMenuModalOverlay,
+    resolveActions,
+    executeAction,
+    setMenu,
+    markDirty,
+  } = options;
+  if (menu === null) {
+    return false;
+  }
+  if (input.length === 1 && input[0] === 0x03) {
+    return false;
+  }
+  if (isQuitShortcut(input)) {
+    setMenu(null);
+    markDirty();
+    return true;
+  }
+  if (isToggleShortcut(input)) {
+    setMenu(null);
+    markDirty();
+    return true;
+  }
+  const maybeMouseSequence = input.includes(0x3c);
+  if (
+    maybeMouseSequence &&
+    dismissOnOutsideClick(
+      input,
+      () => {
+        setMenu(null);
+        markDirty();
+      },
+      (_col, _row) => {
+        return buildCommandMenuModalOverlay() !== null;
+      },
+    )
+  ) {
+    return true;
+  }
+
+  const currentMatches = resolveCommandMenuMatches(
+    resolveActions(),
+    menu.query,
+    COMMAND_MENU_MAX_RESULTS,
+  );
+  const reduction = reduceCommandMenuInput(menu, input, currentMatches.length);
+  if (reduction.submit) {
+    const clamped = clampCommandMenuState(menu, currentMatches.length);
+    const selected = currentMatches[clamped.selectedIndex];
+    setMenu(null);
+    if (selected !== undefined) {
+      executeAction(selected.action.id);
+    }
+    markDirty();
+    return true;
+  }
+
+  const nextMatches = resolveCommandMenuMatches(
+    resolveActions(),
+    reduction.nextState.query,
+    COMMAND_MENU_MAX_RESULTS,
+  );
+  const nextState = clampCommandMenuState(reduction.nextState, nextMatches.length);
+  if (nextState.query !== menu.query || nextState.selectedIndex !== menu.selectedIndex) {
+    setMenu(nextState);
+    markDirty();
+  }
+  return true;
+}

package/src/mux/live-mux/modal-conversation-handlers.ts

@@ -0,0 +1,217 @@
+import {
+  type createNewThreadPromptState,
+  reduceNewThreadPromptInput,
+  type normalizeThreadAgentType,
+} from '../new-thread-prompt.ts';
+import { reduceLinePromptInput } from './modal-input-reducers.ts';
+
+type NewThreadPromptState = ReturnType<typeof createNewThreadPromptState>;
+type ThreadAgentType = ReturnType<typeof normalizeThreadAgentType>;
+
+interface ConversationTitleEditState {
+  conversationId: string;
+  value: string;
+  lastSavedValue: string;
+  error: string | null;
+  persistInFlight: boolean;
+  debounceTimer: NodeJS.Timeout | null;
+}
+
+interface HandleConversationTitleEditInputOptions {
+  input: Buffer;
+  edit: ConversationTitleEditState | null;
+  isQuitShortcut: (input: Buffer) => boolean;
+  isArchiveShortcut: (input: Buffer) => boolean;
+  dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  buildConversationTitleModalOverlay: () => { top: number } | null;
+  stopConversationTitleEdit: (persistPending: boolean) => void;
+  queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  archiveConversation: (sessionId: string) => Promise<void>;
+  markDirty: () => void;
+  conversations: ReadonlyMap<string, { title: string }>;
+  scheduleConversationTitlePersist: () => void;
+}
+
+interface HandleNewThreadPromptInputOptions {
+  input: Buffer;
+  prompt: NewThreadPromptState | null;
+  isQuitShortcut: (input: Buffer) => boolean;
+  dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  buildNewThreadModalOverlay: () => { top: number } | null;
+  resolveNewThreadPromptAgentByRow: (overlayTop: number, row: number) => ThreadAgentType | null;
+  queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  createAndActivateConversationInDirectory: (
+    directoryId: string,
+    agentType: ThreadAgentType,
+  ) => Promise<void>;
+  markDirty: () => void;
+  setPrompt: (prompt: NewThreadPromptState | null) => void;
+}
+
+export function handleConversationTitleEditInput(
+  options: HandleConversationTitleEditInputOptions,
+): boolean {
+  const {
+    input,
+    edit,
+    isQuitShortcut,
+    isArchiveShortcut,
+    dismissOnOutsideClick,
+    buildConversationTitleModalOverlay,
+    stopConversationTitleEdit,
+    queueControlPlaneOp,
+    archiveConversation,
+    markDirty,
+    conversations,
+    scheduleConversationTitlePersist,
+  } = options;
+  if (edit === null) {
+    return false;
+  }
+  if (input.length === 1 && input[0] === 0x03) {
+    return false;
+  }
+  if (isQuitShortcut(input)) {
+    stopConversationTitleEdit(true);
+    return true;
+  }
+  if (isArchiveShortcut(input)) {
+    const targetConversationId = edit.conversationId;
+    stopConversationTitleEdit(true);
+    queueControlPlaneOp(async () => {
+      await archiveConversation(targetConversationId);
+    }, 'modal-archive-conversation');
+    markDirty();
+    return true;
+  }
+  if (
+    dismissOnOutsideClick(
+      input,
+      () => {
+        stopConversationTitleEdit(true);
+      },
+      (_col, row) => {
+        const overlay = buildConversationTitleModalOverlay();
+        if (overlay === null) {
+          return false;
+        }
+        const archiveButtonRow = overlay.top + 5;
+        if (row - 1 !== archiveButtonRow) {
+          return false;
+        }
+        const targetConversationId = edit.conversationId;
+        stopConversationTitleEdit(true);
+        queueControlPlaneOp(async () => {
+          await archiveConversation(targetConversationId);
+        }, 'modal-archive-conversation-click');
+        markDirty();
+        return true;
+      },
+    )
+  ) {
+    return true;
+  }
+
+  const reduced = reduceLinePromptInput(edit.value, input);
+  const nextValue = reduced.value;
+  const done = reduced.submit;
+
+  if (nextValue !== edit.value) {
+    edit.value = nextValue;
+    edit.error = null;
+    const conversation = conversations.get(edit.conversationId);
+    if (conversation !== undefined) {
+      conversation.title = nextValue;
+    }
+    scheduleConversationTitlePersist();
+    markDirty();
+  }
+
+  if (done) {
+    stopConversationTitleEdit(true);
+  }
+  return true;
+}
+
+export function handleNewThreadPromptInput(options: HandleNewThreadPromptInputOptions): boolean {
+  const {
+    input,
+    prompt,
+    isQuitShortcut,
+    dismissOnOutsideClick,
+    buildNewThreadModalOverlay,
+    resolveNewThreadPromptAgentByRow,
+    queueControlPlaneOp,
+    createAndActivateConversationInDirectory,
+    markDirty,
+    setPrompt,
+  } = options;
+  if (prompt === null) {
+    return false;
+  }
+  if (input.length === 1 && input[0] === 0x03) {
+    return false;
+  }
+  if (isQuitShortcut(input)) {
+    setPrompt(null);
+    markDirty();
+    return true;
+  }
+  const maybeMouseSequence = input.includes(0x3c);
+  if (
+    maybeMouseSequence &&
+    dismissOnOutsideClick(
+      input,
+      () => {
+        setPrompt(null);
+        markDirty();
+      },
+      (_col, row) => {
+        const overlay = buildNewThreadModalOverlay();
+        if (overlay === null) {
+          return false;
+        }
+        const selectedAgentType = resolveNewThreadPromptAgentByRow(overlay.top, row);
+        if (selectedAgentType === null) {
+          return false;
+        }
+        const targetDirectoryId = prompt.directoryId;
+        setPrompt(null);
+        queueControlPlaneOp(async () => {
+          await createAndActivateConversationInDirectory(targetDirectoryId, selectedAgentType);
+        }, `modal-new-thread-click:${selectedAgentType}`);
+        markDirty();
+        return true;
+      },
+    )
+  ) {
+    return true;
+  }
+
+  const reduction = reduceNewThreadPromptInput(prompt, input);
+  const changed = reduction.nextState.selectedAgentType !== prompt.selectedAgentType;
+
+  if (changed) {
+    setPrompt(reduction.nextState);
+    markDirty();
+  }
+  if (reduction.submit) {
+    const targetDirectoryId = prompt.directoryId;
+    const selectedAgentType = reduction.nextState.selectedAgentType;
+    setPrompt(null);
+    queueControlPlaneOp(async () => {
+      await createAndActivateConversationInDirectory(targetDirectoryId, selectedAgentType);
+    }, `modal-new-thread:${selectedAgentType}`);
+    markDirty();
+    return true;
+  }
+  return true;
+}