724 lines
23 KiB
TypeScript
724 lines
23 KiB
TypeScript
import { existsSync, readFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import type {
|
|
RoleResult,
|
|
StartStep,
|
|
WorkflowDefinition,
|
|
WorkflowMessage,
|
|
} from "@uncaged/nerve-core";
|
|
import { END, parseNerveConfig } from "@uncaged/nerve-core";
|
|
import type { SpawnError } from "@uncaged/nerve-workflow-utils";
|
|
import {
|
|
cursorAgent,
|
|
isDryRun,
|
|
llmExtract,
|
|
nerveAgentContext,
|
|
readNerveYaml,
|
|
spawnSafe,
|
|
} from "@uncaged/nerve-workflow-utils";
|
|
import { z } from "zod";
|
|
|
|
const HOME = process.env.HOME ?? "/home/azureuser";
|
|
const NERVE_ROOT = join(HOME, ".uncaged-nerve");
|
|
const WORKFLOWS_DIR = join(NERVE_ROOT, "workflows");
|
|
|
|
function getNerveYaml(): string {
|
|
const result = readNerveYaml({ nerveRoot: NERVE_ROOT });
|
|
return result.ok ? result.value : "# nerve.yaml unavailable";
|
|
}
|
|
|
|
async function cfgGet(key: string): Promise<string | null> {
|
|
const result = await spawnSafe("cfg", ["get", key], {
|
|
cwd: NERVE_ROOT,
|
|
env: null,
|
|
timeoutMs: 10_000,
|
|
});
|
|
if (!result.ok) {
|
|
return null;
|
|
}
|
|
return result.value.stdout.trim() || null;
|
|
}
|
|
|
|
async function resolveDashScopeProvider(): Promise<{
|
|
baseUrl: string;
|
|
apiKey: string;
|
|
model: string;
|
|
} | null> {
|
|
const apiKey = process.env.DASHSCOPE_API_KEY ?? (await cfgGet("DASHSCOPE_API_KEY"));
|
|
const baseUrl = process.env.DASHSCOPE_BASE_URL ?? (await cfgGet("DASHSCOPE_BASE_URL"));
|
|
const model = process.env.DASHSCOPE_MODEL ?? (await cfgGet("DASHSCOPE_MODEL")) ?? "qwen-plus";
|
|
if (!apiKey || !baseUrl) {
|
|
return null;
|
|
}
|
|
return { apiKey, baseUrl, model };
|
|
}
|
|
|
|
function formatSpawnFailure(error: SpawnError): string {
|
|
if (error.kind === "spawn_failed") {
|
|
return error.message;
|
|
}
|
|
if (error.kind === "timeout") {
|
|
return `timeout (stdout=${error.stdout.slice(0, 200)})`;
|
|
}
|
|
return `exit ${error.exitCode} stderr=${error.stderr.slice(0, 400)}`;
|
|
}
|
|
|
|
function buildSenseGeneratorReference(): string {
|
|
const ref = join(WORKFLOWS_DIR, "sense-generator", "index.ts");
|
|
if (!existsSync(ref)) {
|
|
return "(reference file workflows/sense-generator/index.ts not found)";
|
|
}
|
|
return readFileSync(ref, "utf-8");
|
|
}
|
|
|
|
function lastMetaForRole<M>(messages: WorkflowMessage[], role: string): M | null {
|
|
for (let i = messages.length - 1; i >= 0; i--) {
|
|
if (messages[i].role === role) {
|
|
return messages[i].meta as M;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
const roleEntrySchema = z
|
|
.object({
|
|
name: z.string().describe("Role key / identifier in kebab-case or short snake name"),
|
|
description: z.string().describe("What this role does in one or two sentences"),
|
|
responsibilities: z.string().describe("Concrete responsibilities, inputs, and outputs for this role"),
|
|
})
|
|
.describe("One role in the generated workflow");
|
|
|
|
const analystExtractSchema = z
|
|
.object({
|
|
workflowName: z
|
|
.string()
|
|
.describe("kebab-case package directory name under workflows/, e.g. 'ticket-triage'"),
|
|
roles: z.array(roleEntrySchema).describe("Planned roles for the new workflow"),
|
|
moderatorFlow: z.string().describe("How the moderator should route between roles; start and exit conditions"),
|
|
externalDeps: z
|
|
.string()
|
|
.describe("External tools, CLIs, HTTP APIs, or services the workflow must integrate with"),
|
|
dataFlow: z
|
|
.string()
|
|
.describe("How data moves between roles: what each step consumes and produces in content/meta"),
|
|
})
|
|
.describe("Structured workflow specification extracted from the analysis");
|
|
|
|
type AnalystMetaItem = {
|
|
name: string;
|
|
description: string;
|
|
responsibilities: string;
|
|
};
|
|
|
|
type WorkflowGenMeta = {
|
|
analyst: {
|
|
userPrompt: string;
|
|
analysis: string;
|
|
workflowName: string;
|
|
roles: AnalystMetaItem[];
|
|
moderatorFlow: string;
|
|
externalDeps: string;
|
|
dataFlow: string;
|
|
};
|
|
architect: { workflowName: string; design: string };
|
|
coder: {
|
|
workflowName: string;
|
|
files: { indexTs: boolean; packageJson: boolean; tsconfigJson: boolean };
|
|
cursorOutput: string;
|
|
};
|
|
reviewer: {
|
|
passed: boolean;
|
|
workflowName: string;
|
|
reason: string;
|
|
attempt: number;
|
|
validationLog: string;
|
|
};
|
|
};
|
|
|
|
const emptyAnalystMeta = (userContent: string): WorkflowGenMeta["analyst"] => ({
|
|
userPrompt: userContent,
|
|
analysis: "",
|
|
workflowName: "",
|
|
roles: [],
|
|
moderatorFlow: "",
|
|
externalDeps: "",
|
|
dataFlow: "",
|
|
});
|
|
|
|
function verifyNerveWorkflowEntry(workflowName: string): { ok: true } | { ok: false; reason: string } {
|
|
const readResult = readNerveYaml({ nerveRoot: NERVE_ROOT });
|
|
if (!readResult.ok) {
|
|
return { ok: false, reason: `readNerveYaml: ${readResult.error.message}` };
|
|
}
|
|
const parsed = parseNerveConfig(readResult.value);
|
|
if (!parsed.ok) {
|
|
return { ok: false, reason: `parseNerveConfig: ${parsed.error.message}` };
|
|
}
|
|
if (parsed.value.workflows[workflowName] === undefined) {
|
|
return { ok: false, reason: `nerve.yaml has no workflows.${workflowName} entry` };
|
|
}
|
|
return { ok: true };
|
|
}
|
|
|
|
function scanGeneratedCodePitfalls(source: string): string[] {
|
|
const issues: string[] = [];
|
|
if (/\bawait\s+import\s*\(/.test(source)) {
|
|
issues.push(
|
|
"Uses await import() — only allowed in sense-runtime / workflow-worker with a documented comment",
|
|
);
|
|
}
|
|
if (/\bimport\s*\(\s*["'`]/.test(source) && !source.includes("Dynamic import required")) {
|
|
issues.push("Dynamic import() without documented exception comment");
|
|
}
|
|
if (/\bexport\s+default\s+/.test(source) === false) {
|
|
issues.push("Missing default export of WorkflowDefinition (engine loads the default export)");
|
|
}
|
|
return issues;
|
|
}
|
|
|
|
async function runReviewerValidation(
|
|
workflowDir: string,
|
|
workflowName: string,
|
|
dry: boolean,
|
|
): Promise<{ ok: true; log: string } | { ok: false; log: string; reason: string }> {
|
|
const logParts: string[] = [];
|
|
|
|
const indexPath = join(workflowDir, "index.ts");
|
|
const pkgPath = join(workflowDir, "package.json");
|
|
const tsconfigPath = join(workflowDir, "tsconfig.json");
|
|
if (!existsSync(indexPath) || !existsSync(pkgPath) || !existsSync(tsconfigPath)) {
|
|
const miss: string[] = [];
|
|
if (!existsSync(indexPath)) miss.push("index.ts");
|
|
if (!existsSync(pkgPath)) miss.push("package.json");
|
|
if (!existsSync(tsconfigPath)) miss.push("tsconfig.json");
|
|
return { ok: false, log: "", reason: `Missing required file(s): ${miss.join(", ")}` };
|
|
}
|
|
|
|
const source = readFileSync(indexPath, "utf-8");
|
|
const pitfalls = scanGeneratedCodePitfalls(source);
|
|
if (pitfalls.length > 0) {
|
|
const pitfallText = pitfalls.join("\n");
|
|
logParts.push(`=== static checks ===\n${pitfallText}`);
|
|
return { ok: false, log: logParts.join("\n\n"), reason: pitfallText };
|
|
}
|
|
|
|
const tsc = await spawnSafe("npx", ["tsc", "--noEmit"], {
|
|
cwd: workflowDir,
|
|
env: null,
|
|
timeoutMs: 300_000,
|
|
dryRun: dry,
|
|
});
|
|
if (!tsc.ok) {
|
|
const msg = formatSpawnFailure(tsc.error);
|
|
logParts.push(`=== npx tsc --noEmit ===\n${msg}`);
|
|
return { ok: false, log: logParts.join("\n\n"), reason: `Typecheck failed: ${msg}` };
|
|
}
|
|
const tscOut = tsc.value.stderr.trim() || tsc.value.stdout.trim() || "(no output)";
|
|
logParts.push(`=== npx tsc --noEmit ===\n${tscOut}`);
|
|
|
|
const nerveCheck = verifyNerveWorkflowEntry(workflowName);
|
|
if (!nerveCheck.ok) {
|
|
logParts.push(`=== nerve.yaml ===\n${nerveCheck.reason}`);
|
|
return {
|
|
ok: false,
|
|
log: logParts.join("\n\n"),
|
|
reason: `nerve.yaml: ${nerveCheck.reason}`,
|
|
};
|
|
}
|
|
logParts.push(`=== nerve.yaml ===\nworkflows.${workflowName} is present.`);
|
|
|
|
const importLines = source.split("\n").filter((l) => /^\s*import\s/.test(l));
|
|
logParts.push(`=== import lines ===\n${importLines.join("\n")}`);
|
|
|
|
return { ok: true, log: logParts.join("\n\n") };
|
|
}
|
|
|
|
const workflow: WorkflowDefinition<WorkflowGenMeta> = {
|
|
name: "workflow-generator",
|
|
|
|
roles: {
|
|
async analyst(
|
|
start: StartStep,
|
|
_messages: WorkflowMessage[],
|
|
): Promise<RoleResult<WorkflowGenMeta["analyst"]>> {
|
|
const dry = isDryRun(start);
|
|
const userInput = start.content;
|
|
const empty = emptyAnalystMeta(userInput);
|
|
|
|
const provider = await resolveDashScopeProvider();
|
|
if (provider === null) {
|
|
return {
|
|
content:
|
|
"Cannot run analyst: set DASHSCOPE_API_KEY and DASHSCOPE_BASE_URL (or configure via `cfg get`), " +
|
|
"and optionally DASHSCOPE_MODEL.",
|
|
meta: empty,
|
|
};
|
|
}
|
|
|
|
const askPrompt = `You are analyzing a user request to build a new Nerve **workflow** (multi-role automaton with a moderator).
|
|
|
|
${nerveAgentContext}
|
|
|
|
User's natural language description:
|
|
${userInput}
|
|
|
|
Nerve root: ${NERVE_ROOT}
|
|
Target workflows live under: ${WORKFLOWS_DIR}/<workflow-name>/
|
|
|
|
## Your task
|
|
- Clarify the goal, constraints, and success criteria.
|
|
- Identify a good kebab-case workflow package name.
|
|
- Propose a role breakdown: what each role should do, in order.
|
|
- Describe how a moderator should route between roles and when to end.
|
|
- List external tools/APIs and how data should flow in \`content\` vs \`meta\` between roles.
|
|
|
|
Current nerve.yaml (for context only; do not edit here):
|
|
\`\`\`yaml
|
|
${getNerveYaml()}
|
|
\`\`\`
|
|
|
|
For reference, here is a complete existing workflow (patterns to mirror, not to copy literally):
|
|
\`\`\`ts
|
|
${buildSenseGeneratorReference().slice(0, 18_000)}
|
|
\`\`\`
|
|
|
|
Output a thorough analysis in markdown. Do not write final implementation code.`;
|
|
|
|
const planResult = await cursorAgent({
|
|
prompt: askPrompt,
|
|
mode: "ask",
|
|
cwd: NERVE_ROOT,
|
|
env: null,
|
|
timeoutMs: null,
|
|
dryRun: dry,
|
|
});
|
|
if (!planResult.ok) {
|
|
return {
|
|
content: `cursor-agent failed: ${formatSpawnFailure(planResult.error)}`,
|
|
meta: { ...empty, analysis: "" },
|
|
};
|
|
}
|
|
const analysis = planResult.value;
|
|
|
|
const extracted = await llmExtract({
|
|
text: analysis,
|
|
schema: analystExtractSchema,
|
|
provider,
|
|
dryRun: dry,
|
|
});
|
|
if (dry) {
|
|
return {
|
|
content: "[dry-run] analyst complete",
|
|
meta: {
|
|
...empty,
|
|
analysis: analysis || "(dry-run)",
|
|
workflowName: "dry-run-test",
|
|
roles: [{ name: "placeholder", description: "dry-run role", responsibilities: "n/a" }],
|
|
moderatorFlow: "placeholder → END",
|
|
externalDeps: "none",
|
|
dataFlow: "n/a",
|
|
},
|
|
};
|
|
}
|
|
if (!extracted.ok) {
|
|
return {
|
|
content: `${analysis}\n\n[llmExtract error] ${JSON.stringify(extracted.error)}`,
|
|
meta: {
|
|
userPrompt: userInput,
|
|
analysis,
|
|
workflowName: "",
|
|
roles: [],
|
|
moderatorFlow: "",
|
|
externalDeps: "",
|
|
dataFlow: "",
|
|
},
|
|
};
|
|
}
|
|
|
|
const e = extracted.value;
|
|
const summary =
|
|
`## Analysis\n\n${analysis}\n\n` +
|
|
`## Structured spec\n\n` +
|
|
`**workflowName:** ${e.workflowName}\n\n` +
|
|
`**moderatorFlow:**\n${e.moderatorFlow}\n\n` +
|
|
`**externalDeps:**\n${e.externalDeps}\n\n` +
|
|
`**dataFlow:**\n${e.dataFlow}\n\n` +
|
|
`**roles:**\n` +
|
|
e.roles
|
|
.map(
|
|
(r, i) =>
|
|
`${i + 1}. **${r.name}** — ${r.description}\n - ${r.responsibilities}`,
|
|
)
|
|
.join("\n\n");
|
|
|
|
return {
|
|
content: summary,
|
|
meta: {
|
|
userPrompt: userInput,
|
|
analysis,
|
|
workflowName: e.workflowName,
|
|
roles: e.roles,
|
|
moderatorFlow: e.moderatorFlow,
|
|
externalDeps: e.externalDeps,
|
|
dataFlow: e.dataFlow,
|
|
},
|
|
};
|
|
},
|
|
|
|
async architect(
|
|
start: StartStep,
|
|
messages: WorkflowMessage[],
|
|
): Promise<RoleResult<WorkflowGenMeta["architect"]>> {
|
|
const dry = isDryRun(start);
|
|
if (dry) {
|
|
return {
|
|
content: "[dry-run] architect complete",
|
|
meta: { workflowName: "dry-run-test", design: "(dry-run design)" },
|
|
};
|
|
}
|
|
const last = messages[messages.length - 1];
|
|
const spec = last.meta as WorkflowGenMeta["analyst"];
|
|
const wfName = spec.workflowName.trim();
|
|
|
|
if (wfName.length === 0) {
|
|
return {
|
|
content: "Architect skipped — analyst did not produce a workflow name.",
|
|
meta: { workflowName: "", design: "" },
|
|
};
|
|
}
|
|
|
|
const rolesText = spec.roles
|
|
.map(
|
|
(r) =>
|
|
`### ${r.name}\n- **description:** ${r.description}\n- **responsibilities:** ${r.responsibilities}`,
|
|
)
|
|
.join("\n\n");
|
|
|
|
const designPrompt = `You are the architect for a new Nerve **workflow** (multi-role state machine with a \`WorkflowDefinition\` and moderator).
|
|
|
|
${nerveAgentContext}
|
|
|
|
Target package directory: ${WORKFLOWS_DIR}/${wfName}/
|
|
|
|
## Analyst output
|
|
|
|
**User prompt:**
|
|
${spec.userPrompt}
|
|
|
|
**Moderator / routing (from analyst):**
|
|
${spec.moderatorFlow}
|
|
|
|
**External dependencies:**
|
|
${spec.externalDeps}
|
|
|
|
**Data flow:**
|
|
${spec.dataFlow}
|
|
|
|
**Roles (planned):**
|
|
${rolesText}
|
|
|
|
## Your task (design document only, no file contents)
|
|
|
|
Produce an implementation-ready design in markdown:
|
|
|
|
1. **Meta type (TypeScript)**
|
|
- A concrete \`type WorkflowMeta = { ... }\` using \`type\` (not interface), no optional \`?:\` — use \`T | null\` for nullable fields.
|
|
- One entry per role with the exact fields each role will put in \`RoleResult\` meta.
|
|
|
|
2. **Role functions**
|
|
- For each role: parameters (\`StartStep\`, \`WorkflowMessage[]\`), return \`RoleResult<…>\`, what to read from \`start\` / prior messages, what to put in \`content\` vs \`meta\`.
|
|
|
|
3. **Moderator**
|
|
- Pseudocode for \`moderator(context)\` using \`END\` from \`@uncaged/nerve-core\`, edge conditions, and error paths (routed in moderator, not via process exit).
|
|
|
|
4. **Error handling**
|
|
- How each role reports recoverable failure (content + meta) and how the moderator steers the thread.
|
|
|
|
5. **Imports**
|
|
- List required imports from \`@uncaged/nerve-core\` and \`@uncaged/nerve-workflow-utils\` only as needed by the final code.
|
|
|
|
6. **Files the coder will write**
|
|
- \`${WORKFLOWS_DIR}/${wfName}/index.ts\` — \`export default\` a \`WorkflowDefinition<YourMeta>\`
|
|
- \`${WORKFLOWS_DIR}/${wfName}/package.json\` with \`"type": "module"\` and dependencies (include \`zod\` if the workflow parses structured data)
|
|
- \`${WORKFLOWS_DIR}/${wfName}/tsconfig.json\` — if \`${NERVE_ROOT}/tsconfig.workflow.base.json\` exists, extend it; else a strict NodeNext \`noEmit\` project
|
|
|
|
7. **nerve.yaml**
|
|
- The coder must add a \`workflows:${wfName}\` block to \`${NERVE_ROOT}/nerve.yaml\` (concurrency, overflow) without removing existing keys.
|
|
|
|
8. **Nerve code rules to preserve in the generated \`index.ts\`**
|
|
- No dynamic \`import()\` in the generated workflow (except documented exceptions in engine loaders).
|
|
- \`type\` over \`interface\`, \`function\` over \`class\` for the workflow’s own code.
|
|
|
|
## Reference (meta-workflow style)
|
|
\`\`\`ts
|
|
${buildSenseGeneratorReference().slice(0, 22_000)}
|
|
\`\`\`
|
|
|
|
Current nerve.yaml:
|
|
\`\`\`yaml
|
|
${getNerveYaml()}
|
|
\`\`\`
|
|
|
|
Output ONLY the design markdown.`;
|
|
|
|
const planResult = await cursorAgent({
|
|
prompt: designPrompt,
|
|
mode: "ask",
|
|
cwd: NERVE_ROOT,
|
|
env: null,
|
|
timeoutMs: null,
|
|
dryRun: dry,
|
|
});
|
|
if (!planResult.ok) {
|
|
return {
|
|
content: `cursor-agent failed: ${formatSpawnFailure(planResult.error)}`,
|
|
meta: { workflowName: wfName, design: "" },
|
|
};
|
|
}
|
|
|
|
return {
|
|
content: planResult.value,
|
|
meta: { workflowName: wfName, design: planResult.value },
|
|
};
|
|
},
|
|
|
|
async coder(
|
|
start: StartStep,
|
|
messages: WorkflowMessage[],
|
|
): Promise<RoleResult<WorkflowGenMeta["coder"]>> {
|
|
const dry = isDryRun(start);
|
|
if (dry) {
|
|
return {
|
|
content: "[dry-run] coder complete",
|
|
meta: { workflowName: "dry-run-test", generatedFiles: ["(dry-run)"], codegenLog: "(dry-run)" },
|
|
};
|
|
}
|
|
const analystMeta = lastMetaForRole<WorkflowGenMeta["analyst"]>(messages, "analyst");
|
|
const architectMeta = lastMetaForRole<WorkflowGenMeta["architect"]>(messages, "architect");
|
|
const priorReviewer = lastMetaForRole<WorkflowGenMeta["reviewer"]>(messages, "reviewer");
|
|
|
|
if (analystMeta === null || architectMeta === null) {
|
|
return {
|
|
content: "coder: missing analyst or architect message in history",
|
|
meta: {
|
|
workflowName: "",
|
|
files: { indexTs: false, packageJson: false, tsconfigJson: false },
|
|
cursorOutput: "",
|
|
},
|
|
};
|
|
}
|
|
|
|
const wfName = analystMeta.workflowName.trim();
|
|
if (wfName.length === 0) {
|
|
return {
|
|
content: "coder: empty workflow name",
|
|
meta: {
|
|
workflowName: "",
|
|
files: { indexTs: false, packageJson: false, tsconfigJson: false },
|
|
cursorOutput: "",
|
|
},
|
|
};
|
|
}
|
|
|
|
const fixSection =
|
|
priorReviewer !== null && priorReviewer.passed === false
|
|
? `\n\n## Previous review (address these before anything else)\n${priorReviewer.reason}\n\nFull validation log:\n${priorReviewer.validationLog}\n`
|
|
: "";
|
|
|
|
const codePrompt = `You are implementing a new Nerve workflow package at ${WORKFLOWS_DIR}/${wfName}/.
|
|
|
|
## Architect design (authoritative for structure)
|
|
${architectMeta.design}
|
|
|
|
## Analyst structured fields
|
|
${JSON.stringify(
|
|
{
|
|
workflowName: analystMeta.workflowName,
|
|
userPrompt: analystMeta.userPrompt,
|
|
roles: analystMeta.roles,
|
|
moderatorFlow: analystMeta.moderatorFlow,
|
|
externalDeps: analystMeta.externalDeps,
|
|
dataFlow: analystMeta.dataFlow,
|
|
},
|
|
null,
|
|
2,
|
|
)}
|
|
${fixSection}
|
|
|
|
## Files to create or update
|
|
1. \`${WORKFLOWS_DIR}/${wfName}/index.ts\` — \`export default\` a \`WorkflowDefinition\` (same style as sense-generator: named imports, default export at end).
|
|
2. \`${WORKFLOWS_DIR}/${wfName}/package.json\` — \`"type": "module"\`, dependencies on \`@uncaged/nerve-core\`, \`@uncaged/nerve-workflow-utils\`, \`zod\` if used; add \`typescript\` in devDependencies so \`npx tsc --noEmit\` works in that directory.
|
|
3. \`${WORKFLOWS_DIR}/${wfName}/tsconfig.json\` — strict, \`module\`/\`moduleResolution\` NodeNext, \`noEmit: true\`, include all \`.ts\` in the folder.
|
|
|
|
4. **Register the workflow** — merge a new block into the existing \`${NERVE_ROOT}/nerve.yaml\` under the top-level \`workflows:\` key:
|
|
\`\`\`yaml
|
|
${wfName}:
|
|
concurrency: 1
|
|
overflow: drop
|
|
\`\`\`
|
|
Do not remove or overwrite unrelated senses, reflexes, or other workflow entries. Preserve valid YAML.
|
|
|
|
## Implementation patterns (when applicable)
|
|
- \`resolveDashScopeProvider\`, \`nerveAgentContext\`, \`readNerveYaml\`, \`cursorAgent\`, \`llmExtract\`, \`spawnSafe\`, \`formatSpawnFailure\` from \`@uncaged/nerve-workflow-utils\` as in sense-generator.
|
|
- No dynamic \`import()\` in the new workflow code.
|
|
- **Every zod schema passed to \`llmExtract\` MUST have \`.default()\` on all fields** (especially arrays and objects). This ensures \`dryRun\` mode returns structurally valid data instead of empty primitives. Example: \`z.array(roleSchema).default([])\`, \`z.string().default("unknown")\`.
|
|
|
|
## Reference workflow
|
|
\`\`\`ts
|
|
${buildSenseGeneratorReference().slice(0, 20_000)}
|
|
\`\`\`
|
|
|
|
Current nerve.yaml (merge carefully; keep all existing content):
|
|
\`\`\`yaml
|
|
${getNerveYaml()}
|
|
\`\`\`
|
|
|
|
Implement now.`;
|
|
|
|
const agentResult = await cursorAgent({
|
|
prompt: codePrompt,
|
|
mode: "default",
|
|
cwd: NERVE_ROOT,
|
|
env: null,
|
|
timeoutMs: null,
|
|
dryRun: dry,
|
|
});
|
|
|
|
const workflowDir = join(WORKFLOWS_DIR, wfName);
|
|
const files = {
|
|
indexTs: existsSync(join(workflowDir, "index.ts")),
|
|
packageJson: existsSync(join(workflowDir, "package.json")),
|
|
tsconfigJson: existsSync(join(workflowDir, "tsconfig.json")),
|
|
};
|
|
|
|
if (!agentResult.ok) {
|
|
const errText = `cursor-agent failed: ${formatSpawnFailure(agentResult.error)}`;
|
|
return {
|
|
content: errText,
|
|
meta: { workflowName: wfName, files, cursorOutput: errText },
|
|
};
|
|
}
|
|
|
|
return {
|
|
content: agentResult.value,
|
|
meta: { workflowName: wfName, files, cursorOutput: agentResult.value },
|
|
};
|
|
},
|
|
|
|
async reviewer(
|
|
start: StartStep,
|
|
messages: WorkflowMessage[],
|
|
): Promise<RoleResult<WorkflowGenMeta["reviewer"]>> {
|
|
const dry = isDryRun(start);
|
|
if (dry) {
|
|
return {
|
|
content: "[dry-run] reviewer complete — LGTM",
|
|
meta: { workflowName: "dry-run-test", approved: true, issues: "" },
|
|
};
|
|
}
|
|
const last = messages[messages.length - 1];
|
|
const { workflowName, files } = last.meta as WorkflowGenMeta["coder"];
|
|
|
|
const attempt = messages.filter((m) => m.role === "reviewer").length + 1;
|
|
|
|
const missing: string[] = [];
|
|
if (!files.indexTs) missing.push("index.ts");
|
|
if (!files.packageJson) missing.push("package.json");
|
|
if (!files.tsconfigJson) missing.push("tsconfig.json");
|
|
if (missing.length > 0) {
|
|
return {
|
|
content: `FAIL — missing: ${missing.join(", ")}`,
|
|
meta: {
|
|
passed: false,
|
|
workflowName,
|
|
reason: `Missing required file(s): ${missing.join(", ")}`,
|
|
attempt,
|
|
validationLog: "",
|
|
},
|
|
};
|
|
}
|
|
|
|
const name = workflowName.trim();
|
|
if (name.length === 0) {
|
|
return {
|
|
content: "FAIL — empty workflow name in coder meta",
|
|
meta: {
|
|
passed: false,
|
|
workflowName: "",
|
|
reason: "Coder meta had empty workflowName",
|
|
attempt,
|
|
validationLog: "",
|
|
},
|
|
};
|
|
}
|
|
|
|
const workflowDir = join(WORKFLOWS_DIR, name);
|
|
const checks = await runReviewerValidation(workflowDir, name, dry);
|
|
|
|
if (!checks.ok) {
|
|
return {
|
|
content: `FAIL — ${checks.reason}`,
|
|
meta: {
|
|
passed: false,
|
|
workflowName: name,
|
|
reason: checks.reason,
|
|
attempt,
|
|
validationLog: checks.log,
|
|
},
|
|
};
|
|
}
|
|
|
|
return {
|
|
content: `PASS — typecheck and nerve.yaml check OK.\n\n${checks.log.slice(0, 8000)}`,
|
|
meta: {
|
|
passed: true,
|
|
workflowName: name,
|
|
reason: "npx tsc --noEmit passed and nerve.yaml contains the workflow entry",
|
|
attempt,
|
|
validationLog: checks.log,
|
|
},
|
|
};
|
|
},
|
|
},
|
|
|
|
moderator(context) {
|
|
if (context.steps.length === 0) {
|
|
return "analyst";
|
|
}
|
|
|
|
const last = context.steps[context.steps.length - 1];
|
|
|
|
if (last.role === "analyst") {
|
|
if (last.meta.workflowName.trim().length === 0) {
|
|
return END;
|
|
}
|
|
return "architect";
|
|
}
|
|
|
|
if (last.role === "architect") {
|
|
if (last.meta.workflowName.trim().length === 0 || last.meta.design.trim().length === 0) {
|
|
return END;
|
|
}
|
|
return "coder";
|
|
}
|
|
|
|
if (last.role === "coder") {
|
|
return "reviewer";
|
|
}
|
|
|
|
if (last.role === "reviewer") {
|
|
if (last.meta.passed) {
|
|
return END;
|
|
}
|
|
if (last.meta.attempt < 3) {
|
|
return "coder";
|
|
}
|
|
return END;
|
|
}
|
|
|
|
return END;
|
|
},
|
|
};
|
|
|
|
export default workflow;
|