nerve-workspace/workflows/solve-issue/roles/implement/index.ts

import type { Role, RoleResult, Schema, StartStep, WorkflowMessage } from "@uncaged/nerve-core";
import { END } from "@uncaged/nerve-core";
import { compileWorkflowSpec } from "@uncaged/nerve-daemon";
import { createCursorAdapter } from "@uncaged/nerve-adapter-cursor";
import type { LlmProvider } from "@uncaged/nerve-workflow-utils";
import { createLlmExtractFn, zodMeta } from "@uncaged/nerve-workflow-utils";
import { z } from "zod";

import { resolveRepoCwd } from "../../lib/repo-context.js";
import { buildImplementPrompt } from "./prompt.js";

export const implementMetaSchema = z.object({
  done: z.boolean().describe("true when changes are complete and build passes this round"),
});
export type ImplementMeta = z.infer<typeof implementMetaSchema>;

export type BuildImplementDeps = {
  provider: LlmProvider;
  nerveRoot: string;
};

const CURSOR_TIMEOUT_MS = 300_000;

export function buildImplementRole({ provider, nerveRoot }: BuildImplementDeps): Role<ImplementMeta> {
  return async (start: StartStep, messages: WorkflowMessage[]): Promise<RoleResult<ImplementMeta>> => {
    const cwd = resolveRepoCwd(messages);
    if (cwd === null) {
      return {
        content: "implement cannot run: missing repo path in thread markers",
        meta: { done: false },
      };
    }

    const innerSpec = {
      main: {
        adapter: createCursorAdapter({
          type: "cursor",
          model: "auto",
          timeout: CURSOR_TIMEOUT_MS,
        }),
        prompt: async (start: StartStep) =>
          buildImplementPrompt({
            threadId: start.meta.threadId,
            nerveRoot,
          }),
        meta: zodMeta(implementMetaSchema),
      },
    };

    const compiled = compileWorkflowSpec(
      {
        name: "_implement-inner",
        roles: innerSpec,
        moderator: () => END,
      },
      {
        extractFn: async <T>(raw: string, schema: Schema<T>, dryRun: boolean) =>
          createLlmExtractFn<T>({ provider, dryRun })(raw, schema),
        createContext: (s, m) => ({
          start: s,
          messages: m,
          workdir: cwd,
          signal: new AbortController().signal,
        }),
      },
    );

    try {
      return await compiled.roles.main(start, messages);
    } catch (e) {
      const msg = e instanceof Error ? e.message : String(e);
      return {
        content: `implement failed: ${msg}`,
        meta: { done: false },
      };
    }
  };
}