nerve-workspace/workflows/solve-issue/build.ts

import type { StartStep, WorkflowDefinition } from "@uncaged/nerve-core";
import { hermesAdapter } from "@uncaged/nerve-adapter-hermes";
import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
import { createRole } from "@uncaged/nerve-workflow-utils";

import { moderator } from "./moderator.js";
import type { WorkflowMeta } from "./moderator.js";
import { buildImplementRole } from "./roles/implement/index.js";
import { buildPlanRole } from "./roles/plan/index.js";
import { prepareMetaSchema } from "./roles/prepare/index.js";
import { preparePrompt } from "./roles/prepare/prompt.js";
import { buildPublishRole } from "./roles/publish/index.js";
import { readIssueMetaSchema } from "./roles/read-issue/index.js";
import { readIssuePrompt } from "./roles/read-issue/prompt.js";
import { reviewMetaSchema } from "./roles/review/index.js";
import { reviewPrompt } from "./roles/review/prompt.js";
import { testMetaSchema } from "./roles/test/index.js";
import { testPrompt } from "./roles/test/prompt.js";

export type BuildSolveIssueDeps = {
  nerveRoot: string;
  extract: LlmExtractorConfig;
};

export function buildSolveIssue({
  nerveRoot,
  extract,
}: BuildSolveIssueDeps): WorkflowDefinition<WorkflowMeta> {
  return {
    name: "solve-issue",
    roles: {
      "read-issue": createRole(
        hermesAdapter,
        async (start: StartStep) => readIssuePrompt({ threadId: start.meta.threadId }),
        readIssueMetaSchema,
        extract,
      ),
      prepare: createRole(
        hermesAdapter,
        async (start: StartStep) => preparePrompt({ threadId: start.meta.threadId }),
        prepareMetaSchema,
        extract,
      ),
      plan: buildPlanRole({ extract, nerveRoot }),
      implement: buildImplementRole({ extract, nerveRoot }),
      review: createRole(
        hermesAdapter,
        async (start: StartStep) =>
          reviewPrompt({ threadId: start.meta.threadId, nerveRoot }),
        reviewMetaSchema,
        extract,
      ),
      test: createRole(
        hermesAdapter,
        async (start: StartStep) => testPrompt({ threadId: start.meta.threadId }),
        testMetaSchema,
        extract,
      ),
      publish: buildPublishRole({ extract, nerveRoot }),
    },
    moderator,
  };
}