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

package/dist/repo-paths.js

@@ -1,26 +1,70 @@
 import { realpathSync } from "node:fs";
-import { isAbsolute, relative, resolve } from "node:path";
-function realPathOrSelf(p) {
-    try {
-        return realpathSync(p);
-    }
-    catch {
-        return p;
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+function isErrno(err, codes) {
+    const code = err?.code;
+    return typeof code === "string" && codes.includes(code);
+}
+/**
+ * Canonicalize for confinement: realpath the longest existing prefix, then
+ * append any missing trailing segments lexically.
+ *
+ * Fail closed (`null`) when realpath fails for a reason other than a missing
+ * path component (ENOENT/ENOTDIR), or when nothing on the chain resolves —
+ * never return the unresolved input (avoids symlink+missing-leaf false-accept).
+ */
+function realpathForConfinement(absPath) {
+    const abs = resolve(absPath);
+    const missing = [];
+    let cur = abs;
+    for (;;) {
+        try {
+            const resolved = realpathSync(cur);
+            return missing.length === 0 ? resolved : join(resolved, ...missing);
+        }
+        catch (err) {
+            if (!isErrno(err, ["ENOENT", "ENOTDIR"])) {
+                return null;
+            }
+            const parent = dirname(cur);
+            if (parent === cur) {
+                return null;
+            }
+            missing.unshift(basename(cur));
+            cur = parent;
+        }
     }
 }
-export function isStrictlyUnderGitTop(absPath, gitTop) {
-    const absR = realPathOrSelf(resolve(absPath));
-    const topR = realPathOrSelf(resolve(gitTop));
-    const rel = relative(topR, absR);
+/** True when `relative(top, path)` is inside or equal to top (not `..` / `../…`). */
+function isRelativeInsideTop(rel) {
     if (rel === "")
         return true;
-    return !rel.startsWith("..") && !isAbsolute(rel);
+    // Exact `..` or `../` / `..\` only — do not treat a segment named `..foo` as escape.
+    if (rel === ".." || rel.startsWith(`..${sep}`))
+        return false;
+    return !isAbsolute(rel);
+}
+export function isStrictlyUnderGitTop(absPath, gitTop) {
+    let topR;
+    try {
+        topR = realpathSync(resolve(gitTop));
+    }
+    catch {
+        return false;
+    }
+    const absR = realpathForConfinement(absPath);
+    if (absR === null)
+        return false;
+    return isRelativeInsideTop(relative(topR, absR));
 }
 export function resolvePathForRepo(p, gitTop) {
     const t = p.trim();
     return isAbsolute(t) ? resolve(t) : resolve(gitTop, t);
 }
 /** Resolved path must lie inside git toplevel (relative or absolute user input). */
-export function assertRelativePathUnderTop(_relPath, absResolved, gitTop) {
+export function assertRelativePathUnderTop(userPath, absResolved, gitTop) {
+    // Use the caller-supplied path: reject mismatched abs vs resolvePathForRepo.
+    if (resolvePathForRepo(userPath, gitTop) !== absResolved) {
+        return false;
+    }
     return isStrictlyUnderGitTop(absResolved, gitTop);
 }

package/dist/server/batch-commit-tool.js

@@ -1,6 +1,8 @@
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import { z } from "zod";
-import { isStrictlyUnderGitTop, resolvePathForRepo } from "../repo-paths.js";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
 import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
 import { getCurrentBranch, inferRemoteFromUpstream } from "./git-refs.js";
@@ -13,8 +15,16 @@ const FileEntrySchema = z.union([
         path: z.string().min(1).describe("File path relative to git root."),
         lines: z
             .object({
-            from: z.number().int().min(1).describe("Start line number (1-indexed)."),
-            to: z.number().int().min(1).describe("End line number (1-indexed, inclusive)."),
+            from: z.number().int().min(1).max(1000000).describe("Start line number (1-indexed)."),
+            to: z
+                .number()
+                .int()
+                .min(1)
+                .max(1000000)
+                .describe("End line number (1-indexed, inclusive)."),
+        })
+            .refine((l) => l.from <= l.to, {
+            message: "lines.from must be <= lines.to",
         })
             .describe("Line range to stage. Only hunks overlapping [from, to] are staged."),
     }),
@@ -25,7 +35,10 @@ const CommitEntrySchema = z.object({
         .array(FileEntrySchema)
         .min(1)
         .describe("Paths to stage, relative to git root. String or `{ path, lines }` for hunk-level staging. " +
-        "Deleted tracked files are staged via `git rm --cached`. Cannot combine `lines` with a deleted file."),
+        "Each path is staged individually (`git add` / `git apply --cached` / `git rm --cached`); " +
+        "on mid-entry stage failure, already-staged paths for that entry are unstaged. " +
+        "Deleted tracked files are staged via `git rm --cached`. Cannot combine `lines` with a deleted file. " +
+        "Rejects `.`, the repo root, and directory pathspecs."),
 });
 const PushModeSchema = z
     .enum(["never", "after"])
@@ -37,7 +50,30 @@ const DryRunSchema = z
     .boolean()
     .optional()
     .default(false)
-    .describe("Stage files and return a preview without writing commits; unstages afterwards. Response is marked DRY RUN.");
+    .describe("Stage files and return a preview without writing commits; restores the index afterwards. Response is marked DRY RUN.");
+/**
+ * True when `path` would stage the whole tree or a directory (not a single file).
+ * Rejects `.`, `./`, paths resolving to gitTop, trailing-slash directory forms,
+ * and on-disk directories.
+ */
+function isWholeTreeOrDirectoryPathspec(path, gitTop) {
+    const t = path.trim();
+    if (t === "" || t === "." || t === "./")
+        return true;
+    if (t.endsWith("/") || t.endsWith("/.") || t.endsWith("/.."))
+        return true;
+    const abs = resolvePathForRepo(path, gitTop);
+    if (resolve(abs) === resolve(gitTop))
+        return true;
+    try {
+        if (existsSync(abs) && statSync(abs).isDirectory())
+            return true;
+    }
+    catch {
+        // ignore stat errors — treat as non-directory
+    }
+    return false;
+}
 /**
  * Parses a unified diff to extract hunks that overlap with a given line range.
  * Returns a partial patch containing only the overlapping hunks, including header lines.
@@ -119,7 +155,10 @@ function extractOverlappingHunks(diffContent, fromLine, toLine) {
             i++;
         }
     }
-    return result.length > fileHeaderLines.length ? result.join("\n") : null;
+    // Trailing newline is required: when the selected hunk(s) aren't the last hunk in the
+    // real diff, the last copied line is a content line that had a newline after it in the
+    // original diff output. Dropping it produces a patch `git apply` rejects as corrupt.
+    return result.length > fileHeaderLines.length ? `${result.join("\n")}\n` : null;
 }
 /**
  * Stages a file with optional line range. If lines are provided, only hunks
@@ -151,23 +190,42 @@ async function stageFile(gitTop, filePath, lines) {
             error: addResult.ok ? undefined : (addResult.stderr || addResult.stdout).trim(),
         };
     }
-    // Line range case: extract overlapping hunks and apply patch
-    const diffResult = await spawnGitAsync(gitTop, ["diff", filePath]);
-    if (!diffResult.ok) {
-        return { ok: false, error: (diffResult.stderr || diffResult.stdout).trim() };
+    // Line range case: extract overlapping hunks and apply patch.
+    // Tracked files: unstaged worktree vs index (`git diff -- path`).
+    // Untracked files: synthesize a new-file diff via `--no-index` (exit 1 with
+    // differences is expected — treat non-empty stdout as success).
+    const tracked = await spawnGitAsync(gitTop, ["ls-files", "--error-unmatch", "--", filePath]);
+    let diffStdout;
+    if (tracked.ok) {
+        const diffResult = await spawnGitAsync(gitTop, ["diff", "--", filePath]);
+        if (!diffResult.ok && !diffResult.stdout.trim()) {
+            return { ok: false, error: (diffResult.stderr || diffResult.stdout).trim() };
+        }
+        diffStdout = diffResult.stdout;
+    }
+    else {
+        const diffResult = await spawnGitAsync(gitTop, [
+            "diff",
+            "--no-index",
+            "--",
+            "/dev/null",
+            filePath,
+        ]);
+        // --no-index exits 1 when files differ; accept stdout as the patch body.
+        if (!diffResult.stdout.trim()) {
+            return {
+                ok: false,
+                error: (diffResult.stderr || diffResult.stdout || "No hunks found in line range").trim(),
+            };
+        }
+        diffStdout = diffResult.stdout;
     }
-    const partialPatch = extractOverlappingHunks(diffResult.stdout, lines.from, lines.to);
+    const partialPatch = extractOverlappingHunks(diffStdout, lines.from, lines.to);
     if (!partialPatch) {
         return { ok: false, error: "No hunks found in line range" };
     }
-    // Resolve the real git dir (works for linked worktrees where .git is a file, not a dir)
-    const gitDirResult = await spawnGitAsync(gitTop, ["rev-parse", "--absolute-git-dir"]);
-    if (!gitDirResult.ok) {
-        return { ok: false, error: (gitDirResult.stderr || gitDirResult.stdout).trim() };
-    }
-    const gitDir = gitDirResult.stdout.trim();
-    // Write partial patch to temp file in the git dir and apply it to the index
-    const tempPatchFile = `${gitDir}/.mcp-patch-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`;
+    // Write partial patch to a temp file outside the git dir (avoids orphan files in .git)
+    const tempPatchFile = join(tmpdir(), `.mcp-patch-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`);
     const { writeFileSync, unlinkSync } = await import("node:fs");
     writeFileSync(tempPatchFile, partialPatch, "utf8");
     const applyResult = await spawnGitAsync(gitTop, ["apply", "--cached", tempPatchFile]);
@@ -218,14 +276,18 @@ export function registerBatchCommitTool(server) {
     server.addTool({
         name: "batch_commit",
         description: "Create multiple sequential git commits in one call. " +
-            "Each entry stages its files then commits. Stops on first failure. " +
+            "Each entry stages its files then commits. Unrelated pre-staged index paths " +
+            "are temporarily unstaged around the commit so they are not included " +
+            "(hunk-level staging is preserved — pathspec commit mode is not used). " +
+            "Stops on first failure; mid-entry stage failures unstage that entry's " +
+            "already-staged paths. " +
             'Optional `push: "after"` pushes after all commits succeed. `dryRun: true` previews without writing.',
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             commits: z
                 .array(CommitEntrySchema)
                 .min(1)
@@ -240,18 +302,18 @@ export function registerBatchCommitTool(server) {
                 return jsonRespond(pre.error);
             const gitTop = pre.gitTop;
             const results = [];
-            const stagedFilesForCleanup = new Set();
-            // Snapshot already-staged paths BEFORE the preview loop so dry-run cleanup
-            // doesn't unstage files the caller had staged before invoking.
-            let preStagedPaths = new Set();
+            // Snapshot the full index before dry-run so cleanup restores pre-staged
+            // paths even when dryRun stages additional hunks onto the same paths.
+            let indexTreeBefore;
             if (args.dryRun) {
-                const snapResult = await spawnGitAsync(gitTop, ["diff", "--cached", "--name-only"]);
-                if (snapResult.ok) {
-                    preStagedPaths = new Set(snapResult.stdout
-                        .split("\n")
-                        .map((s) => s.trim())
-                        .filter(Boolean));
+                const wt = await spawnGitAsync(gitTop, ["write-tree"]);
+                if (!wt.ok) {
+                    return jsonRespond({
+                        error: ERROR_CODES.COMMIT_FAILED,
+                        detail: (wt.stderr || wt.stdout).trim() || "failed to snapshot index before dryRun",
+                    });
                 }
+                indexTreeBefore = wt.stdout.trim();
             }
             for (let i = 0; i < args.commits.length; i++) {
                 const entry = args.commits[i];
@@ -260,21 +322,38 @@ export function registerBatchCommitTool(server) {
                 // Normalize file entries to { path, lines? } format
                 const fileEntries = [];
                 const filePaths = [];
+                let invalidLineRange = false;
                 for (const fileEntry of entry.files) {
                     if (typeof fileEntry === "string") {
                         fileEntries.push({ path: fileEntry });
                         filePaths.push(fileEntry);
                     }
                     else {
+                        if (fileEntry.lines.from > fileEntry.lines.to) {
+                            invalidLineRange = true;
+                            filePaths.push(fileEntry.path);
+                            break;
+                        }
                         fileEntries.push(fileEntry);
                         filePaths.push(fileEntry.path);
                     }
                 }
+                if (invalidLineRange) {
+                    results.push({
+                        index: i,
+                        ok: false,
+                        message: entry.message,
+                        files: filePaths,
+                        error: ERROR_CODES.INVALID_LINE_RANGE,
+                        detail: "lines.from must be <= lines.to",
+                    });
+                    break;
+                }
                 // --- Validate all paths are under the git toplevel ---
                 const escapedPaths = [];
                 for (const path of filePaths) {
                     const abs = resolvePathForRepo(path, gitTop);
-                    if (!isStrictlyUnderGitTop(abs, gitTop)) {
+                    if (!assertRelativePathUnderTop(path, abs, gitTop)) {
                         escapedPaths.push(path);
                     }
                 }
@@ -289,9 +368,23 @@ export function registerBatchCommitTool(server) {
                     });
                     break;
                 }
+                // --- Reject `.` / repo-root / directory pathspecs ---
+                const invalidPaths = filePaths.filter((p) => isWholeTreeOrDirectoryPathspec(p, gitTop));
+                if (invalidPaths.length > 0) {
+                    results.push({
+                        index: i,
+                        ok: false,
+                        message: entry.message,
+                        files: filePaths,
+                        error: ERROR_CODES.INVALID_PATHS,
+                        detail: `directory or whole-tree pathspec rejected: ${invalidPaths.join(", ")}`,
+                    });
+                    break;
+                }
                 // --- Stage files (with optional line ranges) ---
                 let stagingFailed = false;
                 let stagingError = "";
+                const stagedSoFar = [];
                 for (const fileEntry of fileEntries) {
                     const stageResult = await stageFile(gitTop, fileEntry.path, fileEntry.lines);
                     if (!stageResult.ok) {
@@ -299,8 +392,14 @@ export function registerBatchCommitTool(server) {
                         stagingError = stageResult.error || "Unknown error";
                         break;
                     }
+                    stagedSoFar.push(fileEntry.path);
                 }
                 if (stagingFailed) {
+                    // Unstage anything this entry already staged (live + dryRun).
+                    // dryRun final cleanup also restores via read-tree when available.
+                    if (stagedSoFar.length > 0) {
+                        await spawnGitAsync(gitTop, ["restore", "--staged", "--", ...stagedSoFar]);
+                    }
                     results.push({
                         index: i,
                         ok: false,
@@ -312,19 +411,16 @@ export function registerBatchCommitTool(server) {
                     });
                     break;
                 }
-                // Track staged files for cleanup in dry-run, excluding paths that were
-                // already staged before this call (so pre-existing staged state survives).
+                // --- Dry-run mode: collect preview scoped to this entry's paths ---
                 if (args.dryRun) {
-                    for (const path of filePaths) {
-                        if (!preStagedPaths.has(path)) {
-                            stagedFilesForCleanup.add(path);
-                        }
-                    }
-                }
-                // --- Dry-run mode: collect preview and unstage ---
-                if (args.dryRun) {
-                    // Get diff stat for this staged entry
-                    const diffStatResult = await spawnGitAsync(gitTop, ["diff", "--staged", "--stat"]);
+                    // Path-scoped stat so multi-entry previews do not accumulate prior entries.
+                    const diffStatResult = await spawnGitAsync(gitTop, [
+                        "diff",
+                        "--staged",
+                        "--stat",
+                        "--",
+                        ...filePaths,
+                    ]);
                     const diffStat = diffStatResult.ok ? (diffStatResult.stdout || "").trim() : undefined;
                     results.push({
                         index: i,
@@ -334,11 +430,55 @@ export function registerBatchCommitTool(server) {
                         staged: filePaths,
                         ...spreadDefined("diffStat", diffStat || undefined),
                     });
-                    continue; // Skip actual commit in dry-run mode
+                    // Unstage this entry before the next so the next entry's staging starts clean
+                    // relative to the snapshot (final read-tree still restores pre-call index).
+                    await spawnGitAsync(gitTop, ["restore", "--staged", "--", ...filePaths]);
+                    continue;
+                }
+                // --- Commit: isolate entry files from unrelated pre-staged index paths ---
+                // `git commit -- <paths>` uses --only (worktree) mode and would squash
+                // hunk-level staging. Instead: snapshot index, temporarily unstage
+                // unrelated staged paths, commit from the index, then restore them.
+                const stagedNamesResult = await spawnGitAsync(gitTop, ["diff", "--cached", "--name-only"]);
+                const stagedNames = stagedNamesResult.ok
+                    ? stagedNamesResult.stdout
+                        .split("\n")
+                        .map((s) => s.trim())
+                        .filter(Boolean)
+                    : [];
+                const entryPathSet = new Set(filePaths);
+                const unrelatedStaged = stagedNames.filter((p) => !entryPathSet.has(p));
+                let indexSnap;
+                if (unrelatedStaged.length > 0) {
+                    const wt = await spawnGitAsync(gitTop, ["write-tree"]);
+                    if (!wt.ok) {
+                        results.push({
+                            index: i,
+                            ok: false,
+                            message: entry.message,
+                            files: filePaths,
+                            error: ERROR_CODES.COMMIT_FAILED,
+                            detail: (wt.stderr || wt.stdout).trim() ||
+                                "failed to snapshot index for pre-staged path isolation",
+                        });
+                        break;
+                    }
+                    indexSnap = wt.stdout.trim();
+                    await spawnGitAsync(gitTop, ["restore", "--staged", "--", ...unrelatedStaged]);
                 }
-                // --- Commit ---
                 const commitResult = await spawnGitAsync(gitTop, ["commit", "-m", entry.message]);
                 if (!commitResult.ok) {
+                    // Restore unrelated staged paths even on failure so we don't leave the
+                    // index worse than when we entered this entry.
+                    if (indexSnap && unrelatedStaged.length > 0) {
+                        await spawnGitAsync(gitTop, [
+                            "restore",
+                            `--source=${indexSnap}`,
+                            "--staged",
+                            "--",
+                            ...unrelatedStaged,
+                        ]);
+                    }
                     const gitOutput = (commitResult.stderr || commitResult.stdout).trim();
                     results.push({
                         index: i,
@@ -351,6 +491,15 @@ export function registerBatchCommitTool(server) {
                     });
                     break;
                 }
+                if (indexSnap && unrelatedStaged.length > 0) {
+                    await spawnGitAsync(gitTop, [
+                        "restore",
+                        `--source=${indexSnap}`,
+                        "--staged",
+                        "--",
+                        ...unrelatedStaged,
+                    ]);
+                }
                 // --- Extract SHA from commit output ---
                 const shaMatch = /\[[\w/.-]+\s+([0-9a-f]+)\]/.exec(commitResult.stdout);
                 const gitOutput = (commitResult.stdout || commitResult.stderr).trim();
@@ -363,10 +512,9 @@ export function registerBatchCommitTool(server) {
                     ...spreadDefined("output", gitOutput || undefined),
                 });
             }
-            // --- In dry-run mode, unstage all files ---
-            if (args.dryRun && stagedFilesForCleanup.size > 0) {
-                const filesToReset = Array.from(stagedFilesForCleanup);
-                await spawnGitAsync(gitTop, ["reset", "HEAD", "--", ...filesToReset]);
+            // --- In dry-run mode, restore the full pre-call index ---
+            if (args.dryRun && indexTreeBefore) {
+                await spawnGitAsync(gitTop, ["read-tree", indexTreeBefore]);
             }
             const allOk = results.length === args.commits.length && results.every((r) => r.ok);
             // --- Optional push after all commits succeed (not in dry-run mode) ---
@@ -381,8 +529,10 @@ export function registerBatchCommitTool(server) {
                         index: r.index,
                         ok: r.ok,
                         ...spreadDefined("sha", r.sha),
-                        message: r.message,
-                        files: r.files,
+                        // message/files are the caller's own request echoed back — only worth
+                        // repeating on failure, where the caller needs them to diagnose without
+                        // cross-referencing the request.
+                        ...spreadWhen(!r.ok, { message: r.message, files: r.files }),
                         ...spreadDefined("staged", r.staged),
                         ...spreadDefined("diffStat", r.diffStat),
                         ...spreadDefined("error", r.error),

package/dist/server/error-codes.js

@@ -14,15 +14,12 @@ export const ERROR_CODES = {
     // Repository resolution
     NOT_A_GIT_REPOSITORY: "not_a_git_repository",
     NO_WORKSPACE_ROOT: "no_workspace_root",
-    ROOT_INDEX_OUT_OF_RANGE: "root_index_out_of_range",
-    // absoluteGitRoots validation
-    ABSOLUTE_GIT_ROOTS_EMPTY: "absolute_git_roots_empty",
-    ABSOLUTE_GIT_ROOTS_EXCLUSIVE: "absolute_git_roots_exclusive",
-    ABSOLUTE_GIT_ROOTS_NESTED_OR_PRESET_CONFLICT: "absolute_git_roots_nested_or_preset_conflict",
-    ABSOLUTE_GIT_ROOTS_PRESET_CONFLICT: "absolute_git_roots_preset_conflict",
-    ABSOLUTE_GIT_ROOTS_SINGLE_REPO_ONLY: "absolute_git_roots_single_repo_only",
-    ABSOLUTE_GIT_ROOTS_TOO_MANY: "absolute_git_roots_too_many",
-    INVALID_ABSOLUTE_GIT_ROOT: "invalid_absolute_git_root",
+    // `root` array validation
+    INVALID_ROOT_PATH: "invalid_root_path",
+    ROOT_LIST_EMPTY: "root_list_empty",
+    ROOT_LIST_NESTED_OR_PRESET_CONFLICT: "root_list_nested_or_preset_conflict",
+    ROOT_LIST_PRESET_CONFLICT: "root_list_preset_conflict",
+    ROOT_LIST_TOO_MANY: "root_list_too_many",
     // Presets
     PRESET_FILE_INVALID: "preset_file_invalid",
     PRESET_NOT_FOUND: "preset_not_found",
@@ -32,7 +29,13 @@ export const ERROR_CODES = {
     INVALID_PATHS: "invalid_paths",
     INVALID_REMOTE_OR_BRANCH: "invalid_remote_or_branch",
     INVALID_SINCE: "invalid_since",
+    /** Canonical path-escape wire string (grep/diff/blame/show/stash). */
     PATH_ESCAPES_REPO: "path_escapes_repo",
+    /**
+     * Legacy path-escape alias used by `batch_commit`. Same failure class as
+     * `PATH_ESCAPES_REPO`; clients should treat both as equivalent until a
+     * future contract bump unifies them (Worker P owns batch_commit migration).
+     */
     PATH_ESCAPES_REPOSITORY: "path_escapes_repository",
     UNSAFE_RANGE_TOKEN: "unsafe_range_token",
     UNSAFE_REF_TOKEN: "unsafe_ref_token",
@@ -43,8 +46,11 @@ export const ERROR_CODES = {
     ONTO_DETACHED_HEAD: "onto_detached_head",
     PROTECTED_BRANCH: "protected_branch",
     WORKING_TREE_DIRTY: "working_tree_dirty",
-    // Branch list
-    BRANCH_LIST_FAILED: "branch_list_failed",
+    // Branch create/delete/rename
+    BRANCH_CREATE_FAILED: "branch_create_failed",
+    BRANCH_DELETE_FAILED: "branch_delete_failed",
+    BRANCH_RENAME_FAILED: "branch_rename_failed",
+    MISSING_NEW_NAME: "missing_new_name",
     // Commit / stage
     COMMIT_FAILED: "commit_failed",
     STAGE_FAILED: "stage_failed",
@@ -52,16 +58,15 @@ export const ERROR_CODES = {
     GIT_DIFF_FAILED: "git_diff_failed",
     // Log
     GIT_LOG_FAILED: "git_log_failed",
+    // Grep (pickaxe)
+    GIT_GREP_FAILED: "git_grep_failed",
     // Show
     GIT_SHOW_FAILED: "git_show_failed",
     // Blame
     GIT_BLAME_FAILED: "git_blame_failed",
-    // Reflog
-    REFLOG_FAILED: "reflog_failed",
     // Stash
-    STASH_LIST_FAILED: "stash_list_failed",
-    // Fetch
-    // (uses UNSAFE_REMOTE_TOKEN and UNSAFE_REF_TOKEN)
+    STASH_APPLY_FAILED: "stash_apply_failed",
+    STASH_PUSH_FAILED: "stash_push_failed",
     // Push
     PUSH_DETACHED_HEAD: "push_detached_head",
     PUSH_FAILED: "push_failed",
@@ -69,16 +74,26 @@ export const ERROR_CODES = {
     // Merge
     CANNOT_FAST_FORWARD: "cannot_fast_forward",
     DESTINATION_NOT_FOUND: "destination_not_found",
+    MERGE_ABORT_FAILED: "merge_abort_failed",
     MERGE_BASE_FAILED: "merge_base_failed",
     MERGE_CONFLICTS: "merge_conflicts",
     MERGE_FAILED: "merge_failed",
+    REBASE_ABORT_FAILED: "rebase_abort_failed",
     REBASE_CONFLICTS: "rebase_conflicts",
     SOURCE_NOT_FOUND: "source_not_found",
     // Cherry-pick
     CHECKOUT_FAILED: "checkout_failed",
+    CHERRY_PICK_ABORT_FAILED: "cherry_pick_abort_failed",
+    CHERRY_PICK_CONTINUE_FAILED: "cherry_pick_continue_failed",
+    CHERRY_PICK_IN_PROGRESS: "cherry_pick_in_progress",
+    CHERRY_PICK_TOO_MANY_COMMITS: "cherry_pick_too_many_commits",
+    CHERRY_PICK_UNRESOLVED_PATHS: "cherry_pick_unresolved_paths",
+    NO_CHERRY_PICK_IN_PROGRESS: "no_cherry_pick_in_progress",
     RANGE_RESOLUTION_FAILED: "range_resolution_failed",
     // Reset
     RESET_FAILED: "reset_failed",
+    // Revert
+    REVERT_ABORT_FAILED: "revert_abort_failed",
     // Tag
     REF_NOT_FOUND: "ref_not_found",
     TAG_CREATE_FAILED: "tag_create_failed",