@jmoyers/harness 0.1.0

package/src/services/task-pane-selection-actions.ts

@@ -0,0 +1,153 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+
+interface TaskRecordLike {
+  readonly taskId: string;
+  readonly repositoryId: string | null;
+}
+
+interface RepositoryRecordLike {
+  readonly archivedAt: string | null;
+}
+
+interface TaskPaneSelectionActionsOptions<TTaskRecord extends TaskRecordLike> {
+  readonly workspace: WorkspaceModel;
+  readonly taskRecordById: (taskId: string) => TTaskRecord | undefined;
+  readonly hasTask: (taskId: string) => boolean;
+  readonly hasRepository: (repositoryId: string) => boolean;
+  readonly repositoryById: (repositoryId: string) => RepositoryRecordLike | undefined;
+  readonly selectedRepositoryTasks: () => readonly TTaskRecord[];
+  readonly activeRepositoryIds: () => readonly string[];
+  readonly flushTaskComposerPersist: (taskId: string) => void;
+  readonly markDirty: () => void;
+}
+
+export class TaskPaneSelectionActions<TTaskRecord extends TaskRecordLike> {
+  constructor(private readonly options: TaskPaneSelectionActionsOptions<TTaskRecord>) {}
+
+  syncTaskPaneSelectionFocus(): void {
+    const hasTaskSelection =
+      this.options.workspace.taskPaneSelectedTaskId !== null &&
+      this.options.hasTask(this.options.workspace.taskPaneSelectedTaskId);
+    const hasRepositorySelection =
+      this.options.workspace.taskPaneSelectedRepositoryId !== null &&
+      this.options.hasRepository(this.options.workspace.taskPaneSelectedRepositoryId);
+    if (this.options.workspace.taskPaneSelectionFocus === 'task' && hasTaskSelection) {
+      return;
+    }
+    if (this.options.workspace.taskPaneSelectionFocus === 'repository' && hasRepositorySelection) {
+      return;
+    }
+    if (hasTaskSelection) {
+      this.options.workspace.taskPaneSelectionFocus = 'task';
+      return;
+    }
+    if (hasRepositorySelection) {
+      this.options.workspace.taskPaneSelectionFocus = 'repository';
+      return;
+    }
+    this.options.workspace.taskPaneSelectionFocus = 'task';
+  }
+
+  syncTaskPaneSelection(): void {
+    const scopedTaskIds = new Set(
+      this.options.selectedRepositoryTasks().map((task) => task.taskId),
+    );
+    if (
+      this.options.workspace.taskPaneSelectedTaskId !== null &&
+      !scopedTaskIds.has(this.options.workspace.taskPaneSelectedTaskId)
+    ) {
+      this.options.workspace.taskPaneSelectedTaskId = null;
+    }
+    if (this.options.workspace.taskPaneSelectedTaskId === null) {
+      const scopedTasks = this.options.selectedRepositoryTasks();
+      this.options.workspace.taskPaneSelectedTaskId = scopedTasks[0]?.taskId ?? null;
+    }
+    this.syncTaskPaneSelectionFocus();
+    if (
+      this.options.workspace.taskEditorTarget.kind === 'task' &&
+      !scopedTaskIds.has(this.options.workspace.taskEditorTarget.taskId)
+    ) {
+      this.focusDraftComposer();
+    }
+  }
+
+  syncTaskPaneRepositorySelection(): void {
+    if (this.options.workspace.taskPaneSelectedRepositoryId !== null) {
+      const selectedRepository = this.options.repositoryById(
+        this.options.workspace.taskPaneSelectedRepositoryId,
+      );
+      if (selectedRepository === undefined || selectedRepository.archivedAt !== null) {
+        this.options.workspace.taskPaneSelectedRepositoryId = null;
+      }
+    }
+    if (this.options.workspace.taskPaneSelectedRepositoryId === null) {
+      this.options.workspace.taskPaneSelectedRepositoryId =
+        this.options.activeRepositoryIds()[0] ?? null;
+    }
+    this.options.workspace.taskRepositoryDropdownOpen = false;
+    this.syncTaskPaneSelectionFocus();
+    this.syncTaskPaneSelection();
+  }
+
+  focusDraftComposer(): void {
+    if (this.options.workspace.taskEditorTarget.kind === 'task') {
+      this.options.flushTaskComposerPersist(this.options.workspace.taskEditorTarget.taskId);
+    }
+    this.options.workspace.taskEditorTarget = {
+      kind: 'draft',
+    };
+    this.options.workspace.taskPaneSelectionFocus = 'task';
+    this.options.markDirty();
+  }
+
+  focusTaskComposer(taskId: string): void {
+    if (!this.options.hasTask(taskId)) {
+      return;
+    }
+    if (
+      this.options.workspace.taskEditorTarget.kind === 'task' &&
+      this.options.workspace.taskEditorTarget.taskId !== taskId
+    ) {
+      this.options.flushTaskComposerPersist(this.options.workspace.taskEditorTarget.taskId);
+    }
+    this.options.workspace.taskEditorTarget = {
+      kind: 'task',
+      taskId,
+    };
+    this.options.workspace.taskPaneSelectedTaskId = taskId;
+    this.options.workspace.taskPaneSelectionFocus = 'task';
+    this.options.workspace.taskPaneNotice = null;
+    this.options.markDirty();
+  }
+
+  selectTaskById(taskId: string): void {
+    const taskRecord = this.options.taskRecordById(taskId);
+    if (taskRecord === undefined) {
+      return;
+    }
+    this.options.workspace.taskPaneSelectedTaskId = taskId;
+    this.options.workspace.taskPaneSelectionFocus = 'task';
+    if (taskRecord.repositoryId !== null && this.options.hasRepository(taskRecord.repositoryId)) {
+      this.options.workspace.taskPaneSelectedRepositoryId = taskRecord.repositoryId;
+    }
+    this.focusTaskComposer(taskId);
+  }
+
+  selectRepositoryById(repositoryId: string): void {
+    if (!this.options.hasRepository(repositoryId)) {
+      return;
+    }
+    if (this.options.workspace.taskEditorTarget.kind === 'task') {
+      this.options.flushTaskComposerPersist(this.options.workspace.taskEditorTarget.taskId);
+    }
+    this.options.workspace.taskPaneSelectedRepositoryId = repositoryId;
+    this.options.workspace.taskRepositoryDropdownOpen = false;
+    this.options.workspace.taskPaneSelectionFocus = 'repository';
+    this.options.workspace.taskEditorTarget = {
+      kind: 'draft',
+    };
+    this.syncTaskPaneSelection();
+    this.options.workspace.taskPaneNotice = null;
+    this.options.markDirty();
+  }
+}

package/src/services/task-planning-hydration.ts

@@ -0,0 +1,58 @@
+interface RepositoryRecordLike {
+  readonly repositoryId: string;
+}
+
+interface TaskRecordLike {
+  readonly taskId: string;
+}
+
+interface TaskPlanningHydrationServiceControlPlane<
+  TRepositoryRecord extends RepositoryRecordLike,
+  TTaskRecord extends TaskRecordLike,
+> {
+  listRepositories(): Promise<readonly TRepositoryRecord[]>;
+  listTasks(limit: number): Promise<readonly TTaskRecord[]>;
+}
+
+interface TaskPlanningHydrationServiceOptions<
+  TRepositoryRecord extends RepositoryRecordLike,
+  TTaskRecord extends TaskRecordLike,
+> {
+  readonly controlPlaneService: TaskPlanningHydrationServiceControlPlane<
+    TRepositoryRecord,
+    TTaskRecord
+  >;
+  readonly clearRepositories: () => void;
+  readonly setRepository: (repository: TRepositoryRecord) => void;
+  readonly syncTaskPaneRepositorySelection: () => void;
+  readonly clearTasks: () => void;
+  readonly setTask: (task: TTaskRecord) => void;
+  readonly syncTaskPaneSelection: () => void;
+  readonly markDirty: () => void;
+  readonly taskLimit: number;
+}
+
+export class TaskPlanningHydrationService<
+  TRepositoryRecord extends RepositoryRecordLike,
+  TTaskRecord extends TaskRecordLike,
+> {
+  constructor(
+    private readonly options: TaskPlanningHydrationServiceOptions<TRepositoryRecord, TTaskRecord>,
+  ) {}
+
+  async hydrate(): Promise<void> {
+    this.options.clearRepositories();
+    for (const repository of await this.options.controlPlaneService.listRepositories()) {
+      this.options.setRepository(repository);
+    }
+    this.options.syncTaskPaneRepositorySelection();
+
+    this.options.clearTasks();
+    for (const task of await this.options.controlPlaneService.listTasks(this.options.taskLimit)) {
+      this.options.setTask(task);
+    }
+    this.options.syncTaskPaneSelection();
+    this.options.syncTaskPaneRepositorySelection();
+    this.options.markDirty();
+  }
+}

package/src/services/task-planning-observed-events.ts

@@ -0,0 +1,89 @@
+import type { StreamObservedEvent } from '../control-plane/stream-protocol.ts';
+
+interface RepositoryRecordLike {
+  readonly repositoryId: string;
+  readonly archivedAt: string | null;
+}
+
+interface TaskRecordLike {
+  readonly taskId: string;
+}
+
+interface TaskPlanningObservedEventsOptions<
+  TRepositoryRecord extends RepositoryRecordLike,
+  TTaskRecord extends TaskRecordLike,
+> {
+  readonly parseRepositoryRecord: (value: unknown) => TRepositoryRecord | null;
+  readonly parseTaskRecord: (value: unknown) => TTaskRecord | null;
+  readonly getRepository: (repositoryId: string) => TRepositoryRecord | undefined;
+  readonly setRepository: (repositoryId: string, repository: TRepositoryRecord) => void;
+  readonly setTask: (task: TTaskRecord) => void;
+  readonly deleteTask: (taskId: string) => boolean;
+  readonly syncTaskPaneRepositorySelection: () => void;
+  readonly syncTaskPaneSelection: () => void;
+  readonly markDirty: () => void;
+}
+
+export class TaskPlanningObservedEvents<
+  TRepositoryRecord extends RepositoryRecordLike,
+  TTaskRecord extends TaskRecordLike,
+> {
+  constructor(
+    private readonly options: TaskPlanningObservedEventsOptions<TRepositoryRecord, TTaskRecord>,
+  ) {}
+
+  apply(observed: StreamObservedEvent): void {
+    if (observed.type === 'repository-upserted' || observed.type === 'repository-updated') {
+      const repository = this.options.parseRepositoryRecord(observed.repository);
+      if (repository !== null) {
+        this.options.setRepository(repository.repositoryId, repository);
+        this.options.syncTaskPaneRepositorySelection();
+        this.options.markDirty();
+      }
+      return;
+    }
+    if (observed.type === 'repository-archived') {
+      const repository = this.options.getRepository(observed.repositoryId);
+      if (repository !== undefined) {
+        this.options.setRepository(observed.repositoryId, {
+          ...repository,
+          archivedAt: observed.ts,
+        });
+        this.options.syncTaskPaneRepositorySelection();
+        this.options.markDirty();
+      }
+      return;
+    }
+    if (observed.type === 'task-created' || observed.type === 'task-updated') {
+      const task = this.options.parseTaskRecord(observed.task);
+      if (task !== null) {
+        this.options.setTask(task);
+        this.options.syncTaskPaneSelection();
+        this.options.markDirty();
+      }
+      return;
+    }
+    if (observed.type === 'task-deleted') {
+      if (this.options.deleteTask(observed.taskId)) {
+        this.options.syncTaskPaneSelection();
+        this.options.markDirty();
+      }
+      return;
+    }
+    if (observed.type === 'task-reordered') {
+      let changed = false;
+      for (const value of observed.tasks) {
+        const task = this.options.parseTaskRecord(value);
+        if (task === null) {
+          continue;
+        }
+        this.options.setTask(task);
+        changed = true;
+      }
+      if (changed) {
+        this.options.syncTaskPaneSelection();
+        this.options.markDirty();
+      }
+    }
+  }
+}

package/src/services/workspace-observed-events.ts

@@ -0,0 +1,113 @@
+import type { StreamObservedEvent } from '../control-plane/stream-protocol.ts';
+
+interface DirectoryRecordLike {
+  readonly directoryId: string;
+}
+
+interface ConversationRecordLike {
+  readonly conversationId: string;
+  readonly directoryId: string;
+}
+
+interface WorkspaceObservedApplyResult {
+  readonly changed: boolean;
+  readonly removedConversationIds: readonly string[];
+  readonly removedDirectoryIds: readonly string[];
+}
+
+interface WorkspaceObservedEventsOptions<
+  TDirectoryRecord extends DirectoryRecordLike,
+  TConversationRecord extends ConversationRecordLike,
+> {
+  readonly parseDirectoryRecord: (value: unknown) => TDirectoryRecord | null;
+  readonly parseConversationRecord: (value: unknown) => TConversationRecord | null;
+  readonly setDirectory: (directoryId: string, directory: TDirectoryRecord) => void;
+  readonly deleteDirectory: (directoryId: string) => boolean;
+  readonly deleteDirectoryGitState: (directoryId: string) => void;
+  readonly syncGitStateWithDirectories: () => void;
+  readonly upsertConversationFromPersistedRecord: (record: TConversationRecord) => void;
+  readonly removeConversation: (sessionId: string) => boolean;
+  readonly orderedConversationIds: () => readonly string[];
+  readonly conversationDirectoryId: (sessionId: string) => string | null;
+}
+
+export class WorkspaceObservedEvents<
+  TDirectoryRecord extends DirectoryRecordLike,
+  TConversationRecord extends ConversationRecordLike,
+> {
+  constructor(
+    private readonly options: WorkspaceObservedEventsOptions<TDirectoryRecord, TConversationRecord>,
+  ) {}
+
+  apply(observed: StreamObservedEvent): WorkspaceObservedApplyResult {
+    if (observed.type === 'directory-upserted') {
+      const directory = this.options.parseDirectoryRecord(observed.directory);
+      if (directory === null) {
+        return {
+          changed: false,
+          removedConversationIds: [],
+          removedDirectoryIds: [],
+        };
+      }
+      this.options.setDirectory(directory.directoryId, directory);
+      this.options.syncGitStateWithDirectories();
+      return {
+        changed: true,
+        removedConversationIds: [],
+        removedDirectoryIds: [],
+      };
+    }
+
+    if (observed.type === 'directory-archived') {
+      const removedConversationIds: string[] = [];
+      for (const sessionId of this.options.orderedConversationIds()) {
+        if (this.options.conversationDirectoryId(sessionId) !== observed.directoryId) {
+          continue;
+        }
+        if (this.options.removeConversation(sessionId)) {
+          removedConversationIds.push(sessionId);
+        }
+      }
+      const removedDirectory = this.options.deleteDirectory(observed.directoryId);
+      this.options.deleteDirectoryGitState(observed.directoryId);
+      this.options.syncGitStateWithDirectories();
+      return {
+        changed: removedDirectory || removedConversationIds.length > 0,
+        removedConversationIds,
+        removedDirectoryIds: removedDirectory ? [observed.directoryId] : [],
+      };
+    }
+
+    if (observed.type === 'conversation-created' || observed.type === 'conversation-updated') {
+      const conversation = this.options.parseConversationRecord(observed.conversation);
+      if (conversation === null) {
+        return {
+          changed: false,
+          removedConversationIds: [],
+          removedDirectoryIds: [],
+        };
+      }
+      this.options.upsertConversationFromPersistedRecord(conversation);
+      return {
+        changed: true,
+        removedConversationIds: [],
+        removedDirectoryIds: [],
+      };
+    }
+
+    if (observed.type === 'conversation-archived' || observed.type === 'conversation-deleted') {
+      const removed = this.options.removeConversation(observed.conversationId);
+      return {
+        changed: removed,
+        removedConversationIds: removed ? [observed.conversationId] : [],
+        removedDirectoryIds: [],
+      };
+    }
+
+    return {
+      changed: false,
+      removedConversationIds: [],
+      removedDirectoryIds: [],
+    };
+  }
+}