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

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

@@ -1,73 +1,12 @@
 import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
 import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
-import { jsonRespond, spreadDefined } from "./json.js";
+import { conflictPaths } from "./git-refs.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
 // ---------------------------------------------------------------------------
-// git_stash_list
-// ---------------------------------------------------------------------------
-export function registerGitStashListTool(server) {
-    server.addTool({
-        name: "git_stash_list",
-        description: "List all git stashes.",
-        annotations: {
-            readOnlyHint: true,
-        },
-        parameters: WorkspacePickSchema,
-        execute: async (args) => {
-            const pre = requireSingleRepo(server, args);
-            if (!pre.ok)
-                return jsonRespond(pre.error);
-            const { gitTop } = pre;
-            // List all stashes: git stash list --format='%(refname:short)|%(subject)|%(objectname:short)'
-            // git stash list uses git-log format (%s, %h) not for-each-ref format %(subject).
-            const r = await spawnGitAsync(gitTop, ["stash", "list", "--format=%gd|%s|%h"]);
-            if (!r.ok) {
-                // If there are no stashes, git still returns ok=true with empty output
-                // Only treat as error if git itself failed
-                return jsonRespond({
-                    error: ERROR_CODES.STASH_LIST_FAILED,
-                    detail: (r.stderr || r.stdout).trim(),
-                });
-            }
-            const stashes = [];
-            const lines = (r.stdout || "")
-                .split("\n")
-                .map((l) => l.trim())
-                .filter((l) => l.length > 0);
-            for (const line of lines) {
-                const parts = line.split("|");
-                // parts[0] = stash@{N}, last part = short SHA, middle = message (may contain "|")
-                const sha = parts[parts.length - 1];
-                const message = parts.slice(1, -1).join("|");
-                // Parse the real stash index from the canonical stash@{N} ref in parts[0].
-                const indexMatch = parts[0] ? /stash@\{(\d+)\}/.exec(parts[0]) : null;
-                if (!indexMatch || parts.length < 3 || !message || !sha) {
-                    // Malformed line — skip without affecting index tracking.
-                    continue;
-                }
-                stashes.push({
-                    index: Number(indexMatch[1]),
-                    message,
-                    sha,
-                });
-            }
-            if (args.format === "json") {
-                return jsonRespond({ stashes });
-            }
-            if (stashes.length === 0) {
-                return "# Stashes\n_(none)_";
-            }
-            const lines_out = ["# Stashes", ""];
-            for (const s of stashes) {
-                lines_out.push(`- **stash@{${s.index}}** — ${s.message}  (\`${s.sha}\`)`);
-            }
-            return lines_out.join("\n");
-        },
-    });
-}
-// ---------------------------------------------------------------------------
 // git_stash_apply
 // ---------------------------------------------------------------------------
 export function registerGitStashApplyTool(server) {
@@ -76,7 +15,8 @@ export function registerGitStashApplyTool(server) {
         description: "Apply or pop a git stash. `index` defaults to 0. `pop: true` removes stash after applying.",
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            // pop:true deletes a stash entry — treat the tool as destructive for client filters.
+            destructiveHint: true,
             idempotentHint: false,
         },
         parameters: WorkspacePickSchema.extend({
@@ -104,19 +44,122 @@ export function registerGitStashApplyTool(server) {
             const r = await spawnGitAsync(gitTop, ["stash", cmd, stashRef]);
             const applied = r.ok;
             const output = (r.stdout || r.stderr).trim();
+            // On apply/pop failure, surface unresolved conflict paths when present
+            // (mirrors merge/cherry-pick/revert). Leave the tree as git left it —
+            // stash conflicts are not auto-aborted.
+            const paths = applied ? [] : await conflictPaths(gitTop);
             if (args.format === "json") {
                 return jsonRespond({
+                    ...spreadWhen(!applied, { error: ERROR_CODES.STASH_APPLY_FAILED }),
                     applied,
                     stashIndex: args.index,
                     popped: args.pop,
-                    ...spreadDefined("output", output),
+                    ...spreadDefined("output", output || undefined),
+                    ...spreadWhen(paths.length > 0, { conflictPaths: paths }),
                 });
             }
             const verb = args.pop ? "popped" : "applied";
             if (applied) {
                 return `# Stash ${verb}\n✓ ${stashRef}  → ${verb}`;
             }
-            return `# Stash ${verb} (failed)\n✗ ${stashRef}\n\n\`\`\`\n${output}\n\`\`\``;
+            const conflictBlock = paths.length > 0 ? `\n\nConflicts:\n${paths.map((p) => `- ${p}`).join("\n")}` : "";
+            return `# Stash ${verb} (failed)\n✗ ${stashRef}\n\n\`\`\`\n${output}\n\`\`\`${conflictBlock}`;
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// git_stash_push
+// ---------------------------------------------------------------------------
+export function registerGitStashPushTool(server) {
+    server.addTool({
+        name: "git_stash_push",
+        description: "Stash working-tree changes (`git stash push`). Optional `message` for the stash subject, " +
+            "`includeUntracked` (-u) to also stash untracked files, `keepIndex` (--keep-index) to leave " +
+            "staged changes in the index, and `paths` to scope the stash to specific files. " +
+            "Returns the new stash ref/SHA, or `stashed: false` if there was nothing to stash.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            message: z
+                .string()
+                .optional()
+                .describe("Stash subject message (`git stash push -m <message>`)."),
+            includeUntracked: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Include untracked files in the stash (`git stash push -u`)."),
+            keepIndex: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Keep staged changes in the index after stashing (`git stash push --keep-index`)."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe("Scope the stash to specific paths, relative to git root (must resolve within repo root)."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const { gitTop } = pre;
+            // Union + dedup + confine paths within the repo (escaping-attempt rejected).
+            const rawPaths = [];
+            if (Array.isArray(args.paths)) {
+                for (const p of args.paths) {
+                    if (typeof p === "string" && p.trim()) {
+                        rawPaths.push(p.trim());
+                    }
+                }
+            }
+            const dedupedPaths = [...new Set(rawPaths)];
+            for (const p of dedupedPaths) {
+                const resolved = resolvePathForRepo(p, gitTop);
+                if (!assertRelativePathUnderTop(p, resolved, gitTop)) {
+                    return jsonRespond({ error: ERROR_CODES.PATH_ESCAPES_REPO, path: p });
+                }
+            }
+            const stashArgs = ["stash", "push"];
+            if (args.includeUntracked)
+                stashArgs.push("-u");
+            if (args.keepIndex)
+                stashArgs.push("--keep-index");
+            if (args.message)
+                stashArgs.push("-m", args.message);
+            if (dedupedPaths.length > 0)
+                stashArgs.push("--", ...dedupedPaths);
+            const r = await spawnGitAsync(gitTop, stashArgs);
+            const output = (r.stdout || r.stderr).trim();
+            if (!r.ok) {
+                return jsonRespond({
+                    error: ERROR_CODES.STASH_PUSH_FAILED,
+                    detail: output,
+                });
+            }
+            // `git stash push` exits 0 with this message when there is nothing to stash.
+            if (/no local changes to save/i.test(output)) {
+                if (args.format === "json") {
+                    return jsonRespond({ stashed: false, reason: "no_local_changes" });
+                }
+                return "# Stash push\n_(no local changes to save)_";
+            }
+            const shaResult = await spawnGitAsync(gitTop, ["rev-parse", "stash@{0}"]);
+            const sha = shaResult.ok ? shaResult.stdout.trim() : "";
+            const subjectResult = await spawnGitAsync(gitTop, ["log", "-1", "--format=%s", "stash@{0}"]);
+            const message = subjectResult.ok ? subjectResult.stdout.trim() : "";
+            if (args.format === "json") {
+                return jsonRespond({
+                    stashed: true,
+                    ref: "stash@{0}",
+                    sha,
+                    message,
+                });
+            }
+            return `# Stash pushed\n✓ stash@{0} — ${message}${sha ? `  (\`${sha}\`)` : ""}`;
         },
     });
 }

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ERROR_CODES } from "./error-codes.js";
-import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
+import { spawnGitAsync } from "./git.js";
+import { isSafeGitCommitIsh, isSafeGitRefToken } from "./git-refs.js";
 import { jsonRespond } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -38,7 +39,7 @@ async function getTagType(gitTop, tag) {
 export function registerGitTagTool(server) {
     server.addTool({
         name: "git_tag",
-        description: "Create, delete, or inspect git tags. Create annotated tags (with message) or lightweight tags (ref only). " +
+        description: "Create or delete git tags. Create annotated tags (with message) or lightweight tags (ref only). " +
             "Returns tag name, type, and SHA.",
         annotations: {
             readOnlyHint: false,
@@ -69,8 +70,8 @@ export function registerGitTagTool(server) {
             if (!tag) {
                 return jsonRespond({ error: ERROR_CODES.EMPTY_TAG_NAME });
             }
-            // Validate tag name: no shell metacharacters
-            if (!isSafeGitUpstreamToken(tag)) {
+            // Validate tag name with ref-token rules (rejects .lock, //, etc.).
+            if (!isSafeGitRefToken(tag)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_TAG_TOKEN, tag });
             }
             // Handle deletion
@@ -91,9 +92,9 @@ export function registerGitTagTool(server) {
                 }
                 return `Deleted tag: ${tag}`;
             }
-            // Determine the ref to tag (default HEAD)
+            // Determine the ref to tag (default HEAD). Commit-ish allows HEAD~1 / main^2.
             const ref = (args.ref ?? "HEAD").trim();
-            if (!isSafeGitUpstreamToken(ref)) {
+            if (!isSafeGitCommitIsh(ref)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref });
             }
             // Get the SHA of the ref to tag

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

@@ -1,4 +1,4 @@
-import { resolve } from "node:path";
+import { basename, resolve } from "node:path";
 import { z } from "zod";
 import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
@@ -6,38 +6,29 @@ import { isProtectedBranch, isSafeGitRefToken, listWorktrees, } from "./git-refs
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
-// ---------------------------------------------------------------------------
-// git_worktree_list
-// ---------------------------------------------------------------------------
-export function registerGitWorktreeListTool(server) {
-    server.addTool({
-        name: "git_worktree_list",
-        description: "List all git worktrees for the repository (`git worktree list --porcelain`).",
-        annotations: {
-            readOnlyHint: true,
-        },
-        parameters: WorkspacePickSchema,
-        execute: async (args) => {
-            const pre = requireSingleRepo(server, args);
-            if (!pre.ok)
-                return jsonRespond(pre.error);
-            const { gitTop } = pre;
-            const trees = await listWorktrees(gitTop);
-            if (args.format === "json") {
-                return jsonRespond({ worktrees: trees });
-            }
-            if (trees.length === 0) {
-                return "# Worktrees\n_(none)_";
-            }
-            const lines = ["# Worktrees", ""];
-            for (const t of trees) {
-                const branchPart = t.branch ?? "(detached)";
-                const headPart = t.head ? ` @ ${t.head.slice(0, 7)}` : "";
-                lines.push(`- \`${t.path}\`  ${branchPart}${headPart}`);
-            }
-            return lines.join("\n");
-        },
-    });
+/**
+ * Resolve a worktree path for add/remove.
+ *
+ * Sibling worktrees outside `gitTop` are intentional (absolute or relative).
+ * Still refuse empty/whitespace, NUL bytes, and leading-dash / option-like
+ * path tokens so git does not treat the operand as a flag. Callers must pass
+ * the resolved path after `--` in argv.
+ */
+function resolveWorktreePath(gitTop, rawPath) {
+    const trimmed = rawPath.trim();
+    if (trimmed.length === 0 || trimmed.includes("\0")) {
+        return { ok: false, error: ERROR_CODES.INVALID_PATHS, path: rawPath };
+    }
+    // Reject option-like tokens before resolve (relative "-foo") and after
+    // (absolute paths whose basename still starts with `-`, e.g. "/tmp/-evil").
+    if (trimmed.startsWith("-") || basename(trimmed).startsWith("-")) {
+        return { ok: false, error: ERROR_CODES.INVALID_PATHS, path: rawPath };
+    }
+    const wtPath = resolve(gitTop, trimmed);
+    if (basename(wtPath).startsWith("-")) {
+        return { ok: false, error: ERROR_CODES.INVALID_PATHS, path: rawPath };
+    }
+    return { ok: true, path: wtPath };
 }
 // ---------------------------------------------------------------------------
 // git_worktree_add
@@ -55,7 +46,8 @@ export function registerGitWorktreeAddTool(server) {
             path: z
                 .string()
                 .min(1)
-                .describe("Filesystem path for the new worktree (relative paths resolved from git toplevel)."),
+                .describe("Filesystem path for the new worktree (relative paths resolved from git toplevel). " +
+                "Sibling directories outside the repo toplevel are allowed; leading `-` and NUL are rejected."),
             branch: z
                 .string()
                 .min(1)
@@ -70,34 +62,40 @@ export function registerGitWorktreeAddTool(server) {
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const { gitTop } = pre;
+            const branch = args.branch.trim();
+            const baseRef = args.baseRef !== undefined ? args.baseRef.trim() : undefined;
             // Validate branch
-            if (!isSafeGitRefToken(args.branch)) {
+            if (!isSafeGitRefToken(branch)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.branch });
             }
-            if (isProtectedBranch(args.branch)) {
-                return jsonRespond({ error: ERROR_CODES.PROTECTED_BRANCH, branch: args.branch });
+            if (isProtectedBranch(branch)) {
+                return jsonRespond({ error: ERROR_CODES.PROTECTED_BRANCH, branch });
             }
-            if (args.baseRef !== undefined && !isSafeGitRefToken(args.baseRef)) {
+            if (baseRef !== undefined && !isSafeGitRefToken(baseRef)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.baseRef });
             }
-            // Resolve path
-            const wtPath = resolve(gitTop, args.path);
+            const resolved = resolveWorktreePath(gitTop, args.path);
+            if (!resolved.ok) {
+                return jsonRespond({ error: resolved.error, path: resolved.path });
+            }
+            const wtPath = resolved.path;
             // Check if branch already exists
             const branchCheck = await spawnGitAsync(gitTop, [
                 "show-ref",
                 "--verify",
                 "--quiet",
-                `refs/heads/${args.branch}`,
+                `refs/heads/${branch}`,
             ]);
             const branchExists = branchCheck.ok;
+            // Path must follow `--` so a leading-dash path cannot be parsed as an option.
             let gitArgs;
             if (branchExists) {
-                gitArgs = ["worktree", "add", wtPath, args.branch];
+                gitArgs = ["worktree", "add", "--", wtPath, branch];
             }
             else {
-                gitArgs = ["worktree", "add", "-b", args.branch, wtPath];
-                if (args.baseRef)
-                    gitArgs.push(args.baseRef);
+                gitArgs = ["worktree", "add", "-b", branch, "--", wtPath];
+                if (baseRef)
+                    gitArgs.push(baseRef);
             }
             const r = await spawnGitAsync(gitTop, gitArgs);
             if (!r.ok) {
@@ -111,13 +109,13 @@ export function registerGitWorktreeAddTool(server) {
                 return jsonRespond({
                     ok: true,
                     path: wtPath,
-                    branch: args.branch,
+                    branch,
                     created: !branchExists,
-                    ...spreadDefined("baseRef", !branchExists ? (args.baseRef ?? "HEAD") : undefined),
+                    ...spreadDefined("baseRef", !branchExists ? (baseRef ?? "HEAD") : undefined),
                 });
             }
-            const createdNote = branchExists ? "" : ` (new branch from ${args.baseRef ?? "HEAD"})`;
-            return `# Worktree added\n✓ ${wtPath}  →  ${args.branch}${createdNote}`;
+            const createdNote = branchExists ? "" : ` (new branch from ${baseRef ?? "HEAD"})`;
+            return `# Worktree added\n✓ ${wtPath}  →  ${branch}${createdNote}`;
         },
     });
 }
@@ -137,7 +135,8 @@ export function registerGitWorktreeRemoveTool(server) {
             path: z
                 .string()
                 .min(1)
-                .describe("Path of the worktree to remove. Must not be the main worktree."),
+                .describe("Path of the worktree to remove. Must not be the main worktree. " +
+                "Sibling paths outside the repo toplevel are allowed; leading `-` and NUL are rejected."),
             force: z
                 .boolean()
                 .optional()
@@ -149,20 +148,33 @@ export function registerGitWorktreeRemoveTool(server) {
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const { gitTop } = pre;
+            const resolved = resolveWorktreePath(gitTop, args.path);
+            if (!resolved.ok) {
+                return jsonRespond({ error: resolved.error, path: resolved.path });
+            }
+            const wtPath = resolved.path;
             // Refuse to remove the main worktree
-            const wtPath = resolve(gitTop, args.path);
             if (wtPath === gitTop) {
                 return jsonRespond({ error: ERROR_CODES.CANNOT_REMOVE_MAIN_WORKTREE, path: wtPath });
             }
             // Verify it exists in the worktree list
-            const trees = await listWorktrees(gitTop);
+            const listed = await listWorktrees(gitTop);
+            if (!listed.ok) {
+                return jsonRespond({
+                    ok: false,
+                    error: ERROR_CODES.WORKTREE_REMOVE_FAILED,
+                    detail: listed.detail,
+                });
+            }
+            const trees = listed.worktrees;
             const isRegistered = trees.some((t) => t.path === wtPath || t.path === args.path);
             if (!isRegistered) {
                 return jsonRespond({ error: ERROR_CODES.WORKTREE_NOT_FOUND, path: args.path });
             }
-            const removeArgs = ["worktree", "remove", wtPath];
+            const removeArgs = ["worktree", "remove"];
             if (args.force)
                 removeArgs.push("--force");
+            removeArgs.push("--", wtPath);
             const r = await spawnGitAsync(gitTop, removeArgs);
             if (!r.ok) {
                 return jsonRespond({