@selfagency/git-mcp 0.1.0

package/index.js

@@ -0,0 +1,2950 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z11 } from "zod";
+
+// src/config.ts
+import path from "path";
+function parseCliRepoPath() {
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if ((arg === "--repo" || arg === "--repo-path") && i + 1 < args.length) {
+      return args[i + 1];
+    }
+    const match = /^--repo(?:-path)?=(.+)$/.exec(arg);
+    if (match?.[1]) return match[1];
+  }
+  return void 0;
+}
+var configured = process.env["GIT_REPO_PATH"] ?? parseCliRepoPath();
+var DEFAULT_REPO_PATH = configured ? path.resolve(configured) : void 0;
+function resolveRepoPath(repoPath) {
+  const resolved = repoPath ?? DEFAULT_REPO_PATH;
+  if (!resolved) {
+    throw new Error(
+      "No repository path provided. Pass repo_path in the tool request, or configure a server default via the GIT_REPO_PATH environment variable or the --repo / --repo-path CLI argument."
+    );
+  }
+  return resolved;
+}
+var ALLOW_NO_VERIFY = process.env["GIT_ALLOW_NO_VERIFY"] === "true";
+var ALLOW_FORCE_PUSH = process.env["GIT_ALLOW_FORCE_PUSH"] === "true";
+var DEFAULT_SIGNING_KEY = process.env["GIT_SIGNING_KEY"] || void 0;
+var DEFAULT_SIGNING_FORMAT = process.env["GIT_SIGNING_FORMAT"] || void 0;
+var AUTO_SIGN_COMMITS = process.env["GIT_AUTO_SIGN_COMMITS"] === "true";
+var AUTO_SIGN_TAGS = process.env["GIT_AUTO_SIGN_TAGS"] === "true";
+
+// src/constants.ts
+var SERVER_NAME = "git-mcp-server";
+var SERVER_VERSION = "0.1.0";
+var CHARACTER_LIMIT = 25e3;
+var EXCLUDED_DIFF_DIRECTORIES = ["node_modules/", ".yarn/", ".astro/", "dist/"];
+var EXCLUDED_DIFF_EXTENSIONS = [
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "ico",
+  "webp",
+  "bmp",
+  "tiff",
+  "mp4",
+  "mp3",
+  "wav",
+  "ogg",
+  "pdf",
+  "woff",
+  "woff2",
+  "ttf",
+  "eot",
+  "zip",
+  "tar",
+  "gz"
+];
+
+// src/resources/git.resources.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/git/client.ts
+import { existsSync, statSync } from "fs";
+import path2 from "path";
+import { simpleGit } from "simple-git";
+var GIT_NOT_FOUND_PATTERN = /(not found|is not recognized|ENOENT)/i;
+var PERMISSION_PATTERN = /(permission denied|EACCES|EPERM)/i;
+var CONFLICT_PATTERN = /(CONFLICT|merge conflict|rebase in progress|cherry-pick in progress)/i;
+var NETWORK_PATTERN = /(network|timed out|unable to access|could not resolve host|proxy)/i;
+function classifyError(message) {
+  if (GIT_NOT_FOUND_PATTERN.test(message)) {
+    return "missing_git";
+  }
+  if (PERMISSION_PATTERN.test(message)) {
+    return "permission";
+  }
+  if (CONFLICT_PATTERN.test(message)) {
+    return "git_conflict";
+  }
+  if (NETWORK_PATTERN.test(message)) {
+    return "network";
+  }
+  return "unknown";
+}
+function toGitError(error) {
+  if (error instanceof Error) {
+    return {
+      kind: classifyError(error.message),
+      message: error.message
+    };
+  }
+  return {
+    kind: "unknown",
+    message: String(error)
+  };
+}
+function validateRepoPath(repoPath) {
+  const resolved = path2.resolve(repoPath);
+  if (!existsSync(resolved)) {
+    throw new Error(`Repository path does not exist: ${repoPath}`);
+  }
+  if (!statSync(resolved).isDirectory()) {
+    throw new Error(`Repository path is not a directory: ${repoPath}`);
+  }
+  return resolved;
+}
+function getGit(repoPath) {
+  const safePath = validateRepoPath(repoPath);
+  return simpleGit({ baseDir: safePath, binary: "git", maxConcurrentProcesses: 6 });
+}
+
+// src/services/branch.service.ts
+async function listBranches(repoPath, all) {
+  const git = getGit(repoPath);
+  const summary = await git.branch(all ? ["-a"] : []);
+  return summary.all.map((name) => {
+    const details = Object.hasOwn(summary.branches, name) ? summary.branches[name] : void 0;
+    return {
+      name,
+      isCurrent: summary.current === name,
+      commit: details?.commit,
+      upstream: details?.label
+    };
+  });
+}
+async function createBranch(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.fromRef) {
+    if (options.checkout) {
+      await git.checkoutBranch(options.name, options.fromRef);
+    } else {
+      await git.raw(["branch", options.name, options.fromRef]);
+    }
+    return options.checkout ? `Created and checked out ${options.name} from ${options.fromRef}.` : `Created branch ${options.name} from ${options.fromRef}.`;
+  }
+  await git.branch([options.name]);
+  if (options.checkout) {
+    await git.checkout(options.name);
+  }
+  return options.checkout ? `Created and checked out ${options.name}.` : `Created branch ${options.name}.`;
+}
+async function deleteBranch(repoPath, options) {
+  const git = getGit(repoPath);
+  await git.deleteLocalBranch(options.name, options.force);
+  return `Deleted branch ${options.name}.`;
+}
+async function renameBranch(repoPath, oldName, newName) {
+  const git = getGit(repoPath);
+  await git.branch(["-m", oldName, newName]);
+  return `Renamed branch ${oldName} to ${newName}.`;
+}
+async function checkoutRef(repoPath, ref, create) {
+  const git = getGit(repoPath);
+  if (create) {
+    await git.checkoutLocalBranch(ref);
+    return `Created and checked out ${ref}.`;
+  }
+  await git.checkout(ref);
+  return `Checked out ${ref}.`;
+}
+async function setUpstream(repoPath, branch, upstream) {
+  const git = getGit(repoPath);
+  await git.raw(["branch", "--set-upstream-to", upstream, branch]);
+  return `Set upstream of ${branch} to ${upstream}.`;
+}
+
+// src/services/inspect.service.ts
+import path3 from "path";
+function truncate(text) {
+  if (text.length <= CHARACTER_LIMIT) {
+    return text;
+  }
+  return `${text.slice(0, CHARACTER_LIMIT)}
+
+[truncated to ${CHARACTER_LIMIT} characters]`;
+}
+function parseLogLine(line) {
+  const [hash, authorName, authorEmail, dateIso, ...subjectParts] = line.split("	");
+  if (!hash || !authorName || !authorEmail || !dateIso) {
+    return null;
+  }
+  return {
+    hash,
+    authorName,
+    authorEmail,
+    dateIso,
+    subject: subjectParts.join("	")
+  };
+}
+function shouldExcludeFile(filePath) {
+  if (EXCLUDED_DIFF_DIRECTORIES.some((prefix) => filePath.startsWith(prefix))) {
+    return true;
+  }
+  const extension = path3.extname(filePath).replace(/^\./, "").toLowerCase();
+  if (!extension) {
+    return false;
+  }
+  return EXCLUDED_DIFF_EXTENSIONS.includes(extension);
+}
+function buildDiffBaseArgs(options) {
+  if (options.mode === "staged") {
+    return ["diff", "--staged"];
+  }
+  if (options.mode === "refs") {
+    if (!options.fromRef || !options.toRef) {
+      throw new Error("from_ref and to_ref are required when mode='refs'");
+    }
+    return ["diff", `${options.fromRef}..${options.toRef}`];
+  }
+  return ["diff"];
+}
+async function getStatus(repoPath) {
+  const git = getGit(repoPath);
+  const status = await git.status();
+  const files = status.files.map((file) => ({
+    path: file.path,
+    index: file.index,
+    workingTree: file.working_dir
+  }));
+  return {
+    branch: status.current ?? "",
+    current: status.current ?? "",
+    tracking: status.tracking ?? "",
+    ahead: status.ahead,
+    behind: status.behind,
+    files,
+    isClean: status.isClean()
+  };
+}
+async function getLog(repoPath, options) {
+  const git = getGit(repoPath);
+  const args = [
+    "log",
+    "--date=iso-strict",
+    `--skip=${options.offset}`,
+    "-n",
+    String(options.limit),
+    "--pretty=format:%H%x09%an%x09%ae%x09%aI%x09%s"
+  ];
+  if (options.author) {
+    args.push(`--author=${options.author}`);
+  }
+  if (options.grep) {
+    args.push(`--grep=${options.grep}`);
+  }
+  if (options.since) {
+    args.push(`--since=${options.since}`);
+  }
+  if (options.until) {
+    args.push(`--until=${options.until}`);
+  }
+  if (options.filePath) {
+    args.push("--", options.filePath);
+  }
+  const output = await git.raw(args);
+  return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map(parseLogLine).filter((item) => item !== null);
+}
+async function showRef(repoPath, ref) {
+  const git = getGit(repoPath);
+  const output = await git.raw(["show", "--stat", "--patch", ref]);
+  return truncate(output);
+}
+async function getDiffSummary(repoPath, options) {
+  const git = getGit(repoPath);
+  const baseArgs = buildDiffBaseArgs(options).slice(1);
+  const summary = await git.diffSummary(baseArgs);
+  return {
+    filesChanged: summary.files.length,
+    insertions: summary.insertions,
+    deletions: summary.deletions
+  };
+}
+async function getDiff(repoPath, options) {
+  const git = getGit(repoPath);
+  const baseArgs = buildDiffBaseArgs(options);
+  if (!options.filtered) {
+    const output = await git.raw(baseArgs);
+    return truncate(output);
+  }
+  const namesOutput = await git.raw([...baseArgs, "--name-only"]);
+  const files = namesOutput.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => !shouldExcludeFile(line));
+  if (files.length === 0) {
+    return "No changed files after filtering.";
+  }
+  const chunks = [];
+  for (const filePath of files) {
+    const diff = await git.raw([...baseArgs, "--", filePath]);
+    chunks.push(`=== ${filePath} ===
+${diff.trim()}`);
+  }
+  return truncate(chunks.join("\n\n"));
+}
+async function blameFile(repoPath, filePath, ref) {
+  const git = getGit(repoPath);
+  const args = ["blame"];
+  if (ref) {
+    args.push(ref);
+  }
+  args.push("--", filePath);
+  const output = await git.raw(args);
+  return truncate(output);
+}
+async function getReflog(repoPath, limit) {
+  const git = getGit(repoPath);
+  const output = await git.raw(["reflog", "--date=iso", "-n", String(limit)]);
+  return truncate(output);
+}
+
+// src/resources/git.resources.ts
+function decodeRepoPath(value) {
+  return decodeURIComponent(value);
+}
+function stringify(data) {
+  return JSON.stringify(data, null, 2);
+}
+function registerGitResources(server2) {
+  const templateConfig = { list: void 0 };
+  server2.registerResource(
+    "git_repo_status",
+    new ResourceTemplate("git+repo://status/{repo_path}", templateConfig),
+    {
+      title: "Git Repository Status",
+      description: "Read-only repository status snapshot.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const repoPath = decodeRepoPath(String(variables.repo_path ?? ""));
+      const status = await getStatus(repoPath);
+      return {
+        contents: [{ uri: uri.toString(), mimeType: "application/json", text: stringify(status) }]
+      };
+    }
+  );
+  server2.registerResource(
+    "git_repo_log",
+    new ResourceTemplate("git+repo://log/{repo_path}", templateConfig),
+    {
+      title: "Git Repository Log",
+      description: "Read-only recent commit log.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const repoPath = decodeRepoPath(String(variables.repo_path ?? ""));
+      const commits = await getLog(repoPath, { limit: 20, offset: 0 });
+      return {
+        contents: [{ uri: uri.toString(), mimeType: "application/json", text: stringify({ commits }) }]
+      };
+    }
+  );
+  server2.registerResource(
+    "git_repo_branches",
+    new ResourceTemplate("git+repo://branches/{repo_path}", templateConfig),
+    {
+      title: "Git Repository Branches",
+      description: "Read-only branch list.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const repoPath = decodeRepoPath(String(variables.repo_path ?? ""));
+      const branches = await listBranches(repoPath, true);
+      return {
+        contents: [{ uri: uri.toString(), mimeType: "application/json", text: stringify({ branches }) }]
+      };
+    }
+  );
+  server2.registerResource(
+    "git_repo_diff",
+    new ResourceTemplate("git+repo://diff/{repo_path}", templateConfig),
+    {
+      title: "Git Repository Diff",
+      description: "Read-only unstaged + staged diff views.",
+      mimeType: "application/json"
+    },
+    async (uri, variables) => {
+      const repoPath = decodeRepoPath(String(variables.repo_path ?? ""));
+      const [unstaged, staged] = await Promise.all([
+        getDiff(repoPath, { mode: "unstaged", filtered: false }),
+        getDiff(repoPath, { mode: "staged", filtered: false })
+      ]);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: "application/json",
+            text: stringify({ unstaged, staged })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/advanced.tools.ts
+import { z as z2 } from "zod";
+
+// src/schemas/index.ts
+import { z } from "zod";
+var RepoPathSchema = z.string().min(1).optional().describe(
+  "Absolute path to the local Git repository. If omitted, falls back to the server default set via the GIT_REPO_PATH environment variable or --repo-path CLI argument."
+);
+var RefSchema = z.string().min(1, "ref is required").describe("Git reference: branch, tag, commit SHA, or HEAD expression.");
+var PaginationSchema = z.object({
+  limit: z.number().int().min(1).max(200).default(50),
+  offset: z.number().int().min(0).default(0)
+}).strict();
+var ConfirmSchema = z.boolean().default(false);
+var ResponseFormatSchema = z.enum(["markdown", "json"]).default("markdown").describe("Output format for the response.");
+
+// src/services/advanced.service.ts
+async function runStashAction(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.action === "save") {
+    const args = ["stash", "push"];
+    if (options.includeUntracked) {
+      args.push("--include-untracked");
+    }
+    if (options.message) {
+      args.push("-m", options.message);
+    }
+    const output2 = await git.raw(args);
+    return output2.trim() || "Stash saved.";
+  }
+  if (options.action === "list") {
+    const output2 = await git.raw(["stash", "list"]);
+    return output2.trim() || "No stashes.";
+  }
+  const index = options.index ?? 0;
+  if (options.action === "apply") {
+    const output2 = await git.raw(["stash", "apply", `stash@{${index}}`]);
+    return output2.trim() || `Applied stash@{${index}}.`;
+  }
+  if (options.action === "pop") {
+    const output2 = await git.raw(["stash", "pop", `stash@{${index}}`]);
+    return output2.trim() || `Popped stash@{${index}}.`;
+  }
+  const output = await git.raw(["stash", "drop", `stash@{${index}}`]);
+  return output.trim() || `Dropped stash@{${index}}.`;
+}
+async function runRebaseAction(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.action === "continue") {
+    const output2 = await git.raw(["rebase", "--continue"]);
+    return output2.trim() || "Rebase continued.";
+  }
+  if (options.action === "abort") {
+    const output2 = await git.raw(["rebase", "--abort"]);
+    return output2.trim() || "Rebase aborted.";
+  }
+  if (options.action === "skip") {
+    const output2 = await git.raw(["rebase", "--skip"]);
+    return output2.trim() || "Rebase skipped current commit.";
+  }
+  if (!options.onto) {
+    throw new Error("onto is required for rebase start.");
+  }
+  const output = await git.raw(["rebase", options.onto]);
+  return output.trim() || `Rebase started onto ${options.onto}.`;
+}
+async function runCherryPickAction(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.action === "continue") {
+    const output2 = await git.raw(["cherry-pick", "--continue"]);
+    return output2.trim() || "Cherry-pick continued.";
+  }
+  if (options.action === "abort") {
+    const output2 = await git.raw(["cherry-pick", "--abort"]);
+    return output2.trim() || "Cherry-pick aborted.";
+  }
+  if (!options.ref) {
+    throw new Error("ref is required when cherry-pick action is start.");
+  }
+  const output = await git.raw(["cherry-pick", options.ref]);
+  return output.trim() || `Cherry-picked ${options.ref}.`;
+}
+async function runBisectAction(repoPath, options) {
+  const git = getGit(repoPath);
+  switch (options.action) {
+    case "start": {
+      if (!options.badRef || !options.goodRef) {
+        throw new Error("goodRef and badRef are required for bisect start.");
+      }
+      await git.raw(["bisect", "start"]);
+      await git.raw(["bisect", "bad", options.badRef]);
+      await git.raw(["bisect", "good", options.goodRef]);
+      return `Bisect started between good=${options.goodRef} and bad=${options.badRef}.`;
+    }
+    case "good": {
+      const output = await git.raw(["bisect", "good", ...options.ref ? [options.ref] : []]);
+      return output.trim() || "Marked current commit as good.";
+    }
+    case "bad": {
+      const output = await git.raw(["bisect", "bad", ...options.ref ? [options.ref] : []]);
+      return output.trim() || "Marked current commit as bad.";
+    }
+    case "skip": {
+      const output = await git.raw(["bisect", "skip", ...options.ref ? [options.ref] : []]);
+      return output.trim() || "Skipped current bisect commit.";
+    }
+    case "run": {
+      if (!options.command) {
+        throw new Error("command is required for bisect run.");
+      }
+      const output = await git.raw(["bisect", "run", "sh", "-lc", options.command]);
+      return output.trim() || "Bisect run completed.";
+    }
+    case "reset": {
+      const output = await git.raw(["bisect", "reset"]);
+      return output.trim() || "Bisect reset.";
+    }
+  }
+}
+async function runTagAction(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.action === "list") {
+    const output = await git.tags();
+    return output.all.join("\n") || "No tags.";
+  }
+  if (options.action === "delete") {
+    if (!options.name) {
+      throw new Error("name is required for delete action.");
+    }
+    await git.tag(["-d", options.name]);
+    return `Deleted tag ${options.name}.`;
+  }
+  if (!options.name) {
+    throw new Error("name is required for create action.");
+  }
+  const shouldSign = options.sign ?? AUTO_SIGN_TAGS;
+  if (shouldSign) {
+    const key = options.signingKey ?? DEFAULT_SIGNING_KEY;
+    const signFlag = key ? ["-u", key] : ["-s"];
+    const msgFlag = options.message ? ["-m", options.message] : ["-m", options.name];
+    const targetArg = options.target ? [options.target] : [];
+    await git.raw(["tag", ...signFlag, ...msgFlag, options.name, ...targetArg]);
+    return `Created signed tag ${options.name}.`;
+  }
+  if (options.message) {
+    await git.addAnnotatedTag(options.name, options.message);
+    return `Created annotated tag ${options.name}.`;
+  }
+  await git.addTag(options.name);
+  return `Created tag ${options.name}.`;
+}
+async function runWorktreeAction(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.action === "list") {
+    const output = await git.raw(["worktree", "list", "--porcelain"]);
+    return output.trim();
+  }
+  if (options.action === "remove") {
+    if (!options.path) {
+      throw new Error("path is required for worktree remove.");
+    }
+    await git.raw(["worktree", "remove", options.path]);
+    return `Removed worktree ${options.path}.`;
+  }
+  if (!options.path || !options.branch) {
+    throw new Error("path and branch are required for worktree add.");
+  }
+  await git.raw(["worktree", "add", options.path, options.branch]);
+  return `Added worktree at ${options.path} for ${options.branch}.`;
+}
+async function runSubmoduleAction(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.action === "list") {
+    const output = await git.raw(["submodule", "status"]);
+    return output.trim() || "No submodules.";
+  }
+  if (options.action === "sync") {
+    const args = ["submodule", "sync"];
+    if (options.recursive) {
+      args.push("--recursive");
+    }
+    const output = await git.raw(args);
+    return output.trim() || "Submodule sync complete.";
+  }
+  if (options.action === "update") {
+    const args = ["submodule", "update", "--init"];
+    if (options.recursive) {
+      args.push("--recursive");
+    }
+    const output = await git.raw(args);
+    return output.trim() || "Submodule update complete.";
+  }
+  if (!options.url || !options.path) {
+    throw new Error("url and path are required for submodule add.");
+  }
+  await git.raw(["submodule", "add", options.url, options.path]);
+  return `Added submodule ${options.path}.`;
+}
+
+// src/tools/advanced.tools.ts
+function render(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+function buildError(error) {
+  const gitError = toGitError(error);
+  return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+}
+function registerAdvancedTools(server2) {
+  server2.registerTool(
+    "git_stash",
+    {
+      title: "Git Stash Actions",
+      description: "Save, list, apply, pop, or drop stash entries.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z2.enum(["save", "list", "apply", "pop", "drop"]),
+        message: z2.string().optional(),
+        index: z2.number().int().min(0).optional(),
+        include_untracked: z2.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      message,
+      index,
+      include_untracked,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runStashAction(repoPath, {
+          action,
+          message,
+          index,
+          includeUntracked: include_untracked
+        });
+        return {
+          content: [{ type: "text", text: render({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_rebase",
+    {
+      title: "Git Rebase Actions",
+      description: "Start, continue, skip, or abort rebase operations.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z2.enum(["start", "continue", "abort", "skip"]),
+        onto: z2.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      onto,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runRebaseAction(repoPath, { action, onto });
+        return {
+          content: [{ type: "text", text: render({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_cherry_pick",
+    {
+      title: "Git Cherry-pick Actions",
+      description: "Start, continue, or abort cherry-pick.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z2.enum(["start", "continue", "abort"]),
+        ref: z2.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      ref,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runCherryPickAction(repoPath, { action, ref });
+        return {
+          content: [{ type: "text", text: render({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_bisect",
+    {
+      title: "Git Bisect Actions",
+      description: "Run bisect workflows for bug isolation.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z2.enum(["start", "good", "bad", "skip", "run", "reset"]),
+        ref: z2.string().optional(),
+        good_ref: z2.string().optional(),
+        bad_ref: z2.string().optional(),
+        command: z2.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      ref,
+      good_ref,
+      bad_ref,
+      command,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runBisectAction(repoPath, {
+          action,
+          ref,
+          goodRef: good_ref,
+          badRef: bad_ref,
+          command
+        });
+        return {
+          content: [{ type: "text", text: render({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_tag",
+    {
+      title: "Git Tag Actions",
+      description: "List, create, or delete tags. Supports GPG/SSH signed tags.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z2.enum(["list", "create", "delete"]),
+        name: z2.string().optional(),
+        target: z2.string().optional(),
+        message: z2.string().optional(),
+        sign: z2.boolean().default(false).describe("Create a signed tag (-s/-u). Defaults to server AUTO_SIGN_TAGS setting."),
+        signing_key: z2.string().optional().describe("Specific signing key ID or path. Falls back to GIT_SIGNING_KEY env var."),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      name,
+      target,
+      message,
+      sign,
+      signing_key,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runTagAction(repoPath, {
+          action,
+          name,
+          target,
+          message,
+          sign,
+          signingKey: signing_key
+        });
+        return {
+          content: [{ type: "text", text: render({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_worktree",
+    {
+      title: "Git Worktree Actions",
+      description: "Add, list, or remove worktrees.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z2.enum(["add", "list", "remove"]),
+        path: z2.string().optional(),
+        branch: z2.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      path: path5,
+      branch,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runWorktreeAction(repoPath, { action, path: path5, branch });
+        return {
+          content: [{ type: "text", text: render({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_submodule",
+    {
+      title: "Git Submodule Actions",
+      description: "Add, list, update, or sync submodules.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z2.enum(["add", "list", "update", "sync"]),
+        url: z2.string().optional(),
+        path: z2.string().optional(),
+        recursive: z2.boolean().default(true),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      url,
+      path: path5,
+      recursive,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runSubmoduleAction(repoPath, {
+          action,
+          url,
+          path: path5,
+          recursive
+        });
+        return {
+          content: [{ type: "text", text: render({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError(error);
+      }
+    }
+  );
+}
+
+// src/tools/branch.tools.ts
+import { z as z3 } from "zod";
+function render2(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+function registerBranchTools(server2) {
+  server2.registerTool(
+    "git_list_branches",
+    {
+      title: "List Git Branches",
+      description: "List local branches, or all branches including remotes.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        all: z3.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      all,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const branches = await listBranches(repoPath, all);
+        return {
+          content: [{ type: "text", text: render2({ branches }, response_format) }],
+          structuredContent: { branches }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_create_branch",
+    {
+      title: "Create Git Branch",
+      description: "Create a branch from current HEAD or an explicit ref.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        name: z3.string().min(1),
+        from_ref: z3.string().optional(),
+        checkout: z3.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      name,
+      from_ref,
+      checkout,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await createBranch(repoPath, {
+          name,
+          fromRef: from_ref,
+          checkout
+        });
+        return {
+          content: [{ type: "text", text: render2({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_delete_branch",
+    {
+      title: "Delete Git Branch",
+      description: "Delete a local branch.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        name: z3.string().min(1),
+        force: z3.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      name,
+      force,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await deleteBranch(repoPath, { name, force });
+        return {
+          content: [{ type: "text", text: render2({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_rename_branch",
+    {
+      title: "Rename Git Branch",
+      description: "Rename an existing branch.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        old_name: z3.string().min(1),
+        new_name: z3.string().min(1),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      old_name,
+      new_name,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await renameBranch(repoPath, old_name, new_name);
+        return {
+          content: [{ type: "text", text: render2({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_checkout",
+    {
+      title: "Git Checkout",
+      description: "Checkout a branch, tag, or commit; optionally create a new local branch.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        ref: z3.string().min(1),
+        create: z3.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      ref,
+      create,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await checkoutRef(repoPath, ref, create);
+        return {
+          content: [{ type: "text", text: render2({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_set_upstream",
+    {
+      title: "Set Branch Upstream",
+      description: "Set the upstream tracking branch for a local branch.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        branch: z3.string().min(1),
+        upstream: z3.string().min(1),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      branch,
+      upstream,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await setUpstream(repoPath, branch, upstream);
+        return {
+          content: [{ type: "text", text: render2({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+}
+
+// src/tools/context.tools.ts
+import { z as z4 } from "zod";
+
+// src/services/context.service.ts
+import { existsSync as existsSync2 } from "fs";
+import path4 from "path";
+async function getContextSummary(repoPath) {
+  const git = getGit(repoPath);
+  const [status, commits, remotesRaw, gitDir] = await Promise.all([
+    getStatus(repoPath),
+    getLog(repoPath, { limit: 5, offset: 0 }),
+    git.getRemotes(false),
+    git.raw(["rev-parse", "--absolute-git-dir"]).then((s) => s.trim())
+  ]);
+  const rebasing = existsSync2(path4.join(gitDir, "rebase-merge")) || existsSync2(path4.join(gitDir, "rebase-apply"));
+  const merging = existsSync2(path4.join(gitDir, "MERGE_HEAD"));
+  const cherryPicking = existsSync2(path4.join(gitDir, "CHERRY_PICK_HEAD"));
+  const bisecting = existsSync2(path4.join(gitDir, "BISECT_LOG"));
+  return {
+    branch: status.current,
+    ahead: status.ahead,
+    behind: status.behind,
+    isClean: status.isClean,
+    changedFiles: status.files.length,
+    recentCommits: commits.map((commit) => ({
+      hash: commit.hash,
+      subject: commit.subject,
+      dateIso: commit.dateIso
+    })),
+    remotes: remotesRaw.map((remote) => remote.name),
+    inProgress: {
+      rebasing,
+      merging,
+      cherryPicking,
+      bisecting
+    }
+  };
+}
+async function searchHistory(repoPath, query, limit) {
+  const git = getGit(repoPath);
+  const [pickaxe, grep] = await Promise.all([
+    git.raw(["log", "-S", query, "--oneline", "-n", String(limit)]),
+    git.raw(["grep", "-n", "-m", String(limit), "--", query]).catch(() => "")
+  ]);
+  const sections = [
+    "## Pickaxe (-S)",
+    pickaxe.trim() || "No history matches.",
+    "",
+    "## grep",
+    grep.trim() || "No working-tree matches."
+  ];
+  const combined = sections.join("\n");
+  return combined.length > CHARACTER_LIMIT ? `${combined.slice(0, CHARACTER_LIMIT)}
+
+[Output truncated at ${CHARACTER_LIMIT} characters]` : combined;
+}
+var BLOCKED_CONFIG_KEY_PATTERNS = [/^credential\./i, /^url\./i];
+var SENSITIVE_KEY_PATTERNS = [/(password|token|secret|auth|passphrase)/i];
+function isBlockedConfigKey(key) {
+  return BLOCKED_CONFIG_KEY_PATTERNS.some((p) => p.test(key));
+}
+function redactConfigValue(key, value) {
+  if (SENSITIVE_KEY_PATTERNS.some((p) => p.test(key))) {
+    return "***";
+  }
+  const stripped = value.replace(/(https?:\/\/)[^@\s]+@/g, "$1***@");
+  if (/\b[0-9a-f]{40,}\b/i.test(stripped)) {
+    return "***";
+  }
+  return stripped;
+}
+async function getConfig(repoPath, key) {
+  const git = getGit(repoPath);
+  if (key) {
+    if (isBlockedConfigKey(key)) {
+      throw new Error(`Access to git config key '${key}' is not permitted.`);
+    }
+    const value = await git.raw(["config", "--get", key]);
+    return redactConfigValue(key, value.trim());
+  }
+  const output = await git.raw(["config", "--list"]);
+  const lines = output.split("\n").map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    const eq = line.indexOf("=");
+    if (eq === -1) return [];
+    const k = line.slice(0, eq);
+    const v = line.slice(eq + 1);
+    if (isBlockedConfigKey(k)) return [];
+    return [`${k}=${redactConfigValue(k, v)}`];
+  });
+  return lines.join("\n").trim();
+}
+async function setConfig(repoPath, key, value) {
+  const git = getGit(repoPath);
+  await git.raw(["config", key, value]);
+  return `Set ${key}.`;
+}
+
+// src/tools/context.tools.ts
+function render3(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+function buildError2(error) {
+  const gitError = toGitError(error);
+  return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+}
+function registerContextTools(server2) {
+  server2.registerTool(
+    "git_context_summary",
+    {
+      title: "Git Context Summary",
+      description: "High-signal repository context for LLM-assisted workflows.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ repo_path, response_format }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const summary = await getContextSummary(repoPath);
+        return {
+          content: [{ type: "text", text: render3(summary, response_format) }],
+          structuredContent: { summary }
+        };
+      } catch (error) {
+        return buildError2(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_search",
+    {
+      title: "Git Search",
+      description: "Search code and history using pickaxe and grep.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        query: z4.string().min(1),
+        limit: z4.number().int().min(1).max(200).default(20),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      query,
+      limit,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await searchHistory(repoPath, query, limit);
+        return {
+          content: [{ type: "text", text: render3({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        return buildError2(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_get_config",
+    {
+      title: "Get Git Config",
+      description: "Read repository/local git configuration values.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        key: z4.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      key,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const value = await getConfig(repoPath, key);
+        return {
+          content: [{ type: "text", text: render3({ value }, response_format) }],
+          structuredContent: { value }
+        };
+      } catch (error) {
+        return buildError2(error);
+      }
+    }
+  );
+  server2.registerTool(
+    "git_set_config",
+    {
+      title: "Set Git Config",
+      description: "Set repository-local git configuration value.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        key: z4.string().min(1),
+        value: z4.string(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      key,
+      value,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await setConfig(repoPath, key, value);
+        return {
+          content: [{ type: "text", text: render3({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        return buildError2(error);
+      }
+    }
+  );
+}
+
+// src/tools/docs.tools.ts
+import { z as z5 } from "zod";
+
+// src/services/docs.service.ts
+function stripHtml(html) {
+  let text = html.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, " ");
+  text = text.replace(/<[^>]+>/g, " ");
+  text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)));
+  return text.replace(/\s+/g, " ").trim();
+}
+function extractBetween(html, startMarker, endMarker) {
+  const startMatch = startMarker.exec(html);
+  if (!startMatch) return html;
+  const startIdx = startMatch.index + startMatch[0].length;
+  const remainder = html.slice(startIdx);
+  const endMatch = endMarker.exec(remainder);
+  return endMatch ? remainder.slice(0, endMatch.index) : remainder;
+}
+async function searchGitDocs(query) {
+  const url = `https://git-scm.com/search/results?search=${encodeURIComponent(query)}&language=en`;
+  let html;
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "text/html", "User-Agent": "git-mcp-docs/1.0" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`git-scm.com returned HTTP ${response.status}`);
+    }
+    html = await response.text();
+  } catch (err) {
+    throw new Error(`Failed to fetch git docs search: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const results = [];
+  const listMatch = /<ul[^>]*class="[^"]*result-list[^"]*"[^>]*>([\s\S]*?)<\/ul>/i.exec(html);
+  const listHtml = listMatch ? listMatch[1] : html;
+  const itemRegex = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+  let itemMatch;
+  while ((itemMatch = itemRegex.exec(listHtml)) !== null) {
+    const item = itemMatch[1];
+    const linkMatch = /<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i.exec(item);
+    if (!linkMatch) continue;
+    const href = linkMatch[1].trim();
+    const title = stripHtml(linkMatch[2]).trim();
+    if (!title) continue;
+    const excerptMatch = /<(?:p|span)[^>]*class="[^"]*excerpt[^"]*"[^>]*>([\s\S]*?)<\/(?:p|span)>/i.exec(item);
+    const excerpt = excerptMatch ? stripHtml(excerptMatch[1]).trim() : "";
+    const fullUrl = href.startsWith("http") ? href : `https://git-scm.com${href}`;
+    results.push({ title, url: fullUrl, excerpt });
+  }
+  if (results.length === 0) {
+    const linkRegex = /<a[^>]+href="(\/docs\/[^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    let m;
+    const seen = /* @__PURE__ */ new Set();
+    while ((m = linkRegex.exec(html)) !== null && results.length < 20) {
+      const href = m[1];
+      const title = stripHtml(m[2]).trim();
+      if (!title || seen.has(href)) continue;
+      seen.add(href);
+      results.push({ title, url: `https://git-scm.com${href}`, excerpt: "" });
+    }
+  }
+  return { query, results };
+}
+async function fetchGitManPage(command) {
+  const normalized = command.trim().toLowerCase().replace(/^git[- ]/, "");
+  const url = `https://git-scm.com/docs/git-${normalized}`;
+  let html;
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: "text/html", "User-Agent": "git-mcp-docs/1.0" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(
+          `No man page found for "git ${normalized}". Check the command name or search with action="search".`
+        );
+      }
+      throw new Error(`git-scm.com returned HTTP ${response.status} for git-${normalized}`);
+    }
+    html = await response.text();
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("No man page")) throw err;
+    throw new Error(`Failed to fetch git man page: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const articleContent = extractBetween(
+    html,
+    /<(?:article|div)[^>]*(?:id="main"|class="[^"]*(?:sect|man-page|article)[^"]*")[^>]*>/i,
+    /<\/(?:article|div)>/i
+  );
+  const content = stripHtml(articleContent || html);
+  const header = `# git-${normalized}(1)
+
+Source: ${url}
+
+`;
+  const full = header + content;
+  return full.length > CHARACTER_LIMIT ? full.slice(0, CHARACTER_LIMIT) + "\n\n[...truncated \u2014 content exceeded limit]" : full;
+}
+
+// src/tools/docs.tools.ts
+function render4(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+function registerDocsTools(server2) {
+  server2.registerTool(
+    "git_docs",
+    {
+      title: "Git Documentation",
+      description: 'Search and browse official Git documentation from git-scm.com. Use action="search" to find relevant commands and concepts by keyword. Use action="man" to fetch the full man page for a specific git command (e.g. query="commit" fetches the git-commit man page). Useful for answering questions about how to use git commands, understanding options, and discovering the right git command for a task.',
+      inputSchema: {
+        action: z5.enum(["search", "man"]),
+        query: z5.string().min(1).describe(
+          'For action="search": search terms (e.g. "undo last commit"). For action="man": git command name without "git-" prefix (e.g. "commit", "rebase", "merge").'
+        ),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({
+      action,
+      query,
+      response_format
+    }) => {
+      try {
+        if (action === "search") {
+          const results = await searchGitDocs(query);
+          const structuredContent = {
+            query: results.query,
+            results: results.results
+          };
+          if (response_format === "json") {
+            return {
+              content: [{ type: "text", text: JSON.stringify(structuredContent, null, 2) }],
+              structuredContent
+            };
+          }
+          if (results.results.length === 0) {
+            const text3 = `No results found for "${query}" on git-scm.com.`;
+            return { content: [{ type: "text", text: text3 }], structuredContent };
+          }
+          const lines = [`## Git Docs Search: "${results.query}"`, ""];
+          for (const r of results.results) {
+            lines.push(`### [${r.title}](${r.url})`);
+            if (r.excerpt) lines.push(r.excerpt);
+            lines.push("");
+          }
+          const text2 = lines.join("\n");
+          return { content: [{ type: "text", text: text2 }], structuredContent };
+        }
+        const text = await fetchGitManPage(query);
+        return {
+          content: [{ type: "text", text: render4(text, response_format) }],
+          structuredContent: { command: query, content: text }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+}
+
+// src/tools/flow.tools.ts
+import { z as z6 } from "zod";
+
+// src/services/flow.service.ts
+async function getFlowConfig(git, overrides) {
+  const get = async (key, fallback) => {
+    try {
+      const value = await git.raw(["config", "--local", key]);
+      return value.trim() || fallback;
+    } catch {
+      return fallback;
+    }
+  };
+  const mainBranch = overrides.mainBranch ?? await get("gitflow.branch.master", "main");
+  const developBranch = overrides.developBranch ?? await get("gitflow.branch.develop", "develop");
+  return {
+    mainBranch,
+    developBranch,
+    featurePrefix: await get("gitflow.prefix.feature", "feature/"),
+    releasePrefix: await get("gitflow.prefix.release", "release/"),
+    hotfixPrefix: await get("gitflow.prefix.hotfix", "hotfix/"),
+    supportPrefix: await get("gitflow.prefix.support", "support/"),
+    versionTagPrefix: await get("gitflow.prefix.versiontag", "")
+  };
+}
+async function listBranchesByPrefix(git, prefix) {
+  const result = await git.branch(["-a"]);
+  const matching = result.all.map((b) => b.replace(/^remotes\/[^/]+\//, "").trim()).filter((b, idx, arr) => b.startsWith(prefix) && arr.indexOf(b) === idx).map((b) => b.slice(prefix.length));
+  return matching.length > 0 ? matching.join("\n") : `No ${prefix.slice(0, -1)} branches found.`;
+}
+async function branchExists(git, branch) {
+  try {
+    const result = await git.branch(["-a"]);
+    return result.all.some((b) => b === branch || b === `remotes/origin/${branch}` || b.endsWith(`/${branch}`));
+  } catch {
+    return false;
+  }
+}
+async function runFlowAction(repoPath, options) {
+  const git = getGit(repoPath);
+  const cfg = await getFlowConfig(git, options);
+  const deleteBranch2 = options.deleteBranch ?? true;
+  const tagOnFinish = options.tag ?? true;
+  switch (options.action) {
+    // -----------------------------------------------------------------------
+    // init
+    // -----------------------------------------------------------------------
+    case "init": {
+      const sets = [
+        ["gitflow.branch.master", cfg.mainBranch],
+        ["gitflow.branch.develop", cfg.developBranch],
+        ["gitflow.prefix.feature", cfg.featurePrefix],
+        ["gitflow.prefix.release", cfg.releasePrefix],
+        ["gitflow.prefix.hotfix", cfg.hotfixPrefix],
+        ["gitflow.prefix.support", cfg.supportPrefix],
+        ["gitflow.prefix.versiontag", cfg.versionTagPrefix]
+      ];
+      for (const [key, val] of sets) {
+        await git.raw(["config", "--local", key, val]);
+      }
+      if (!await branchExists(git, cfg.developBranch)) {
+        await git.checkoutLocalBranch(cfg.developBranch);
+        const lines = [`Initialized git flow.`, `Created branch: ${cfg.developBranch}`];
+        lines.push(`Main branch: ${cfg.mainBranch}, Develop branch: ${cfg.developBranch}`);
+        return lines.join("\n");
+      }
+      return [
+        `Initialized git flow.`,
+        `Main branch: ${cfg.mainBranch}, Develop branch: ${cfg.developBranch}`,
+        `Prefixes \u2014 feature: ${cfg.featurePrefix}, release: ${cfg.releasePrefix}, hotfix: ${cfg.hotfixPrefix}`
+      ].join("\n");
+    }
+    // -----------------------------------------------------------------------
+    // feature
+    // -----------------------------------------------------------------------
+    case "feature-list": {
+      return listBranchesByPrefix(git, cfg.featurePrefix);
+    }
+    case "feature-start": {
+      if (!options.name) throw new Error("name is required for feature-start.");
+      const branch = `${cfg.featurePrefix}${options.name}`;
+      await git.checkoutBranch(branch, cfg.developBranch);
+      return `Created and switched to branch ${branch} from ${cfg.developBranch}.`;
+    }
+    case "feature-finish": {
+      if (!options.name) throw new Error("name is required for feature-finish.");
+      const branch = `${cfg.featurePrefix}${options.name}`;
+      await git.checkout(cfg.developBranch);
+      await git.raw(["merge", "--no-ff", branch, "-m", `Merge branch '${branch}' into ${cfg.developBranch}`]);
+      if (deleteBranch2) {
+        await git.deleteLocalBranch(branch);
+        return `Merged ${branch} into ${cfg.developBranch} and deleted branch.`;
+      }
+      return `Merged ${branch} into ${cfg.developBranch}.`;
+    }
+    case "feature-publish": {
+      if (!options.name) throw new Error("name is required for feature-publish.");
+      const branch = `${cfg.featurePrefix}${options.name}`;
+      const remote = options.remote ?? "origin";
+      await git.push(remote, branch, ["--set-upstream"]);
+      return `Published ${branch} to ${remote}.`;
+    }
+    // -----------------------------------------------------------------------
+    // release
+    // -----------------------------------------------------------------------
+    case "release-list": {
+      return listBranchesByPrefix(git, cfg.releasePrefix);
+    }
+    case "release-start": {
+      if (!options.name) throw new Error("name is required for release-start.");
+      const branch = `${cfg.releasePrefix}${options.name}`;
+      await git.checkoutBranch(branch, cfg.developBranch);
+      return `Created and switched to branch ${branch} from ${cfg.developBranch}.`;
+    }
+    case "release-finish": {
+      if (!options.name) throw new Error("name is required for release-finish.");
+      const branch = `${cfg.releasePrefix}${options.name}`;
+      const tagName = `${cfg.versionTagPrefix}${options.name}`;
+      const tagMsg = options.tagMessage ?? `Release ${options.name}`;
+      await git.checkout(cfg.mainBranch);
+      await git.raw(["merge", "--no-ff", branch, "-m", `Merge branch '${branch}' into ${cfg.mainBranch}`]);
+      if (tagOnFinish) {
+        await git.addAnnotatedTag(tagName, tagMsg);
+      }
+      await git.checkout(cfg.developBranch);
+      await git.raw(["merge", "--no-ff", branch, "-m", `Merge branch '${branch}' into ${cfg.developBranch}`]);
+      const lines = [
+        `Merged ${branch} into ${cfg.mainBranch}.`,
+        ...tagOnFinish ? [`Tagged: ${tagName}`] : [],
+        `Merged ${branch} into ${cfg.developBranch}.`
+      ];
+      if (deleteBranch2) {
+        await git.deleteLocalBranch(branch);
+        lines.push(`Deleted branch ${branch}.`);
+      }
+      return lines.join("\n");
+    }
+    case "release-publish": {
+      if (!options.name) throw new Error("name is required for release-publish.");
+      const branch = `${cfg.releasePrefix}${options.name}`;
+      const remote = options.remote ?? "origin";
+      await git.push(remote, branch, ["--set-upstream"]);
+      return `Published ${branch} to ${remote}.`;
+    }
+    // -----------------------------------------------------------------------
+    // hotfix
+    // -----------------------------------------------------------------------
+    case "hotfix-list": {
+      return listBranchesByPrefix(git, cfg.hotfixPrefix);
+    }
+    case "hotfix-start": {
+      if (!options.name) throw new Error("name is required for hotfix-start.");
+      const branch = `${cfg.hotfixPrefix}${options.name}`;
+      await git.checkoutBranch(branch, cfg.mainBranch);
+      return `Created and switched to branch ${branch} from ${cfg.mainBranch}.`;
+    }
+    case "hotfix-finish": {
+      if (!options.name) throw new Error("name is required for hotfix-finish.");
+      const branch = `${cfg.hotfixPrefix}${options.name}`;
+      const tagName = `${cfg.versionTagPrefix}${options.name}`;
+      const tagMsg = options.tagMessage ?? `Hotfix ${options.name}`;
+      await git.checkout(cfg.mainBranch);
+      await git.raw(["merge", "--no-ff", branch, "-m", `Merge branch '${branch}' into ${cfg.mainBranch}`]);
+      if (tagOnFinish) {
+        await git.addAnnotatedTag(tagName, tagMsg);
+      }
+      await git.checkout(cfg.developBranch);
+      await git.raw(["merge", "--no-ff", branch, "-m", `Merge branch '${branch}' into ${cfg.developBranch}`]);
+      const lines = [
+        `Merged ${branch} into ${cfg.mainBranch}.`,
+        ...tagOnFinish ? [`Tagged: ${tagName}`] : [],
+        `Merged ${branch} into ${cfg.developBranch}.`
+      ];
+      if (deleteBranch2) {
+        await git.deleteLocalBranch(branch);
+        lines.push(`Deleted branch ${branch}.`);
+      }
+      return lines.join("\n");
+    }
+    // -----------------------------------------------------------------------
+    // support
+    // -----------------------------------------------------------------------
+    case "support-list": {
+      return listBranchesByPrefix(git, cfg.supportPrefix);
+    }
+    case "support-start": {
+      if (!options.name) throw new Error("name is required for support-start.");
+      const branch = `${cfg.supportPrefix}${options.name}`;
+      await git.checkoutBranch(branch, cfg.mainBranch);
+      return `Created and switched to branch ${branch} from ${cfg.mainBranch}.`;
+    }
+  }
+}
+
+// src/tools/flow.tools.ts
+function render5(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+var FLOW_ACTION_VALUES = [
+  "init",
+  "feature-start",
+  "feature-finish",
+  "feature-publish",
+  "feature-list",
+  "release-start",
+  "release-finish",
+  "release-publish",
+  "release-list",
+  "hotfix-start",
+  "hotfix-finish",
+  "hotfix-list",
+  "support-start",
+  "support-list"
+];
+function registerFlowTools(server2) {
+  server2.registerTool(
+    "git_flow",
+    {
+      title: "Git Flow Actions",
+      description: 'Implements the git-flow branching model without requiring the git-flow CLI extension. Supports feature, release, hotfix, and support branches. Use "init" first to configure branch names and prefixes in local git config. Branch names (main/develop) and prefixes are read from gitflow.* config with sensible defaults. Actions: init \u2014 set up flow config and develop branch. feature-start/finish/publish/list \u2014 manage feature branches off develop. release-start/finish/publish/list \u2014 manage release branches; finish merges to main+develop and tags. hotfix-start/finish/list \u2014 manage hotfix branches off main; finish merges to main+develop and tags. support-start/list \u2014 create long-lived support branches off main.',
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z6.enum(FLOW_ACTION_VALUES),
+        name: z6.string().optional().describe('Feature/release/hotfix/support name or version (e.g. "my-feature", "1.2.0").'),
+        main_branch: z6.string().optional().describe('Override the main branch name (default: gitflow.branch.master config or "main").'),
+        develop_branch: z6.string().optional().describe('Override the develop branch name (default: gitflow.branch.develop config or "develop").'),
+        remote: z6.string().optional().describe('Remote name for publish operations (default: "origin").'),
+        tag: z6.boolean().default(true).describe("Create an annotated tag when finishing a release or hotfix (default: true)."),
+        tag_message: z6.string().optional().describe("Message for the version tag."),
+        delete_branch: z6.boolean().default(true).describe("Delete the branch after a finish operation (default: true)."),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      name,
+      main_branch,
+      develop_branch,
+      remote,
+      tag,
+      tag_message,
+      delete_branch,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runFlowAction(repoPath, {
+          action,
+          name,
+          mainBranch: main_branch,
+          developBranch: develop_branch,
+          remote,
+          tag,
+          tagMessage: tag_message,
+          deleteBranch: delete_branch
+        });
+        return {
+          content: [{ type: "text", text: render5({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+}
+
+// src/tools/inspect.tools.ts
+import { z as z7 } from "zod";
+function toText(content, responseFormat) {
+  if (responseFormat === "json") {
+    return JSON.stringify(content, null, 2);
+  }
+  return typeof content === "string" ? content : JSON.stringify(content, null, 2);
+}
+function registerInspectTools(server2) {
+  server2.registerTool(
+    "git_status",
+    {
+      title: "Git Status",
+      description: "Get repository working tree and branch status.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ repo_path, response_format }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const status = await getStatus(repoPath);
+        return {
+          content: [{ type: "text", text: toText(status, response_format) }],
+          structuredContent: { status }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_log",
+    {
+      title: "Git Log",
+      description: "Get commit history with optional filters and pagination.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        limit: z7.number().int().min(1).max(200).default(30),
+        offset: z7.number().int().min(0).default(0),
+        author: z7.string().optional(),
+        grep: z7.string().optional(),
+        since: z7.string().optional(),
+        until: z7.string().optional(),
+        file_path: z7.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      limit,
+      offset,
+      author,
+      grep,
+      since,
+      until,
+      file_path,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const commits = await getLog(repoPath, {
+          limit,
+          offset,
+          author,
+          grep,
+          since,
+          until,
+          filePath: file_path
+        });
+        return {
+          content: [{ type: "text", text: toText(commits, response_format) }],
+          structuredContent: { commits }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_show",
+    {
+      title: "Git Show",
+      description: "Show patch and metadata for a commit, tag, or ref.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        ref: z7.string().min(1),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      ref,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await showRef(repoPath, ref);
+        return {
+          content: [{ type: "text", text: toText(output, response_format) }],
+          structuredContent: { ref, output }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_diff",
+    {
+      title: "Git Diff",
+      description: "Show unstaged, staged, or ref-to-ref diff. Supports optional LLM-oriented filtering.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        mode: z7.enum(["unstaged", "staged", "refs"]).default("unstaged"),
+        from_ref: z7.string().optional(),
+        to_ref: z7.string().optional(),
+        filtered: z7.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      mode,
+      from_ref,
+      to_ref,
+      filtered,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const [summary, output] = await Promise.all([
+          getDiffSummary(repoPath, {
+            mode,
+            fromRef: from_ref,
+            toRef: to_ref,
+            filtered
+          }),
+          getDiff(repoPath, {
+            mode,
+            fromRef: from_ref,
+            toRef: to_ref,
+            filtered
+          })
+        ]);
+        const payload = { summary, output };
+        return {
+          content: [{ type: "text", text: toText(payload, response_format) }],
+          structuredContent: payload
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_blame",
+    {
+      title: "Git Blame",
+      description: "Show line-level author attribution for a file.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        file_path: z7.string().min(1),
+        ref: z7.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      file_path,
+      ref,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await blameFile(repoPath, file_path, ref);
+        return {
+          content: [{ type: "text", text: toText(output, response_format) }],
+          structuredContent: { file_path, ref, output }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_reflog",
+    {
+      title: "Git Reflog",
+      description: "Show local HEAD and ref movement history for recovery.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        limit: z7.number().int().min(1).max(200).default(30),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      limit,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await getReflog(repoPath, limit);
+        return {
+          content: [{ type: "text", text: toText(output, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+}
+
+// src/tools/lfs.tools.ts
+import { z as z8 } from "zod";
+
+// src/services/lfs.service.ts
+async function runLfsAction(repoPath, options) {
+  const git = getGit(repoPath);
+  switch (options.action) {
+    case "install": {
+      const output = await git.raw(["lfs", "install"]);
+      return output.trim() || "Git LFS installed for this repository.";
+    }
+    case "track": {
+      if (!options.patterns || options.patterns.length === 0) {
+        throw new Error("patterns is required for lfs track.");
+      }
+      const output = await git.raw(["lfs", "track", ...options.patterns]);
+      return output.trim() || `Tracking: ${options.patterns.join(", ")}`;
+    }
+    case "untrack": {
+      if (!options.patterns || options.patterns.length === 0) {
+        throw new Error("patterns is required for lfs untrack.");
+      }
+      const output = await git.raw(["lfs", "untrack", ...options.patterns]);
+      return output.trim() || `Untracked: ${options.patterns.join(", ")}`;
+    }
+    case "ls-files": {
+      const output = await git.raw(["lfs", "ls-files"]);
+      return output.trim() || "No LFS-tracked files found.";
+    }
+    case "status": {
+      const output = await git.raw(["lfs", "status"]);
+      return output.trim() || "No LFS status changes.";
+    }
+    case "pull": {
+      const args = ["lfs", "pull"];
+      if (options.remote) args.push(options.remote);
+      if (options.include) args.push("--include", options.include);
+      if (options.exclude) args.push("--exclude", options.exclude);
+      const output = await git.raw(args);
+      return output.trim() || "LFS pull complete.";
+    }
+    case "push": {
+      if (!options.remote) {
+        throw new Error("remote is required for lfs push.");
+      }
+      const args = ["lfs", "push", options.remote];
+      if (options.everything) args.push("--all");
+      const output = await git.raw(args);
+      return output.trim() || `LFS push to ${options.remote} complete.`;
+    }
+    case "migrate-import": {
+      const args = ["lfs", "migrate", "import"];
+      if (options.everything) args.push("--everything");
+      if (options.include) args.push("--include", options.include);
+      if (options.exclude) args.push("--exclude", options.exclude);
+      const output = await git.raw(args);
+      return output.trim() || "LFS migrate import complete.";
+    }
+    case "migrate-export": {
+      const args = ["lfs", "migrate", "export"];
+      if (options.everything) args.push("--everything");
+      if (options.include) args.push("--include", options.include);
+      if (options.exclude) args.push("--exclude", options.exclude);
+      const output = await git.raw(args);
+      return output.trim() || "LFS migrate export complete.";
+    }
+  }
+}
+
+// src/tools/lfs.tools.ts
+function render6(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+function registerLfsTools(server2) {
+  server2.registerTool(
+    "git_lfs",
+    {
+      title: "Git LFS Actions",
+      description: "Manage Git Large File Storage (LFS). Supports tracking/untracking file patterns, listing LFS-tracked files and status, pulling/pushing LFS objects, installing LFS hooks for the repository, and migrating existing files into or out of LFS storage.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z8.enum([
+          "track",
+          "untrack",
+          "ls-files",
+          "status",
+          "pull",
+          "push",
+          "install",
+          "migrate-import",
+          "migrate-export"
+        ]),
+        patterns: z8.array(z8.string()).optional().describe('File glob patterns for track/untrack (e.g. ["*.psd", "*.zip"]).'),
+        remote: z8.string().optional().describe("Remote name for pull/push operations."),
+        include: z8.string().optional().describe("Comma-separated include patterns for migrate or pull operations."),
+        exclude: z8.string().optional().describe("Comma-separated exclude patterns for migrate or pull operations."),
+        everything: z8.boolean().default(false).describe("Pass --all/--everything to include all refs in push/migrate operations."),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      patterns,
+      remote,
+      include,
+      exclude,
+      everything,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const output = await runLfsAction(repoPath, {
+          action,
+          patterns,
+          remote,
+          include,
+          exclude,
+          everything
+        });
+        return {
+          content: [{ type: "text", text: render6({ output }, response_format) }],
+          structuredContent: { output }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+}
+
+// src/tools/remote.tools.ts
+import { z as z9 } from "zod";
+
+// src/services/remote.service.ts
+function sanitizeRemoteUrl(url) {
+  if (!url) return url;
+  try {
+    const parsed = new URL(url);
+    if (!parsed.username && !parsed.password) return url;
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+async function listRemotes(repoPath) {
+  const git = getGit(repoPath);
+  const remotes = await git.getRemotes(true);
+  return remotes.map((remote) => ({
+    name: remote.name,
+    fetchUrl: sanitizeRemoteUrl(remote.refs.fetch),
+    pushUrl: sanitizeRemoteUrl(remote.refs.push)
+  }));
+}
+async function manageRemote(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.action === "add") {
+    if (!options.url) {
+      throw new Error("url is required for action='add'");
+    }
+    await git.addRemote(options.name, options.url);
+    return `Added remote ${options.name}.`;
+  }
+  if (options.action === "remove") {
+    await git.removeRemote(options.name);
+    return `Removed remote ${options.name}.`;
+  }
+  if (!options.url) {
+    throw new Error("url is required for action='set-url'");
+  }
+  await git.remote(["set-url", options.name, options.url]);
+  return `Updated remote ${options.name} URL.`;
+}
+async function fetchRemote(repoPath, options) {
+  const git = getGit(repoPath);
+  const args = [];
+  if (options.prune) {
+    args.push("--prune");
+  }
+  if (options.remote && options.branch) {
+    await git.fetch(options.remote, options.branch, args);
+    return `Fetched ${options.remote}/${options.branch}.`;
+  } else if (options.remote) {
+    await git.fetch(options.remote, args);
+    return `Fetched ${options.remote}.`;
+  } else {
+    await git.fetch(args);
+    return "Fetched default remote.";
+  }
+}
+async function pullRemote(repoPath, options) {
+  const git = getGit(repoPath);
+  const pullOptions = [];
+  if (options.rebase) {
+    pullOptions.push("--rebase");
+  }
+  await git.pull(options.remote, options.branch, pullOptions);
+  return `Pulled ${options.remote ?? "tracking remote"}${options.branch ? `/${options.branch}` : ""}${options.rebase ? " with rebase" : ""}.`;
+}
+async function pushRemote(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.noVerify && !ALLOW_NO_VERIFY) {
+    throw new Error(
+      "no_verify is disabled on this server. Set GIT_ALLOW_NO_VERIFY=true to permit bypassing git hooks."
+    );
+  }
+  if (options.force && !ALLOW_FORCE_PUSH) {
+    throw new Error(
+      "force push is disabled on this server. Set GIT_ALLOW_FORCE_PUSH=true to enable it. Consider using force_with_lease instead for a safer alternative."
+    );
+  }
+  const pushOptions = [];
+  if (options.setUpstream) {
+    pushOptions.push("--set-upstream");
+  }
+  if (options.forceWithLease) {
+    pushOptions.push("--force-with-lease");
+  }
+  if (options.force) {
+    pushOptions.push("--force");
+  }
+  if (options.tags) {
+    pushOptions.push("--tags");
+  }
+  if (options.noVerify) {
+    pushOptions.push("--no-verify");
+  }
+  await git.push(options.remote, options.branch, pushOptions);
+  return `Pushed ${options.remote ?? "tracking remote"}${options.branch ? `/${options.branch}` : ""}.`;
+}
+
+// src/tools/remote.tools.ts
+function render7(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+function registerRemoteTools(server2) {
+  server2.registerTool(
+    "git_list_remotes",
+    {
+      title: "List Git Remotes",
+      description: "List configured repository remotes with fetch and push URLs.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({ repo_path, response_format }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const remotes = await listRemotes(repoPath);
+        return {
+          content: [{ type: "text", text: render7({ remotes }, response_format) }],
+          structuredContent: { remotes }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_remote",
+    {
+      title: "Manage Git Remotes",
+      description: "Add, remove, or set URL for remotes using action-based input.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        action: z9.enum(["add", "remove", "set-url"]),
+        name: z9.string().min(1),
+        url: z9.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      action,
+      name,
+      url,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await manageRemote(repoPath, { action, name, url });
+        return {
+          content: [{ type: "text", text: render7({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_fetch",
+    {
+      title: "Git Fetch",
+      description: "Fetch updates from remote with optional pruning.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        remote: z9.string().optional(),
+        branch: z9.string().optional(),
+        prune: z9.boolean().default(true),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({
+      repo_path,
+      remote,
+      branch,
+      prune,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await fetchRemote(repoPath, { remote, branch, prune });
+        return {
+          content: [{ type: "text", text: render7({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_pull",
+    {
+      title: "Git Pull",
+      description: "Pull from remote with merge (default) or rebase mode.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        remote: z9.string().optional(),
+        branch: z9.string().optional(),
+        rebase: z9.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({
+      repo_path,
+      remote,
+      branch,
+      rebase,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await pullRemote(repoPath, { remote, branch, rebase });
+        return {
+          content: [{ type: "text", text: render7({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_push",
+    {
+      title: "Git Push",
+      description: "Push to remote. Supports safe force (`--force-with-lease`), hard force (if enabled server-side), and bypassing pre-push hooks (if enabled server-side).",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        remote: z9.string().optional(),
+        branch: z9.string().optional(),
+        set_upstream: z9.boolean().default(false),
+        force_with_lease: z9.boolean().default(false),
+        force: z9.boolean().default(false).describe(
+          "Hard force push (--force). Only accepted when GIT_ALLOW_FORCE_PUSH=true is set on the server. Prefer force_with_lease unless you have a specific reason for a hard force."
+        ),
+        no_verify: z9.boolean().default(false).describe(
+          "Bypass pre-push hooks (--no-verify). Only accepted when GIT_ALLOW_NO_VERIFY=true is set on the server."
+        ),
+        tags: z9.boolean().default(false),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: true
+      }
+    },
+    async ({
+      repo_path,
+      remote,
+      branch,
+      set_upstream,
+      force_with_lease,
+      force,
+      no_verify,
+      tags,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await pushRemote(repoPath, {
+          remote,
+          branch,
+          setUpstream: set_upstream,
+          forceWithLease: force_with_lease,
+          force,
+          noVerify: no_verify,
+          tags
+        });
+        return {
+          content: [{ type: "text", text: render7({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+}
+
+// src/tools/write.tools.ts
+import { z as z10 } from "zod";
+
+// src/services/write.service.ts
+async function addFiles(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.all) {
+    await git.add(".");
+    return "Staged all changes.";
+  }
+  const paths = options.paths ?? [];
+  if (paths.length === 0) {
+    throw new Error("Provide paths or set all=true.");
+  }
+  await git.add(paths);
+  return `Staged ${paths.length} path(s).`;
+}
+async function restoreFiles(repoPath, options) {
+  const git = getGit(repoPath);
+  if (!options.staged && !options.worktree) {
+    throw new Error("At least one of staged/worktree must be true.");
+  }
+  const args = ["restore"];
+  if (options.staged) {
+    args.push("--staged");
+  }
+  if (options.worktree) {
+    args.push("--worktree");
+  }
+  if (options.source) {
+    args.push("--source", options.source);
+  }
+  args.push("--", ...options.paths);
+  await git.raw(args);
+  return `Restored ${options.paths.length} path(s).`;
+}
+async function commitChanges(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.noVerify && !ALLOW_NO_VERIFY) {
+    throw new Error(
+      "no_verify is disabled on this server. Set GIT_ALLOW_NO_VERIFY=true to permit bypassing git hooks."
+    );
+  }
+  const args = [];
+  if (options.all) {
+    args.push("-a");
+  }
+  if (options.amend) {
+    args.push("--amend");
+  }
+  if (options.noEdit) {
+    args.push("--no-edit");
+  }
+  if (options.noVerify) {
+    args.push("--no-verify");
+  }
+  const shouldSign = options.sign ?? AUTO_SIGN_COMMITS;
+  if (shouldSign) {
+    const key = options.signingKey ?? DEFAULT_SIGNING_KEY;
+    args.push(key ? `--gpg-sign=${key}` : "--gpg-sign");
+  }
+  const result = await git.commit(options.message, args);
+  return `Committed ${result.commit}.`;
+}
+async function resetChanges(repoPath, options) {
+  const git = getGit(repoPath);
+  if (options.paths && options.paths.length > 0) {
+    const args2 = ["reset"];
+    if (options.target) {
+      args2.push(options.target);
+    }
+    args2.push("--", ...options.paths);
+    await git.raw(args2);
+    return `Unstaged ${options.paths.length} path(s).`;
+  }
+  const args = ["reset", `--${options.mode}`];
+  if (options.target) {
+    args.push(options.target);
+  }
+  await git.raw(args);
+  return `Reset completed with mode=${options.mode}.`;
+}
+async function revertCommit(repoPath, options) {
+  const git = getGit(repoPath);
+  const args = ["revert"];
+  if (options.noCommit) {
+    args.push("--no-commit");
+  }
+  if (typeof options.mainline === "number") {
+    args.push("-m", String(options.mainline));
+  }
+  args.push(options.ref);
+  await git.raw(args);
+  return `Reverted ${options.ref}.`;
+}
+
+// src/tools/write.tools.ts
+function render8(content, format) {
+  if (typeof content === "string" && format === "markdown") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2);
+}
+function registerWriteTools(server2) {
+  server2.registerTool(
+    "git_add",
+    {
+      title: "Git Add",
+      description: "Stage files in the index.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        all: z10.boolean().default(false),
+        paths: z10.array(z10.string()).optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      all,
+      paths,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await addFiles(repoPath, { all, paths });
+        return {
+          content: [{ type: "text", text: render8({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_restore",
+    {
+      title: "Git Restore",
+      description: "Restore paths in worktree and/or index from current state or source ref.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        paths: z10.array(z10.string()).min(1),
+        staged: z10.boolean().default(false),
+        worktree: z10.boolean().default(true),
+        source: z10.string().optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: true,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      paths,
+      staged,
+      worktree,
+      source,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await restoreFiles(repoPath, { paths, staged, worktree, source });
+        return {
+          content: [{ type: "text", text: render8({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_commit",
+    {
+      title: "Git Commit",
+      description: "Create a commit from staged changes, optionally amending the previous commit. Supports GPG/SSH commit signing and bypassing git hooks (if enabled server-side).",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        message: z10.string().min(1),
+        all: z10.boolean().default(false),
+        amend: z10.boolean().default(false),
+        no_edit: z10.boolean().default(false),
+        sign: z10.boolean().default(false).describe("Sign the commit with GPG/SSH. Defaults to server AUTO_SIGN_COMMITS setting."),
+        signing_key: z10.string().optional().describe("Specific signing key ID or path. Falls back to GIT_SIGNING_KEY env var."),
+        no_verify: z10.boolean().default(false).describe(
+          "Bypass pre-commit and commit-msg hooks (--no-verify). Only accepted when GIT_ALLOW_NO_VERIFY=true is set on the server."
+        ),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      message,
+      all,
+      amend,
+      no_edit,
+      sign,
+      signing_key,
+      no_verify,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const commitMessage = await commitChanges(repoPath, {
+          message,
+          all,
+          amend,
+          noEdit: no_edit,
+          sign,
+          signingKey: signing_key,
+          noVerify: no_verify
+        });
+        return {
+          content: [{ type: "text", text: render8({ message: commitMessage }, response_format) }],
+          structuredContent: { message: commitMessage }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_reset",
+    {
+      title: "Git Reset",
+      description: "Reset HEAD/index/worktree by mode. Hard reset requires confirm=true.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        mode: z10.enum(["soft", "mixed", "hard"]).default("mixed"),
+        target: z10.string().optional(),
+        paths: z10.array(z10.string()).optional(),
+        confirm: ConfirmSchema,
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      mode,
+      target,
+      paths,
+      confirm,
+      response_format
+    }) => {
+      try {
+        if (mode === "hard" && !confirm) {
+          throw new Error("Hard reset requires confirm=true.");
+        }
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await resetChanges(repoPath, { mode, target, paths });
+        return {
+          content: [{ type: "text", text: render8({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+  server2.registerTool(
+    "git_revert",
+    {
+      title: "Git Revert",
+      description: "Revert a commit without rewriting history.",
+      inputSchema: {
+        repo_path: RepoPathSchema,
+        ref: z10.string().min(1),
+        no_commit: z10.boolean().default(false),
+        mainline: z10.number().int().min(1).optional(),
+        response_format: ResponseFormatSchema
+      },
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false
+      }
+    },
+    async ({
+      repo_path,
+      ref,
+      no_commit,
+      mainline,
+      response_format
+    }) => {
+      try {
+        const repoPath = resolveRepoPath(repo_path);
+        const message = await revertCommit(repoPath, {
+          ref,
+          noCommit: no_commit,
+          mainline
+        });
+        return {
+          content: [{ type: "text", text: render8({ message }, response_format) }],
+          structuredContent: { message }
+        };
+      } catch (error) {
+        const gitError = toGitError(error);
+        return { content: [{ type: "text", text: `Error (${gitError.kind}): ${gitError.message}` }] };
+      }
+    }
+  );
+}
+
+// src/index.ts
+var server = new McpServer2({
+  name: SERVER_NAME,
+  version: SERVER_VERSION
+});
+registerInspectTools(server);
+registerWriteTools(server);
+registerBranchTools(server);
+registerRemoteTools(server);
+registerAdvancedTools(server);
+registerContextTools(server);
+registerLfsTools(server);
+registerFlowTools(server);
+registerDocsTools(server);
+registerGitResources(server);
+server.registerTool(
+  "git_ping",
+  {
+    title: "Git MCP Ping",
+    description: "Returns a simple response to verify the server is running.",
+    inputSchema: {
+      message: z11.string().default("pong")
+    },
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      destructiveHint: false,
+      openWorldHint: false
+    }
+  },
+  async ({ message }) => {
+    return {
+      content: [{ type: "text", text: `git-mcp-server: ${message}` }],
+      structuredContent: {
+        ok: true,
+        message
+      }
+    };
+  }
+);
+async function main() {
+  if (DEFAULT_REPO_PATH) {
+    console.error(`[git-mcp] default repository path: ${DEFAULT_REPO_PATH}`);
+  }
+  if (ALLOW_NO_VERIFY) console.error("[git-mcp] hook bypass enabled (GIT_ALLOW_NO_VERIFY=true)");
+  if (ALLOW_FORCE_PUSH) console.error("[git-mcp] force push enabled (GIT_ALLOW_FORCE_PUSH=true)");
+  if (AUTO_SIGN_COMMITS) console.error("[git-mcp] auto-signing commits (GIT_AUTO_SIGN_COMMITS=true)");
+  if (AUTO_SIGN_TAGS) console.error("[git-mcp] auto-signing tags (GIT_AUTO_SIGN_TAGS=true)");
+  if (DEFAULT_SIGNING_KEY) console.error(`[git-mcp] signing key: ${DEFAULT_SIGNING_KEY}`);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Server startup failed: ${message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map