135 lines
7.5 KiB
JavaScript
135 lines
7.5 KiB
JavaScript
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import { spawnSync } from "node:child_process";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
|
|
const abs = (file) => path.join(root, file);
|
|
const read = (file) => fs.readFileSync(abs(file), "utf8");
|
|
const maxArg = process.argv.indexOf("--max-iterations");
|
|
const maxIterations = maxArg >= 0 ? Number(process.argv[maxArg + 1]) : 0;
|
|
if (!Number.isSafeInteger(maxIterations) || maxIterations < 0) throw new Error("--max-iterations must be a non-negative integer; 0 means unlimited");
|
|
const commitEnabled = process.argv.includes("--commit");
|
|
const pushEnabled = process.argv.includes("--push");
|
|
if (pushEnabled && !commitEnabled) throw new Error("--push requires --commit");
|
|
const pushRetryArg = process.argv.indexOf("--push-retries");
|
|
const pushRetries = pushRetryArg >= 0 ? Number(process.argv[pushRetryArg + 1]) : 6;
|
|
if (!Number.isSafeInteger(pushRetries) || pushRetries < 0) throw new Error("--push-retries must be a non-negative integer");
|
|
const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
|
|
|
|
function waitMs(milliseconds) {
|
|
if (milliseconds <= 0) return;
|
|
const wait = new Int32Array(new SharedArrayBuffer(4));
|
|
Atomics.wait(wait, 0, 0, milliseconds);
|
|
}
|
|
|
|
function command(command, logPath) {
|
|
const started = Date.now();
|
|
const result = spawnSync("bash", ["-lc", command], { cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
|
|
const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
|
|
if (logPath) fs.writeFileSync(abs(logPath), output);
|
|
return { code: result.status ?? 1, durationMs: Date.now() - started, output };
|
|
}
|
|
|
|
function currentTask() {
|
|
const queue = read("docs/EXECUTION_QUEUE.md");
|
|
const task = queue.match(/\| 当前任务 \| `(WBV2-P\d+-\d+)` \|/u)?.[1];
|
|
const parentManifest = queue.match(/\| parent manifest \| `([^`]+)` \|/u)?.[1];
|
|
if (!task || !parentManifest) throw new Error("queue pointer is incomplete");
|
|
return { task, parentManifest };
|
|
}
|
|
|
|
function terminalTask(task) {
|
|
try {
|
|
const index = JSON.parse(read("tests/golden/WBV2/task-index.json"));
|
|
const manifestPath = `tests/golden/${task}/manifest.json`;
|
|
const manifest = fs.existsSync(abs(manifestPath)) ? JSON.parse(read(manifestPath)) : null;
|
|
return index.activeTask === null && manifest?.task === task && manifest.status === "done" && manifest.nextTask === null;
|
|
}
|
|
catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function taskCommand(task) {
|
|
const card = read(`docs/tasks/${task}.md`);
|
|
const match = card.match(/- Implementation entrypoint: `([^`]+)`/u);
|
|
if (!match) throw new Error(`task card has no implementation entrypoint: ${task}`);
|
|
return match[1];
|
|
}
|
|
|
|
let iterations = 0;
|
|
const summary = [];
|
|
while (maxIterations === 0 || iterations < maxIterations) {
|
|
const before = currentTask();
|
|
// A completed V2 plan intentionally leaves the final task as an auditable
|
|
// pointer. Do not replay its implementation command on later unattended
|
|
// passes; close the runner cleanly at the terminal boundary.
|
|
if (terminalTask(before.task)) {
|
|
summary.push({ task: before.task, command: null, nextTask: null, terminal: true, log: null });
|
|
process.stdout.write(`continuous-terminal task=${before.task}\n`);
|
|
break;
|
|
}
|
|
const focused = taskCommand(before.task);
|
|
const logPath = `tests/golden/${before.task}/continuous-runner.log`;
|
|
const focusedResult = command(focused, logPath);
|
|
if (focusedResult.code !== 0) throw new Error(`${before.task} focused command failed (exit ${focusedResult.code}); log=${logPath}`);
|
|
const after = currentTask();
|
|
const terminal = after.task === before.task && terminalTask(before.task);
|
|
if (after.task === before.task && !terminal) throw new Error(`${before.task} focused command exited 0 without advancing queue; log=${logPath}`);
|
|
// Implementation cycles keep the post-handoff gate incremental. Full API,
|
|
// format, Chromium, performance and release gates belong to the explicit
|
|
// final audit and must not be repeated for every batch.
|
|
const gates = command(`python3 my-tools/validate_incremental_context.py --task ${before.task}`, `tests/golden/${before.task}/continuous-gates.log`);
|
|
if (gates.code !== 0) throw new Error(`${before.task} post-handoff gate failed (exit ${gates.code}); log=tests/golden/${before.task}/continuous-gates.log`);
|
|
iterations += 1;
|
|
summary.push({ task: before.task, command: focused, nextTask: terminal ? null : after.task, terminal, log: logPath });
|
|
process.stdout.write(`continuous-iteration=${iterations} task=${before.task} next=${after.task}\n`);
|
|
if (commitEnabled) {
|
|
const manifestPath = `tests/golden/${before.task}/manifest.json`;
|
|
const artifactPaths = fs.existsSync(abs(manifestPath))
|
|
? Object.values(JSON.parse(read(manifestPath).toString()).artifacts ?? {}).map((artifact) => artifact?.path).filter((file) => typeof file === "string")
|
|
: [];
|
|
const handoffPaths = [
|
|
"docs/EXECUTION_QUEUE.md",
|
|
`docs/tasks/${before.task}.md`,
|
|
...(terminal ? [] : [`docs/tasks/${after.task}.md`]),
|
|
`docs/status/${before.task}.md`,
|
|
...(terminal ? [] : [`docs/status/${after.task}.md`]),
|
|
manifestPath,
|
|
...artifactPaths,
|
|
"tests/golden/WBV2/task-index.json",
|
|
"tests/golden/WBV2/task-catalog.jsonl",
|
|
].filter((file, index, all) => file && all.indexOf(file) === index && fs.existsSync(abs(file)));
|
|
// Every path named by the manifest is part of the auditable handoff. Some
|
|
// task logs are intentionally ignored by the repository defaults, so use
|
|
// force-add for this exact, manifest-derived list instead of failing after
|
|
// the task has already produced a valid receipt.
|
|
const commit = command(`git add -f ${handoffPaths.map(shellQuote).join(" ")}`, `tests/golden/${before.task}/continuous-commit.log`);
|
|
if (commit.code !== 0) throw new Error(`${before.task} staging failed; log=tests/golden/${before.task}/continuous-commit.log`);
|
|
const commitResult = command(`git diff --cached --quiet || git commit -m "chore(web): continuous handoff ${before.task}"`, `tests/golden/${before.task}/continuous-commit-result.log`);
|
|
if (commitResult.code !== 0) throw new Error(`${before.task} commit failed; log=tests/golden/${before.task}/continuous-commit-result.log`);
|
|
if (pushEnabled) {
|
|
let pushed = false;
|
|
for (let attempt = 0; attempt <= pushRetries; attempt += 1) {
|
|
const pushLog = attempt === 0
|
|
? `tests/golden/${before.task}/continuous-push.log`
|
|
: `tests/golden/${before.task}/continuous-push-attempt-${attempt + 1}.log`;
|
|
const push = command("git push origin main", pushLog);
|
|
const pushVerification = command(
|
|
"local_head=$(git rev-parse --verify HEAD) && remote_head=$(git ls-remote --refs origin refs/heads/main | awk '$2 == \"refs/heads/main\" { print $1; exit }') && printf 'local_head=%s remote_head=%s\\n' \"$local_head\" \"$remote_head\" && test -n \"$remote_head\" && test \"$local_head\" = \"$remote_head\"",
|
|
`tests/golden/${before.task}/continuous-push-verify.log`,
|
|
);
|
|
if (pushVerification.code === 0) {
|
|
pushed = true;
|
|
break;
|
|
}
|
|
if (attempt < pushRetries) waitMs(Math.min(30000, 1000 * 2 ** attempt));
|
|
}
|
|
if (!pushed) throw new Error(`${before.task} remote push verification failed after ${pushRetries + 1} attempts; log=tests/golden/${before.task}/continuous-push-verify.log`);
|
|
}
|
|
}
|
|
if (terminal) break;
|
|
}
|
|
process.stdout.write(`continuous-run-complete iterations=${iterations} current=${currentTask().task} committed=${commitEnabled} pushed=${pushEnabled}\n`);
|