@jmoyers/harness 0.1.11 → 0.1.20

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

@@ -1,6 +1,5 @@
 import type { WorkspaceModel } from '../domain/workspace.ts';
 import type { TaskPaneAction } from '../mux/harness-core-ui.ts';
-import { runTaskPaneAction as runTaskPaneActionFrame } from '../mux/live-mux/actions-task.ts';
 
 interface TaskRecordShape {
   readonly taskId: string;
@@ -16,7 +15,7 @@ interface RuntimeTaskPaneActionService<TTaskRecord extends TaskRecordShape> {
   taskComplete(taskId: string): Promise<TTaskRecord>;
 }
 
-interface RuntimeTaskPaneActionsOptions<TTaskRecord extends TaskRecordShape> {
+export interface RuntimeTaskPaneActionsOptions<TTaskRecord extends TaskRecordShape> {
   readonly workspace: WorkspaceModel;
   readonly controlPlaneService: RuntimeTaskPaneActionService<TTaskRecord>;
   readonly repositoriesHas: (repositoryId: string) => boolean;
@@ -41,158 +40,245 @@ interface RuntimeTaskPaneActionsOptions<TTaskRecord extends TaskRecordShape> {
   readonly openRepositoryPromptForEdit: (repositoryId: string) => void;
   readonly archiveRepositoryById: (repositoryId: string) => Promise<void>;
   readonly markDirty: () => void;
-  readonly runTaskPaneAction?: typeof runTaskPaneActionFrame;
 }
 
-export class RuntimeTaskPaneActions<TTaskRecord extends TaskRecordShape> {
-  private readonly runTaskPaneActionFn: typeof runTaskPaneActionFrame;
+export interface RuntimeTaskPaneActions<TTaskRecord extends TaskRecordShape> {
+  openTaskCreatePrompt(): void;
+  openTaskEditPrompt(taskId: string): void;
+  applyTaskRecord(task: TTaskRecord): TTaskRecord;
+  applyTaskList(tasks: readonly TTaskRecord[]): boolean;
+  queueTaskReorderByIds(orderedActiveTaskIds: readonly string[], label: string): void;
+  reorderTaskByDrop(draggedTaskId: string, targetTaskId: string): void;
+  runTaskPaneAction(action: TaskPaneAction): void;
+}
+
+export function createRuntimeTaskPaneActions<TTaskRecord extends TaskRecordShape>(
+  options: RuntimeTaskPaneActionsOptions<TTaskRecord>,
+): RuntimeTaskPaneActions<TTaskRecord> {
+  const applyTaskList = (tasks: readonly TTaskRecord[]): boolean => {
+    let changed = false;
+    for (const task of tasks) {
+      options.setTask(task);
+      changed = true;
+    }
+    if (changed) {
+      options.syncTaskPaneSelection();
+      options.markDirty();
+    }
+    return changed;
+  };
 
-  constructor(private readonly options: RuntimeTaskPaneActionsOptions<TTaskRecord>) {
-    this.runTaskPaneActionFn = options.runTaskPaneAction ?? runTaskPaneActionFrame;
-  }
+  const applyTaskRecord = (task: TTaskRecord): TTaskRecord => {
+    options.setTask(task);
+    options.workspace.taskPaneSelectedTaskId = task.taskId;
+    if (task.repositoryId !== null && options.repositoriesHas(task.repositoryId)) {
+      options.workspace.taskPaneSelectedRepositoryId = task.repositoryId;
+    }
+    options.workspace.taskPaneSelectionFocus = 'task';
+    options.syncTaskPaneSelection();
+    options.markDirty();
+    return task;
+  };
+
+  const queueTaskReorderByIds = (orderedActiveTaskIds: readonly string[], label: string): void => {
+    options.queueControlPlaneOp(async () => {
+      const tasks = await options.controlPlaneService.reorderTasks(
+        options.taskReorderPayloadIds(orderedActiveTaskIds),
+      );
+      applyTaskList(tasks);
+    }, label);
+  };
 
-  openTaskCreatePrompt(): void {
-    const repositoryId = this.options.workspace.taskPaneSelectedRepositoryId;
-    if (repositoryId === null || !this.options.repositoriesHas(repositoryId)) {
-      this.options.workspace.taskPaneNotice = 'select a repository first';
-      this.options.markDirty();
+  const openTaskCreatePrompt = (): void => {
+    const repositoryId = options.workspace.taskPaneSelectedRepositoryId;
+    if (repositoryId === null || !options.repositoriesHas(repositoryId)) {
+      options.workspace.taskPaneNotice = 'select a repository first';
+      options.markDirty();
       return;
     }
-    this.options.focusDraftComposer();
-    this.options.workspace.taskPaneNotice = null;
-    this.options.markDirty();
-  }
+    options.focusDraftComposer();
+    options.workspace.taskPaneNotice = null;
+    options.markDirty();
+  };
 
-  openTaskEditPrompt(taskId: string): void {
-    const task = this.options.getTask(taskId);
+  const openTaskEditPrompt = (taskId: string): void => {
+    const task = options.getTask(taskId);
     if (task === undefined) {
       return;
     }
     if (task.repositoryId !== null) {
-      this.options.workspace.taskPaneSelectedRepositoryId = task.repositoryId;
-    }
-    this.options.focusTaskComposer(task.taskId);
-    this.options.workspace.taskPaneNotice = null;
-    this.options.markDirty();
-  }
-
-  applyTaskRecord(task: TTaskRecord): TTaskRecord {
-    this.options.setTask(task);
-    this.options.workspace.taskPaneSelectedTaskId = task.taskId;
-    if (task.repositoryId !== null && this.options.repositoriesHas(task.repositoryId)) {
-      this.options.workspace.taskPaneSelectedRepositoryId = task.repositoryId;
-    }
-    this.options.workspace.taskPaneSelectionFocus = 'task';
-    this.options.syncTaskPaneSelection();
-    this.options.markDirty();
-    return task;
-  }
+      options.workspace.taskPaneSelectedRepositoryId = task.repositoryId;
+    }
+    options.focusTaskComposer(task.taskId);
+    options.workspace.taskPaneNotice = null;
+    options.markDirty();
+  };
 
-  applyTaskList(tasks: readonly TTaskRecord[]): boolean {
-    let changed = false;
-    for (const task of tasks) {
-      this.options.setTask(task);
-      changed = true;
+  const openRepositoryPromptForEditFromSelection = (): void => {
+    const selectedRepositoryId = options.workspace.taskPaneSelectedRepositoryId;
+    if (selectedRepositoryId === null || !options.repositoriesHas(selectedRepositoryId)) {
+      options.workspace.taskPaneNotice = 'select a repository first';
+      options.markDirty();
+      return;
     }
-    if (changed) {
-      this.options.syncTaskPaneSelection();
-      this.options.markDirty();
+    options.workspace.taskPaneSelectionFocus = 'repository';
+    options.workspace.taskPaneNotice = null;
+    options.openRepositoryPromptForEdit(selectedRepositoryId);
+  };
+
+  const queueArchiveRepositoryFromSelection = (): void => {
+    const selectedRepositoryId = options.workspace.taskPaneSelectedRepositoryId;
+    if (selectedRepositoryId === null || !options.repositoriesHas(selectedRepositoryId)) {
+      options.workspace.taskPaneNotice = 'select a repository first';
+      options.markDirty();
+      return;
     }
-    return changed;
-  }
+    options.workspace.taskPaneSelectionFocus = 'repository';
+    options.queueControlPlaneOp(async () => {
+      await options.archiveRepositoryById(selectedRepositoryId);
+      options.syncTaskPaneRepositorySelection();
+    }, 'tasks-archive-repository');
+  };
 
-  queueTaskReorderByIds(orderedActiveTaskIds: readonly string[], label: string): void {
-    this.options.queueControlPlaneOp(async () => {
-      const tasks = await this.options.controlPlaneService.reorderTasks(
-        this.options.taskReorderPayloadIds(orderedActiveTaskIds),
-      );
-      this.applyTaskList(tasks);
-    }, label);
-  }
+  const requireSelectedTaskOrNotice = (): TTaskRecord | null => {
+    const selectedTask = options.selectedTask();
+    if (selectedTask !== null) {
+      return selectedTask;
+    }
+    options.workspace.taskPaneNotice = 'select a task first';
+    options.markDirty();
+    return null;
+  };
+
+  const queueDeleteTask = (taskId: string): void => {
+    options.queueControlPlaneOp(async () => {
+      options.clearTaskAutosaveTimer(taskId);
+      await options.controlPlaneService.deleteTask(taskId);
+      options.deleteTask(taskId);
+      options.deleteTaskComposer(taskId);
+      if (
+        options.workspace.taskEditorTarget.kind === 'task' &&
+        options.workspace.taskEditorTarget.taskId === taskId
+      ) {
+        options.workspace.taskEditorTarget = {
+          kind: 'draft',
+        };
+      }
+      options.syncTaskPaneSelection();
+      options.markDirty();
+    }, 'tasks-delete');
+  };
 
-  reorderTaskByDrop(draggedTaskId: string, targetTaskId: string): void {
-    const reordered = this.options.reorderedActiveTaskIdsForDrop(draggedTaskId, targetTaskId);
+  const queueTaskStatusUpdate = (taskId: string, status: 'ready' | 'draft' | 'complete'): void => {
+    const labelByStatus: Readonly<Record<typeof status, string>> = {
+      ready: 'tasks-ready',
+      draft: 'tasks-draft',
+      complete: 'tasks-complete',
+    };
+    options.queueControlPlaneOp(async () => {
+      const task =
+        status === 'ready'
+          ? await options.controlPlaneService.taskReady(taskId)
+          : status === 'draft'
+            ? await options.controlPlaneService.taskDraft(taskId)
+            : await options.controlPlaneService.taskComplete(taskId);
+      applyTaskRecord(task);
+    }, labelByStatus[status]);
+  };
+
+  const reorderSelectedTask = (selectedTaskId: string, direction: 'up' | 'down'): void => {
+    const activeTasks = options.orderedTaskRecords().filter((task) => task.status !== 'completed');
+    const selectedIndex = activeTasks.findIndex((task) => task.taskId === selectedTaskId);
+    if (selectedIndex < 0) {
+      options.workspace.taskPaneNotice = 'cannot reorder completed tasks';
+      options.markDirty();
+      return;
+    }
+    const swapIndex = direction === 'up' ? selectedIndex - 1 : selectedIndex + 1;
+    if (swapIndex < 0 || swapIndex >= activeTasks.length) {
+      return;
+    }
+    const reordered = [...activeTasks];
+    const currentTask = reordered[selectedIndex]!;
+    reordered[selectedIndex] = reordered[swapIndex]!;
+    reordered[swapIndex] = currentTask;
+    options.workspace.taskPaneSelectionFocus = 'task';
+    queueTaskReorderByIds(
+      reordered.map((task) => task.taskId),
+      direction === 'up' ? 'tasks-reorder-up' : 'tasks-reorder-down',
+    );
+  };
+
+  const reorderTaskByDrop = (draggedTaskId: string, targetTaskId: string): void => {
+    const reordered = options.reorderedActiveTaskIdsForDrop(draggedTaskId, targetTaskId);
     if (reordered === 'cannot-reorder-completed') {
-      this.options.workspace.taskPaneNotice = 'cannot reorder completed tasks';
-      this.options.markDirty();
+      options.workspace.taskPaneNotice = 'cannot reorder completed tasks';
+      options.markDirty();
       return;
     }
     if (reordered === null) {
       return;
     }
-    this.queueTaskReorderByIds(reordered, 'tasks-reorder-drag');
-  }
-
-  runTaskPaneAction(action: TaskPaneAction): void {
-    this.runTaskPaneActionFn({
-      action,
-      openTaskCreatePrompt: () => {
-        this.openTaskCreatePrompt();
-      },
-      openRepositoryPromptForCreate: () => {
-        this.options.openRepositoryPromptForCreate();
-      },
-      selectedRepositoryId: this.options.workspace.taskPaneSelectedRepositoryId,
-      repositoryExists: (repositoryId) => this.options.repositoriesHas(repositoryId),
-      setTaskPaneNotice: (notice) => {
-        this.options.workspace.taskPaneNotice = notice;
-      },
-      markDirty: () => {
-        this.options.markDirty();
-      },
-      setTaskPaneSelectionFocus: (focus) => {
-        this.options.workspace.taskPaneSelectionFocus = focus;
-      },
-      openRepositoryPromptForEdit: (repositoryId) => {
-        this.options.openRepositoryPromptForEdit(repositoryId);
-      },
-      queueArchiveRepository: (repositoryId) => {
-        this.options.queueControlPlaneOp(async () => {
-          await this.options.archiveRepositoryById(repositoryId);
-          this.options.syncTaskPaneRepositorySelection();
-        }, 'tasks-archive-repository');
-      },
-      selectedTask: this.options.selectedTask(),
-      openTaskEditPrompt: (taskId) => {
-        this.openTaskEditPrompt(taskId);
-      },
-      queueDeleteTask: (taskId) => {
-        this.options.queueControlPlaneOp(async () => {
-          this.options.clearTaskAutosaveTimer(taskId);
-          await this.options.controlPlaneService.deleteTask(taskId);
-          this.options.deleteTask(taskId);
-          this.options.deleteTaskComposer(taskId);
-          if (
-            this.options.workspace.taskEditorTarget.kind === 'task' &&
-            this.options.workspace.taskEditorTarget.taskId === taskId
-          ) {
-            this.options.workspace.taskEditorTarget = {
-              kind: 'draft',
-            };
-          }
-          this.options.syncTaskPaneSelection();
-          this.options.markDirty();
-        }, 'tasks-delete');
-      },
-      queueTaskReady: (taskId) => {
-        this.options.queueControlPlaneOp(async () => {
-          this.applyTaskRecord(await this.options.controlPlaneService.taskReady(taskId));
-        }, 'tasks-ready');
-      },
-      queueTaskDraft: (taskId) => {
-        this.options.queueControlPlaneOp(async () => {
-          this.applyTaskRecord(await this.options.controlPlaneService.taskDraft(taskId));
-        }, 'tasks-draft');
-      },
-      queueTaskComplete: (taskId) => {
-        this.options.queueControlPlaneOp(async () => {
-          this.applyTaskRecord(await this.options.controlPlaneService.taskComplete(taskId));
-        }, 'tasks-complete');
-      },
-      orderedTaskRecords: () => this.options.orderedTaskRecords(),
-      queueTaskReorderByIds: (orderedTaskIds, label) => {
-        this.queueTaskReorderByIds(orderedTaskIds, label);
-      },
-    });
-  }
+    queueTaskReorderByIds(reordered, 'tasks-reorder-drag');
+  };
+
+  const runTaskPaneAction = (action: TaskPaneAction): void => {
+    if (action === 'task.create') {
+      openTaskCreatePrompt();
+      return;
+    }
+    if (action === 'repository.create') {
+      options.workspace.taskPaneNotice = null;
+      options.openRepositoryPromptForCreate();
+      return;
+    }
+    if (action === 'repository.edit') {
+      openRepositoryPromptForEditFromSelection();
+      return;
+    }
+    if (action === 'repository.archive') {
+      queueArchiveRepositoryFromSelection();
+      return;
+    }
+    const selectedTask = requireSelectedTaskOrNotice();
+    if (selectedTask === null) {
+      return;
+    }
+    if (action === 'task.edit') {
+      options.workspace.taskPaneSelectionFocus = 'task';
+      openTaskEditPrompt(selectedTask.taskId);
+      return;
+    }
+    if (action === 'task.delete') {
+      options.workspace.taskPaneSelectionFocus = 'task';
+      queueDeleteTask(selectedTask.taskId);
+      return;
+    }
+    if (action === 'task.ready') {
+      options.workspace.taskPaneSelectionFocus = 'task';
+      queueTaskStatusUpdate(selectedTask.taskId, 'ready');
+      return;
+    }
+    if (action === 'task.draft') {
+      options.workspace.taskPaneSelectionFocus = 'task';
+      queueTaskStatusUpdate(selectedTask.taskId, 'draft');
+      return;
+    }
+    if (action === 'task.complete') {
+      options.workspace.taskPaneSelectionFocus = 'task';
+      queueTaskStatusUpdate(selectedTask.taskId, 'complete');
+      return;
+    }
+    reorderSelectedTask(selectedTask.taskId, action === 'task.reorder-up' ? 'up' : 'down');
+  };
+
+  return {
+    openTaskCreatePrompt,
+    openTaskEditPrompt,
+    applyTaskRecord,
+    applyTaskList,
+    queueTaskReorderByIds,
+    reorderTaskByDrop,
+    runTaskPaneAction,
+  };
 }