@nyxa/nyx-agent 0.4.1 → 0.6.0

package/dist/runtime/runPhase.js

@@ -1,122 +1,65 @@
 import path from "node:path";
 import { execa } from "execa";
-import { buildPhasePrompt, phaseRequiresStructuredResult } from "./buildPrompt.js";
-import { getEffectiveHarness, getEffectiveModel } from "./effectiveConfig.js";
-import { ensureDir, readText, writeJson, writeText } from "./files.js";
+import { ensureDir, writeJson, writeText } from "./files.js";
 import { getGitSnapshot } from "./git.js";
-import { parseNyxAgentResult, getOutcome } from "./parseResult.js";
-import { resolveNyxPath } from "./paths.js";
-import { renderTemplate } from "./renderTemplate.js";
+import { buildHarnessInvocation } from "./harness.js";
+import { parseNyxAgentResult } from "./parseResult.js";
 import { validateAgainstSchema } from "./validateResult.js";
-import { validateWorkItemIdentity, validateWorkItemQueue } from "./validateWorkItem.js";
-export async function runPhase(input) {
-    const phaseDir = path.join(input.iterationDir, "phases", input.phase.id);
-    await ensureDir(phaseDir);
-    const context = buildContext({ ...input, phaseDir });
-    const prompt = await buildPhasePrompt({
-        projectRoot: input.projectRoot,
-        runDir: input.runDir,
-        iterationDir: input.iterationDir,
-        phaseDir,
-        stateFile: input.stateFile,
-        config: input.config,
-        phase: input.phase,
-        context
-    });
-    const attempt = await runHarnessAttempt({
-        attemptDir: path.join(phaseDir, "attempt-001"),
-        prompt,
-        context,
-        config: input.config,
-        phase: input.phase,
-        workdir: input.workdir ?? input.projectRoot
+/**
+ * Run one agent phase: invoke the harness with the prompt on stdin, and — when a
+ * schema is given — parse, validate, and (on failure) repair the structured
+ * result. Decoupled from any workflow graph: the pipeline owns control flow.
+ */
+export async function runAgentPhase(input) {
+    await ensureDir(input.phaseDir);
+    const attempt = await invokeHarness({
+        attemptDir: path.join(input.phaseDir, "attempt-001"),
+        input,
+        prompt: input.prompt
     });
     if (attempt.exitCode !== 0) {
-        await writeAttemptMeta(attempt, {
-            failure: `Harness exited with code ${attempt.exitCode}`
-        });
         return {
             ok: false,
-            error: `Phase "${input.phase.id}" failed with exit code ${attempt.exitCode}`
+            error: `Phase "${input.phaseId}" failed with exit code ${attempt.exitCode}`
         };
     }
-    if (!phaseRequiresStructuredResult(input.phase)) {
-        await writeAttemptMeta(attempt);
+    if (!input.schema) {
         return { ok: true };
     }
-    const parsed = await parseAndValidatePhaseResult({
-        input,
-        phaseDir,
-        attempt
-    });
+    const parsed = parseAndValidate(input.schema, attempt.stdout);
     if (parsed.ok) {
+        await writeJson(path.join(input.phaseDir, "result.json"), parsed.result);
         return parsed;
     }
-    await writeAttemptMeta(attempt, {
-        result_error: parsed.error
-    });
-    const repaired = await repairStructuredResult({
+    const repaired = await repairResult({
         input,
-        phaseDir,
-        originalPrompt: prompt,
-        originalAttempt: attempt,
+        originalStdout: attempt.stdout,
         validationError: parsed.error
     });
-    if (repaired.ok) {
-        return repaired;
+    if (repaired.ok && repaired.result !== undefined) {
+        await writeJson(path.join(input.phaseDir, "result.json"), repaired.result);
     }
-    return {
-        ok: false,
-        error: repaired.error
-    };
-}
-function buildContext(input) {
-    const model = getEffectiveModel(input.config, input.phase);
-    const harness = getEffectiveHarness(input.config, input.phase);
-    return {
-        project_root: input.projectRoot,
-        run_dir: input.runDir,
-        iteration_dir: input.iterationDir,
-        phase_dir: input.phaseDir,
-        state_file: input.stateFile,
-        phase: input.phase,
-        workflow: input.config.workflow,
-        work_items: input.config.work_items ?? {},
-        available_work_items: input.state.available_work_items ?? [],
-        recommended_work_item_queue: input.state.recommended_work_item_queue ?? [],
-        selected_work_item_queue: input.state.selected_work_item_queue ?? [],
-        work_item_annotations: input.state.work_item_annotations ?? [],
-        work_item: input.state.work_item ?? {},
-        seen_work_item_keys: input.state.seen_work_item_keys ?? [],
-        completed_work_item_keys: input.state.completed_work_item_keys ?? [],
-        last_completed_work_item: input.state.last_completed_work_item ?? null,
-        phase_results: input.state.phase_results ?? {},
-        state: input.state,
-        model,
-        harness,
-        workdir: input.workdir ?? input.projectRoot,
-        git: input.git ?? {}
-    };
+    return repaired;
 }
-async function runHarnessAttempt(input) {
-    await ensureDir(input.attemptDir);
-    await writeText(path.join(input.attemptDir, "prompt.md"), input.prompt);
-    const harness = getEffectiveHarness(input.config, input.phase);
-    if (harness.prompt_input !== "stdin") {
-        throw new Error(`Unsupported prompt_input "${harness.prompt_input}"`);
-    }
-    const command = renderTemplate(harness.command, input.context);
-    const args = harness.args.map((arg) => renderTemplate(arg, input.context));
+async function invokeHarness(args) {
+    await ensureDir(args.attemptDir);
+    await writeText(path.join(args.attemptDir, "prompt.md"), args.prompt);
+    const invocation = buildHarnessInvocation({
+        harness: args.input.harness,
+        capability: args.forceReadonly ? "readonly" : args.input.capability,
+        model: args.input.model,
+        reasoning: args.input.reasoning
+    });
     const startedAt = new Date().toISOString();
     const started = Date.now();
-    const gitBefore = await getGitSnapshot(input.workdir);
+    const gitBefore = await getGitSnapshot(args.input.workdir);
     let stdout = "";
     let stderr = "";
     let exitCode = 0;
     try {
-        const result = await execa(command, args, {
-            cwd: input.workdir,
-            input: input.prompt,
+        const result = await execa(invocation.command, invocation.args, {
+            cwd: args.input.workdir,
+            input: args.prompt,
             reject: false
         });
         stdout = result.stdout;
@@ -127,186 +70,74 @@ async function runHarnessAttempt(input) {
         exitCode = 127;
         stderr = error instanceof Error ? error.message : String(error);
     }
-    const endedAt = new Date().toISOString();
-    const durationMs = Date.now() - started;
-    const gitAfter = await getGitSnapshot(input.workdir);
-    await writeText(path.join(input.attemptDir, "stdout.log"), stdout);
-    await writeText(path.join(input.attemptDir, "stderr.log"), stderr);
-    const attempt = {
-        attemptDir: input.attemptDir,
-        metaPath: path.join(input.attemptDir, "meta.json"),
-        stdout,
-        stderr,
-        exitCode,
-        command,
-        args,
-        startedAt,
-        endedAt,
-        durationMs,
-        gitBefore,
-        gitAfter
-    };
-    await writeAttemptMeta(attempt);
-    return attempt;
-}
-async function writeAttemptMeta(attempt, extra = {}) {
-    await writeJson(attempt.metaPath, {
-        command: attempt.command,
-        args: attempt.args,
-        started_at: attempt.startedAt,
-        ended_at: attempt.endedAt,
-        duration_ms: attempt.durationMs,
-        exit_code: attempt.exitCode,
-        git_before: attempt.gitBefore,
-        git_after: attempt.gitAfter,
-        ...extra
+    const gitAfter = await getGitSnapshot(args.input.workdir);
+    await writeText(path.join(args.attemptDir, "stdout.log"), stdout);
+    await writeText(path.join(args.attemptDir, "stderr.log"), stderr);
+    await writeJson(path.join(args.attemptDir, "meta.json"), {
+        command: invocation.command,
+        args: invocation.args,
+        started_at: startedAt,
+        ended_at: new Date().toISOString(),
+        duration_ms: Date.now() - started,
+        exit_code: exitCode,
+        git_before: gitBefore,
+        git_after: gitAfter
     });
+    return { stdout, stderr, exitCode };
 }
-async function parseAndValidatePhaseResult(input) {
-    const parsed = parseNyxAgentResult(input.attempt.stdout);
+function parseAndValidate(schema, stdout) {
+    const parsed = parseNyxAgentResult(stdout);
     if (!parsed.ok) {
         return parsed;
     }
-    if (input.input.phase.output_schema) {
-        const schemaPath = resolveNyxPath(input.input.projectRoot, input.input.phase.output_schema, `output_schema for phase "${input.input.phase.id}"`);
-        const validation = await validateAgainstSchema(schemaPath, parsed.value);
-        if (!validation.ok) {
-            return validation;
-        }
-    }
-    if (input.input.phase.transitions && !getOutcome(parsed.value)) {
-        return {
-            ok: false,
-            error: `Phase "${input.input.phase.id}" has transitions but result has no string outcome`
-        };
-    }
-    const workItem = readObjectProperty(parsed.value, "work_item");
-    if (workItem !== undefined) {
-        const currentWorkItemKey = readObjectProperty(readObjectProperty(input.input.state, "work_item"), "key");
-        const workItemValidation = validateWorkItemIdentity({
-            config: input.input.config,
-            workItem,
-            availableWorkItems: readWorkItemCandidates(input.input.state.available_work_items),
-            seenWorkItemKeys: readStringArray(input.input.state.seen_work_item_keys),
-            completedWorkItemKeys: readStringArray(input.input.state.completed_work_item_keys),
-            allowKnownKey: typeof currentWorkItemKey === "string" ? currentWorkItemKey : undefined
-        });
-        if (!workItemValidation.ok) {
-            return workItemValidation;
-        }
+    const validation = validateAgainstSchema(schema, parsed.value);
+    if (!validation.ok) {
+        return validation;
     }
-    const workItems = readObjectProperty(parsed.value, "work_items");
-    if (workItems !== undefined) {
-        const workItemQueueValidation = validateWorkItemQueue({
-            config: input.input.config,
-            workItems,
-            availableWorkItems: readWorkItemCandidates(input.input.state.available_work_items),
-            seenWorkItemKeys: readStringArray(input.input.state.seen_work_item_keys),
-            completedWorkItemKeys: readStringArray(input.input.state.completed_work_item_keys)
-        });
-        if (!workItemQueueValidation.ok) {
-            return workItemQueueValidation;
-        }
-    }
-    await writeJson(path.join(input.phaseDir, "result.json"), parsed.value);
-    return {
-        ok: true,
-        result: parsed.value,
-        outcome: getOutcome(parsed.value)
-    };
+    return { ok: true, result: parsed.value };
 }
-async function repairStructuredResult(input) {
-    const maxAttempts = input.input.config.repair.max_attempts;
-    if (maxAttempts <= 0) {
-        return {
-            ok: false,
-            error: input.validationError
-        };
-    }
-    const repairPromptTemplate = await readText(resolveNyxPath(input.input.projectRoot, input.input.config.repair.prompt, "repair prompt"));
-    let lastError = input.validationError;
+async function repairResult(args) {
+    const maxAttempts = args.input.repairAttempts ?? 1;
+    let lastError = args.validationError;
     for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber += 1) {
-        const repairContext = buildContext({
-            ...input.input,
-            phaseDir: input.phaseDir
-        });
-        const renderedRepairPrompt = renderTemplate(repairPromptTemplate, {
-            ...repairContext,
-            original_prompt: input.originalPrompt,
-            original_stdout: input.originalAttempt.stdout,
-            original_stderr: input.originalAttempt.stderr,
-            validation_error: lastError
-        });
         const repairPrompt = [
-            "# NyxAgent Result Repair",
+            "# NyxAgent result repair",
+            "",
+            "Your previous response did not produce a valid structured result.",
+            "Do not redo the work and do not modify any files. Re-emit only the result.",
             "",
-            "Repair only the structured result for the previous phase attempt.",
-            "Do not modify project files. Do not redo the phase work.",
-            "Return a valid result inside the final <nyxagent_result> block.",
+            "Validation error:",
+            "```",
+            lastError,
+            "```",
             "",
-            renderedRepairPrompt
+            "Previous response:",
+            "```",
+            args.originalStdout,
+            "```",
+            "",
+            "Original prompt:",
+            "",
+            args.input.prompt
         ].join("\n");
-        const repairAttempt = await runHarnessAttempt({
-            attemptDir: path.join(input.phaseDir, `repair-${String(attemptNumber).padStart(3, "0")}`),
+        const attempt = await invokeHarness({
+            attemptDir: path.join(args.input.phaseDir, `repair-${String(attemptNumber).padStart(3, "0")}`),
+            input: args.input,
             prompt: repairPrompt,
-            context: repairContext,
-            config: input.input.config,
-            phase: input.input.phase,
-            workdir: input.input.workdir ?? input.input.projectRoot
+            forceReadonly: true
         });
-        if (repairAttempt.exitCode !== 0) {
-            lastError = `Repair harness exited with code ${repairAttempt.exitCode}`;
-            await writeAttemptMeta(repairAttempt, {
-                failure: lastError
-            });
+        if (attempt.exitCode !== 0) {
+            lastError = `Repair harness exited with code ${attempt.exitCode}`;
             continue;
         }
-        const repaired = await parseAndValidatePhaseResult({
-            input: input.input,
-            phaseDir: input.phaseDir,
-            attempt: repairAttempt
-        });
-        if (repaired.ok) {
-            return repaired;
+        const parsed = parseAndValidate(args.input.schema, attempt.stdout);
+        if (parsed.ok) {
+            return parsed;
         }
-        lastError = repaired.error;
-        await writeAttemptMeta(repairAttempt, {
-            result_error: repaired.error
-        });
+        lastError = parsed.error;
     }
     return {
         ok: false,
-        error: lastError
+        error: `Phase "${args.input.phaseId}" produced an invalid result: ${lastError}`
     };
 }
-function readObjectProperty(value, key) {
-    if (value &&
-        typeof value === "object" &&
-        Object.prototype.hasOwnProperty.call(value, key)) {
-        return value[key];
-    }
-    return undefined;
-}
-function readStringArray(value) {
-    if (!Array.isArray(value)) {
-        return undefined;
-    }
-    return value.filter((item) => typeof item === "string");
-}
-function readWorkItemCandidates(value) {
-    if (!Array.isArray(value)) {
-        return undefined;
-    }
-    return value.filter(isWorkItemCandidate);
-}
-function isWorkItemCandidate(value) {
-    const key = readObjectProperty(value, "key");
-    const title = readObjectProperty(value, "title");
-    const source = readObjectProperty(value, "source");
-    const type = readObjectProperty(source, "type");
-    const locator = readObjectProperty(source, "locator");
-    return (typeof key === "string" &&
-        typeof title === "string" &&
-        (type === "local" || type === "github") &&
-        typeof locator === "string");
-}