patchwarden 0.6.4 → 1.5.0

package/dist/test/unit/evidence-pack.test.js

@@ -0,0 +1,130 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { reloadConfig } from "../../config.js";
+import { recommendAgentForTask } from "../../tools/recommendAgentForTask.js";
+import { exportTaskEvidencePack, listEvidencePacks, readEvidencePack } from "../../tools/evidencePack.js";
+import { writeTaskLineage } from "../../tools/taskLineage.js";
+let tempDir;
+let prevConfigEnv;
+function writeConfig() {
+    const configPath = join(tempDir, "patchwarden.config.json");
+    writeFileSync(configPath, JSON.stringify({
+        workspaceRoot: tempDir,
+        tasksDir: ".patchwarden/tasks",
+        plansDir: ".patchwarden/plans",
+        assessmentsDir: ".patchwarden/assessments",
+        agents: {
+            codex: { command: "codex", args: [] },
+            opencode: { command: "opencode", args: [] },
+        },
+        allowedTestCommands: ["npm test", "npm run build"],
+        defaultTaskTimeoutSeconds: 30,
+        maxTaskTimeoutSeconds: 120,
+    }), "utf-8");
+    prevConfigEnv = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = configPath;
+    reloadConfig();
+}
+describe("v1.5 evidence packs and agent recommendations", () => {
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "pw-evidence-"));
+        writeConfig();
+    });
+    afterEach(() => {
+        if (prevConfigEnv === undefined)
+            delete process.env.PATCHWARDEN_CONFIG;
+        else
+            process.env.PATCHWARDEN_CONFIG = prevConfigEnv;
+        reloadConfig();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("recommends an agent without creating task evidence", () => {
+        const recommendation = recommendAgentForTask({
+            repo_path: ".",
+            goal: "Refactor two modules safely",
+            scope_files: ["src/a.ts", "src/b.ts"],
+        });
+        assert.equal(recommendation.bounded, true);
+        assert.ok(["codex", "opencode"].includes(recommendation.recommended_agent));
+        assert.ok(Array.isArray(recommendation.suggested_verify_commands));
+        const payload = JSON.stringify(recommendation);
+        assert.ok(!payload.includes("stdout"));
+        assert.ok(!payload.includes("stderr"));
+        assert.ok(!payload.includes("diff"));
+    });
+    it("exports bounded BOM-free evidence pack from lineage", () => {
+        writeTaskLineage({
+            lineage_id: "lineage_v15_pack",
+            goal: "Export evidence",
+            repo_path: ".",
+            created_at: "2026-07-05T12:00:00.000Z",
+            updated_at: "2026-07-05T12:01:00.000Z",
+            final_status: "accepted",
+            stop_reason: "success",
+            next_action: "accept",
+            main_task: "task-main",
+            fix_tasks: [],
+            cleanup_tasks: [],
+            direct_sessions: [{
+                    session_id: "direct-one",
+                    status: "passed",
+                    command_count: 1,
+                    passed_commands: 1,
+                    failed_commands: 0,
+                    timed_out_commands: 0,
+                    audit_decision: "pass",
+                    changed_files_total: 0,
+                    next_action: "accept",
+                }],
+            rounds: [{
+                    iteration: 1,
+                    task_id: "task-main",
+                    role: "main",
+                    status: "done_by_agent",
+                    terminal: true,
+                    verification_status: "passed",
+                    audit_verdict: "pass",
+                    fail_checks: [],
+                    warn_checks: [],
+                    next_action: "accept",
+                }],
+            warnings: [],
+            errors: [],
+            worktree: {
+                isolation_mode: "worktree",
+                worktree_id: "wt-one",
+                worktree_path: join(tempDir, "_workspacetrees", "wt-one"),
+                branch: "pw-test",
+                cleanup: "keep",
+                status: "active",
+                next_action: "merge or discard explicitly",
+            },
+            agent_routing: {
+                requested_agent: "auto",
+                selected_agent: "codex",
+                reason: "test route",
+                fallback: false,
+            },
+        });
+        const pack = exportTaskEvidencePack({ lineage_id: "lineage_v15_pack" });
+        assert.equal(pack.bounded, true);
+        assert.equal(pack.lineage.worktree.worktree_id, "wt-one");
+        assert.equal(pack.lineage.agent_routing?.selected_agent, "codex");
+        const raw = readFileSync(pack.files.json);
+        assert.notEqual(raw[0], 0xef);
+        JSON.parse(raw.toString("utf-8"));
+        const payload = JSON.stringify(pack);
+        assert.ok(!payload.includes("stdout_tail"));
+        assert.ok(!payload.includes("stderr_tail"));
+        assert.ok(!payload.includes("diff.patch"));
+        assert.ok(!payload.includes("verification.log"));
+        const readBack = readEvidencePack("lineage_v15_pack");
+        assert.equal(readBack?.lineage_id, "lineage_v15_pack");
+        const listed = listEvidencePacks();
+        assert.equal(listed.total, 1);
+        assert.equal(listed.evidence_packs[0].lineage_id, "lineage_v15_pack");
+    });
+});

package/dist/test/unit/goal-graph.test.d.ts

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

package/dist/test/unit/goal-graph.test.js

@@ -0,0 +1,298 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { getReadySubgoals, getBlockedSubgoals, suggestNextSubgoal, detectCycle, topologicalSort, } from "../../goal/goalGraph.js";
+import { PatchWardenError } from "../../errors.js";
+// ── Helpers ───────────────────────────────────────────────────────
+function makeSubgoal(overrides) {
+    return {
+        title: "Subgoal " + overrides.id,
+        status: "ready",
+        depends_on: [],
+        task_ids: [],
+        ...overrides,
+    };
+}
+function makeGoalStatus(subgoals, overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        goal_id: "goal_test_001",
+        title: "Test Goal",
+        status: "active",
+        repo_path: "/repo/test",
+        created_at: now,
+        updated_at: now,
+        subgoals,
+        ...overrides,
+    };
+}
+// ── Tests ─────────────────────────────────────────────────────────
+describe("goalGraph", () => {
+    describe("getReadySubgoals", () => {
+        it("无 subgoal 返回空数组", () => {
+            const goal = makeGoalStatus([]);
+            assert.deepEqual(getReadySubgoals(goal), []);
+        });
+        it("ready 且无依赖 → 返回", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+            ]);
+            const ready = getReadySubgoals(goal);
+            assert.equal(ready.length, 1);
+            assert.equal(ready[0].id, "subgoal-001");
+        });
+        it("ready 但依赖未 accepted → 不返回", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "running" }),
+                makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+            ]);
+            const ready = getReadySubgoals(goal);
+            assert.equal(ready.length, 0);
+        });
+        it("ready 且依赖已 accepted → 返回", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+                makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+            ]);
+            const ready = getReadySubgoals(goal);
+            assert.equal(ready.length, 1);
+            assert.equal(ready[0].id, "subgoal-002");
+        });
+        it("非 ready 状态（running 等）→ 不返回", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "running" }),
+                makeSubgoal({ id: "subgoal-002", status: "done_by_agent" }),
+                makeSubgoal({ id: "subgoal-003", status: "accepted" }),
+            ]);
+            const ready = getReadySubgoals(goal);
+            assert.equal(ready.length, 0);
+        });
+        it("依赖引用不存在的 subgoal → 不返回", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: ["subgoal-999"] }),
+            ]);
+            const ready = getReadySubgoals(goal);
+            assert.equal(ready.length, 0);
+        });
+        it("不修改传入的 goalStatus（不可变）", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+            ]);
+            const snapshot = JSON.stringify(goal);
+            getReadySubgoals(goal);
+            assert.equal(JSON.stringify(goal), snapshot);
+        });
+    });
+    describe("getBlockedSubgoals", () => {
+        it("无 blocked 返回空数组", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+                makeSubgoal({ id: "subgoal-002", status: "running" }),
+            ]);
+            assert.deepEqual(getBlockedSubgoals(goal), []);
+        });
+        it("ready 但依赖 running → 返回，blocked_by 包含该 id", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "running" }),
+                makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+            ]);
+            const blocked = getBlockedSubgoals(goal);
+            assert.equal(blocked.length, 1);
+            assert.equal(blocked[0].subgoal.id, "subgoal-002");
+            assert.deepEqual(blocked[0].blocked_by, ["subgoal-001"]);
+        });
+        it("依赖引用不存在 → blocked_by 包含该不存在的 id", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: ["subgoal-999"] }),
+            ]);
+            const blocked = getBlockedSubgoals(goal);
+            assert.equal(blocked.length, 1);
+            assert.equal(blocked[0].subgoal.id, "subgoal-001");
+            assert.deepEqual(blocked[0].blocked_by, ["subgoal-999"]);
+        });
+        it("依赖部分 accepted 部分 running → blocked_by 只含未 accepted 的", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+                makeSubgoal({ id: "subgoal-002", status: "running" }),
+                makeSubgoal({ id: "subgoal-003", depends_on: ["subgoal-001", "subgoal-002"] }),
+            ]);
+            const blocked = getBlockedSubgoals(goal);
+            assert.equal(blocked.length, 1);
+            assert.deepEqual(blocked[0].blocked_by, ["subgoal-002"]);
+        });
+        it("非 ready 状态的 subgoal 不计入 blocked", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "running", depends_on: ["subgoal-999"] }),
+            ]);
+            const blocked = getBlockedSubgoals(goal);
+            assert.equal(blocked.length, 0);
+        });
+    });
+    describe("suggestNextSubgoal", () => {
+        it("有 ready → 返回第一个 ready", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+            ]);
+            const suggestion = suggestNextSubgoal(goal);
+            assert.equal(suggestion.subgoal_id, "subgoal-001");
+            assert.equal(suggestion.title, "Subgoal subgoal-001");
+            assert.deepEqual(suggestion.depends_on, []);
+            assert.equal(suggestion.reason, undefined);
+        });
+        it("无 ready 有 blocked → 返回 null + blocked_by", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "running" }),
+                makeSubgoal({ id: "subgoal-002", depends_on: ["subgoal-001"] }),
+            ]);
+            const suggestion = suggestNextSubgoal(goal);
+            assert.equal(suggestion.subgoal_id, null);
+            assert.equal(suggestion.reason, "dependencies_not_met");
+            assert.deepEqual(suggestion.blocked_by, ["subgoal-002"]);
+        });
+        it("无 ready 无 blocked → 返回 null + no_ready_subgoal", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+                makeSubgoal({ id: "subgoal-002", status: "running" }),
+            ]);
+            const suggestion = suggestNextSubgoal(goal);
+            assert.equal(suggestion.subgoal_id, null);
+            assert.equal(suggestion.reason, "no_ready_subgoal");
+            assert.equal(suggestion.blocked_by, undefined);
+        });
+        it("多个 ready → 返回数组顺序第一个", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+                makeSubgoal({ id: "subgoal-002", depends_on: [] }),
+                makeSubgoal({ id: "subgoal-003", depends_on: [] }),
+            ]);
+            const suggestion = suggestNextSubgoal(goal);
+            assert.equal(suggestion.subgoal_id, "subgoal-001");
+        });
+        it("空 subgoals → no_ready_subgoal", () => {
+            const goal = makeGoalStatus([]);
+            const suggestion = suggestNextSubgoal(goal);
+            assert.equal(suggestion.subgoal_id, null);
+            assert.equal(suggestion.reason, "no_ready_subgoal");
+        });
+    });
+    describe("detectCycle", () => {
+        it("无依赖无环", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", depends_on: [] }),
+                makeSubgoal({ id: "subgoal-002", depends_on: [] }),
+            ]);
+            assert.equal(detectCycle(goal), null);
+        });
+        it("线性依赖 A→B 无环（B depends_on A）", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: [] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+            ]);
+            assert.equal(detectCycle(goal), null);
+        });
+        it("A→B→A 有环，返回环路径", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: ["B"] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+            ]);
+            const cycle = detectCycle(goal);
+            assert.ok(cycle !== null);
+            assert.ok(cycle.length >= 2);
+            assert.ok(cycle.includes("A"));
+            assert.ok(cycle.includes("B"));
+        });
+        it("自环 A→A 有环", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: ["A"] }),
+            ]);
+            const cycle = detectCycle(goal);
+            assert.ok(cycle !== null);
+            assert.ok(cycle.includes("A"));
+        });
+        it("引用不存在的 subgoal 不算环", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: ["nonexistent"] }),
+            ]);
+            assert.equal(detectCycle(goal), null);
+        });
+        it("三节点环 A→B→C→A", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: ["C"] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+                makeSubgoal({ id: "C", depends_on: ["B"] }),
+            ]);
+            const cycle = detectCycle(goal);
+            assert.ok(cycle !== null);
+            assert.ok(cycle.includes("A"));
+            assert.ok(cycle.includes("B"));
+            assert.ok(cycle.includes("C"));
+        });
+        it("无环的复杂依赖图", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: [] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+                makeSubgoal({ id: "C", depends_on: ["A"] }),
+                makeSubgoal({ id: "D", depends_on: ["B", "C"] }),
+            ]);
+            assert.equal(detectCycle(goal), null);
+        });
+    });
+    describe("topologicalSort", () => {
+        it("线性 A→B（B 依赖 A）→ 返回 [A, B]", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: [] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+            ]);
+            const sorted = topologicalSort(goal);
+            assert.equal(sorted.length, 2);
+            const aIndex = sorted.indexOf("A");
+            const bIndex = sorted.indexOf("B");
+            assert.ok(aIndex < bIndex, "A should come before B");
+        });
+        it("有环抛错", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: ["B"] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+            ]);
+            assert.throws(() => topologicalSort(goal), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "dependency_cycle");
+                return true;
+            });
+        });
+        it("单节点无依赖", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: [] }),
+            ]);
+            assert.deepEqual(topologicalSort(goal), ["A"]);
+        });
+        it("菱形依赖：D 依赖 B、C，B/C 依赖 A → A 最前，D 最后", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: [] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+                makeSubgoal({ id: "C", depends_on: ["A"] }),
+                makeSubgoal({ id: "D", depends_on: ["B", "C"] }),
+            ]);
+            const sorted = topologicalSort(goal);
+            assert.equal(sorted.length, 4);
+            const aIndex = sorted.indexOf("A");
+            const bIndex = sorted.indexOf("B");
+            const cIndex = sorted.indexOf("C");
+            const dIndex = sorted.indexOf("D");
+            assert.ok(aIndex < bIndex, "A before B");
+            assert.ok(aIndex < cIndex, "A before C");
+            assert.ok(bIndex < dIndex, "B before D");
+            assert.ok(cIndex < dIndex, "C before D");
+        });
+        it("引用不存在的 subgoal 不影响排序", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", depends_on: ["nonexistent"] }),
+                makeSubgoal({ id: "B", depends_on: ["A"] }),
+            ]);
+            const sorted = topologicalSort(goal);
+            assert.equal(sorted.length, 2);
+            const aIndex = sorted.indexOf("A");
+            const bIndex = sorted.indexOf("B");
+            assert.ok(aIndex < bIndex, "A before B");
+        });
+    });
+});

package/dist/test/unit/goal-progress.test.d.ts

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