@jmoyers/harness 0.1.10 → 0.1.20

package/src/services/runtime-stream-subscriptions.ts

@@ -7,50 +7,58 @@ export interface RuntimeStreamSubscriptionsOptions {
   readonly unsubscribeObservedStream: (subscriptionId: string) => Promise<void>;
 }
 
-export class RuntimeStreamSubscriptions {
-  private observedStreamSubscriptionId: string | null = null;
+export interface RuntimeStreamSubscriptions {
+  subscribeConversationEvents(sessionId: string): Promise<void>;
+  unsubscribeConversationEvents(sessionId: string): Promise<void>;
+  subscribeTaskPlanningEvents(afterCursor: number | null): Promise<void>;
+  unsubscribeTaskPlanningEvents(): Promise<void>;
+}
 
-  constructor(private readonly options: RuntimeStreamSubscriptionsOptions) {}
+export function createRuntimeStreamSubscriptions(
+  options: RuntimeStreamSubscriptionsOptions,
+): RuntimeStreamSubscriptions {
+  let observedStreamSubscriptionId: string | null = null;
 
-  async subscribeConversationEvents(sessionId: string): Promise<void> {
+  const subscribeConversationEvents = async (sessionId: string): Promise<void> => {
     try {
-      await this.options.subscribePtyEvents(sessionId);
+      await options.subscribePtyEvents(sessionId);
     } catch (error: unknown) {
-      if (
-        !this.options.isSessionNotFoundError(error) &&
-        !this.options.isSessionNotLiveError(error)
-      ) {
+      if (!options.isSessionNotFoundError(error) && !options.isSessionNotLiveError(error)) {
         throw error;
       }
     }
-  }
+  };
 
-  async unsubscribeConversationEvents(sessionId: string): Promise<void> {
+  const unsubscribeConversationEvents = async (sessionId: string): Promise<void> => {
     try {
-      await this.options.unsubscribePtyEvents(sessionId);
+      await options.unsubscribePtyEvents(sessionId);
     } catch (error: unknown) {
-      if (
-        !this.options.isSessionNotFoundError(error) &&
-        !this.options.isSessionNotLiveError(error)
-      ) {
+      if (!options.isSessionNotFoundError(error) && !options.isSessionNotLiveError(error)) {
         throw error;
       }
     }
-  }
+  };
 
-  async subscribeTaskPlanningEvents(afterCursor: number | null): Promise<void> {
-    if (this.observedStreamSubscriptionId !== null) {
+  const subscribeTaskPlanningEvents = async (afterCursor: number | null): Promise<void> => {
+    if (observedStreamSubscriptionId !== null) {
       return;
     }
-    this.observedStreamSubscriptionId = await this.options.subscribeObservedStream(afterCursor);
-  }
+    observedStreamSubscriptionId = await options.subscribeObservedStream(afterCursor);
+  };
 
-  async unsubscribeTaskPlanningEvents(): Promise<void> {
-    if (this.observedStreamSubscriptionId === null) {
+  const unsubscribeTaskPlanningEvents = async (): Promise<void> => {
+    if (observedStreamSubscriptionId === null) {
       return;
     }
-    const subscriptionId = this.observedStreamSubscriptionId;
-    this.observedStreamSubscriptionId = null;
-    await this.options.unsubscribeObservedStream(subscriptionId);
-  }
+    const subscriptionId = observedStreamSubscriptionId;
+    observedStreamSubscriptionId = null;
+    await options.unsubscribeObservedStream(subscriptionId);
+  };
+
+  return {
+    subscribeConversationEvents,
+    unsubscribeConversationEvents,
+    subscribeTaskPlanningEvents,
+    unsubscribeTaskPlanningEvents,
+  };
 }

package/src/services/runtime-task-composer-persistence.ts

@@ -1,13 +1,13 @@
 interface TaskComposerFields {
-  readonly title: string;
-  readonly description: string;
+  readonly title: string | null;
+  readonly body: string;
 }
 
 interface TaskRecordShape {
   readonly taskId: string;
   readonly repositoryId: string | null;
   readonly title: string;
-  readonly description: string;
+  readonly body: string;
 }
 
 interface TaskComposerBufferShape {
@@ -33,7 +33,7 @@ interface RuntimeTaskComposerPersistenceOptions<
     taskId: string;
     repositoryId: string | null;
     title: string;
-    description: string;
+    body: string;
   }) => Promise<TTaskRecord>;
   readonly applyTaskRecord: (task: TTaskRecord) => void;
   readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
@@ -44,96 +44,108 @@ interface RuntimeTaskComposerPersistenceOptions<
   readonly clearTimeoutFn?: (timer: TTaskAutosaveTimer) => void;
 }
 
-export class RuntimeTaskComposerPersistenceService<
-  TTaskRecord extends TaskRecordShape,
+export interface RuntimeTaskComposerPersistenceService<
   TTaskComposerBuffer extends TaskComposerBufferShape,
-  TTaskAutosaveTimer extends { unref?: () => void } = NodeJS.Timeout,
 > {
-  private readonly setTimeoutFn: (callback: () => void, ms: number) => TTaskAutosaveTimer;
-  private readonly clearTimeoutFn: (timer: TTaskAutosaveTimer) => void;
+  taskComposerForTask(taskId: string): TTaskComposerBuffer | null;
+  setTaskComposerForTask(taskId: string, buffer: TTaskComposerBuffer): void;
+  clearTaskAutosaveTimer(taskId: string): void;
+  scheduleTaskComposerPersist(taskId: string): void;
+  flushTaskComposerPersist(taskId: string): void;
+}
 
-  constructor(
-    private readonly options: RuntimeTaskComposerPersistenceOptions<
-      TTaskRecord,
-      TTaskComposerBuffer,
-      TTaskAutosaveTimer
-    >,
-  ) {
-    this.setTimeoutFn =
-      options.setTimeoutFn ??
-      ((callback, ms) => setTimeout(callback, ms) as unknown as TTaskAutosaveTimer);
-    this.clearTimeoutFn =
-      options.clearTimeoutFn ?? ((timer) => clearTimeout(timer as unknown as NodeJS.Timeout));
-  }
+export function createRuntimeTaskComposerPersistenceService<
+  TTaskRecord extends TaskRecordShape,
+  TTaskComposerBuffer extends TaskComposerBufferShape,
+  TTaskAutosaveTimer extends { unref?: () => void } = NodeJS.Timeout,
+>(
+  options: RuntimeTaskComposerPersistenceOptions<
+    TTaskRecord,
+    TTaskComposerBuffer,
+    TTaskAutosaveTimer
+  >,
+): RuntimeTaskComposerPersistenceService<TTaskComposerBuffer> {
+  const setTimeoutFn =
+    options.setTimeoutFn ??
+    ((callback, ms) => setTimeout(callback, ms) as unknown as TTaskAutosaveTimer);
+  const clearTimeoutFn =
+    options.clearTimeoutFn ?? ((timer) => clearTimeout(timer as unknown as NodeJS.Timeout));
 
-  taskComposerForTask(taskId: string): TTaskComposerBuffer | null {
-    const existing = this.options.getTaskComposer(taskId);
+  function taskComposerForTask(taskId: string): TTaskComposerBuffer | null {
+    const existing = options.getTaskComposer(taskId);
     if (existing !== undefined) {
       return existing;
     }
-    const task = this.options.getTask(taskId);
+    const task = options.getTask(taskId);
     if (task === undefined) {
       return null;
     }
-    return this.options.buildComposerFromTask(task);
+    return options.buildComposerFromTask(task);
   }
 
-  setTaskComposerForTask(taskId: string, buffer: TTaskComposerBuffer): void {
-    this.options.setTaskComposer(taskId, this.options.normalizeTaskComposerBuffer(buffer));
+  function setTaskComposerForTask(taskId: string, buffer: TTaskComposerBuffer): void {
+    options.setTaskComposer(taskId, options.normalizeTaskComposerBuffer(buffer));
   }
 
-  clearTaskAutosaveTimer(taskId: string): void {
-    const timer = this.options.getTaskAutosaveTimer(taskId);
+  function clearTaskAutosaveTimer(taskId: string): void {
+    const timer = options.getTaskAutosaveTimer(taskId);
     if (timer !== undefined) {
-      this.clearTimeoutFn(timer);
-      this.options.deleteTaskAutosaveTimer(taskId);
+      clearTimeoutFn(timer);
+      options.deleteTaskAutosaveTimer(taskId);
     }
   }
 
-  scheduleTaskComposerPersist(taskId: string): void {
-    this.clearTaskAutosaveTimer(taskId);
-    const timer = this.setTimeoutFn(() => {
-      this.options.deleteTaskAutosaveTimer(taskId);
-      this.queuePersistTaskComposer(taskId, 'debounced');
-    }, this.options.autosaveDebounceMs);
+  function scheduleTaskComposerPersist(taskId: string): void {
+    clearTaskAutosaveTimer(taskId);
+    const timer = setTimeoutFn(() => {
+      options.deleteTaskAutosaveTimer(taskId);
+      queuePersistTaskComposer(taskId, 'debounced');
+    }, options.autosaveDebounceMs);
     timer.unref?.();
-    this.options.setTaskAutosaveTimer(taskId, timer);
+    options.setTaskAutosaveTimer(taskId, timer);
   }
 
-  flushTaskComposerPersist(taskId: string): void {
-    this.clearTaskAutosaveTimer(taskId);
-    this.queuePersistTaskComposer(taskId, 'flush');
+  function flushTaskComposerPersist(taskId: string): void {
+    clearTaskAutosaveTimer(taskId);
+    queuePersistTaskComposer(taskId, 'flush');
   }
 
-  private queuePersistTaskComposer(taskId: string, reason: 'debounced' | 'flush'): void {
-    const task = this.options.getTask(taskId);
-    const buffer = this.options.getTaskComposer(taskId);
+  function queuePersistTaskComposer(taskId: string, reason: 'debounced' | 'flush'): void {
+    const task = options.getTask(taskId);
+    const buffer = options.getTaskComposer(taskId);
     if (task === undefined || buffer === undefined) {
       return;
     }
-    const fields = this.options.taskFieldsFromComposerText(buffer.text);
-    if (fields.title.length === 0) {
-      this.options.setTaskPaneNotice('first line is required');
-      this.options.markDirty();
+    const fields = options.taskFieldsFromComposerText(buffer.text);
+    if (fields.body.trim().length === 0) {
+      options.setTaskPaneNotice('task body is required');
+      options.markDirty();
       return;
     }
-    if (fields.title === task.title && fields.description === task.description) {
+    if (fields.title === task.title && fields.body === task.body) {
       return;
     }
-    this.options.queueControlPlaneOp(async () => {
-      const parsed = await this.options.updateTask({
+    options.queueControlPlaneOp(async () => {
+      const parsed = await options.updateTask({
         taskId,
         repositoryId: task.repositoryId,
-        title: fields.title,
-        description: fields.description,
+        title: fields.title ?? '',
+        body: fields.body,
       });
-      this.options.applyTaskRecord(parsed);
-      const persistedText =
-        parsed.description.length === 0 ? parsed.title : `${parsed.title}\n${parsed.description}`;
-      const latestBuffer = this.options.getTaskComposer(taskId);
+      options.applyTaskRecord(parsed);
+      const persistedText = parsed.body.length === 0 ? parsed.title : parsed.body;
+      const latestBuffer = options.getTaskComposer(taskId);
       if (latestBuffer !== undefined && latestBuffer.text === persistedText) {
-        this.options.deleteTaskComposer(taskId);
+        options.deleteTaskComposer(taskId);
       }
     }, `task-editor-save:${reason}:${taskId}`);
   }
+
+  return {
+    taskComposerForTask,
+    setTaskComposerForTask,
+    clearTaskAutosaveTimer,
+    scheduleTaskComposerPersist,
+    flushTaskComposerPersist,
+  };
 }

package/src/services/runtime-task-composer-snapshot.ts

@@ -0,0 +1,14 @@
+import type { TaskComposerBuffer } from '../mux/task-composer.ts';
+
+export function snapshotTaskComposerBuffers(
+  buffers: ReadonlyMap<string, TaskComposerBuffer>,
+): ReadonlyMap<string, TaskComposerBuffer> {
+  const snapshot = new Map<string, TaskComposerBuffer>();
+  for (const [taskId, buffer] of buffers) {
+    snapshot.set(taskId, {
+      text: buffer.text,
+      cursor: buffer.cursor,
+    });
+  }
+  return snapshot;
+}

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

@@ -6,28 +6,31 @@ interface TaskRecordShape {
 
 interface RuntimeTaskEditorActionService<TTaskRecord extends TaskRecordShape> {
   createTask(input: {
-    repositoryId: string;
-    title: string;
-    description: string;
+    repositoryId?: string;
+    projectId?: string;
+    title?: string | null;
+    body: string;
   }): Promise<TTaskRecord>;
   updateTask(input: {
     taskId: string;
-    repositoryId: string;
-    title: string;
-    description: string;
+    repositoryId?: string | null;
+    projectId?: string | null;
+    title?: string | null;
+    body?: string;
   }): Promise<TTaskRecord>;
 }
 
 export interface RuntimeTaskEditorSubmitPayload {
   readonly mode: 'create' | 'edit';
   readonly taskId: string | null;
-  readonly repositoryId: string;
-  readonly title: string;
-  readonly description: string;
+  readonly repositoryId: string | null;
+  readonly projectId?: string | null;
+  readonly title: string | null;
+  readonly body: string;
   readonly commandLabel: string;
 }
 
-interface RuntimeTaskEditorActionsOptions<TTaskRecord extends TaskRecordShape> {
+export interface RuntimeTaskEditorActionsOptions<TTaskRecord extends TaskRecordShape> {
   readonly workspace: WorkspaceModel;
   readonly controlPlaneService: RuntimeTaskEditorActionService<TTaskRecord>;
   readonly applyTaskRecord: (task: TTaskRecord) => void;
@@ -39,45 +42,59 @@ function formatErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-export class RuntimeTaskEditorActions<TTaskRecord extends TaskRecordShape> {
-  constructor(private readonly options: RuntimeTaskEditorActionsOptions<TTaskRecord>) {}
+export interface RuntimeTaskEditorActions {
+  submitTaskEditorPayload(payload: RuntimeTaskEditorSubmitPayload): void;
+}
 
-  submitTaskEditorPayload(payload: RuntimeTaskEditorSubmitPayload): void {
-    this.options.queueControlPlaneOp(async () => {
+export function createRuntimeTaskEditorActions<TTaskRecord extends TaskRecordShape>(
+  options: RuntimeTaskEditorActionsOptions<TTaskRecord>,
+): RuntimeTaskEditorActions {
+  const submitTaskEditorPayload = (payload: RuntimeTaskEditorSubmitPayload): void => {
+    options.queueControlPlaneOp(async () => {
       try {
         if (payload.mode === 'create') {
-          this.options.applyTaskRecord(
-            await this.options.controlPlaneService.createTask({
-              repositoryId: payload.repositoryId,
+          options.applyTaskRecord(
+            await options.controlPlaneService.createTask({
+              ...(payload.repositoryId === null ? {} : { repositoryId: payload.repositoryId }),
+              ...(payload.projectId === undefined || payload.projectId === null
+                ? {}
+                : { projectId: payload.projectId }),
               title: payload.title,
-              description: payload.description,
+              body: payload.body,
             }),
           );
         } else {
           if (payload.taskId === null) {
             throw new Error('task edit state missing task id');
           }
-          this.options.applyTaskRecord(
-            await this.options.controlPlaneService.updateTask({
+          options.applyTaskRecord(
+            await options.controlPlaneService.updateTask({
               taskId: payload.taskId,
-              repositoryId: payload.repositoryId,
+              ...(payload.repositoryId === null ? {} : { repositoryId: payload.repositoryId }),
+              ...(payload.projectId === undefined || payload.projectId === null
+                ? {}
+                : { projectId: payload.projectId }),
               title: payload.title,
-              description: payload.description,
+              body: payload.body,
             }),
           );
         }
-        this.options.workspace.taskEditorPrompt = null;
-        this.options.workspace.taskPaneNotice = null;
+        options.workspace.taskEditorPrompt = null;
+        options.workspace.taskPaneNotice = null;
       } catch (error: unknown) {
         const message = formatErrorMessage(error);
-        if (this.options.workspace.taskEditorPrompt !== null) {
-          this.options.workspace.taskEditorPrompt.error = message;
+        if (options.workspace.taskEditorPrompt !== null) {
+          options.workspace.taskEditorPrompt.error = message;
         } else {
-          this.options.workspace.taskPaneNotice = message;
+          options.workspace.taskPaneNotice = message;
         }
       } finally {
-        this.options.markDirty();
+        options.markDirty();
       }
     }, payload.commandLabel);
-  }
+  };
+
+  return {
+    submitTaskEditorPayload,
+  };
 }