@jmoyers/harness 0.1.11 → 0.1.20

package/src/diff-ui/state.ts

@@ -0,0 +1,224 @@
+import { buildFinderResults } from './finder.ts';
+import { maxTopRowForModel } from './model.ts';
+import type { DiffUiModel, DiffUiState, DiffUiStateAction, DiffUiViewMode } from './types.ts';
+
+const AUTO_SPLIT_MIN_WIDTH = 120;
+
+function clamp(value: number, min: number, max: number): number {
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}
+
+function clampIndex(value: number, length: number): number {
+  if (length <= 0) {
+    return 0;
+  }
+  return clamp(value, 0, length - 1);
+}
+
+function firstHunkIndexForFile(model: DiffUiModel, fileIndex: number): number {
+  const row = model.rows.find(
+    (candidate) => candidate.kind === 'hunk-header' && candidate.fileIndex === fileIndex,
+  );
+  return row?.hunkIndex ?? 0;
+}
+
+function resolveTopForFile(model: DiffUiModel, fileIndex: number): number {
+  if (model.fileStartRows.length === 0) {
+    return 0;
+  }
+  return model.fileStartRows[clampIndex(fileIndex, model.fileStartRows.length)] ?? 0;
+}
+
+function resolveTopForHunk(model: DiffUiModel, hunkIndex: number): number {
+  if (model.hunkStartRows.length === 0) {
+    return 0;
+  }
+  return model.hunkStartRows[clampIndex(hunkIndex, model.hunkStartRows.length)] ?? 0;
+}
+
+export function resolveEffectiveViewMode(
+  viewMode: DiffUiViewMode,
+  viewportWidth: number,
+): 'split' | 'unified' {
+  if (viewMode === 'split') {
+    return 'split';
+  }
+  if (viewMode === 'unified') {
+    return 'unified';
+  }
+  return viewportWidth >= AUTO_SPLIT_MIN_WIDTH ? 'split' : 'unified';
+}
+
+export function createInitialDiffUiState(
+  model: DiffUiModel,
+  viewMode: DiffUiViewMode,
+  viewportWidth: number,
+): DiffUiState {
+  return {
+    viewMode,
+    effectiveViewMode: resolveEffectiveViewMode(viewMode, viewportWidth),
+    topRow: 0,
+    activeFileIndex: model.diff.files.length === 0 ? 0 : 0,
+    activeHunkIndex: model.hunkStartRows.length === 0 ? 0 : 0,
+    finderOpen: false,
+    finderQuery: '',
+    finderSelectedIndex: 0,
+    finderResults: buildFinderResults(model, ''),
+    searchQuery: '',
+  };
+}
+
+function withClampedTop(
+  state: DiffUiState,
+  model: DiffUiModel,
+  viewportHeight: number,
+): DiffUiState {
+  const maxTop = maxTopRowForModel(model, viewportHeight);
+  return {
+    ...state,
+    topRow: clamp(state.topRow, 0, maxTop),
+  };
+}
+
+export function reduceDiffUiState(input: {
+  readonly model: DiffUiModel;
+  readonly state: DiffUiState;
+  readonly action: DiffUiStateAction;
+  readonly viewportWidth: number;
+  readonly viewportHeight: number;
+}): DiffUiState {
+  const { model, action, viewportHeight, viewportWidth } = input;
+  let next: DiffUiState = input.state;
+
+  if (action.type === 'viewport.changed') {
+    next = {
+      ...next,
+      effectiveViewMode: resolveEffectiveViewMode(next.viewMode, action.width),
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'view.setMode') {
+    next = {
+      ...next,
+      viewMode: action.mode,
+      effectiveViewMode: resolveEffectiveViewMode(action.mode, viewportWidth),
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'nav.scroll') {
+    next = {
+      ...next,
+      topRow: next.topRow + action.delta,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'nav.page') {
+    next = {
+      ...next,
+      topRow: next.topRow + action.delta * Math.max(1, action.pageSize),
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'nav.gotoFile') {
+    const fileIndex = clampIndex(action.fileIndex, model.diff.files.length);
+    next = {
+      ...next,
+      activeFileIndex: fileIndex,
+      activeHunkIndex: firstHunkIndexForFile(model, fileIndex),
+      topRow: resolveTopForFile(model, fileIndex),
+      finderOpen: false,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'nav.gotoHunk') {
+    const hunkIndex = clampIndex(action.hunkIndex, model.hunkStartRows.length);
+    const hunkRow = model.rows.find(
+      (row) => row.kind === 'hunk-header' && row.hunkIndex === hunkIndex,
+    );
+    next = {
+      ...next,
+      activeHunkIndex: hunkIndex,
+      activeFileIndex: hunkRow?.fileIndex ?? next.activeFileIndex,
+      topRow: resolveTopForHunk(model, hunkIndex),
+      finderOpen: false,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'finder.open') {
+    next = {
+      ...next,
+      finderOpen: true,
+      finderResults: buildFinderResults(model, next.finderQuery),
+      finderSelectedIndex: 0,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'finder.close') {
+    next = {
+      ...next,
+      finderOpen: false,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'finder.query') {
+    const results = buildFinderResults(model, action.query);
+    next = {
+      ...next,
+      finderOpen: true,
+      finderQuery: action.query,
+      finderResults: results,
+      finderSelectedIndex: 0,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'finder.move') {
+    const selected = clampIndex(next.finderSelectedIndex + action.delta, next.finderResults.length);
+    next = {
+      ...next,
+      finderSelectedIndex: selected,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'finder.accept') {
+    if (next.finderResults.length === 0) {
+      return withClampedTop(next, model, viewportHeight);
+    }
+    const selection =
+      next.finderResults[clampIndex(next.finderSelectedIndex, next.finderResults.length)] ??
+      next.finderResults[0]!;
+    next = {
+      ...next,
+      activeFileIndex: selection.fileIndex,
+      activeHunkIndex: firstHunkIndexForFile(model, selection.fileIndex),
+      topRow: resolveTopForFile(model, selection.fileIndex),
+      finderOpen: false,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  if (action.type === 'search.set') {
+    next = {
+      ...next,
+      searchQuery: action.query,
+    };
+    return withClampedTop(next, model, viewportHeight);
+  }
+
+  return withClampedTop(next, model, viewportHeight);
+}

package/src/diff-ui/types.ts

@@ -0,0 +1,236 @@
+import type { DiffCoverageReason, DiffMode, NormalizedDiff } from '../diff/types.ts';
+
+export type DiffUiViewMode = 'auto' | 'split' | 'unified';
+type DiffUiEffectiveViewMode = 'split' | 'unified';
+export type DiffUiSyntaxMode = 'auto' | 'on' | 'off';
+export type DiffUiWordDiffMode = 'auto' | 'on' | 'off';
+
+interface DiffUiBudget {
+  readonly maxFiles: number;
+  readonly maxHunks: number;
+  readonly maxLines: number;
+  readonly maxBytes: number;
+  readonly maxRuntimeMs: number;
+}
+
+export interface DiffUiCliOptions {
+  readonly cwd: string;
+  readonly mode: DiffMode;
+  readonly baseRef: string | null;
+  readonly headRef: string | null;
+  readonly includeGenerated: boolean;
+  readonly includeBinary: boolean;
+  readonly noRenames: boolean;
+  readonly renameLimit: number | null;
+  readonly viewMode: DiffUiViewMode;
+  readonly syntaxMode: DiffUiSyntaxMode;
+  readonly wordDiffMode: DiffUiWordDiffMode;
+  readonly color: boolean;
+  readonly pager: boolean;
+  readonly watch: boolean;
+  readonly jsonEvents: boolean;
+  readonly rpcStdio: boolean;
+  readonly snapshot: boolean;
+  readonly width: number | null;
+  readonly height: number | null;
+  readonly theme: string | null;
+  readonly budget: DiffUiBudget;
+}
+
+export type DiffUiRowKind =
+  | 'file-header'
+  | 'hunk-header'
+  | 'code-context'
+  | 'code-add'
+  | 'code-del'
+  | 'notice';
+
+export interface DiffUiVirtualRow {
+  readonly kind: DiffUiRowKind;
+  readonly unified: string;
+  readonly left: string;
+  readonly right: string;
+  readonly fileId: string | null;
+  readonly hunkId: string | null;
+  readonly fileIndex: number | null;
+  readonly hunkIndex: number | null;
+  readonly language: string | null;
+  readonly oldLine: number | null;
+  readonly newLine: number | null;
+}
+
+export interface DiffUiModel {
+  readonly diff: NormalizedDiff;
+  readonly rows: readonly DiffUiVirtualRow[];
+  readonly fileStartRows: readonly number[];
+  readonly hunkStartRows: readonly number[];
+}
+
+export interface DiffUiFinderResult {
+  readonly fileIndex: number;
+  readonly fileId: string;
+  readonly path: string;
+  readonly score: number;
+}
+
+export interface DiffUiState {
+  readonly viewMode: DiffUiViewMode;
+  readonly effectiveViewMode: DiffUiEffectiveViewMode;
+  readonly topRow: number;
+  readonly activeFileIndex: number;
+  readonly activeHunkIndex: number;
+  readonly finderOpen: boolean;
+  readonly finderQuery: string;
+  readonly finderSelectedIndex: number;
+  readonly finderResults: readonly DiffUiFinderResult[];
+  readonly searchQuery: string;
+}
+
+export type DiffUiStateAction =
+  | {
+      readonly type: 'viewport.changed';
+      readonly width: number;
+    }
+  | {
+      readonly type: 'view.setMode';
+      readonly mode: DiffUiViewMode;
+    }
+  | {
+      readonly type: 'nav.scroll';
+      readonly delta: number;
+    }
+  | {
+      readonly type: 'nav.page';
+      readonly delta: number;
+      readonly pageSize: number;
+    }
+  | {
+      readonly type: 'nav.gotoFile';
+      readonly fileIndex: number;
+    }
+  | {
+      readonly type: 'nav.gotoHunk';
+      readonly hunkIndex: number;
+    }
+  | {
+      readonly type: 'finder.open';
+    }
+  | {
+      readonly type: 'finder.close';
+    }
+  | {
+      readonly type: 'finder.query';
+      readonly query: string;
+    }
+  | {
+      readonly type: 'finder.move';
+      readonly delta: number;
+    }
+  | {
+      readonly type: 'finder.accept';
+    }
+  | {
+      readonly type: 'search.set';
+      readonly query: string;
+    };
+
+export type DiffUiCommand =
+  | {
+      readonly type: 'view.setMode';
+      readonly mode: DiffUiViewMode;
+    }
+  | {
+      readonly type: 'nav.scroll';
+      readonly delta: number;
+    }
+  | {
+      readonly type: 'nav.page';
+      readonly delta: number;
+    }
+  | {
+      readonly type: 'nav.gotoFile';
+      readonly index: number;
+    }
+  | {
+      readonly type: 'nav.gotoHunk';
+      readonly index: number;
+    }
+  | {
+      readonly type: 'finder.open';
+    }
+  | {
+      readonly type: 'finder.close';
+    }
+  | {
+      readonly type: 'finder.query';
+      readonly query: string;
+    }
+  | {
+      readonly type: 'finder.move';
+      readonly delta: number;
+    }
+  | {
+      readonly type: 'finder.accept';
+    }
+  | {
+      readonly type: 'search.set';
+      readonly query: string;
+    }
+  | {
+      readonly type: 'session.quit';
+    };
+
+export type DiffUiEvent =
+  | {
+      readonly type: 'diff.loaded';
+      readonly files: number;
+      readonly hunks: number;
+      readonly lines: number;
+      readonly coverageReason: DiffCoverageReason;
+    }
+  | {
+      readonly type: 'state.changed';
+      readonly state: DiffUiState;
+    }
+  | {
+      readonly type: 'render.completed';
+      readonly rows: number;
+      readonly width: number;
+      readonly height: number;
+      readonly view: DiffUiEffectiveViewMode;
+    }
+  | {
+      readonly type: 'warning';
+      readonly message: string;
+    }
+  | {
+      readonly type: 'session.quit';
+    };
+
+export interface DiffUiRenderTheme {
+  readonly headerAnsi: string;
+  readonly footerAnsi: string;
+  readonly fileHeaderAnsi: string;
+  readonly hunkHeaderAnsi: string;
+  readonly contextAnsi: string;
+  readonly addAnsi: string;
+  readonly delAnsi: string;
+  readonly noticeAnsi: string;
+  readonly gutterAnsi: string;
+  readonly resetAnsi: string;
+  readonly syntaxKeywordAnsi: string;
+  readonly syntaxStringAnsi: string;
+  readonly syntaxCommentAnsi: string;
+  readonly syntaxNumberAnsi: string;
+}
+
+export interface DiffUiRenderOutput {
+  readonly lines: readonly string[];
+  readonly state: DiffUiState;
+}
+
+export interface DiffUiRunOutput {
+  readonly exitCode: number;
+  readonly events: readonly DiffUiEvent[];
+  readonly renderedLines: readonly string[];
+}

package/src/domain/workspace.ts

@@ -1,13 +1,14 @@
 import type { ProjectPaneSnapshot } from '../mux/harness-core-ui.ts';
 import type { CommandMenuState } from '../mux/live-mux/command-menu.ts';
 import type { LeftNavSelection } from '../mux/live-mux/left-nav.ts';
+import type { LinePromptInputState } from '../mux/live-mux/modal-input-reducers.ts';
 import type { PaneSelection, PaneSelectionDrag } from '../mux/live-mux/selection.ts';
 import type { createNewThreadPromptState } from '../mux/new-thread-prompt.ts';
 import type { TaskComposerBuffer } from '../mux/task-composer.ts';
 import type { TaskFocusedPaneView } from '../mux/task-focused-pane.ts';
 import type { buildWorkspaceRailViewRows } from '../mux/workspace-rail-model.ts';
 
-type MainPaneMode = 'conversation' | 'project' | 'home';
+type MainPaneMode = 'conversation' | 'project' | 'home' | 'nim';
 
 export interface ConversationTitleEditState {
   conversationId: string;
@@ -25,19 +26,20 @@ export interface RepositoryPromptState {
   readonly error: string | null;
 }
 
-export interface ApiKeyPromptState {
+interface ApiKeyPromptState {
   readonly keyName: string;
   readonly displayName: string;
   readonly value: string;
   readonly error: string | null;
   readonly hasExistingValue: boolean;
+  readonly lineInputState?: LinePromptInputState;
 }
 
 export interface TaskEditorPromptState {
   mode: 'create' | 'edit';
   taskId: string | null;
   title: string;
-  description: string;
+  body: string;
   repositoryIds: readonly string[];
   repositoryIndex: number;
   fieldIndex: 0 | 1 | 2;
@@ -60,7 +62,8 @@ interface WorkspaceModelInit {
   latestTaskPaneView: TaskFocusedPaneView;
   taskDraftComposer: TaskComposerBuffer;
   repositoriesCollapsed: boolean;
-  shortcutsCollapsed: boolean;
+  shortcutsCollapsed?: boolean;
+  showDebugBar?: boolean;
 }
 
 export class WorkspaceModel {
@@ -98,9 +101,12 @@ export class WorkspaceModel {
   paneDividerDragActive = false;
   previousSelectionRows: readonly number[] = [];
   latestRailViewRows: ReturnType<typeof buildWorkspaceRailViewRows> = [];
+  visibleGitHubDirectoryIds = new Set<string>();
+  expandedGitHubDirectoryIds = new Set<string>();
 
   repositoriesCollapsed: boolean;
   shortcutsCollapsed: boolean;
+  showDebugBar: boolean;
 
   constructor(init: WorkspaceModelInit) {
     this.activeDirectoryId = init.activeDirectoryId;
@@ -108,7 +114,8 @@ export class WorkspaceModel {
     this.latestTaskPaneView = init.latestTaskPaneView;
     this.taskDraftComposer = init.taskDraftComposer;
     this.repositoriesCollapsed = init.repositoriesCollapsed;
-    this.shortcutsCollapsed = init.shortcutsCollapsed;
+    this.shortcutsCollapsed = init.shortcutsCollapsed ?? false;
+    this.showDebugBar = init.showDebugBar ?? false;
   }
 
   selectLeftNavHome(): void {
@@ -117,6 +124,18 @@ export class WorkspaceModel {
     };
   }
 
+  selectLeftNavNim(): void {
+    this.leftNavSelection = {
+      kind: 'nim',
+    };
+  }
+
+  selectLeftNavTasks(): void {
+    this.leftNavSelection = {
+      kind: 'tasks',
+    };
+  }
+
   selectLeftNavRepository(repositoryGroupId: string): void {
     this.activeRepositorySelectionId = repositoryGroupId;
     this.leftNavSelection = {
@@ -133,6 +152,14 @@ export class WorkspaceModel {
     };
   }
 
+  selectLeftNavGitHub(directoryId: string, repositoryGroupId: string): void {
+    this.activeRepositorySelectionId = repositoryGroupId;
+    this.leftNavSelection = {
+      kind: 'github',
+      directoryId,
+    };
+  }
+
   selectLeftNavConversation(sessionId: string): void {
     this.leftNavSelection = {
       kind: 'conversation',
@@ -150,6 +177,16 @@ export class WorkspaceModel {
     this.projectPaneScrollTop = 0;
   }
 
+  enterGitHubPane(directoryId: string, repositoryGroupId: string): void {
+    this.activeDirectoryId = directoryId;
+    this.selectLeftNavGitHub(directoryId, repositoryGroupId);
+    this.mainPaneMode = 'project';
+    this.homePaneDragState = null;
+    this.taskPaneTaskEditClickState = null;
+    this.taskPaneRepositoryEditClickState = null;
+    this.projectPaneScrollTop = 0;
+  }
+
   enterHomePane(): void {
     this.mainPaneMode = 'home';
     this.selectLeftNavHome();
@@ -162,4 +199,30 @@ export class WorkspaceModel {
     this.taskPaneRepositoryEditClickState = null;
     this.homePaneDragState = null;
   }
+
+  enterNimPane(): void {
+    this.mainPaneMode = 'nim';
+    this.selectLeftNavNim();
+    this.projectPaneSnapshot = null;
+    this.projectPaneScrollTop = 0;
+    this.taskPaneScrollTop = 0;
+    this.taskPaneNotice = null;
+    this.taskRepositoryDropdownOpen = false;
+    this.taskPaneTaskEditClickState = null;
+    this.taskPaneRepositoryEditClickState = null;
+    this.homePaneDragState = null;
+  }
+
+  enterTasksPane(): void {
+    this.mainPaneMode = 'home';
+    this.selectLeftNavTasks();
+    this.projectPaneSnapshot = null;
+    this.projectPaneScrollTop = 0;
+    this.taskPaneScrollTop = 0;
+    this.taskPaneNotice = null;
+    this.taskRepositoryDropdownOpen = false;
+    this.taskPaneTaskEditClickState = null;
+    this.taskPaneRepositoryEditClickState = null;
+    this.homePaneDragState = null;
+  }
 }