@jmoyers/harness 0.1.0

package/src/domain/directories.ts

@@ -0,0 +1,78 @@
+export class DirectoryManager<TDirectoryRecord, TGitSummary> {
+  private readonly directoriesById = new Map<string, TDirectoryRecord>();
+  private readonly gitSummaryByDirectoryId = new Map<string, TGitSummary>();
+
+  constructor() {}
+
+  readonlyDirectories(): ReadonlyMap<string, TDirectoryRecord> {
+    return this.directoriesById;
+  }
+
+  readonlyGitSummaries(): ReadonlyMap<string, TGitSummary> {
+    return this.gitSummaryByDirectoryId;
+  }
+
+  mutableGitSummaries(): Map<string, TGitSummary> {
+    return this.gitSummaryByDirectoryId;
+  }
+
+  hasDirectory(directoryId: string): boolean {
+    return this.directoriesById.has(directoryId);
+  }
+
+  getDirectory(directoryId: string): TDirectoryRecord | undefined {
+    return this.directoriesById.get(directoryId);
+  }
+
+  setDirectory(directoryId: string, directory: TDirectoryRecord): void {
+    this.directoriesById.set(directoryId, directory);
+  }
+
+  deleteDirectory(directoryId: string): void {
+    this.directoriesById.delete(directoryId);
+  }
+
+  clearDirectories(): void {
+    this.directoriesById.clear();
+  }
+
+  directoryIds(): readonly string[] {
+    return [...this.directoriesById.keys()];
+  }
+
+  directoriesSize(): number {
+    return this.directoriesById.size;
+  }
+
+  firstDirectoryId(): string | null {
+    const iterator = this.directoriesById.keys().next();
+    if (iterator.done === true) {
+      return null;
+    }
+    return iterator.value;
+  }
+
+  resolveActiveDirectoryId(activeDirectoryId: string | null): string | null {
+    if (activeDirectoryId !== null && this.directoriesById.has(activeDirectoryId)) {
+      return activeDirectoryId;
+    }
+    return this.firstDirectoryId();
+  }
+
+  ensureGitSummary(directoryId: string, loadingSummary: TGitSummary): void {
+    if (!this.gitSummaryByDirectoryId.has(directoryId)) {
+      this.gitSummaryByDirectoryId.set(directoryId, loadingSummary);
+    }
+  }
+
+  syncGitSummariesWithDirectories(loadingSummary: TGitSummary): void {
+    for (const directoryId of this.directoriesById.keys()) {
+      this.ensureGitSummary(directoryId, loadingSummary);
+    }
+    for (const directoryId of this.gitSummaryByDirectoryId.keys()) {
+      if (!this.directoriesById.has(directoryId)) {
+        this.gitSummaryByDirectoryId.delete(directoryId);
+      }
+    }
+  }
+}

package/src/domain/repositories.ts

@@ -0,0 +1,123 @@
+export class RepositoryManager<TRepositoryRecord, TRepositorySnapshot> {
+  private readonly repositories = new Map<string, TRepositoryRecord>();
+  private readonly repositoryAssociationByDirectoryId = new Map<string, string>();
+  private readonly directoryRepositorySnapshotByDirectoryId = new Map<
+    string,
+    TRepositorySnapshot
+  >();
+  private readonly collapsedRepositoryGroupIds = new Set<string>();
+  private readonly expandedRepositoryGroupIds = new Set<string>();
+
+  constructor() {}
+
+  mutableRepositories(): Map<string, TRepositoryRecord> {
+    return this.repositories;
+  }
+
+  readonlyRepositories(): ReadonlyMap<string, TRepositoryRecord> {
+    return this.repositories;
+  }
+
+  mutableDirectoryAssociations(): Map<string, string> {
+    return this.repositoryAssociationByDirectoryId;
+  }
+
+  readonlyDirectoryAssociations(): ReadonlyMap<string, string> {
+    return this.repositoryAssociationByDirectoryId;
+  }
+
+  mutableDirectorySnapshots(): Map<string, TRepositorySnapshot> {
+    return this.directoryRepositorySnapshotByDirectoryId;
+  }
+
+  readonlyDirectorySnapshots(): ReadonlyMap<string, TRepositorySnapshot> {
+    return this.directoryRepositorySnapshotByDirectoryId;
+  }
+
+  readonlyCollapsedRepositoryGroupIds(): ReadonlySet<string> {
+    return this.collapsedRepositoryGroupIds;
+  }
+
+  clearRepositories(): void {
+    this.repositories.clear();
+  }
+
+  private isRepositoryGroupCollapsed(
+    repositoryGroupId: string,
+    repositoriesCollapsed: boolean,
+  ): boolean {
+    if (repositoriesCollapsed) {
+      return !this.expandedRepositoryGroupIds.has(repositoryGroupId);
+    }
+    return this.collapsedRepositoryGroupIds.has(repositoryGroupId);
+  }
+
+  collapseRepositoryGroup(repositoryGroupId: string, repositoriesCollapsed: boolean): void {
+    if (repositoriesCollapsed) {
+      this.expandedRepositoryGroupIds.delete(repositoryGroupId);
+      return;
+    }
+    this.collapsedRepositoryGroupIds.add(repositoryGroupId);
+  }
+
+  expandRepositoryGroup(repositoryGroupId: string, repositoriesCollapsed: boolean): void {
+    if (repositoriesCollapsed) {
+      this.expandedRepositoryGroupIds.add(repositoryGroupId);
+      return;
+    }
+    this.collapsedRepositoryGroupIds.delete(repositoryGroupId);
+  }
+
+  toggleRepositoryGroup(repositoryGroupId: string, repositoriesCollapsed: boolean): void {
+    if (this.isRepositoryGroupCollapsed(repositoryGroupId, repositoriesCollapsed)) {
+      this.expandRepositoryGroup(repositoryGroupId, repositoriesCollapsed);
+      return;
+    }
+    this.collapseRepositoryGroup(repositoryGroupId, repositoriesCollapsed);
+  }
+
+  collapseAllRepositoryGroups(): true {
+    this.collapsedRepositoryGroupIds.clear();
+    this.expandedRepositoryGroupIds.clear();
+    return true;
+  }
+
+  expandAllRepositoryGroups(): false {
+    this.collapsedRepositoryGroupIds.clear();
+    this.expandedRepositoryGroupIds.clear();
+    return false;
+  }
+
+  repositoryGroupIdForDirectory(directoryId: string, fallbackGroupId: string): string {
+    return this.repositoryAssociationByDirectoryId.get(directoryId) ?? fallbackGroupId;
+  }
+
+  setDirectoryRepositorySnapshot(directoryId: string, snapshot: TRepositorySnapshot): void {
+    this.directoryRepositorySnapshotByDirectoryId.set(directoryId, snapshot);
+  }
+
+  setDirectoryRepositoryAssociation(directoryId: string, repositoryId: string | null): void {
+    if (repositoryId === null) {
+      this.repositoryAssociationByDirectoryId.delete(directoryId);
+      return;
+    }
+    this.repositoryAssociationByDirectoryId.set(directoryId, repositoryId);
+  }
+
+  setRepository(repositoryId: string, repository: TRepositoryRecord): void {
+    this.repositories.set(repositoryId, repository);
+  }
+
+  syncWithDirectories(directoriesHas: (directoryId: string) => boolean): void {
+    for (const directoryId of this.repositoryAssociationByDirectoryId.keys()) {
+      if (!directoriesHas(directoryId)) {
+        this.repositoryAssociationByDirectoryId.delete(directoryId);
+      }
+    }
+    for (const directoryId of this.directoryRepositorySnapshotByDirectoryId.keys()) {
+      if (!directoriesHas(directoryId)) {
+        this.directoryRepositorySnapshotByDirectoryId.delete(directoryId);
+      }
+    }
+  }
+}

package/src/domain/tasks.ts

@@ -0,0 +1,148 @@
+export class TaskManager<
+  TTaskRecord extends { taskId: string },
+  TTaskComposerBuffer,
+  TTaskAutosaveTimer,
+> {
+  private readonly tasksById = new Map<string, TTaskRecord>();
+  private readonly taskComposerByTaskId = new Map<string, TTaskComposerBuffer>();
+  private readonly taskAutosaveTimerByTaskId = new Map<string, TTaskAutosaveTimer>();
+
+  constructor() {}
+
+  readonlyTasks(): ReadonlyMap<string, TTaskRecord> {
+    return this.tasksById;
+  }
+
+  readonlyTaskComposers(): ReadonlyMap<string, TTaskComposerBuffer> {
+    return this.taskComposerByTaskId;
+  }
+
+  values(): IterableIterator<TTaskRecord> {
+    return this.tasksById.values();
+  }
+
+  getTask(taskId: string): TTaskRecord | undefined {
+    return this.tasksById.get(taskId);
+  }
+
+  hasTask(taskId: string): boolean {
+    return this.tasksById.has(taskId);
+  }
+
+  setTask(task: TTaskRecord): void {
+    this.tasksById.set(task.taskId, task);
+  }
+
+  deleteTask(taskId: string): boolean {
+    return this.tasksById.delete(taskId);
+  }
+
+  clearTasks(): void {
+    this.tasksById.clear();
+  }
+
+  getTaskComposer(taskId: string): TTaskComposerBuffer | undefined {
+    return this.taskComposerByTaskId.get(taskId);
+  }
+
+  setTaskComposer(taskId: string, buffer: TTaskComposerBuffer): void {
+    this.taskComposerByTaskId.set(taskId, buffer);
+  }
+
+  deleteTaskComposer(taskId: string): boolean {
+    return this.taskComposerByTaskId.delete(taskId);
+  }
+
+  clearTaskComposers(): void {
+    this.taskComposerByTaskId.clear();
+  }
+
+  autosaveTaskIds(): IterableIterator<string> {
+    return this.taskAutosaveTimerByTaskId.keys();
+  }
+
+  getTaskAutosaveTimer(taskId: string): TTaskAutosaveTimer | undefined {
+    return this.taskAutosaveTimerByTaskId.get(taskId);
+  }
+
+  setTaskAutosaveTimer(taskId: string, timer: TTaskAutosaveTimer): void {
+    this.taskAutosaveTimerByTaskId.set(taskId, timer);
+  }
+
+  deleteTaskAutosaveTimer(taskId: string): boolean {
+    return this.taskAutosaveTimerByTaskId.delete(taskId);
+  }
+
+  clearTaskAutosaveTimers(): void {
+    this.taskAutosaveTimerByTaskId.clear();
+  }
+
+  orderedTasks(
+    sortTasks: (tasks: readonly TTaskRecord[]) => readonly TTaskRecord[],
+  ): readonly TTaskRecord[] {
+    return sortTasks([...this.tasksById.values()]);
+  }
+
+  tasksForRepository(input: {
+    repositoryId: string | null;
+    sortTasks: (tasks: readonly TTaskRecord[]) => readonly TTaskRecord[];
+    taskRepositoryId: (task: TTaskRecord) => string | null;
+  }): readonly TTaskRecord[] {
+    if (input.repositoryId === null) {
+      return [];
+    }
+    return this.orderedTasks(input.sortTasks).filter(
+      (task) => input.taskRepositoryId(task) === input.repositoryId,
+    );
+  }
+
+  taskReorderPayloadIds(input: {
+    orderedActiveTaskIds: readonly string[];
+    sortTasks: (tasks: readonly TTaskRecord[]) => readonly TTaskRecord[];
+    isCompleted: (task: TTaskRecord) => boolean;
+  }): readonly string[] {
+    const completedTaskIds = this.orderedTasks(input.sortTasks)
+      .filter(input.isCompleted)
+      .map((task) => task.taskId);
+    return [...input.orderedActiveTaskIds, ...completedTaskIds];
+  }
+
+  reorderedActiveTaskIdsForDrop(input: {
+    draggedTaskId: string;
+    targetTaskId: string;
+    sortTasks: (tasks: readonly TTaskRecord[]) => readonly TTaskRecord[];
+    isCompleted: (task: TTaskRecord) => boolean;
+  }): readonly string[] | 'cannot-reorder-completed' | null {
+    const draggedTask = this.tasksById.get(input.draggedTaskId);
+    const targetTask = this.tasksById.get(input.targetTaskId);
+    if (draggedTask === undefined || targetTask === undefined) {
+      return null;
+    }
+    if (input.isCompleted(draggedTask) || input.isCompleted(targetTask)) {
+      return 'cannot-reorder-completed';
+    }
+    const orderedActiveTaskIds = this.orderedTasks(input.sortTasks)
+      .filter((task) => !input.isCompleted(task))
+      .map((task) => task.taskId);
+    return this.reorderIdsByMove(orderedActiveTaskIds, input.draggedTaskId, input.targetTaskId);
+  }
+
+  private reorderIdsByMove(
+    orderedIds: readonly string[],
+    movedId: string,
+    targetId: string,
+  ): readonly string[] | null {
+    const fromIndex = orderedIds.indexOf(movedId);
+    const targetIndex = orderedIds.indexOf(targetId);
+    if (fromIndex < 0 || targetIndex < 0 || fromIndex === targetIndex) {
+      return null;
+    }
+    const reordered = [...orderedIds];
+    const [moved] = reordered.splice(fromIndex, 1);
+    if (moved === undefined) {
+      return null;
+    }
+    reordered.splice(targetIndex, 0, moved);
+    return reordered;
+  }
+}

package/src/domain/workspace.ts

@@ -0,0 +1,156 @@
+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 { 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';
+
+export interface ConversationTitleEditState {
+  conversationId: string;
+  value: string;
+  lastSavedValue: string;
+  error: string | null;
+  persistInFlight: boolean;
+  debounceTimer: NodeJS.Timeout | null;
+}
+
+export interface RepositoryPromptState {
+  readonly mode: 'add' | 'edit';
+  readonly repositoryId: string | null;
+  readonly value: string;
+  readonly error: string | null;
+}
+
+export interface TaskEditorPromptState {
+  mode: 'create' | 'edit';
+  taskId: string | null;
+  title: string;
+  description: string;
+  repositoryIds: readonly string[];
+  repositoryIndex: number;
+  fieldIndex: 0 | 1 | 2;
+  error: string | null;
+}
+
+interface HomePaneDragState {
+  readonly kind: 'task' | 'repository';
+  readonly itemId: string;
+  readonly startedRowIndex: number;
+  readonly latestRowIndex: number;
+  readonly hasDragged: boolean;
+}
+
+type TaskEditorTarget = { kind: 'draft' } | { kind: 'task'; taskId: string };
+
+interface WorkspaceModelInit {
+  activeDirectoryId: string | null;
+  leftNavSelection: LeftNavSelection;
+  latestTaskPaneView: TaskFocusedPaneView;
+  taskDraftComposer: TaskComposerBuffer;
+  repositoriesCollapsed: boolean;
+  shortcutsCollapsed: boolean;
+}
+
+export class WorkspaceModel {
+  activeDirectoryId: string | null;
+  mainPaneMode: MainPaneMode = 'conversation';
+  leftNavSelection: LeftNavSelection;
+  activeRepositorySelectionId: string | null = null;
+  repositoryToggleChordPrefixAtMs: number | null = null;
+  projectPaneSnapshot: ProjectPaneSnapshot | null = null;
+  projectPaneScrollTop = 0;
+  taskPaneScrollTop = 0;
+  latestTaskPaneView: TaskFocusedPaneView;
+  taskPaneSelectedTaskId: string | null = null;
+  taskPaneSelectedRepositoryId: string | null = null;
+  taskRepositoryDropdownOpen = false;
+  taskEditorTarget: TaskEditorTarget = { kind: 'draft' };
+  taskDraftComposer: TaskComposerBuffer;
+  taskPaneSelectionFocus: 'task' | 'repository' = 'task';
+  taskPaneNotice: string | null = null;
+  taskPaneTaskEditClickState: { entityId: string; atMs: number } | null = null;
+  taskPaneRepositoryEditClickState: { entityId: string; atMs: number } | null = null;
+  homePaneDragState: HomePaneDragState | null = null;
+
+  selection: PaneSelection | null = null;
+  selectionDrag: PaneSelectionDrag | null = null;
+  selectionPinnedFollowOutput: boolean | null = null;
+  repositoryPrompt: RepositoryPromptState | null = null;
+  commandMenu: CommandMenuState | null = null;
+  newThreadPrompt: ReturnType<typeof createNewThreadPromptState> | null = null;
+  addDirectoryPrompt: { value: string; error: string | null } | null = null;
+  taskEditorPrompt: TaskEditorPromptState | null = null;
+  conversationTitleEdit: ConversationTitleEditState | null = null;
+  conversationTitleEditClickState: { conversationId: string; atMs: number } | null = null;
+  paneDividerDragActive = false;
+  previousSelectionRows: readonly number[] = [];
+  latestRailViewRows: ReturnType<typeof buildWorkspaceRailViewRows> = [];
+
+  repositoriesCollapsed: boolean;
+  shortcutsCollapsed: boolean;
+
+  constructor(init: WorkspaceModelInit) {
+    this.activeDirectoryId = init.activeDirectoryId;
+    this.leftNavSelection = init.leftNavSelection;
+    this.latestTaskPaneView = init.latestTaskPaneView;
+    this.taskDraftComposer = init.taskDraftComposer;
+    this.repositoriesCollapsed = init.repositoriesCollapsed;
+    this.shortcutsCollapsed = init.shortcutsCollapsed;
+  }
+
+  selectLeftNavHome(): void {
+    this.leftNavSelection = {
+      kind: 'home',
+    };
+  }
+
+  selectLeftNavRepository(repositoryGroupId: string): void {
+    this.activeRepositorySelectionId = repositoryGroupId;
+    this.leftNavSelection = {
+      kind: 'repository',
+      repositoryId: repositoryGroupId,
+    };
+  }
+
+  selectLeftNavProject(directoryId: string, repositoryGroupId: string): void {
+    this.activeRepositorySelectionId = repositoryGroupId;
+    this.leftNavSelection = {
+      kind: 'project',
+      directoryId,
+    };
+  }
+
+  selectLeftNavConversation(sessionId: string): void {
+    this.leftNavSelection = {
+      kind: 'conversation',
+      sessionId,
+    };
+  }
+
+  enterProjectPane(directoryId: string, repositoryGroupId: string): void {
+    this.activeDirectoryId = directoryId;
+    this.selectLeftNavProject(directoryId, repositoryGroupId);
+    this.mainPaneMode = 'project';
+    this.homePaneDragState = null;
+    this.taskPaneTaskEditClickState = null;
+    this.taskPaneRepositoryEditClickState = null;
+    this.projectPaneScrollTop = 0;
+  }
+
+  enterHomePane(): void {
+    this.mainPaneMode = 'home';
+    this.selectLeftNavHome();
+    this.projectPaneSnapshot = null;
+    this.projectPaneScrollTop = 0;
+    this.taskPaneScrollTop = 0;
+    this.taskPaneNotice = null;
+    this.taskRepositoryDropdownOpen = false;
+    this.taskPaneTaskEditClickState = null;
+    this.taskPaneRepositoryEditClickState = null;
+    this.homePaneDragState = null;
+  }
+}

package/src/events/normalized-events.ts

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+
+type EventSource = 'provider' | 'meta';
+
+type ProviderEventType =
+  | 'provider-thread-started'
+  | 'provider-turn-started'
+  | 'provider-turn-completed'
+  | 'provider-turn-failed'
+  | 'provider-turn-interrupted'
+  | 'provider-diff-updated'
+  | 'provider-text-delta'
+  | 'provider-tool-call-started'
+  | 'provider-tool-call-completed';
+
+type MetaEventType =
+  | 'meta-attention-raised'
+  | 'meta-attention-cleared'
+  | 'meta-queue-updated'
+  | 'meta-conversation-handoff';
+
+type EventType = ProviderEventType | MetaEventType;
+
+export interface EventScope {
+  tenantId: string;
+  userId: string;
+  workspaceId: string;
+  worktreeId: string;
+  conversationId: string;
+  turnId?: string;
+}
+
+interface BaseEventPayload {
+  kind: string;
+}
+
+interface ThreadEventPayload extends BaseEventPayload {
+  kind: 'thread';
+  threadId: string;
+}
+
+interface TurnEventPayload extends BaseEventPayload {
+  kind: 'turn';
+  threadId: string;
+  turnId: string;
+  status: 'in-progress' | 'completed' | 'failed' | 'interrupted';
+}
+
+interface TextDeltaPayload extends BaseEventPayload {
+  kind: 'text-delta';
+  threadId: string;
+  turnId: string;
+  delta: string;
+}
+
+interface DiffUpdatedPayload extends BaseEventPayload {
+  kind: 'diff-updated';
+  threadId: string;
+  turnId: string;
+  summary: string;
+}
+
+interface ToolPayload extends BaseEventPayload {
+  kind: 'tool';
+  threadId: string;
+  turnId: string;
+  toolName: string;
+}
+
+interface AttentionPayload extends BaseEventPayload {
+  kind: 'attention';
+  threadId: string;
+  turnId: string;
+  reason: 'approval' | 'user-input' | 'stalled';
+  detail: string;
+}
+
+interface QueuePayload extends BaseEventPayload {
+  kind: 'queue';
+  queueSize: number;
+}
+
+type EventPayload =
+  | AttentionPayload
+  | DiffUpdatedPayload
+  | QueuePayload
+  | TextDeltaPayload
+  | ThreadEventPayload
+  | ToolPayload
+  | TurnEventPayload;
+
+export interface NormalizedEventEnvelope {
+  schemaVersion: '1';
+  eventId: string;
+  source: EventSource;
+  type: EventType;
+  ts: string;
+  scope: EventScope;
+  payload: EventPayload;
+}
+
+function nowIsoString(clock?: () => Date): string {
+  const value = clock?.() ?? new Date();
+  return value.toISOString();
+}
+
+export function createNormalizedEvent(
+  source: EventSource,
+  type: EventType,
+  scope: EventScope,
+  payload: EventPayload,
+  clock?: () => Date,
+  idFactory?: () => string,
+): NormalizedEventEnvelope {
+  return {
+    schemaVersion: '1',
+    eventId: idFactory?.() ?? randomUUID(),
+    source,
+    type,
+    ts: nowIsoString(clock),
+    scope,
+    payload,
+  };
+}