patchwarden 0.6.4 → 1.5.0

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

@@ -0,0 +1,253 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { generateGoalId, getGoalsDir, getGoalDir, createGoal, listGoals, readGoal, writeGoalStatus, readGoalStatus, } from "../../goal/goalStore.js";
+import { addSubgoal, updateSubgoalStatus } from "../../goal/goalStatus.js";
+import { PatchWardenError } from "../../errors.js";
+// ── Helpers ───────────────────────────────────────────────────────
+let tempDir;
+beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "pw-goalstore-"));
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+function todayDatePart() {
+    const now = new Date();
+    const y = now.getFullYear();
+    const m = String(now.getMonth() + 1).padStart(2, "0");
+    const d = String(now.getDate()).padStart(2, "0");
+    return `${y}${m}${d}`;
+}
+// ── Tests ─────────────────────────────────────────────────────────
+describe("goalStore", () => {
+    describe("generateGoalId", () => {
+        it("正常 title 生成 goal_{date}_{slug}", () => {
+            const id = generateGoalId("Implement Feature X", []);
+            assert.equal(id, `goal_${todayDatePart()}_implement_feature_x`);
+        });
+        it("特殊字符 title 转换为 slug", () => {
+            const id = generateGoalId("Fix: Bug #123 & Refactor!", []);
+            assert.equal(id, `goal_${todayDatePart()}_fix_bug_123_refactor`);
+        });
+        it("空 title 用 untitled 代替", () => {
+            const id = generateGoalId("", []);
+            assert.equal(id, `goal_${todayDatePart()}_untitled`);
+        });
+        it("纯符号 title 用 untitled 代替", () => {
+            const id = generateGoalId("!!!@#$%^&*()", []);
+            assert.equal(id, `goal_${todayDatePart()}_untitled`);
+        });
+        it("title 截断到 30 字符 slug", () => {
+            const longTitle = "abcdefghijklmnopqrstuvwxyz0123456789";
+            const id = generateGoalId(longTitle, []);
+            const slug = id.split("_").slice(2).join("_");
+            assert.ok(slug.length <= 30, `slug length should be <= 30, got ${slug.length}`);
+        });
+        it("冲突时追加 _2", () => {
+            const base = `goal_${todayDatePart()}_implement_feature_x`;
+            const id = generateGoalId("Implement Feature X", [base]);
+            assert.equal(id, `${base}_2`);
+        });
+        it("多次冲突递增 _3", () => {
+            const base = `goal_${todayDatePart()}_implement_feature_x`;
+            const id = generateGoalId("Implement Feature X", [base, `${base}_2`]);
+            assert.equal(id, `${base}_3`);
+        });
+        it("不冲突时不追加后缀", () => {
+            const base = `goal_${todayDatePart()}_implement_feature_x`;
+            const other = `goal_${todayDatePart()}_other_goal`;
+            const id = generateGoalId("Implement Feature X", [other]);
+            assert.equal(id, base);
+        });
+    });
+    describe("getGoalsDir / getGoalDir", () => {
+        it("getGoalsDir 返回 .patchwarden/goals 路径", () => {
+            const dir = getGoalsDir(tempDir);
+            assert.equal(dir, join(tempDir, ".patchwarden", "goals"));
+        });
+        it("getGoalDir 返回 {goalsDir}/{goalId}", () => {
+            const dir = getGoalDir("goal_001", tempDir);
+            assert.equal(dir, join(tempDir, ".patchwarden", "goals", "goal_001"));
+        });
+    });
+    describe("createGoal", () => {
+        it("成功创建目录结构和文件", () => {
+            const repoRel = "my-repo";
+            const { goal_id, goal_dir } = createGoal(repoRel, "Test Goal", "A test description", tempDir);
+            assert.ok(goal_id.startsWith(`goal_${todayDatePart()}_test_goal`));
+            assert.equal(goal_dir, join(tempDir, ".patchwarden", "goals", goal_id));
+            // 验证目录结构
+            assert.ok(existsSync(goal_dir), "goal_dir exists");
+            assert.ok(existsSync(join(goal_dir, "tasks")), "tasks/ exists");
+            assert.ok(existsSync(join(goal_dir, "artifacts")), "artifacts/ exists");
+            // 验证 GOAL.md
+            const goalMd = readFileSync(join(goal_dir, "GOAL.md"), "utf-8");
+            assert.ok(goalMd.includes("# Test Goal"));
+            assert.ok(goalMd.includes("A test description"));
+            assert.ok(goalMd.includes("- Status: active"));
+            assert.ok(goalMd.includes("- Repo:"));
+            // 验证 GOALS.md
+            const goalsMd = readFileSync(join(goal_dir, "GOALS.md"), "utf-8");
+            assert.ok(goalsMd.includes("# Subgoals: Test Goal"));
+            assert.ok(goalsMd.includes("_No subgoals yet._"));
+            // 验证 goal_status.json
+            const statusPath = join(goal_dir, "goal_status.json");
+            assert.ok(existsSync(statusPath));
+            const status = JSON.parse(readFileSync(statusPath, "utf-8"));
+            assert.equal(status.goal_id, goal_id);
+            assert.equal(status.title, "Test Goal");
+            assert.equal(status.status, "active");
+            assert.deepEqual(status.subgoals, []);
+        });
+        it("repo_path 越界抛出 workspace_path_escape", () => {
+            const outside = process.platform === "win32" ? "C:\\Windows\\System32" : "/etc";
+            assert.throws(() => createGoal(outside, "Bad", "desc", tempDir), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "workspace_path_escape");
+                return true;
+            });
+        });
+        it("相同 title 创建多个 goal 时 id 不冲突", () => {
+            const r1 = createGoal("repo", "Same Title", "d1", tempDir);
+            const r2 = createGoal("repo", "Same Title", "d2", tempDir);
+            assert.notEqual(r1.goal_id, r2.goal_id);
+            assert.ok(r2.goal_id.endsWith("_2"));
+        });
+    });
+    describe("listGoals", () => {
+        it("空目录返回空数组", () => {
+            const list = listGoals(tempDir);
+            assert.deepEqual(list, []);
+        });
+        it("goals 目录不存在返回空数组", () => {
+            // tempDir 中没有 .patchwarden/goals
+            const list = listGoals(tempDir);
+            assert.deepEqual(list, []);
+        });
+        it("返回多个 goal 的摘要", () => {
+            createGoal("repo", "Goal A", "desc A", tempDir);
+            createGoal("repo", "Goal B", "desc B", tempDir);
+            const list = listGoals(tempDir);
+            assert.equal(list.length, 2);
+            const titles = list.map((g) => g.title).sort();
+            assert.deepEqual(titles, ["Goal A", "Goal B"]);
+        });
+        it("按 updated_at 降序排列", async () => {
+            const r1 = createGoal("repo", "Older", "desc", tempDir);
+            // 等待一小段时间确保 updated_at 不同
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            const r2 = createGoal("repo", "Newer", "desc", tempDir);
+            // 修改 older 的 status，使其 updated_at 更新
+            const olderStatus = readGoalStatus(r1.goal_id, tempDir);
+            const newerStatus = readGoalStatus(r2.goal_id, tempDir);
+            // 让 older 的 updated_at 比 newer 更晚
+            const future = new Date(Date.now() + 10000).toISOString();
+            writeGoalStatus(r1.goal_id, { ...olderStatus, updated_at: future }, tempDir);
+            const list = listGoals(tempDir);
+            assert.equal(list.length, 2);
+            assert.equal(list[0].goal_id, r1.goal_id);
+            assert.equal(list[1].goal_id, r2.goal_id);
+            assert.ok(list[0].updated_at >= list[1].updated_at);
+        });
+        it("subgoal 摘要正确计算", () => {
+            const { goal_id } = createGoal("repo", "With Subs", "desc", tempDir);
+            let status = readGoalStatus(goal_id, tempDir);
+            status = addSubgoal(status, "S1").goalStatus;
+            status = updateSubgoalStatus(status, "subgoal-001", "running");
+            status = addSubgoal(status, "S2").goalStatus;
+            status = updateSubgoalStatus(status, "subgoal-002", "running");
+            status = updateSubgoalStatus(status, "subgoal-002", "done_by_agent");
+            status = updateSubgoalStatus(status, "subgoal-002", "accepted");
+            writeGoalStatus(goal_id, status, tempDir);
+            const list = listGoals(tempDir);
+            assert.equal(list.length, 1);
+            const item = list[0];
+            assert.equal(item.subgoal_total, 2);
+            assert.equal(item.subgoal_accepted, 1);
+            assert.equal(item.subgoal_running, 1);
+        });
+        it("跳过无法解析的目录", () => {
+            // 创建一个有效的 goal
+            createGoal("repo", "Valid", "desc", tempDir);
+            // 创建一个无效的目录（没有 goal_status.json）
+            const goalsDir = getGoalsDir(tempDir);
+            const badDir = join(goalsDir, "goal_bad_9999_invalid");
+            mkdirSync(badDir, { recursive: true });
+            const list = listGoals(tempDir);
+            assert.equal(list.length, 1);
+            assert.equal(list[0].title, "Valid");
+        });
+    });
+    describe("readGoal", () => {
+        it("返回完整详情", () => {
+            const { goal_id } = createGoal("repo", "Read Me", "description here", tempDir);
+            const detail = readGoal(goal_id, tempDir);
+            assert.equal(detail.goal_id, goal_id);
+            assert.equal(detail.title, "Read Me");
+            assert.equal(detail.status, "active");
+            assert.equal(detail.created_at, detail.updated_at);
+            assert.ok(detail.goal_description.includes("# Read Me"));
+            assert.ok(detail.goal_description.includes("description here"));
+            assert.deepEqual(detail.subgoals, []);
+        });
+        it("goal 不存在抛出 goal_not_found", () => {
+            assert.throws(() => readGoal("goal_nonexistent", tempDir), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "goal_not_found");
+                return true;
+            });
+        });
+        it("goal_status.json 不存在抛出 goal_not_found", () => {
+            // 手动创建一个 goal 目录但不写 status
+            const goalsDir = getGoalsDir(tempDir);
+            const emptyGoalDir = join(goalsDir, "goal_empty");
+            mkdirSync(emptyGoalDir, { recursive: true });
+            assert.throws(() => readGoal("goal_empty", tempDir), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "goal_not_found");
+                return true;
+            });
+        });
+    });
+    describe("writeGoalStatus + readGoalStatus", () => {
+        it("写入后读取一致", () => {
+            const { goal_id } = createGoal("repo", "Round Trip", "desc", tempDir);
+            const original = readGoalStatus(goal_id, tempDir);
+            const withSub = addSubgoal(original, "New Sub").goalStatus;
+            writeGoalStatus(goal_id, withSub, tempDir);
+            const read = readGoalStatus(goal_id, tempDir);
+            assert.equal(read.subgoals.length, 1);
+            assert.equal(read.subgoals[0].id, "subgoal-001");
+            assert.equal(read.subgoals[0].title, "New Sub");
+            assert.equal(read.subgoals[0].status, "ready");
+        });
+        it("原子写：tmp 文件不留", () => {
+            const { goal_id, goal_dir } = createGoal("repo", "Atomic", "desc", tempDir);
+            const status = readGoalStatus(goal_id, tempDir);
+            writeGoalStatus(goal_id, status, tempDir);
+            const entries = readdirSync(goal_dir);
+            assert.ok(!entries.includes("goal_status.json.tmp"), "tmp file should not remain");
+            assert.ok(entries.includes("goal_status.json"), "final file should exist");
+        });
+        it("readGoalStatus 文件不存在抛出 goal_not_found", () => {
+            assert.throws(() => readGoalStatus("goal_nonexistent", tempDir), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "goal_not_found");
+                return true;
+            });
+        });
+        it("JSON 格式化（2 空格缩进 + 末尾换行）", () => {
+            const { goal_id, goal_dir } = createGoal("repo", "Format", "desc", tempDir);
+            const status = readGoalStatus(goal_id, tempDir);
+            writeGoalStatus(goal_id, status, tempDir);
+            const raw = readFileSync(join(goal_dir, "goal_status.json"), "utf-8");
+            // 末尾换行
+            assert.ok(raw.endsWith("\n"), "should end with newline");
+            // 2 空格缩进
+            assert.ok(raw.includes('\n  "goal_id"'), "should use 2-space indent");
+        });
+    });
+});

package/dist/test/unit/goal-subgoal-task.test.d.ts

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

package/dist/test/unit/goal-subgoal-task.test.js

@@ -0,0 +1,55 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { createSubgoalTask } from "../../tools/goalSubgoalTask.js";
+import { PatchWardenError } from "../../errors.js";
+// ── Tests ─────────────────────────────────────────────────────────
+//
+// 说明：createSubgoalTask 内部调用 createTask，后者使用 getConfig()（无 workspaceRoot
+// 覆盖），因此 happy-path 依赖真实配置的工作区，留待集成测试覆盖。
+// 此处仅测试不触及 createTask 完整流程的错误路径：
+//   - invalid_execution_mode：在读取 goal 之前即抛错
+//   - goal_not_found：readGoalStatus 在默认工作区找不到 goal 即抛错
+describe("createSubgoalTask", () => {
+    describe("错误路径", () => {
+        it("execution_mode=assess_only 抛 invalid_execution_mode", () => {
+            assert.throws(() => createSubgoalTask({
+                goal_id: "goal_nonexistent_test",
+                subgoal_title: "Sub A",
+                repo_path: "repo",
+                execution_mode: "assess_only",
+            }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_execution_mode");
+                assert.equal(err.blocked, true);
+                return true;
+            });
+        });
+        it("goal_id 不存在抛 goal_not_found", () => {
+            assert.throws(() => createSubgoalTask({
+                goal_id: "goal_definitely_does_not_exist_99999",
+                subgoal_title: "Sub A",
+                repo_path: "repo",
+            }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "goal_not_found");
+                assert.equal(err.blocked, true);
+                assert.ok(err.details.goal_id === "goal_definitely_does_not_exist_99999");
+                return true;
+            });
+        });
+        it("assess_only 优先于 goal_not_found（在读取 goal 前校验）", () => {
+            // execution_mode=assess_only 应先抛 invalid_execution_mode，
+            // 而不是去读不存在的 goal
+            assert.throws(() => createSubgoalTask({
+                goal_id: "goal_definitely_does_not_exist_99999",
+                subgoal_title: "Sub A",
+                repo_path: "repo",
+                execution_mode: "assess_only",
+            }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_execution_mode");
+                return true;
+            });
+        });
+    });
+});

package/dist/test/unit/goal-tools-registry.test.d.ts

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

package/dist/test/unit/goal-tools-registry.test.js

@@ -0,0 +1,190 @@
+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",
+];
+// ── 测试环境隔离：使用临时 workspaceRoot + full profile ───────────
+let tempDir;
+let prevConfigEnv;
+let prevProfileEnv;
+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;
+            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) => {
+                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) => {
+                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) => {
+                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) => {
+                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) => {
+                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) => {
+                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) => {
+                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) => {
+                assert.ok(err instanceof PatchWardenError, "should be PatchWardenError");
+                assert.equal(err.reason, "goal_not_found");
+                return true;
+            });
+        });
+    });
+});

package/dist/test/unit/handoff-export.test.d.ts

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