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

package/dist/server/git-refs.js

@@ -51,13 +51,14 @@ export function isProtectedBranch(name) {
  * Conservative check for branch/ref names passed to git argv.
  * Rejects anything outside the ASCII subset `A-Z a-z 0-9 _ . / + -`,
  * sequences git itself rejects (`..`, `@{`, leading `-`, trailing `.lock`/`/`),
- * and pathological tokens.
+ * leading `+` (git force-refspec), and pathological tokens.
  */
 export function isSafeGitRefToken(s) {
     const t = s.trim();
     if (t.length === 0 || t.length > 256)
         return false;
-    if (t.startsWith("-"))
+    // Leading `-` is a git option; leading `+` is a force-update refspec.
+    if (t.startsWith("-") || t.startsWith("+"))
         return false;
     if (t.endsWith("/") || t.endsWith(".lock") || t.endsWith("."))
         return false;
@@ -70,32 +71,52 @@ export function isSafeGitRefToken(s) {
     return /^[A-Za-z0-9_./+-]+$/.test(t);
 }
 /**
- * Same as `isSafeGitRefToken` but also allows `~N` / `^N` ancestor notation used
- * by `git reset --soft HEAD~3`. Permits `~` and `^` suffix characters.
+ * Same as `isSafeGitCommitIsh` — trailing `~N` / `^N` ancestor notation used
+ * by `git reset --soft HEAD~3`, plus the full `isSafeGitRefToken` base guards
+ * (`..`, `.lock`, `//`, `@{`, leading `+/-`, etc.). Kept as a named export for
+ * call sites that only need ancestor-capable single refs (not ranges).
  */
 export function isSafeGitAncestorRef(s) {
+    return isSafeGitCommitIsh(s);
+}
+/**
+ * Same as `isSafeGitRefToken`, but also accepts a trailing run of ancestor
+ * operators (`~N` / `^N`, mixable and order-independent, e.g. `HEAD~3`,
+ * `main^2`, `v1.0.0~2^1`) as used by commit-ish arguments to `git diff`,
+ * `git blame`, and `git show`. The base name (everything before the first
+ * ancestor operator) must itself pass `isSafeGitRefToken` — so all of that
+ * function's guards (leading `-`/`+`, `..`, `.lock` suffix, `//`, `@{`,
+ * whitespace, `:`, etc.) still apply. Ancestor operators are only permitted
+ * as a trailing suffix run, not embedded mid-name (e.g. `a~b` is rejected).
+ */
+export function isSafeGitCommitIsh(s) {
     const t = s.trim();
     if (t.length === 0 || t.length > 256)
         return false;
-    if (t.startsWith("-"))
+    const suffixMatch = /(?:[~^][0-9]*)+$/.exec(t);
+    const base = suffixMatch ? t.slice(0, suffixMatch.index) : t;
+    if (base.length === 0)
         return false;
-    return /^[A-Za-z0-9_./+~^-]+$/.test(t);
+    return isSafeGitRefToken(base);
 }
 /**
  * Same as `isSafeGitRefToken` but also allows the `A..B` / `A...B` range forms
- * used by `git log` / `git cherry-pick`. Splits once and validates each side.
+ * used by `git log` / `git cherry-pick` / `git_diff_summary`. Splits once and
+ * validates each side (and the no-range single-ref fallthrough) with
+ * `isSafeGitCommitIsh`, so ancestor notation (`HEAD~3`, `main^2`) is accepted
+ * on either endpoint, e.g. `HEAD~3..HEAD` or `main...feature^2`.
  */
 export function isSafeGitRangeToken(s) {
     const t = s.trim();
     if (t.includes("...")) {
         const parts = t.split("...");
-        return parts.length === 2 && parts.every((p) => isSafeGitRefToken(p));
+        return parts.length === 2 && parts.every((p) => isSafeGitCommitIsh(p));
     }
     if (t.includes("..")) {
         const parts = t.split("..");
-        return parts.length === 2 && parts.every((p) => isSafeGitRefToken(p));
+        return parts.length === 2 && parts.every((p) => isSafeGitCommitIsh(p));
     }
-    return isSafeGitRefToken(t);
+    return isSafeGitCommitIsh(t);
 }
 // ---------------------------------------------------------------------------
 // Async helpers
@@ -218,11 +239,16 @@ export async function commitListBetween(cwd, excludeRef, includeRef) {
         .map((l) => l.trim())
         .filter((l) => l.length > 0);
 }
-/** Parse `git worktree list --porcelain` into structured entries. */
+/**
+ * Parse `git worktree list --porcelain` into structured entries.
+ * Returns `{ ok: false, detail }` when git fails — callers must not treat
+ * failure as an empty worktree list.
+ */
 export async function listWorktrees(cwd) {
     const r = await spawnGitAsync(cwd, ["worktree", "list", "--porcelain"]);
-    if (!r.ok)
-        return [];
+    if (!r.ok) {
+        return { ok: false, detail: (r.stderr || r.stdout).trim() || "git worktree list failed" };
+    }
     const out = [];
     let cur = {};
     for (const line of r.stdout.split("\n")) {
@@ -245,12 +271,17 @@ export async function listWorktrees(cwd) {
     }
     if (cur.path)
         out.push({ path: cur.path, branch: cur.branch ?? null, head: cur.head ?? null });
-    return out;
+    return { ok: true, worktrees: out };
 }
-/** Path of the worktree currently checked out on `branch`; `null` if none. */
+/**
+ * Path of the worktree currently checked out on `branch`; `null` if none
+ * or if listing worktrees failed (fail closed for destructive callers).
+ */
 export async function worktreeForBranch(cwd, branch) {
-    const trees = await listWorktrees(cwd);
-    const hit = trees.find((t) => t.branch === branch);
+    const listed = await listWorktrees(cwd);
+    if (!listed.ok)
+        return null;
+    const hit = listed.worktrees.find((t) => t.branch === branch);
     return hit?.path ?? null;
 }
 // ---------------------------------------------------------------------------

package/dist/server/git-reset-soft-tool.js

@@ -15,7 +15,7 @@ export function registerGitResetSoftTool(server) {
             destructiveHint: false,
             idempotentHint: false,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             ref: z
                 .string()
                 .min(1)

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

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { ERROR_CODES } from "./error-codes.js";
+import { spawnGitAsync } from "./git.js";
+import { conflictPaths, isSafeGitAncestorRef, isWorkingTreeClean } from "./git-refs.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** SHA of REVERT_HEAD (the commit currently mid-revert), or undefined once resolved/absent. */
+async function revertHead(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["rev-parse", "--verify", "--quiet", "REVERT_HEAD"]);
+    if (!r.ok)
+        return undefined;
+    const sha = r.stdout.trim();
+    return sha === "" ? undefined : sha;
+}
+/** Result of attempting `git revert --abort` — callers must check `ok` before claiming a clean abort. */
+export async function abortRevert(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["revert", "--abort"]);
+    if (r.ok)
+        return { ok: true };
+    const detail = (r.stderr || r.stdout).trim();
+    return detail === "" ? { ok: false } : { ok: false, detail };
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitRevertTool(server) {
+    server.addTool({
+        name: "git_revert",
+        description: "`git revert`: creates new commit(s) that undo the changes introduced by one or more source " +
+            "commits. Unlike `git_reset_soft`, this never rewrites history — safe on shared/pushed branches. " +
+            "Refuses on a dirty tree. On conflict, aborts and returns the tree clean. `noCommit` stages the " +
+            "revert(s) without committing (working tree intentionally left staged in that case). `mainline` " +
+            "selects the parent to diff against when reverting a merge commit.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            sources: z
+                .array(z.string().min(1))
+                .min(1)
+                .max(20)
+                .describe("Commits to revert, applied in order: SHA, branch/tag name, or ancestor notation (`HEAD~1`)."),
+            noCommit: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Pass `--no-commit`: apply the revert(s) to the index/working tree without committing " +
+                "(changes are left staged instead)."),
+            mainline: z
+                .number()
+                .int()
+                .min(1)
+                .optional()
+                .describe("Parent number (`-m N`) to diff against — required when reverting a merge commit."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const { gitTop } = pre;
+            // --- Validate sources ---
+            for (const raw of args.sources) {
+                if (!isSafeGitAncestorRef(raw)) {
+                    return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, source: raw });
+                }
+            }
+            // --- Refuse dirty tree ---
+            if (!(await isWorkingTreeClean(gitTop))) {
+                return jsonRespond({
+                    error: ERROR_CODES.WORKING_TREE_DIRTY,
+                    detail: "git_revert requires a clean working tree. Commit or stash pending changes first.",
+                });
+            }
+            const preHeadProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+            const preHead = preHeadProbe.ok ? preHeadProbe.stdout.trim() : "";
+            const revertArgs = ["revert"];
+            if (args.noCommit)
+                revertArgs.push("--no-commit");
+            if (args.mainline !== undefined)
+                revertArgs.push("-m", String(args.mainline));
+            revertArgs.push(...args.sources);
+            const r = await spawnGitAsync(gitTop, revertArgs);
+            if (!r.ok) {
+                const failedSha = await revertHead(gitTop);
+                const paths = await conflictPaths(gitTop);
+                const abortResult = await abortRevert(gitTop);
+                return jsonRespond({
+                    ok: false,
+                    aborted: abortResult.ok,
+                    ...spreadDefined("commit", failedSha),
+                    conflicts: paths,
+                    ...spreadDefined("detail", (r.stderr || r.stdout).trim() || undefined),
+                    ...spreadWhen(!abortResult.ok, {
+                        error: ERROR_CODES.REVERT_ABORT_FAILED,
+                        ...spreadDefined("abortDetail", abortResult.detail),
+                    }),
+                });
+            }
+            // --- No-commit: revert(s) staged, no new commits ---
+            if (args.noCommit) {
+                const stagedResult = await spawnGitAsync(gitTop, ["diff", "--cached", "--name-only"]);
+                const stagedFiles = stagedResult.ok
+                    ? stagedResult.stdout
+                        .split("\n")
+                        .map((l) => l.trim())
+                        .filter((l) => l.length > 0)
+                    : [];
+                if (args.format === "json") {
+                    return jsonRespond({
+                        ok: true,
+                        staged: true,
+                        sources: args.sources,
+                        stagedCount: stagedFiles.length,
+                    });
+                }
+                return [
+                    "# Revert (staged, not committed)",
+                    `${args.sources.length} source(s) → ${stagedFiles.length} file(s) staged`,
+                    ...args.sources.map((s) => `- ${s}`),
+                ].join("\n");
+            }
+            // --- Committed: one new commit per source, oldest-first ---
+            const newCommitsResult = await spawnGitAsync(gitTop, [
+                "rev-list",
+                "--reverse",
+                `${preHead}..HEAD`,
+            ]);
+            const newCommits = newCommitsResult.ok
+                ? newCommitsResult.stdout
+                    .split("\n")
+                    .map((l) => l.trim())
+                    .filter((l) => l.length > 0)
+                : [];
+            const reverted = [];
+            for (let i = 0; i < args.sources.length; i++) {
+                const source = args.sources[i];
+                const sha = newCommits[i];
+                if (source !== undefined && sha !== undefined)
+                    reverted.push({ source, sha });
+            }
+            if (args.format === "json") {
+                return jsonRespond({
+                    ok: true,
+                    reverted,
+                });
+            }
+            const lines = [`# Revert: ${reverted.length} commit(s)`, ""];
+            for (const item of reverted) {
+                lines.push(`- ${item.source} → ${item.sha.slice(0, 7)}`);
+            }
+            return lines.join("\n");
+        },
+    });
+}

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

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
 import { ERROR_CODES } from "./error-codes.js";
 import { spawnGitAsync } from "./git.js";
-import { isSafeGitAncestorRef } from "./git-refs.js";
+import { isSafeGitCommitIsh } from "./git-refs.js";
 import { jsonRespond } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -39,6 +39,7 @@ async function runGitShow(opts) {
     if (!r.ok) {
         return {
             error: ERROR_CODES.GIT_SHOW_FAILED,
+            detail: (r.stderr || r.stdout).trim(),
         };
     }
     // Parse the output. For a commit, git show outputs:
@@ -156,17 +157,11 @@ export function registerGitShowTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
-            .pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        })
-            .extend({
+        parameters: WorkspacePickSchema.extend({
             ref: z
                 .string()
                 .min(1)
-                .describe("Commit reference (SHA, branch, tag, or any git rev-spec)."),
+                .describe('Commit reference (SHA, branch, tag, or ancestor notation like "HEAD~3", "main^2").'),
             path: z
                 .string()
                 .optional()
@@ -185,7 +180,7 @@ export function registerGitShowTool(server) {
             if (!pre.ok)
                 return jsonRespond(pre.error);
             const top = pre.gitTop;
-            if (!isSafeGitAncestorRef(args.ref)) {
+            if (!isSafeGitCommitIsh(args.ref)) {
                 return jsonRespond({ error: ERROR_CODES.UNSAFE_REF_TOKEN, ref: args.ref });
             }
             if (args.path !== undefined) {

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

@@ -1,77 +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.omit({ absoluteGitRoots: true, allWorkspaceRoots: true }).pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        }),
-        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) {
@@ -80,20 +15,16 @@ 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.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
-            .pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        })
-            .extend({
+        parameters: WorkspacePickSchema.extend({
             index: z
                 .number()
                 .int()
                 .min(0)
+                .max(10000)
                 .optional()
                 .default(0)
                 .describe("Stash index (defaults to 0 for stash@{0})."),
@@ -113,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-status-tool.js

@@ -4,7 +4,7 @@ import { isStrictlyUnderGitTop } from "../repo-paths.js";
 import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitStatusShortBranchAsync, gitTopLevel, hasGitMetadata, parseGitSubmodulePaths, } from "./git.js";
 import { jsonRespond } from "./json.js";
 import { requireGitAndRoots } from "./roots.js";
-import { WorkspacePickSchema } from "./schemas.js";
+import { RootPickSchema } from "./schemas.js";
 export function registerGitStatusTool(server) {
     server.addTool({
         name: "git_status",
@@ -12,7 +12,7 @@ export function registerGitStatusTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.extend({
+        parameters: RootPickSchema.extend({
             includeSubmodules: z.boolean().optional().default(true),
         }),
         execute: async (args) => {

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,19 +39,13 @@ 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,
             destructiveHint: true,
         },
-        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
-            .pick({
-            workspaceRoot: true,
-            rootIndex: true,
-            format: true,
-        })
-            .extend({
+        parameters: WorkspacePickSchema.extend({
             tag: z.string().min(1).describe("Tag name (e.g. 'v1.2.3')."),
             message: z
                 .string()
@@ -75,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
@@ -97,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