@tea-agent/loop-agent 0.1.0 → 0.2.1

package/dist/workflows/loop/actions/pi-review.js

@@ -0,0 +1,267 @@
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_PI_MODEL, DEFAULT_PI_PROVIDER, } from "../../../executors/pi-defaults.js";
+import { executeSingleSdkAttempt } from "../../../executors/pi-sdk-executor.js";
+import { writeLoopPiReviewPrompt, writeLoopPiReviewRecord, } from "../../../infrastructure/harness/loop-action-store.js";
+import { createOneShotActiveRunDir, transferOneShotRunToCompleted, transferOneShotRunToFailed, writeOneShotRunMarkdown, writeOneShotRunMeta, } from "../../../infrastructure/harness/one-shot-run-store.js";
+import { getLoopPaths } from "../paths.js";
+import { appendLoopRound } from "../rounds.js";
+import { rewriteLoopContext } from "../context.js";
+import { readLoopRounds } from "../rounds.js";
+import { latestVerificationSummary, relativeRef, truncateSummary } from "./shared.js";
+const PI_REVIEW_TOOLS = ["read", "grep", "find", "ls"];
+export async function buildLoopPiReviewPrompt(repoRoot, taskId) {
+    const paths = getLoopPaths(repoRoot, taskId);
+    const [objective, context, rounds] = await Promise.all([
+        readFile(paths.objectivePath, "utf-8"),
+        readFile(paths.contextPath, "utf-8"),
+        readLoopRounds(repoRoot, taskId),
+    ]);
+    return [
+        "You are running as a read-only loop-agent loop Pi review action.",
+        "Do not edit files. Do not run shell commands. Use only read, grep, find, and ls tools if tools are needed.",
+        "Review the current loop state and return exactly one JSON object with these fields:",
+        '{"findingSummary":"","failureCategory":"","nextHypothesis":"","recommendedAction":"implement_fix|replan|pause|done","fixScope":["path/or/component"],"rootCause":"","invariant":""}',
+        "recommendedAction must be exactly one of: implement_fix, replan, pause, done.",
+        "",
+        "<objective>",
+        objective.trim(),
+        "</objective>",
+        "",
+        "<context>",
+        context.trim(),
+        "</context>",
+        "",
+        "<latest_verification>",
+        latestVerificationSummary(rounds),
+        "</latest_verification>",
+    ].join("\n");
+}
+function parsePiReviewStructuredOutput(text) {
+    const trimmed = text.trim();
+    const jsonMatch = trimmed.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+        throw new Error("pi-review output did not contain a JSON object");
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    for (const key of [
+        "findingSummary",
+        "failureCategory",
+        "nextHypothesis",
+        "recommendedAction",
+        "rootCause",
+    ]) {
+        if (typeof parsed[key] !== "string" || parsed[key].trim().length === 0) {
+            throw new Error(`pi-review output missing structured field: ${key}`);
+        }
+    }
+    if (!Array.isArray(parsed.fixScope) || parsed.fixScope.length === 0) {
+        throw new Error("pi-review output missing structured field: fixScope");
+    }
+    const findingSummary = parsed.findingSummary;
+    const failureCategory = parsed.failureCategory;
+    const nextHypothesis = parsed.nextHypothesis;
+    const recommendedAction = parsed.recommendedAction;
+    const rootCause = parsed.rootCause;
+    if (typeof findingSummary !== "string" ||
+        typeof failureCategory !== "string" ||
+        typeof nextHypothesis !== "string" ||
+        typeof recommendedAction !== "string" ||
+        typeof rootCause !== "string") {
+        throw new Error("pi-review output failed structured field validation");
+    }
+    if (!isLoopPiReviewRecommendedAction(recommendedAction)) {
+        throw new Error(`pi-review output recommendedAction must be one of implement_fix|replan|pause|done, got: ${recommendedAction}`);
+    }
+    const fixScope = parsed.fixScope
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (fixScope.length === 0) {
+        throw new Error("pi-review output fixScope must contain at least one non-empty string");
+    }
+    return {
+        findingSummary: findingSummary.trim(),
+        failureCategory: failureCategory.trim(),
+        nextHypothesis: nextHypothesis.trim(),
+        recommendedAction,
+        fixScope,
+        rootCause: rootCause.trim(),
+        invariant: typeof parsed.invariant === "string" ? parsed.invariant.trim() : undefined,
+    };
+}
+function isLoopPiReviewRecommendedAction(value) {
+    return (value === "implement_fix" ||
+        value === "replan" ||
+        value === "pause" ||
+        value === "done");
+}
+async function defaultPiReviewExecutor(input) {
+    const startedAt = Date.now();
+    const result = await executeSingleSdkAttempt({
+        repoRoot: input.cwd,
+        prompt: "You are a read-only reviewer for loop-agent loop. Return only structured JSON.",
+        userMessage: input.prompt,
+        attachedFiles: [],
+        toolNames: [...input.toolNames],
+        timeoutMs: input.timeoutMs,
+        step: "analyze",
+        modelConfig: {
+            provider: input.provider,
+            model: input.model,
+        },
+    });
+    return {
+        ok: result.ok,
+        assistantText: result.assistantText,
+        durationMs: Date.now() - startedAt,
+        failureCategory: result.failureCategory,
+        stderr: result.stderr,
+    };
+}
+export async function readLatestPiReviewRecord(repoRoot, taskId) {
+    const paths = getLoopPaths(repoRoot, taskId);
+    let entries;
+    try {
+        entries = await readdir(paths.reviewDir);
+    }
+    catch {
+        return undefined;
+    }
+    const roundFiles = entries
+        .map((entry) => {
+        const match = entry.match(/^round-(\d+)\.json$/);
+        return match ? { entry, round: Number.parseInt(match[1], 10) } : undefined;
+    })
+        .filter((entry) => Boolean(entry))
+        .sort((a, b) => b.round - a.round);
+    for (const { entry } of roundFiles) {
+        try {
+            const parsed = JSON.parse(await readFile(path.join(paths.reviewDir, entry), "utf-8"));
+            if (parsed.action === "pi-review" && parsed.structured) {
+                return parsed;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+}
+export async function runLoopPiReview(repoRoot, taskId, options = {}) {
+    const provider = options.provider ?? DEFAULT_PI_PROVIDER;
+    const model = options.model ?? DEFAULT_PI_MODEL;
+    const timeoutMs = options.timeoutMs ?? 300_000;
+    const cwd = options.cwd ? path.resolve(repoRoot, options.cwd) : repoRoot;
+    const executor = options.executor ?? defaultPiReviewExecutor;
+    const rounds = await readLoopRounds(repoRoot, taskId);
+    const round = rounds.length + 1;
+    const paths = getLoopPaths(repoRoot, taskId);
+    const prompt = await buildLoopPiReviewPrompt(repoRoot, taskId);
+    const promptPath = path.join(paths.reviewDir, `round-${round}-prompt.md`);
+    await writeLoopPiReviewPrompt(repoRoot, taskId, round, prompt);
+    const result = await executor({
+        prompt,
+        cwd,
+        provider,
+        model,
+        timeoutMs,
+        toolNames: PI_REVIEW_TOOLS,
+    });
+    let structured;
+    let ok = result.ok;
+    let failureCategory = result.failureCategory ?? "";
+    try {
+        structured = parsePiReviewStructuredOutput(result.assistantText);
+    }
+    catch (error) {
+        ok = false;
+        failureCategory = "invalid-structured-output";
+        structured = {
+            findingSummary: error instanceof Error ? error.message : "pi-review output parse failed",
+            failureCategory,
+            nextHypothesis: "rerun pi-review with a stricter structured-output prompt",
+            recommendedAction: "pause",
+            fixScope: ["unknown"],
+            rootCause: "invalid pi-review structured output",
+            invariant: "do not write until review output is valid",
+        };
+    }
+    const targetLifecycle = ok ? "completed" : "failed";
+    const runBaseName = `${new Date().toISOString().slice(0, 10)}-${taskId}-pi-review-r${round}`;
+    const activeRunDir = await createOneShotActiveRunDir(repoRoot, runBaseName);
+    const runId = path.basename(activeRunDir);
+    const runMarkdown = [
+        "# Pi Review Run",
+        "",
+        "| Field | Value |",
+        "|---|---|",
+        `| taskId | ${taskId} |`,
+        `| status | ${ok ? "completed" : "failed"} |`,
+        `| provider | ${provider} |`,
+        `| model | ${model} |`,
+        `| tools | ${PI_REVIEW_TOOLS.join(",")} |`,
+        `| prompt | ${relativeRef(repoRoot, promptPath)} |`,
+        "",
+        "## Structured Output",
+        "",
+        "```json",
+        JSON.stringify(structured, null, 2),
+        "```",
+        "",
+        "## Assistant Text Summary",
+        "",
+        truncateSummary(result.assistantText || result.stderr || ""),
+        "",
+    ].join("\n");
+    await writeOneShotRunMarkdown(repoRoot, activeRunDir, runMarkdown);
+    await writeOneShotRunMeta(repoRoot, activeRunDir, {
+        runId,
+        taskId,
+        status: ok ? "completed" : "failed",
+        model,
+        provider,
+        channel: "pi-review",
+        cwd,
+        durationMs: result.durationMs,
+        failureCategory,
+        toolNames: PI_REVIEW_TOOLS,
+        logPath: "run.md",
+    });
+    const targetRunDir = targetLifecycle === "completed"
+        ? await transferOneShotRunToCompleted(repoRoot, activeRunDir, runId)
+        : await transferOneShotRunToFailed(repoRoot, activeRunDir, runId);
+    const runRef = relativeRef(repoRoot, path.join(targetRunDir, "run.md"));
+    const record = {
+        schemaVersion: 1,
+        taskId,
+        round,
+        action: "pi-review",
+        ok,
+        provider,
+        model,
+        toolNames: PI_REVIEW_TOOLS,
+        promptPath: relativeRef(repoRoot, promptPath),
+        runRef,
+        structured,
+        assistantTextSummary: truncateSummary(result.assistantText || result.stderr || ""),
+        failureCategory,
+        recordedAt: new Date().toISOString(),
+    };
+    await writeLoopPiReviewRecord(repoRoot, taskId, round, record);
+    await appendLoopRound(repoRoot, taskId, {
+        action: "pi-review",
+        refs: [runRef, relativeRef(repoRoot, path.join(paths.reviewDir, `round-${round}.json`))],
+        result: ok ? "pi review completed" : "pi review failed",
+        verification: ok
+            ? `pi-review structured output: ${structured.findingSummary}`
+            : `pi-review failed: ${structured.findingSummary}`,
+        lesson: structured.findingSummary,
+        next: structured.recommendedAction,
+        decision: "continue",
+        failureCategory: structured.failureCategory,
+        completedCriteria: ok ? ["pi read-only review action executed"] : [],
+    });
+    await rewriteLoopContext(repoRoot, taskId);
+    return record;
+}

package/dist/workflows/loop/actions/shared.js

@@ -0,0 +1,157 @@
+import path from "node:path";
+import { repoRelativePath, toPosixPath } from "../../../shared/path-refs.js";
+import { workflowReportSchema } from "../../dynamic/artifacts.js";
+import { normalizePattern } from "../policy/cursor-fix-policy.js";
+export const SUMMARY_LIMIT = 1200;
+export function truncateSummary(text) {
+    const normalized = text.trim();
+    if (normalized.length <= SUMMARY_LIMIT)
+        return normalized;
+    return `${normalized.slice(0, SUMMARY_LIMIT)}\n[truncated]`;
+}
+export function extractCommandsFromObjective(objective) {
+    const lines = objective.split("\n");
+    const commands = [];
+    let inVerification = false;
+    for (const line of lines) {
+        if (/^##\s+/.test(line)) {
+            inVerification = /verification|验证/i.test(line);
+            continue;
+        }
+        if (!inVerification)
+            continue;
+        const backtick = line.match(/`([^`]+)`/);
+        if (backtick?.[1]) {
+            commands.push(backtick[1]);
+            continue;
+        }
+        const bullet = line.match(/^[-*]\s+(.+)$/);
+        if (bullet?.[1] && !bullet[1].includes(":")) {
+            commands.push(bullet[1].trim());
+        }
+    }
+    return commands;
+}
+export function hasDagRound(rounds) {
+    return rounds.some((round) => round.action === "dag");
+}
+export function latestVerificationSummary(rounds) {
+    const latest = [...rounds].reverse().find((round) => round.verification.trim());
+    return latest
+        ? `${latest.verification}\nrefs=${latest.refs.join(", ")}`
+        : "No verification summary recorded yet.";
+}
+export function asRecord(value, label) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    throw new Error(`${label} did not return a JSON object`);
+}
+export function stringField(value, key, label) {
+    const raw = value[key];
+    if (typeof raw === "string" && raw.length > 0)
+        return raw;
+    throw new Error(`${label} missing string field: ${key}`);
+}
+export function optionalStringField(value, key) {
+    const raw = value[key];
+    return typeof raw === "string" ? raw : "";
+}
+export function relativeRef(repoRoot, value) {
+    if (!value)
+        return "";
+    return path.isAbsolute(value) ? repoRelativePath(repoRoot, value) : toPosixPath(value);
+}
+export function firstReportRun(report) {
+    const root = asRecord(report, "dag report");
+    const runs = root.runs;
+    if (!Array.isArray(runs) || runs.length === 0) {
+        throw new Error("dag report JSON did not contain any runs");
+    }
+    return asRecord(runs[0], "dag report run");
+}
+export function loopDecisionForDagRun(run) {
+    const lifecycle = optionalStringField(run, "lifecycle");
+    const status = optionalStringField(run, "status");
+    return lifecycle === "paused" || status === "paused" ? "pause" : "continue";
+}
+export function loopResultForDagRun(run) {
+    const lifecycle = optionalStringField(run, "lifecycle");
+    const status = optionalStringField(run, "status");
+    if (lifecycle === "paused" || status === "paused") {
+        return "dag run paused";
+    }
+    if (status === "finished")
+        return "dag run finished";
+    if (status === "partial_failed" || status === "failed") {
+        return `dag run ${status}`;
+    }
+    return `dag run status=${status || "unknown"}`;
+}
+export function dagFailureCategory(run) {
+    const raw = optionalStringField(run, "failureCategory");
+    if (raw)
+        return raw;
+    const status = optionalStringField(run, "status");
+    if (status === "partial_failed" || status === "failed")
+        return status;
+    return "";
+}
+export function summarizeWorkflowReport(raw) {
+    if (!raw?.trim()) {
+        return {
+            markdown: "# Workflow Report\n\nNo final workflow report output was emitted.\n",
+            verification: "workflow produced no final report output",
+            result: "workflow run finished without final report output",
+        };
+    }
+    try {
+        const parsed = workflowReportSchema.parse(JSON.parse(raw));
+        return {
+            markdown: [
+                "# Workflow Report",
+                "",
+                parsed.summary,
+                "",
+                `- Verified findings: ${parsed.verifiedFindings.length}`,
+                `- Uncertain findings: ${parsed.uncertainFindings.length}`,
+                `- Refuted findings ref: ${parsed.refutedFindingsRef ?? "none"}`,
+                "",
+            ].join("\n"),
+            verification: `${parsed.verifiedFindings.length} verified, ${parsed.uncertainFindings.length} uncertain`,
+            result: parsed.summary,
+        };
+    }
+    catch {
+        return {
+            markdown: `# Workflow Report\n\n${raw.trim()}\n`,
+            verification: "workflow final output was not a standard WorkflowReport",
+            result: "workflow run produced a non-standard final report",
+        };
+    }
+}
+export function workflowFailureCategory(nodes) {
+    for (const node of Object.values(nodes)) {
+        if (node.status === "ERROR")
+            return node.failureCategory ?? "workflow-node-error";
+    }
+    return "";
+}
+export function dagRunIdFromRef(ref) {
+    const normalized = ref.split(path.sep).join("/");
+    const match = normalized.match(/\.harness\/dag-runs\/paused\/([^/]+)/);
+    return match?.[1];
+}
+export function dagRunIdFromApprovalMessage(message) {
+    const match = message.match(/\brun[-_ ]?id\s*[:=]\s*([a-zA-Z0-9][a-zA-Z0-9_-]*)/i);
+    return match?.[1];
+}
+export function filterLoopOwnedChangedPaths(changedPaths, repoRoot, runDir) {
+    if (!runDir)
+        return changedPaths;
+    const runDirRelative = normalizePattern(relativeRef(repoRoot, runDir));
+    return changedPaths.filter((changedPath) => {
+        const normalized = normalizePattern(changedPath);
+        return normalized !== runDirRelative && !normalized.startsWith(`${runDirRelative}/`);
+    });
+}

package/dist/workflows/loop/actions/shell-verify.js

@@ -0,0 +1,82 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { executeShellCommand } from "../../../executors/shell-executor.js";
+import { writeLoopShellVerifyRecord } from "../../../infrastructure/harness/loop-action-store.js";
+import { getTaskPaths } from "../../../task/runtime.js";
+import { getLoopPaths } from "../paths.js";
+import { appendLoopRound } from "../rounds.js";
+import { rewriteLoopContext } from "../context.js";
+import { readLoopRounds } from "../rounds.js";
+import { extractCommandsFromObjective, relativeRef, truncateSummary } from "./shared.js";
+export async function resolveLoopShellVerifyCommands(repoRoot, taskId, explicitCommands = []) {
+    const commands = explicitCommands
+        .map((command) => command.trim())
+        .filter(Boolean);
+    if (commands.length > 0)
+        return commands;
+    const objective = await readFile(getLoopPaths(repoRoot, taskId).objectivePath, "utf-8");
+    const objectiveCommands = extractCommandsFromObjective(objective);
+    if (objectiveCommands.length > 0)
+        return objectiveCommands;
+    const constraints = await readFile(path.join(getTaskPaths(repoRoot, taskId).sourceDir, "执行约束.md"), "utf-8").catch(() => "");
+    const constraintCommands = extractCommandsFromObjective(constraints);
+    if (constraintCommands.length > 0)
+        return constraintCommands;
+    throw new Error("loop shell-verify requires at least one --command or verification commands in objective.md");
+}
+export async function runLoopShellVerification(repoRoot, taskId, options = {}) {
+    const commands = await resolveLoopShellVerifyCommands(repoRoot, taskId, options.commands);
+    const rounds = await readLoopRounds(repoRoot, taskId);
+    const round = rounds.length + 1;
+    const cwd = options.cwd ? path.resolve(repoRoot, options.cwd) : repoRoot;
+    const timeoutMs = options.timeoutMs ?? 300_000;
+    const results = [];
+    for (const command of commands) {
+        results.push(await executeShellCommand({ command, cwd, timeoutMs }));
+    }
+    const ok = results.every((result) => result.ok);
+    const paths = getLoopPaths(repoRoot, taskId);
+    const verificationPath = path.join(paths.verificationDir, `round-${round}.json`);
+    const record = {
+        schemaVersion: 1,
+        taskId,
+        round,
+        action: "shell-verify",
+        ok,
+        commandCount: commands.length,
+        results: results.map((result) => ({
+            command: result.command,
+            cwd: relativeRef(repoRoot, result.cwd) || ".",
+            durationMs: result.durationMs,
+            exitCode: result.exitCode,
+            failureCategory: result.failureCategory,
+            ok: result.ok,
+            timedOut: result.timedOut,
+            stdoutSummary: truncateSummary(result.stdout),
+            stderrSummary: truncateSummary(result.stderr),
+        })),
+        recordedAt: new Date().toISOString(),
+    };
+    await writeLoopShellVerifyRecord(repoRoot, taskId, round, record);
+    const failed = results.find((result) => !result.ok);
+    const verification = ok
+        ? `passed: ${commands.join(" && ")}`
+        : `failed: ${failed?.command ?? commands[0]} (${failed?.failureCategory ?? "unknown"})`;
+    await appendLoopRound(repoRoot, taskId, {
+        action: "shell-verify",
+        refs: [relativeRef(repoRoot, verificationPath)],
+        result: ok ? "verification passed" : "verification failed",
+        verification,
+        lesson: ok
+            ? "deterministic shell verification passed"
+            : "deterministic shell verification failed; inspect verification ref before another implementation round",
+        next: ok
+            ? "evaluate success criteria coverage"
+            : "fix the failing verification command",
+        decision: ok ? "continue" : "continue",
+        failureCategory: ok ? undefined : failed?.failureCategory,
+        completedCriteria: ok ? ["shell verification action executed"] : [],
+    });
+    await rewriteLoopContext(repoRoot, taskId);
+    return record;
+}

package/dist/workflows/loop/actions/types.js

@@ -0,0 +1 @@
+export {};