@rethunk/mcp-multi-root-git 3.1.0 → 4.0.0

package/dist/server/git-cherry-pick-tool.js

@@ -5,6 +5,8 @@ import { commitListBetween, conflictPaths, getCurrentBranch, isContentEquivalent
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
+/** Hard cap on SHAs fed to a single `git cherry-pick` (ARG_MAX / runtime guard). */
+export const MAX_CHERRY_PICK_COMMITS = 100;
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -15,8 +17,13 @@ async function cherryPickHead(gitTop) {
     const sha = r.stdout.trim();
     return sha === "" ? undefined : sha;
 }
-async function abortCherryPick(gitTop) {
-    await spawnGitAsync(gitTop, ["cherry-pick", "--abort"]);
+/** Result of `git cherry-pick --abort` — callers must check `ok` before claiming a clean abort. */
+export async function abortCherryPick(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["cherry-pick", "--abort"]);
+    if (r.ok)
+        return { ok: true };
+    const detail = (r.stderr || r.stdout).trim();
+    return detail === "" ? { ok: false } : { ok: false, detail };
 }
 async function branchExists(gitTop, name) {
     const r = await spawnGitAsync(gitTop, ["show-ref", "--verify", "--quiet", `refs/heads/${name}`]);
@@ -96,6 +103,7 @@ export function registerGitCherryPickTool(server) {
         name: "git_cherry_pick",
         description: "Cherry-pick commits from one or more sources onto a destination. Sources: SHAs, `A..B` ranges, " +
             "or branch names (expanded to `onto..<branch>`, oldest-first). Already-reachable commits skipped. " +
+            `Hard-capped at ${MAX_CHERRY_PICK_COMMITS} commits per call (after dedupe). ` +
             "Refuses on dirty tree; stops on first conflict. Optional flags delete source branches/worktrees " +
             "after success using patch-id equivalence (set `strictMergedRefEquality: true` for strict ancestry). " +
             "Protected names always skipped.",
@@ -123,19 +131,39 @@ export function registerGitCherryPickTool(server) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("Remove local worktrees on branch-kind sources after success. Protected tails skipped."),
+                .describe("Remove local worktrees on branch-kind sources after success. Protected names and path tails skipped."),
             strictMergedRefEquality: z
                 .boolean()
                 .optional()
                 .default(false)
                 .describe("false (default): delete branch when every commit is content-equivalent on destination (patch-id, normal cherry-pick outcome). " +
                 "true: require strict ref ancestry (`git branch -d` semantics — will refuse after cherry-pick due to SHA mismatch)."),
+            onConflict: z
+                .enum(["abort", "pause"])
+                .optional()
+                .default("abort")
+                .describe("`abort` (default): on conflict, run `cherry-pick --abort` and roll back the whole range " +
+                "(unchanged behavior). `pause`: on conflict, leave the conflict and native cherry-pick " +
+                "sequencer state in place — commits already applied stay applied — so it can be resolved " +
+                "and resumed via `git_cherry_pick_continue`."),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const gitTop = pre.gitTop;
+            // --- Guard: refuse when a cherry-pick is already in progress (native sequencer state,
+            // read live off CHERRY_PICK_HEAD — this server is stateless per call). Checked before the
+            // dirty-tree refusal below so callers get a specific, actionable error instead of the
+            // generic working_tree_dirty. ---
+            const alreadyInProgress = await cherryPickHead(gitTop);
+            if (alreadyInProgress) {
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_IN_PROGRESS,
+                    commit: alreadyInProgress,
+                });
+            }
+            const onConflict = args.onConflict ?? "abort";
             // --- Resolve destination ---
             const startBranch = await getCurrentBranch(gitTop);
             const onto = args.onto?.trim() || startBranch;
@@ -176,6 +204,13 @@ export function registerGitCherryPickTool(server) {
             }
             // --- Dedupe + skip already-present ---
             const { picks, perSourceKept } = await filterAndDedupe(gitTop, onto, resolved);
+            if (picks.length > MAX_CHERRY_PICK_COMMITS) {
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_TOO_MANY_COMMITS,
+                    picked: picks.length,
+                    max: MAX_CHERRY_PICK_COMMITS,
+                });
+            }
             // --- Apply cherry-pick (single atomic call) ---
             // `--empty=drop` silently drops commits that would produce no change against the
             // current tip — makes the tool idempotent when the same patch is re-applied.
@@ -188,13 +223,33 @@ export function registerGitCherryPickTool(server) {
                 if (!r.ok) {
                     const failedSha = await cherryPickHead(gitTop);
                     const paths = await conflictPaths(gitTop);
-                    await abortCherryPick(gitTop);
-                    conflict = {
-                        stage: "cherry-pick",
-                        ...spreadDefined("commit", failedSha),
-                        paths,
-                        detail: (r.stderr || r.stdout).trim(),
-                    };
+                    if (onConflict === "pause") {
+                        // Leave the conflict + native sequencer state in place. Commits already
+                        // applied before the conflicting one stay applied — compute that count
+                        // cheaply from the HEAD advance so far (resumable via git_cherry_pick_continue).
+                        const adv = await spawnGitAsync(gitTop, ["rev-list", "--count", `${preHead}..HEAD`]);
+                        appliedCount = adv.ok ? parseInt(adv.stdout.trim(), 10) || 0 : 0;
+                        conflict = {
+                            stage: "cherry-pick",
+                            paused: true,
+                            ...spreadDefined("commit", failedSha),
+                            paths,
+                            detail: (r.stderr || r.stdout).trim(),
+                        };
+                    }
+                    else {
+                        const abort = await abortCherryPick(gitTop);
+                        conflict = {
+                            stage: "cherry-pick",
+                            ...spreadDefined("commit", failedSha),
+                            paths,
+                            detail: (r.stderr || r.stdout).trim(),
+                            ...spreadWhen(!abort.ok, {
+                                abortFailed: true,
+                                ...spreadDefined("abortDetail", abort.detail),
+                            }),
+                        };
+                    }
                 }
                 else {
                     // Actual commits written = HEAD advance count (empty-drop may skip some).
@@ -265,18 +320,29 @@ export function registerGitCherryPickTool(server) {
                     ...spreadWhen(conflict !== undefined, {
                         conflict: {
                             stage: conflict?.stage ?? "cherry-pick",
+                            ...spreadWhen(conflict?.paused === true, { paused: true }),
                             ...spreadDefined("commit", conflict?.commit),
                             paths: conflict?.paths ?? [],
                             ...spreadDefined("detail", conflict?.detail),
+                            ...spreadWhen(conflict?.abortFailed === true, {
+                                abortFailed: true,
+                                ...spreadDefined("abortDetail", conflict?.abortDetail),
+                            }),
                         },
                     }),
+                    ...spreadWhen(conflict?.abortFailed === true, {
+                        error: ERROR_CODES.CHERRY_PICK_ABORT_FAILED,
+                        ...spreadDefined("abortDetail", conflict?.abortDetail),
+                    }),
                 });
             }
             // --- Markdown ---
             const lines = [];
             const header = allOk
                 ? `# Cherry-pick onto \`${onto}\`: ${appliedCount} commit(s) applied`
-                : `# Cherry-pick onto \`${onto}\`: stopped on conflict after ${appliedCount} commit(s)`;
+                : conflict?.paused
+                    ? `# Cherry-pick onto \`${onto}\`: paused on conflict after ${appliedCount} commit(s)`
+                    : `# Cherry-pick onto \`${onto}\`: stopped on conflict after ${appliedCount} commit(s)`;
             lines.push(header, "");
             for (const s of perSourceReport) {
                 const kept = perSourceKept.get(s.raw)?.length ?? 0;
@@ -293,8 +359,151 @@ export function registerGitCherryPickTool(server) {
                     lines.push(`  conflict: ${p}`);
                 if (conflict.detail)
                     lines.push(`  detail: ${conflict.detail}`);
+                if (conflict.paused) {
+                    lines.push("  Paused: cherry-pick left in progress. Resolve the conflict, then call `git_cherry_pick_continue`.");
+                }
+                if (conflict.abortFailed) {
+                    lines.push(`  Error: ${ERROR_CODES.CHERRY_PICK_ABORT_FAILED}${conflict.abortDetail ? ` — ${conflict.abortDetail}` : ""}`);
+                }
             }
             return lines.join("\n");
         },
     });
 }
+function renderCherryPickContinueMarkdown(action, ok, applied, headSha, conflict) {
+    if (action === "abort") {
+        return ok
+            ? `# Cherry-pick abort\nAborted. HEAD restored to \`${headSha ?? "?"}\`.`
+            : "# Cherry-pick abort\nAbort failed — see error.";
+    }
+    if (conflict) {
+        const lines = [
+            `# Cherry-pick continue: paused on conflict after ${applied} commit(s)`,
+            "",
+            `Conflict at commit \`${conflict.commit ?? "?"}\` (${conflict.stage}):`,
+        ];
+        for (const p of conflict.paths)
+            lines.push(`  conflict: ${p}`);
+        if (conflict.detail)
+            lines.push(`  detail: ${conflict.detail}`);
+        lines.push("  Paused: cherry-pick still in progress. Resolve the conflict, then call `git_cherry_pick_continue` again.");
+        return lines.join("\n");
+    }
+    return `# Cherry-pick continue: ${applied} commit(s) applied\nHEAD now \`${headSha ?? "?"}\`.`;
+}
+export function registerGitCherryPickContinueTool(server) {
+    server.addTool({
+        name: "git_cherry_pick_continue",
+        description: "Resume or abort a cherry-pick left in progress — typically by `git_cherry_pick`'s " +
+            '`onConflict: "pause"`, but this tool is stateless and reads `CHERRY_PICK_HEAD` / the native ' +
+            "sequencer live off `.git`, so it works regardless of how the in-progress state was left. " +
+            '`action: "continue"` (default) requires every previously conflicted path to be staged (no ' +
+            "remaining unmerged entries — `cherry_pick_unresolved_paths` otherwise), then runs " +
+            "`git -c core.editor=true cherry-pick --continue` so git's sequencer both commits the resolved " +
+            "pick and resumes through any remaining picks in the same range. If a *later* pick then " +
+            "conflicts, the response reports it the same way as a paused `git_cherry_pick` call (`conflict." +
+            'paused: true`) so this tool can be called again to keep walking the range. `action: "abort"` ' +
+            "rolls back the whole in-progress cherry-pick via `git cherry-pick --abort`.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            action: z
+                .enum(["continue", "abort"])
+                .optional()
+                .default("continue")
+                .describe('"continue" (default): resolve conflicts, stage them, then resume the sequencer. ' +
+                '"abort": roll back to the pre-cherry-pick HEAD.'),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            const action = args.action ?? "continue";
+            const inProgressSha = await cherryPickHead(gitTop);
+            if (!inProgressSha) {
+                return jsonRespond({ error: ERROR_CODES.NO_CHERRY_PICK_IN_PROGRESS });
+            }
+            const preHeadProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+            const preHead = preHeadProbe.ok ? preHeadProbe.stdout.trim() : "";
+            // --- abort: reuse the same hardened abort helper/reporting as git_cherry_pick ---
+            if (action === "abort") {
+                const abort = await abortCherryPick(gitTop);
+                if (!abort.ok) {
+                    return jsonRespond({
+                        ok: false,
+                        action: "abort",
+                        error: ERROR_CODES.CHERRY_PICK_ABORT_FAILED,
+                        ...spreadDefined("abortDetail", abort.detail),
+                    });
+                }
+                const headProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+                const headSha = headProbe.ok ? headProbe.stdout.trim() : undefined;
+                if (args.format === "json") {
+                    return jsonRespond({ ok: true, action: "abort", ...spreadDefined("headSha", headSha) });
+                }
+                return renderCherryPickContinueMarkdown("abort", true, 0, headSha);
+            }
+            // --- continue: precheck no unmerged paths remain ---
+            const unmerged = await conflictPaths(gitTop);
+            if (unmerged.length > 0) {
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_UNRESOLVED_PATHS,
+                    paths: unmerged,
+                });
+            }
+            // `-c core.editor=true` avoids launching an interactive editor for the reused commit message.
+            const r = await spawnGitAsync(gitTop, [
+                "-c",
+                "core.editor=true",
+                "cherry-pick",
+                "--continue",
+            ]);
+            if (!r.ok) {
+                const failedSha = await cherryPickHead(gitTop);
+                const paths = failedSha ? await conflictPaths(gitTop) : [];
+                if (failedSha && paths.length > 0) {
+                    // A later commit in the same range conflicted — report it the same shape as a
+                    // paused git_cherry_pick call so the caller can loop this tool to resolution.
+                    const adv = await spawnGitAsync(gitTop, ["rev-list", "--count", `${preHead}..HEAD`]);
+                    const applied = adv.ok ? parseInt(adv.stdout.trim(), 10) || 0 : 0;
+                    const conflict = {
+                        stage: "cherry-pick",
+                        paused: true,
+                        ...spreadDefined("commit", failedSha),
+                        paths,
+                        ...spreadDefined("detail", (r.stderr || r.stdout).trim() || undefined),
+                    };
+                    if (args.format === "json") {
+                        return jsonRespond({ ok: false, action: "continue", applied, conflict });
+                    }
+                    return renderCherryPickContinueMarkdown("continue", false, applied, undefined, conflict);
+                }
+                // Not a new conflict (e.g. the resolved pick would produce an empty commit) —
+                // surface a generic, non-resumable-loop error with whatever detail git gave.
+                return jsonRespond({
+                    error: ERROR_CODES.CHERRY_PICK_CONTINUE_FAILED,
+                    ...spreadDefined("commit", failedSha),
+                    detail: (r.stderr || r.stdout).trim(),
+                });
+            }
+            // --- success: sequencer completed the resolved pick and any remaining ones ---
+            const adv = await spawnGitAsync(gitTop, ["rev-list", "--count", `${preHead}..HEAD`]);
+            const applied = adv.ok ? parseInt(adv.stdout.trim(), 10) || 0 : 0;
+            const headProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+            const headSha = headProbe.ok ? headProbe.stdout.trim() : undefined;
+            if (args.format === "json") {
+                return jsonRespond({
+                    ok: true,
+                    action: "continue",
+                    applied,
+                    ...spreadDefined("headSha", headSha),
+                });
+            }
+            return renderCherryPickContinueMarkdown("continue", true, applied, headSha);
+        },
+    });
+}

package/dist/server/git-conflicts-tool.js

@@ -0,0 +1,230 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+import { ERROR_CODES } from "./error-codes.js";
+import { spawnGitAsync } from "./git.js";
+import { conflictPaths } from "./git-refs.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Operation-state detection
+// ---------------------------------------------------------------------------
+/** Resolve the repo's git directory (handles worktrees, where it is not literally `<top>/.git`). */
+async function resolveGitDir(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["rev-parse", "--git-dir"]);
+    if (!r.ok)
+        return null;
+    const raw = r.stdout.trim();
+    if (!raw)
+        return null;
+    return isAbsolute(raw) ? raw : join(gitTop, raw);
+}
+/** Detect the in-progress operation, if any, via marker files/dirs under the git dir. */
+export async function detectConflictState(gitTop) {
+    const gitDir = await resolveGitDir(gitTop);
+    if (!gitDir)
+        return undefined;
+    if (existsSync(join(gitDir, "MERGE_HEAD")))
+        return "merge";
+    if (existsSync(join(gitDir, "CHERRY_PICK_HEAD")))
+        return "cherry-pick";
+    if (existsSync(join(gitDir, "REVERT_HEAD")))
+        return "revert";
+    if (existsSync(join(gitDir, "rebase-merge")) || existsSync(join(gitDir, "rebase-apply"))) {
+        return "rebase";
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Conflict marker parsing
+// ---------------------------------------------------------------------------
+const OURS_MARKER = "<<<<<<<";
+const BASE_MARKER = "|||||||";
+const SPLIT_MARKER = "=======";
+const THEIRS_MARKER = ">>>>>>>";
+function labelAfterMarker(line, marker) {
+    const rest = line.slice(marker.length).trim();
+    return rest.length > 0 ? rest : undefined;
+}
+/**
+ * Parse `<<<<<<<`/`|||||||`/`=======`/`>>>>>>>` conflict markers out of file text.
+ * Only the first `maxLinesPerFile` lines are scanned; when the file is longer,
+ * `truncated: true` is reported and any hunk still open at the cutoff is dropped
+ * rather than emitted half-formed. An incomplete hunk at EOF (corrupt/missing
+ * closing marker within the scan window) also sets `truncated: true`.
+ */
+export function parseConflictHunks(text, maxLinesPerFile) {
+    const allLines = text.split("\n");
+    const truncatedByCap = allLines.length > maxLinesPerFile;
+    const lines = truncatedByCap ? allLines.slice(0, maxLinesPerFile) : allLines;
+    const hunks = [];
+    let state = "outside";
+    let cur = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const lineNo = i + 1;
+        if (line.startsWith(OURS_MARKER)) {
+            cur = {
+                startLine: lineNo,
+                oursLines: [],
+                baseLines: [],
+                theirsLines: [],
+                oursLabel: labelAfterMarker(line, OURS_MARKER),
+            };
+            state = "ours";
+            continue;
+        }
+        if (state === "ours" && line.startsWith(BASE_MARKER)) {
+            state = "base";
+            continue;
+        }
+        if ((state === "ours" || state === "base") && line.startsWith(SPLIT_MARKER)) {
+            state = "theirs";
+            continue;
+        }
+        if (state === "theirs" && line.startsWith(THEIRS_MARKER) && cur) {
+            cur.theirsLabel = labelAfterMarker(line, THEIRS_MARKER);
+            hunks.push({
+                startLine: cur.startLine,
+                ours: cur.oursLines.join("\n"),
+                theirs: cur.theirsLines.join("\n"),
+                ...spreadWhen(cur.baseLines.length > 0, { base: cur.baseLines.join("\n") }),
+                ...spreadDefined("oursLabel", cur.oursLabel),
+                ...spreadDefined("theirsLabel", cur.theirsLabel),
+            });
+            cur = null;
+            state = "outside";
+            continue;
+        }
+        if (!cur)
+            continue;
+        if (state === "ours")
+            cur.oursLines.push(line);
+        else if (state === "base")
+            cur.baseLines.push(line);
+        else if (state === "theirs")
+            cur.theirsLines.push(line);
+    }
+    // Incomplete open hunk at EOF (or at the line-cap) → flag truncated so callers
+    // know markers were present but not fully parsed.
+    const truncated = truncatedByCap || cur !== null;
+    return { hunks, truncated };
+}
+/** Conservative binary sniff: a NUL byte in the first 8000 bytes. */
+function isLikelyBinary(buf) {
+    const len = Math.min(buf.length, 8000);
+    for (let i = 0; i < len; i++) {
+        if (buf[i] === 0)
+            return true;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Per-file resolution
+// ---------------------------------------------------------------------------
+export function readConflictFile(gitTop, relPath, maxLinesPerFile) {
+    const resolved = resolvePathForRepo(relPath, gitTop);
+    if (!assertRelativePathUnderTop(relPath, resolved, gitTop)) {
+        return { path: relPath, error: ERROR_CODES.PATH_ESCAPES_REPO };
+    }
+    let buf;
+    try {
+        buf = readFileSync(resolved);
+    }
+    catch {
+        return { path: relPath };
+    }
+    if (isLikelyBinary(buf)) {
+        return { path: relPath };
+    }
+    const { hunks, truncated } = parseConflictHunks(buf.toString("utf8"), maxLinesPerFile);
+    return {
+        path: relPath,
+        ...spreadWhen(hunks.length > 0, { hunks }),
+        ...spreadWhen(truncated, { truncated: true }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderConflictsMarkdown(result) {
+    const lines = ["# Git conflicts"];
+    if (result.state)
+        lines.push(`_state: ${result.state}_`);
+    lines.push("");
+    if (result.files.length === 0) {
+        lines.push("_(no conflicts)_");
+        return lines.join("\n");
+    }
+    for (const f of result.files) {
+        lines.push(`## ${f.path}`);
+        if (f.error)
+            lines.push(`_error: ${f.error}_`);
+        if (f.truncated)
+            lines.push("_(truncated)_");
+        if (!f.hunks || f.hunks.length === 0) {
+            lines.push("_(no parsed hunks — unreadable, binary, or no markers found)_", "");
+            continue;
+        }
+        for (const h of f.hunks) {
+            lines.push(`### hunk @ line ${h.startLine}`);
+            lines.push(`**ours${h.oursLabel ? ` (${h.oursLabel})` : ""}:**`, "```", h.ours, "```");
+            if (h.base !== undefined) {
+                lines.push("**base:**", "```", h.base, "```");
+            }
+            lines.push(`**theirs${h.theirsLabel ? ` (${h.theirsLabel})` : ""}:**`, "```", h.theirs, "```");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitConflictsTool(server) {
+    server.addTool({
+        name: "git_conflicts",
+        description: "Inspect unresolved merge conflicts after git_merge/git_cherry_pick reports them. " +
+            "Reports the in-progress operation (merge/cherry-pick/revert/rebase, when detectable) and, " +
+            "per conflicted file, the parsed ours/theirs (and base, for diff3-style markers) hunks.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.extend({
+            withHunks: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Parse conflict-marker hunks per file. Set false for just the path list."),
+            maxLinesPerFile: z
+                .number()
+                .int()
+                .min(1)
+                .max(2000)
+                .optional()
+                .default(200)
+                .describe("Cap on lines scanned per file before marking `truncated: true`."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            const state = await detectConflictState(gitTop);
+            const paths = await conflictPaths(gitTop);
+            const withHunks = args.withHunks !== false;
+            const maxLinesPerFile = typeof args.maxLinesPerFile === "number" ? args.maxLinesPerFile : 200;
+            const files = paths.map((p) => withHunks ? readConflictFile(gitTop, p, maxLinesPerFile) : { path: p });
+            const result = {
+                ...spreadDefined("state", state),
+                files,
+            };
+            if (args.format === "json") {
+                return jsonRespond(result);
+            }
+            return renderConflictsMarkdown(result);
+        },
+    });
+}