111 lines
4.5 KiB
TypeScript
111 lines
4.5 KiB
TypeScript
import { mkdirSync, writeFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import type { AgentFn, Role, RoleResult, ThreadContext } from "@uncaged/nerve-core";
|
|
import type { LlmExtractorConfig } from "@uncaged/nerve-workflow-utils";
|
|
import { createRole, isDryRun } from "@uncaged/nerve-workflow-utils";
|
|
import { z } from "zod";
|
|
|
|
function buildPublishPrompt({ threadId, nerveRoot }: { threadId: string; nerveRoot: string }): string {
|
|
return `You are the **publish** agent (Hermes). Test has passed. Open a pull request for the current branch using the **tea** CLI.
|
|
|
|
## Context
|
|
|
|
- Read the full workflow thread: \`nerve thread show ${threadId}\`
|
|
- Nerve workspace conventions (for tone/consistency, optional): \`cat ${nerveRoot}/CONVENTIONS.md\`
|
|
|
|
## Repo and issue (from the thread)
|
|
|
|
Find \`---SOLVE_ISSUE_PARSE---\` and \`---SOLVE_ISSUE_REPO---\` in prior messages. You need:
|
|
- \`path\` — clone checkout directory (this is your working copy)
|
|
- \`host\`, \`owner\`, \`repo\`, \`number\` for the issue
|
|
- \`defaultBranch\` (for PR base) from SOLVE_ISSUE_REPO
|
|
|
|
**Issue link** for the Ref section: \`https://<host>/<owner>/<repo>/issues/<number>\`
|
|
|
|
## Steps (in order)
|
|
|
|
1. \`cd\` to the **repo \`path\`**. Run \`git rev-parse --abbrev-ref HEAD\` to get the current branch name. The **committer** step should already have pushed this branch; run \`git push -u origin <that-branch>\` only if the branch is not yet on the remote.
|
|
2. Choose a **PR title** that reflects the real change (not a generic \`fix: issue #N\`): derive it from the issue title, plan, and thread summary (keep it concise; Conventional Commits style is fine, e.g. \`fix(auth): handle session expiry\`).
|
|
3. Write a **PR body** in Markdown with exactly these sections, in this order, each with a \`##\` heading (fill with concise content based on the thread: plan, implement, review, test):
|
|
- **## What** — one short paragraph: what this PR does
|
|
- **## Why** — one short paragraph: motivation / issue
|
|
- **## Changes** — bullet list of notable changes
|
|
- **## Ref** — include one line \`Fixes #<number>\` (same \`number\` from SOLVE_ISSUE_PARSE; closes/links the issue where supported) **and** the issue URL \`https://<host>/<owner>/<repo>/issues/<number>\`
|
|
4. Create the PR with **tea** (not curl/fetch to Gitea):
|
|
- \`tea pr create --repo <owner>/<repo> --base <defaultBranch> --head <branch> --title "<your meaningful title>" --body <your markdown body>\`
|
|
- You may use a heredoc or a temp file for \`--body\` if the shell requires it; keep the four sections in the body.
|
|
5. Confirm the PR was created (tea prints a URL or PR number in typical setups).
|
|
|
|
**success=true** only if both **push** and **tea** PR creation succeed. If any step fails, set **success=false** and say why.
|
|
|
|
End your reply with a JSON line:
|
|
\`\`\`json
|
|
{ "success": true }
|
|
\`\`\`
|
|
or
|
|
\`\`\`json
|
|
{ "success": false }
|
|
\`\`\``;
|
|
}
|
|
|
|
export const publishMetaSchema = z.object({
|
|
success: z.boolean().describe("true if git push and tea pr create both succeeded"),
|
|
});
|
|
export type PublishMeta = z.infer<typeof publishMetaSchema>;
|
|
|
|
export type CreatePublishRoleDeps = {
|
|
extract: LlmExtractorConfig;
|
|
nerveRoot: string;
|
|
};
|
|
|
|
function logPath(nerveRoot: string): string {
|
|
return join(nerveRoot, "logs", `solve-issue-publish-${Date.now()}.log`);
|
|
}
|
|
|
|
export function createPublishRole(
|
|
adapter: AgentFn,
|
|
{ extract, nerveRoot }: CreatePublishRoleDeps,
|
|
): Role<PublishMeta> {
|
|
const innerRole = createRole(
|
|
adapter,
|
|
async (ctx: ThreadContext) =>
|
|
buildPublishPrompt({ threadId: ctx.start.meta.threadId, nerveRoot }),
|
|
publishMetaSchema,
|
|
extract,
|
|
);
|
|
|
|
return async (ctx: ThreadContext): Promise<RoleResult<PublishMeta>> => {
|
|
const file = logPath(nerveRoot);
|
|
mkdirSync(join(file, ".."), { recursive: true });
|
|
|
|
if (isDryRun(ctx.start)) {
|
|
const msg = "[dry-run] publish skipped (no git push / PR)";
|
|
writeFileSync(file, `${msg}\n`, "utf-8");
|
|
return {
|
|
content: `[dry-run] publish skipped — log: ${file}`,
|
|
meta: { success: true },
|
|
};
|
|
}
|
|
|
|
const innerCtx: ThreadContext = {
|
|
...ctx,
|
|
start: {
|
|
...ctx.start,
|
|
meta: { ...ctx.start.meta, workdir: nerveRoot },
|
|
},
|
|
};
|
|
|
|
try {
|
|
return await innerRole(innerCtx);
|
|
} catch (e) {
|
|
const msg = e instanceof Error ? e.message : String(e);
|
|
const body = `publish failed: ${msg}\n`;
|
|
writeFileSync(file, body, "utf-8");
|
|
return {
|
|
content: `publish failed: ${msg}\nLog: ${file}`,
|
|
meta: { success: false },
|
|
};
|
|
}
|
|
};
|
|
}
|