patchwarden 0.6.4 → 1.5.0

package/src/test/unit/goal-tools-registry.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { getToolDefs, handleToolCall } from "../../tools/registry.js";
+import { reloadConfig } from "../../config.js";
+import { PatchWardenError } from "../../errors.js";
+
+// ── 9 个 Goal Session MCP 工具名 ──────────────────────────────────
+
+const GOAL_TOOL_NAMES = [
+  "create_goal",
+  "list_goals",
+  "read_goal",
+  "create_subgoal_task",
+  "accept_subgoal",
+  "reject_subgoal",
+  "suggest_next_subgoal",
+  "summarize_goal_progress",
+  "export_handoff",
+] as const;
+
+// ── 测试环境隔离：使用临时 workspaceRoot + full profile ───────────
+
+let tempDir: string;
+let prevConfigEnv: string | undefined;
+let prevProfileEnv: string | undefined;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "pw-goal-registry-"));
+  const configPath = join(tempDir, "patchwarden.config.json");
+  writeFileSync(
+    configPath,
+    JSON.stringify({
+      workspaceRoot: tempDir,
+      toolProfile: "full",
+      agents: {},
+      allowedTestCommands: [],
+    }),
+    "utf-8"
+  );
+  prevConfigEnv = process.env.PATCHWARDEN_CONFIG;
+  prevProfileEnv = process.env.PATCHWARDEN_TOOL_PROFILE;
+  process.env.PATCHWARDEN_CONFIG = configPath;
+  process.env.PATCHWARDEN_TOOL_PROFILE = "full";
+  reloadConfig();
+});
+
+afterEach(() => {
+  if (prevConfigEnv === undefined) {
+    delete process.env.PATCHWARDEN_CONFIG;
+  } else {
+    process.env.PATCHWARDEN_CONFIG = prevConfigEnv;
+  }
+  if (prevProfileEnv === undefined) {
+    delete process.env.PATCHWARDEN_TOOL_PROFILE;
+  } else {
+    process.env.PATCHWARDEN_TOOL_PROFILE = prevProfileEnv;
+  }
+  reloadConfig();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+// ── Tests ─────────────────────────────────────────────────────────
+
+describe("goal tools registry", () => {
+
+  describe("getToolDefs — 工具定义", () => {
+    it("包含全部 9 个 goal 工具", () => {
+      const tools = getToolDefs();
+      const names = new Set(tools.map((t) => t.name));
+      for (const name of GOAL_TOOL_NAMES) {
+        assert.ok(names.has(name), `Missing tool definition: ${name}`);
+      }
+    });
+
+    it("每个 goal 工具描述以 v0.8.0 开头且 inputSchema.type 为 object", () => {
+      const tools = getToolDefs();
+      const byName = new Map(tools.map((t) => [t.name, t]));
+      for (const name of GOAL_TOOL_NAMES) {
+        const tool = byName.get(name);
+        assert.ok(tool, `Tool not found: ${name}`);
+        assert.equal(tool.inputSchema.type, "object", `${name} schema type should be object`);
+        assert.ok(
+          tool.description.startsWith("v0.8.0:"),
+          `${name} description should start with v0.8.0:`
+        );
+      }
+    });
+
+    it("create_goal required 字段为 title/goal_description/repo_path", () => {
+      const tools = getToolDefs();
+      const tool = tools.find((t) => t.name === "create_goal");
+      assert.ok(tool);
+      assert.deepEqual(tool.inputSchema.required, ["title", "goal_description", "repo_path"]);
+    });
+
+    it("create_subgoal_task required 字段为 goal_id/subgoal_title/repo_path", () => {
+      const tools = getToolDefs();
+      const tool = tools.find((t) => t.name === "create_subgoal_task");
+      assert.ok(tool);
+      assert.deepEqual(tool.inputSchema.required, ["goal_id", "subgoal_title", "repo_path"]);
+    });
+
+    it("create_subgoal_task template enum 复用 TASK_TEMPLATE_NAMES", () => {
+      const tools = getToolDefs();
+      const tool = tools.find((t) => t.name === "create_subgoal_task");
+      assert.ok(tool);
+      const props = tool.inputSchema.properties as Record<string, any>;
+      assert.ok(Array.isArray(props.template.enum));
+      assert.ok(props.template.enum.length > 0);
+    });
+
+    it("accept_subgoal required 字段为 goal_id/subgoal_id", () => {
+      const tools = getToolDefs();
+      const tool = tools.find((t) => t.name === "accept_subgoal");
+      assert.ok(tool);
+      assert.deepEqual(tool.inputSchema.required, ["goal_id", "subgoal_id"]);
+    });
+
+    it("reject_subgoal required 字段为 goal_id/subgoal_id/reason", () => {
+      const tools = getToolDefs();
+      const tool = tools.find((t) => t.name === "reject_subgoal");
+      assert.ok(tool);
+      assert.deepEqual(tool.inputSchema.required, ["goal_id", "subgoal_id", "reason"]);
+    });
+  });
+
+  describe("handleToolCall — handler 分发", () => {
+    it("list_goals 返回 { goals: [] } 格式（空工作区）", async () => {
+      const result = await handleToolCall("list_goals", {});
+      assert.ok(Array.isArray(result.content));
+      assert.equal(result.content[0].type, "text");
+      const data = JSON.parse(result.content[0].text);
+      assert.ok(Array.isArray(data.goals));
+      assert.equal(data.goals.length, 0);
+    });
+
+    it("read_goal 不存在时抛出 goal_not_found", async () => {
+      await assert.rejects(
+        () => handleToolCall("read_goal", { goal_id: "goal_nonexistent_xyz_99999" }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("create_goal 路径越界抛出 workspace_path_escape", async () => {
+      await assert.rejects(
+        () => handleToolCall("create_goal", {
+          title: "Test Goal",
+          goal_description: "desc",
+          repo_path: "../../../../..",
+        }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "workspace_path_escape");
+          return true;
+        }
+      );
+    });
+
+    it("suggest_next_subgoal 不存在时抛出 goal_not_found", async () => {
+      await assert.rejects(
+        () => handleToolCall("suggest_next_subgoal", { goal_id: "goal_nonexistent_xyz_99999" }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("summarize_goal_progress 不存在时抛出 goal_not_found", async () => {
+      await assert.rejects(
+        () => handleToolCall("summarize_goal_progress", { goal_id: "goal_nonexistent_xyz_99999" }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("export_handoff 不存在时抛出 goal_not_found", async () => {
+      await assert.rejects(
+        () => handleToolCall("export_handoff", { goal_id: "goal_nonexistent_xyz_99999" }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("accept_subgoal 不存在时抛出 goal_not_found", async () => {
+      await assert.rejects(
+        () => handleToolCall("accept_subgoal", {
+          goal_id: "goal_nonexistent_xyz_99999",
+          subgoal_id: "sg_1",
+        }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("reject_subgoal 不存在时抛出 goal_not_found", async () => {
+      await assert.rejects(
+        () => handleToolCall("reject_subgoal", {
+          goal_id: "goal_nonexistent_xyz_99999",
+          subgoal_id: "sg_1",
+          reason: "test reason",
+        }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+
+    it("create_subgoal_task 不存在时抛出 goal_not_found", async () => {
+      await assert.rejects(
+        () => handleToolCall("create_subgoal_task", {
+          goal_id: "goal_nonexistent_xyz_99999",
+          subgoal_title: "Sub A",
+          repo_path: "repo",
+        }),
+        (err: unknown) => {
+          assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+          assert.equal(err.reason, "goal_not_found");
+          return true;
+        }
+      );
+    });
+  });
+});

package/src/test/unit/handoff-export.test.ts

@@ -0,0 +1,295 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, existsSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { generateHandoff, exportHandoff } from "../../goal/handoffExport.js";
+import type { GoalStatus, Subgoal } from "../../goal/goalStatus.js";
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+function makeSubgoal(overrides: Partial<Subgoal> & { id: string }): Subgoal {
+  return {
+    title: "Subgoal " + overrides.id,
+    status: "ready",
+    depends_on: [],
+    task_ids: [],
+    ...overrides,
+  };
+}
+
+function makeGoalStatus(subgoals: Subgoal[], overrides: Partial<GoalStatus> = {}): GoalStatus {
+  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("handoffExport", () => {
+
+  describe("generateHandoff", () => {
+
+    it("空 subgoals → 文档包含所有章节", () => {
+      const goal = makeGoalStatus([]);
+      const md = generateHandoff("goal_test_001", goal);
+      assert.ok(md.includes("# Goal Session Handoff"));
+      assert.ok(md.includes("## 当前 Goal"));
+      assert.ok(md.includes("## 版本目标"));
+      assert.ok(md.includes("## 已完成子目标"));
+      assert.ok(md.includes("## 未完成子目标"));
+      assert.ok(md.includes("## 已拒绝子目标"));
+      assert.ok(md.includes("## 最近一次 diff 摘要"));
+      assert.ok(md.includes("## 最近一次测试结果"));
+      assert.ok(md.includes("## 当前阻塞点"));
+      assert.ok(md.includes("## 下一步建议"));
+      assert.ok(md.includes("## 风险提醒"));
+      assert.ok(md.includes("## 接手说明"));
+      assert.ok(md.includes("Generated:"));
+    });
+
+    it("空 subgoals → 已完成/未完成显示无", () => {
+      const goal = makeGoalStatus([]);
+      const md = generateHandoff("goal_test_001", goal);
+      const completedSection = md.split("## 已完成子目标")[1].split("##")[0];
+      assert.ok(completedSection.includes("无"));
+      const incompleteSection = md.split("## 未完成子目标")[1].split("##")[0];
+      assert.ok(incompleteSection.includes("无"));
+    });
+
+    it("有 accepted subgoal → 出现在已完成子目标", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({
+          id: "subgoal-001",
+          title: "Implement feature A",
+          status: "accepted",
+          accepted_at: "2026-01-01T00:00:00.000Z",
+        }),
+      ]);
+      const md = generateHandoff("goal_test_001", goal);
+      const completedSection = md.split("## 已完成子目标")[1].split("##")[0];
+      assert.ok(completedSection.includes("subgoal-001"));
+      assert.ok(completedSection.includes("Implement feature A"));
+      assert.ok(completedSection.includes("2026-01-01T00:00:00.000Z"));
+    });
+
+    it("有 running subgoal → 出现在未完成子目标和风险提醒", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({
+          id: "subgoal-001",
+          title: "WIP task",
+          status: "running",
+        }),
+      ]);
+      const md = generateHandoff("goal_test_001", goal);
+      const incompleteSection = md.split("## 未完成子目标")[1].split("##")[0];
+      assert.ok(incompleteSection.includes("subgoal-001"));
+      assert.ok(incompleteSection.includes("running"));
+      const riskSection = md.split("## 风险提醒")[1].split("##")[0];
+      assert.ok(riskSection.includes("subgoal-001"));
+      assert.ok(riskSection.includes("running"));
+    });
+
+    it("有 rejected subgoal → 出现在已拒绝子目标", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({
+          id: "subgoal-001",
+          title: "Failed task",
+          status: "rejected",
+          rejected_reason: "Tests failed",
+        }),
+      ]);
+      const md = generateHandoff("goal_test_001", goal);
+      const rejectedSection = md.split("## 已拒绝子目标")[1].split("##")[0];
+      assert.ok(rejectedSection.includes("subgoal-001"));
+      assert.ok(rejectedSection.includes("Failed task"));
+      assert.ok(rejectedSection.includes("Tests failed"));
+    });
+
+    it("无 rejected subgoal → 已拒绝子目标显示无", () => {
+      const goal = makeGoalStatus([]);
+      const md = generateHandoff("goal_test_001", goal);
+      const rejectedSection = md.split("## 已拒绝子目标")[1].split("##")[0];
+      assert.ok(rejectedSection.includes("无"));
+    });
+
+    it("有 needs_fix subgoal → 出现在当前阻塞点和风险提醒", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({
+          id: "subgoal-001",
+          title: "Needs fix task",
+          status: "needs_fix",
+        }),
+      ]);
+      const md = generateHandoff("goal_test_001", goal);
+      const blockerSection = md.split("## 当前阻塞点")[1].split("##")[0];
+      assert.ok(blockerSection.includes("subgoal-001"));
+      assert.ok(blockerSection.includes("Needs fix task"));
+      const riskSection = md.split("## 风险提醒")[1].split("##")[0];
+      assert.ok(riskSection.includes("subgoal-001"));
+      assert.ok(riskSection.includes("needs_fix"));
+    });
+
+    it("有 recentDiff → 出现在最近一次 diff 摘要", () => {
+      const goal = makeGoalStatus([]);
+      const diff = "diff --git a/src/foo.ts b/src/foo.ts\n+console.log('hello')";
+      const md = generateHandoff("goal_test_001", goal, diff);
+      const diffSection = md.split("## 最近一次 diff 摘要")[1].split("##")[0];
+      assert.ok(diffSection.includes("src/foo.ts"));
+      assert.ok(diffSection.includes("console.log"));
+    });
+
+    it("无 recentDiff → 显示暂无", () => {
+      const goal = makeGoalStatus([]);
+      const md = generateHandoff("goal_test_001", goal);
+      const diffSection = md.split("## 最近一次 diff 摘要")[1].split("##")[0];
+      assert.ok(diffSection.includes("暂无"));
+    });
+
+    it("有 recentTestResult → 出现在最近一次测试结果", () => {
+      const goal = makeGoalStatus([]);
+      const testResult = "PASS: 42 tests passed, 0 failed";
+      const md = generateHandoff("goal_test_001", goal, undefined, testResult);
+      const testSection = md.split("## 最近一次测试结果")[1].split("##")[0];
+      assert.ok(testSection.includes("42 tests passed"));
+    });
+
+    it("无 recentTestResult → 显示暂无", () => {
+      const goal = makeGoalStatus([]);
+      const md = generateHandoff("goal_test_001", goal);
+      const testSection = md.split("## 最近一次测试结果")[1].split("##")[0];
+      assert.ok(testSection.includes("暂无"));
+    });
+
+    it("接手说明包含 goalId", () => {
+      const goal = makeGoalStatus([]);
+      const md = generateHandoff("goal_handoff_999", goal);
+      const handoffSection = md.split("## 接手说明")[1];
+      assert.ok(handoffSection.includes("goal_handoff_999"));
+      assert.ok(handoffSection.includes("read_goal"));
+      assert.ok(handoffSection.includes("suggest_next_subgoal"));
+    });
+
+    it("当前 Goal 章节包含 goal_id/title/status/repo_path", () => {
+      const goal = makeGoalStatus([], {
+        goal_id: "goal_abc",
+        title: "My Custom Goal",
+        status: "active",
+        repo_path: "/custom/repo",
+      });
+      const md = generateHandoff("goal_abc", goal);
+      const goalSection = md.split("## 当前 Goal")[1].split("##")[0];
+      assert.ok(goalSection.includes("goal_abc"));
+      assert.ok(goalSection.includes("My Custom Goal"));
+      assert.ok(goalSection.includes("active"));
+      assert.ok(goalSection.includes("/custom/repo"));
+    });
+
+    it("有 ready subgoal → 下一步建议包含该 subgoal", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", title: "Ready task", depends_on: [] }),
+      ]);
+      const md = generateHandoff("goal_test_001", goal);
+      const suggestSection = md.split("## 下一步建议")[1].split("##")[0];
+      assert.ok(suggestSection.includes("subgoal-001"));
+      assert.ok(suggestSection.includes("Ready task"));
+    });
+
+    it("未完成子目标显示 depends_on", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "A", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+        makeSubgoal({ id: "B", title: "Depends on A", status: "ready", depends_on: ["A"] }),
+      ]);
+      const md = generateHandoff("goal_test_001", goal);
+      const incompleteSection = md.split("## 未完成子目标")[1].split("##")[0];
+      assert.ok(incompleteSection.includes("B"));
+      assert.ok(incompleteSection.includes("depends_on: A"));
+    });
+  });
+
+  describe("exportHandoff", () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      tempDir = mkdtempSync(join(tmpdir(), "pw-handoff-"));
+    });
+
+    afterEach(() => {
+      rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it("写入 handoff.md 文件到 .patchwarden/goals/{goalId}/", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", title: "Task A", depends_on: [] }),
+      ]);
+      const result = exportHandoff("goal_export_001", goal, tempDir);
+
+      const expectedPath = resolve(tempDir, ".patchwarden", "goals", "goal_export_001", "handoff.md");
+      assert.equal(result.handoff_path, expectedPath);
+      assert.ok(existsSync(expectedPath));
+
+      const fileContent = readFileSync(expectedPath, "utf-8");
+      assert.ok(fileContent.includes("# Goal Session Handoff"));
+      assert.ok(fileContent.includes("goal_export_001"));
+    });
+
+    it("返回的 handoff_path 是绝对路径", () => {
+      const goal = makeGoalStatus([]);
+      const result = exportHandoff("goal_export_002", goal, tempDir);
+      assert.ok(result.handoff_path.includes(tempDir));
+      assert.ok(result.handoff_path.endsWith("handoff.md"));
+    });
+
+    it("content_preview 不超过 500 字符（加省略号）", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", title: "A".repeat(200), depends_on: [] }),
+        makeSubgoal({ id: "subgoal-002", title: "B".repeat(200), depends_on: [] }),
+        makeSubgoal({ id: "subgoal-003", title: "C".repeat(200), depends_on: [] }),
+      ]);
+      const result = exportHandoff("goal_export_003", goal, tempDir);
+      assert.ok(result.content_preview.length > 0);
+      assert.ok(result.content_preview.endsWith("..."));
+      assert.ok(result.content_preview.length <= 503); // 500 + "..."
+    });
+
+    it("content_preview 是文档前 500 字符的截取", () => {
+      const goal = makeGoalStatus([]);
+      const result = exportHandoff("goal_export_004", goal, tempDir);
+      const fileContent = readFileSync(result.handoff_path, "utf-8");
+      if (fileContent.length > 500) {
+        assert.equal(result.content_preview, fileContent.slice(0, 500) + "...");
+      } else {
+        assert.equal(result.content_preview, fileContent);
+      }
+    });
+
+    it("文件内容与 generateHandoff 一致", () => {
+      const goal = makeGoalStatus([
+        makeSubgoal({ id: "subgoal-001", title: "Verify content", depends_on: [] }),
+      ]);
+      const expected = generateHandoff("goal_export_005", goal);
+      const result = exportHandoff("goal_export_005", goal, tempDir);
+      const fileContent = readFileSync(result.handoff_path, "utf-8");
+      // 排除 Generated 时间戳行（两次调用可能跨越毫秒边界）
+      const stripGenerated = (s: string) => s.replace(/^Generated: .*$/m, "Generated: <ts>");
+      assert.equal(stripGenerated(fileContent), stripGenerated(expected));
+    });
+
+    it("创建多层目录结构", () => {
+      const goal = makeGoalStatus([]);
+      const result = exportHandoff("goal_deep_001", goal, tempDir);
+      const goalDir = resolve(tempDir, ".patchwarden", "goals", "goal_deep_001");
+      const stat = statSync(goalDir);
+      assert.ok(stat.isDirectory());
+      assert.ok(existsSync(result.handoff_path));
+    });
+  });
+});