chore: archive legacy workflow extensions

__archived/extensions/workflow/index.ts

@@ -0,0 +1,132 @@
+import * as path from "node:path";
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { loadWorkflowConfig } from "./config.ts";
+import type { WorkflowRun } from "./domain.ts";
+import { openWorkflowDashboard } from "./dashboard.ts";
+import {
+  registerWorkflowContextTransitions,
+  type ContextTransitionRuntime,
+} from "./context-transition.ts";
+import { WorkflowEngine } from "./engine.ts";
+import {
+  PiAssignmentExecutor,
+  type ProcessAssignmentScheduler,
+} from "./execution.ts";
+import { loadAgentProfiles } from "./profiles.ts";
+import {
+  reconcileWorkflowDeliveries,
+  registerWorkflowNotifications,
+} from "./notifications.ts";
+import { runScriptSandbox } from "./script-runtime.ts";
+import { WorkflowStore } from "./store.ts";
+import { registerWorkflowTool } from "./tool.ts";
+import {
+  refreshWorkflowProgress,
+  registerWorkflowProgress,
+} from "./progress.ts";
+import {
+  ApprovedHostCommandExecutor,
+  FilesystemPrototypeValidator,
+  GitDiffProvider,
+  GitWorkspaceManager,
+} from "./workspace.ts";
+import type { ThinkingLevel, WorkflowModel } from "../_workflows/runner.ts";
+
+export interface WorkflowExtensionOptions {
+  stateRoot?: string;
+  scheduler?: ProcessAssignmentScheduler;
+  afterRunPersist?: (
+    ctx: ExtensionContext,
+    run: WorkflowRun,
+  ) => void | Promise<void>;
+}
+
+export function createWorkflowRuntime(
+  options: WorkflowExtensionOptions = {},
+): ContextTransitionRuntime {
+  const store = new WorkflowStore(
+    options.stateRoot ?? path.join(getAgentDir(), "workflows"),
+  );
+  return {
+    store,
+    async engineForContext(ctx: ExtensionContext) {
+      const config = await loadWorkflowConfig({
+        cwd: ctx.cwd,
+        projectTrusted: ctx.isProjectTrusted(),
+      });
+      const catalog = await loadAgentProfiles({
+        cwd: ctx.cwd,
+        projectTrusted: ctx.isProjectTrusted(),
+        standardAgents: config.standardAgents,
+      });
+      const executor = new PiAssignmentExecutor({
+        modelRegistry: ctx.modelRegistry,
+        parentCwd: ctx.cwd,
+        parentProjectTrusted: ctx.isProjectTrusted(),
+        parentModel: ctx.model as WorkflowModel | undefined,
+        parentThinkingLevel: (ctx.thinkingLevel ?? "off") as ThinkingLevel,
+        concurrencyCeiling: config.concurrency.ceiling,
+        runConcurrency: config.concurrency.default,
+        ...(options.scheduler ? { scheduler: options.scheduler } : {}),
+      });
+      return new WorkflowEngine({
+        store,
+        workspace: new GitWorkspaceManager(),
+        executor,
+        hostCommands: new ApprovedHostCommandExecutor(),
+        reviewDiff: new GitDiffProvider(),
+        scriptRuntime: { run: runScriptSandbox },
+        prototypeValidator: new FilesystemPrototypeValidator(),
+        sourceRoot: ctx.cwd,
+        parentSessionId: ctx.sessionManager.getSessionId(),
+        effectiveConfig: config,
+        profiles: catalog.profiles,
+        ...(options.afterRunPersist
+          ? {
+              afterRunPersist: (run) => options.afterRunPersist!(ctx, run),
+            }
+          : {}),
+      });
+    },
+  };
+}
+
+export function registerWorkflowRecovery(
+  pi: ExtensionAPI,
+  runtime: ContextTransitionRuntime,
+) {
+  pi.on("session_start", async (_event, ctx) => {
+    try {
+      const engine = await runtime.engineForContext(ctx);
+      await engine.recover();
+    } catch (error) {
+      ctx.ui.notify(
+        `workflow startup recovery failed: ${error instanceof Error ? error.message : String(error)}`,
+        "error",
+      );
+    }
+  });
+}
+
+export default function workflowExtension(pi: ExtensionAPI) {
+  let runtime: ContextTransitionRuntime;
+  runtime = createWorkflowRuntime({
+    afterRunPersist: async (ctx) => {
+      await Promise.all([
+        reconcileWorkflowDeliveries(pi, runtime, ctx),
+        refreshWorkflowProgress(runtime, ctx),
+      ]);
+    },
+  });
+  registerWorkflowContextTransitions(pi, runtime, (args, ctx) =>
+    openWorkflowDashboard(pi, runtime, ctx, args || undefined),
+  );
+  registerWorkflowTool(pi, runtime);
+  registerWorkflowRecovery(pi, runtime);
+  registerWorkflowNotifications(pi, runtime);
+  registerWorkflowProgress(pi, runtime);
+}