@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/executors/shell-presets.js

@@ -0,0 +1,99 @@
+/** Preset command lists run before explicit `shell.commands` (deterministic ordering). */
+export const DAG_SHELL_PRESETS = {
+    "loop-agent-standard-verify": [
+        "npm run lint",
+        "npm run typecheck",
+        "npx vitest run test/dag-shell-executor.test.ts test/dag-validate.test.ts test/dag-runner.test.ts --reporter=dot",
+    ],
+};
+export function expandShellPreset(preset) {
+    return [...DAG_SHELL_PRESETS[preset]];
+}
+function escapeShellSingleQuoted(value) {
+    return value.replace(/'/g, "'\\''");
+}
+/**
+ * Build a single shell command that reads `$HARNESS_DAG_RUN_DIR/<fromNodeId>.json`
+ * (injected by the shell executor from runtime meta), parses a single candidate
+ * verdict from `assistantText ?? stdout`, and accepts only exact verdict values.
+ * Sources:
+ * - verdict-line: line-based legacy VERDICT protocol
+ * - json-review-verdict: structured review JSON with verdict: pass/request-revision
+ * Modes:
+ * - first-non-empty: first non-empty line
+ * - first-verdict-line: first line matching /^VERDICT:/ after trim and optional whole-line Markdown emphasis normalization
+ *
+ * Implemented as one pure `node -e` invocation (no bash state/subshell chaining) so Windows
+ * Git Bash cannot crash the gate with STATUS_DLL_INIT_FAILED on long compound scripts.
+ */
+export function buildVerdictGateShellCommand(gate) {
+    const gateLabel = gate.label ?? `${gate.fromNodeId} verdict`;
+    const source = gate.source ?? "verdict-line";
+    const lineMode = gate.lineMode ?? "first-non-empty";
+    const candidateNodeIds = [
+        gate.fromNodeId,
+        ...(gate.fallbackFromNodeIds ?? []).filter((id) => id !== gate.fromNodeId),
+    ];
+    const config = {
+        label: gateLabel,
+        source,
+        lineMode,
+        accept: gate.accept,
+        routingAccept: gate.routingAccept ?? [],
+        candidateNodeIds,
+    };
+    const configLiteral = escapeShellSingleQuoted(JSON.stringify(config));
+    const program = [
+        'const fs=require("fs");',
+        'const path=require("path");',
+        'const cfg=JSON.parse(process.argv[1]);',
+        'const runDir=process.env.HARNESS_DAG_RUN_DIR;',
+        'if(!runDir){console.error("missing HARNESS_DAG_RUN_DIR for "+cfg.label+" gate");process.exit(1);}',
+        'let file="";',
+        'for(const id of cfg.candidateNodeIds){const candidate=path.join(runDir,id+".json");if(fs.existsSync(candidate)){file=candidate;break;}}',
+        'if(!file){console.error("missing "+cfg.label+" JSON output (tried: "+cfg.candidateNodeIds.join(", ")+")");process.exit(1);}',
+        'const raw=JSON.parse(fs.readFileSync(file,"utf8"));',
+        'const text=String(raw.assistantText ?? raw.stdout ?? "");',
+        'const extractJson=(value)=>{const text=String(value).trim();const fenced=[...text.matchAll(/```(?:json)?\\s*([\\s\\S]*?)\\s*```/gi)];const source=fenced.length===1?String(fenced[0][1]).trim():text;for(let start=0;start<source.length;start+=1){if(source[start]!=="{")continue;let depth=0,inString=false,escaped=false;for(let i=start;i<source.length;i+=1){const ch=source[i];if(inString){if(escaped){escaped=false;}else if(ch==="\\\\"){escaped=true;}else if(ch===String.fromCharCode(34)){inString=false;}continue;}if(ch===String.fromCharCode(34)){inString=true;continue;}if(ch==="{"){depth+=1;}else if(ch===String.fromCharCode(125)){depth-=1;if(depth===0){const candidate=source.slice(start,i+1);try{const parsed=JSON.parse(candidate);if(parsed&&typeof parsed==="object"&&!Array.isArray(parsed))return candidate;}catch{}break;}}}}return "";};',
+        'let first="";',
+        'if(cfg.source==="json-review-verdict"){const jsonText=extractJson(text);if(!jsonText){console.error(cfg.label+" gate blocked: missing JSON review verdict");process.exit(1);}let parsed;try{parsed=JSON.parse(jsonText);}catch(error){console.error(cfg.label+" gate blocked: invalid JSON review verdict: "+error.message);process.exit(1);}first=String(parsed&&parsed.verdict||"");}',
+        'const normalize=(value)=>{const trimmed=String(value).trim();const emphasized=trimmed.match(/^\\*{1,3}\\s*(VERDICT:[^*]+?)\\s*\\*{1,3}$/);return (emphasized?emphasized[1]:trimmed).trim();};',
+        'if(cfg.source!=="json-review-verdict"){const lines=text.split(/\\r?\\n/).map(normalize);first=cfg.lineMode==="first-verdict-line"? (lines.find((value)=>/^VERDICT:/.test(value))??"") : (lines.find((value)=>value.length>0)??"");}',
+        'const routing=Array.isArray(cfg.routingAccept)?cfg.routingAccept:[];if(!cfg.accept.includes(first)&&!routing.includes(first)){console.error(cfg.label+" gate blocked: "+(first|| (cfg.source==="json-review-verdict"?"missing JSON verdict":"missing VERDICT line")));process.exit(1);}',
+        'process.stdout.write(first+"\\n");',
+    ].join("");
+    return `node -e '${escapeShellSingleQuoted(program)}' '${configLiteral}'`;
+}
+/** Build a deterministic current-run gate over exact REQ-/BR-/AC- ids in node facts. */
+export function buildRequirementCoverageGateShellCommand(gate) {
+    const label = gate.label ?? "requirement coverage";
+    const requiredJson = escapeShellSingleQuoted(JSON.stringify(gate.requiredIds.map((id) => id.toUpperCase())));
+    const sourceConfig = {
+        primary: gate.fromNodeIds,
+        fallback: [
+            ...new Set((gate.fallbackFromNodeIds ?? []).filter((nodeId) => !gate.fromNodeIds.includes(nodeId))),
+        ],
+    };
+    const program = [
+        'const fs=require("fs");',
+        'const path=require("path");',
+        "const required=JSON.parse(process.argv[1]);",
+        `const sources=${JSON.stringify(sourceConfig)};`,
+        "let files=sources.primary.map((id)=>path.join(process.env.HARNESS_DAG_RUN_DIR,id+'.json'));",
+        "if(sources.fallback.length){",
+        " files=[]; const candidates=[sources.primary[0],...sources.fallback];",
+        " for(const id of candidates){const file=path.join(process.env.HARNESS_DAG_RUN_DIR,id+'.json'); try{fs.statSync(file);files=[file];break;}catch(error){if(error&&error.code==='ENOENT')continue;throw error;}}",
+        ` if(!files.length){console.error(${JSON.stringify(`${label} gate blocked: missing node output (tried: `)}+[sources.primary[0],...sources.fallback].join(', ')+')');process.exit(1);}`,
+        "}",
+        "let text='';",
+        "for(const file of files){",
+        " if(!fs.existsSync(file)){console.error('missing requirement coverage node output: '+file);process.exit(1);}",
+        " const raw=JSON.parse(fs.readFileSync(file,'utf8')); text+='\\n'+String(raw.assistantText ?? raw.stdout ?? '');",
+        "}",
+        "const found=new Set((text.toUpperCase().match(/\\b(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*\\b/g)||[]));",
+        "const missing=required.filter((id)=>!found.has(id));",
+        `if(missing.length){console.error(${JSON.stringify(`${label} gate blocked: missing `)}+missing.join(', '));process.exit(1);}`,
+        `console.log(${JSON.stringify(`${label} gate passed: `)}+required.join(', '));`,
+    ].join("");
+    return `test -n "\${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for ${label} gate" >&2; exit 1; }; node -e '${escapeShellSingleQuoted(program)}' '${requiredJson}'`;
+}

package/dist/executors/shell-verification.js

@@ -0,0 +1,262 @@
+import { spawn } from "node:child_process";
+import { processTreeSpawnOptions, terminateProcessTree } from "./process-tree.js";
+export const DEFAULT_VERIFY_TIMEOUT_MS = 1_800_000;
+const VERIFY_ENV_ALLOWLIST = [
+    "HOME",
+    "PATH",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "TERM",
+    "CI",
+    "NODE_OPTIONS",
+    "NODE_PATH",
+    "PNPM_HOME",
+    "COREPACK_ENABLE",
+    "COREPACK_ENABLE_AUTO_PIN",
+    "COREPACK_HOME",
+    // Windows DLL 加载必需
+    "SystemRoot",
+    "SYSTEMROOT",
+    "windir",
+    "WINDIR",
+    "ComSpec",
+    "PATHEXT",
+    // Python/pip and other Windows per-user tools discover user installs here.
+    "APPDATA",
+];
+export function buildVerifyProcessEnv(mode = "clean") {
+    if (mode === "inherit") {
+        return { ...process.env };
+    }
+    const env = { CI: "true" };
+    for (const key of VERIFY_ENV_ALLOWLIST) {
+        const value = process.env[key];
+        if (value !== undefined && value !== "") {
+            env[key] = value;
+        }
+    }
+    return env;
+}
+/** Clean verify env plus explicitly allowlisted host variables (no broad passthrough). */
+export function buildShellProcessEnv(envAllowlist, injected) {
+    const env = buildVerifyProcessEnv("clean");
+    if (envAllowlist) {
+        for (const key of envAllowlist) {
+            const value = process.env[key];
+            if (value !== undefined) {
+                env[key] = value;
+            }
+        }
+    }
+    if (injected) {
+        for (const [key, value] of Object.entries(injected)) {
+            env[key] = value;
+        }
+    }
+    return env;
+}
+export function extractLastFailureCategory(verifyReportText) {
+    const categoryLine = verifyReportText.match(/- category:\s*([a-z0-9-]+)/i);
+    if (categoryLine?.[1])
+        return categoryLine[1].toLowerCase();
+    const kindLine = verifyReportText.match(/:\s*(environment-failure|governance-failure|typecheck-failure|test-failure|verify-failure|timeout)/i);
+    return kindLine?.[1]?.toLowerCase();
+}
+export function renderVerifyReport(results) {
+    const passed = results.filter((result) => result.ok);
+    const failed = results.filter((result) => !result.ok);
+    const commandBlock = results
+        .map((result) => result.args.join(" "))
+        .join("\n");
+    const passedList = passed.length > 0
+        ? passed.map((result) => `- ${result.label}`).join("\n")
+        : "- 无";
+    const failedList = failed.length > 0
+        ? failed
+            .map((result) => `- ${result.label}${result.timedOut ? " (TIMEOUT)" : ""}`)
+            .join("\n")
+        : "- 无";
+    const failureKinds = failed.length > 0
+        ? failed
+            .map((result) => `- ${result.label}: ${result.failureCategory ?? "unknown"}${result.attempts > 1 ? ` (attempts=${result.attempts})` : ""}`)
+            .join("\n")
+        : "- 无";
+    const failureSummary = failed.length > 0
+        ? failed
+            .map((result) => `- ${result.label}${result.timedOut ? " [TIMEOUT]" : ""}: ${summarize(result.stderr || result.stdout)}`)
+            .join("\n")
+        : "- 无";
+    const commandDetails = results
+        .map((result) => [
+        `### ${result.label}`,
+        `- command: \`${result.args.join(" ")}\``,
+        `- cwd: \`${result.cwd}\``,
+        `- exitCode: ${result.exitCode ?? "null"}`,
+        `- attempts: ${result.attempts}`,
+        `- category: ${result.failureCategory ?? (result.ok ? "success" : "unknown")}`,
+        `- durationMs: ${result.durationMs}`,
+    ].join("\n"))
+        .join("\n\n");
+    const nextStep = failed.length > 0
+        ? "- [ ] 进入修复子循环\n- [ ] 需要人工判断失败原因是否由环境导致"
+        : "- [x] 无需继续修复\n- [ ] 可进入 retrospective";
+    return [
+        "# 验证结果",
+        "",
+        "## 1. 执行的命令",
+        "```bash",
+        commandBlock,
+        "```",
+        "",
+        "## 2. 通过项",
+        passedList,
+        "",
+        "## 3. 失败项",
+        failedList,
+        "",
+        "## 4. 失败摘要",
+        failureSummary,
+        "",
+        "## 5. 失败分类",
+        failureKinds,
+        "",
+        "## 6. 命令详情",
+        commandDetails,
+        "",
+        "## 7. 下一步建议",
+        nextStep,
+        "",
+    ].join("\n");
+}
+export async function executeCommand(command, defaultTimeoutMs = DEFAULT_VERIFY_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const [binary, ...args] = command.args;
+        const timeoutMs = command.timeoutMs ?? defaultTimeoutMs;
+        const startedAt = Date.now();
+        const child = spawn(binary, args, {
+            cwd: command.cwd,
+            env: command.env ?? process.env,
+            ...processTreeSpawnOptions(),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let timeoutHandle;
+        let sigkillHandle;
+        child.stdout.setEncoding("utf-8");
+        child.stderr.setEncoding("utf-8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (sigkillHandle)
+                clearTimeout(sigkillHandle);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            if (sigkillHandle)
+                clearTimeout(sigkillHandle);
+            resolve({
+                ...command,
+                attempts: 1,
+                durationMs: Date.now() - startedAt,
+                exitCode: code,
+                failureCategory: classifyVerifyCommandFailure(command, code, timedOut, stderr, stdout),
+                ok: code === 0,
+                stderr,
+                stdout,
+                timedOut,
+            });
+        });
+        if (timeoutMs > 0) {
+            timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                terminateProcessTree(child, "SIGTERM");
+                sigkillHandle = setTimeout(() => {
+                    if (child.exitCode === null) {
+                        terminateProcessTree(child, "SIGKILL");
+                    }
+                }, 5_000);
+            }, timeoutMs);
+        }
+    });
+}
+export async function executeVerifyCommands(commands, defaultTimeoutMs, options) {
+    if (options.mode === "parallel") {
+        return Promise.all(commands.map((command) => executeCommandWithRetry(command, defaultTimeoutMs, options.retryCount)));
+    }
+    const results = [];
+    for (const command of commands) {
+        const result = await executeCommandWithRetry(command, defaultTimeoutMs, options.retryCount);
+        results.push(result);
+        if (options.failFast && !result.ok) {
+            break;
+        }
+    }
+    return results;
+}
+async function executeCommandWithRetry(command, defaultTimeoutMs, retryCount) {
+    let lastResult = await executeCommand(command, defaultTimeoutMs);
+    let attempts = 1;
+    while (!lastResult.ok && attempts <= retryCount) {
+        attempts += 1;
+        lastResult = await executeCommand(command, defaultTimeoutMs);
+    }
+    return {
+        ...lastResult,
+        attempts,
+    };
+}
+export function summarizeVerifyFailure(results) {
+    const firstFailure = results.find((result) => !result.ok);
+    if (!firstFailure)
+        return "success";
+    return firstFailure.failureCategory ?? "verify-failure";
+}
+function classifyVerifyCommandFailure(command, exitCode, timedOut, stderr, stdout) {
+    if (timedOut)
+        return "timeout";
+    if (exitCode === 0)
+        return "success";
+    const joined = `${command.label} ${command.args.join(" ")} ${stderr} ${stdout}`.toLowerCase();
+    if (joined.includes("check-repo") || joined.includes("governance"))
+        return "governance-failure";
+    if (/pnpm.*configured to use|corepack invoked pnpm|packagemanager|cannot find pnpm|enoent.*pnpm/.test(joined)) {
+        return "environment-failure";
+    }
+    if (joined.includes("typecheck") || joined.includes("tsc"))
+        return "typecheck-failure";
+    if (joined.includes("test"))
+        return "test-failure";
+    if (/not found|enoent/.test(joined))
+        return "environment-failure";
+    return "verify-failure";
+}
+function summarize(text) {
+    return text.replace(/\s+/g, " ").trim().slice(0, 240) || "no output captured";
+}
+export function resolveVerifyPreset(preset, taskConfig) {
+    if (!preset || preset === "auto") {
+        if (taskConfig.complexity === "small")
+            return "quick";
+        if (taskConfig.complexity === "large")
+            return "full";
+        return "standard";
+    }
+    return preset;
+}