test(execute-handlers): close coverage gap via fake-server harness

FastMCP has no injectable transport API, so the execute handlers were
unreachable from tests. Adds test-harness.ts: a duck-typed fake server
that captures addTool definitions and calls execute directly, bypassing
the MCP protocol while exercising the full handler path.

17 new execute-handler tests cover: happy paths (markdown + JSON format),
error propagation (not_a_git_repo, path_escapes_repository, stage_failed),
filter/truncation behavior (fileFilter, maxLinesPerFile, maxCommits,
paths, since), and partial-failure semantics for batch_commit.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: AlbinoGeek

src/server/batch-commit-tool.test.ts

@@ -23,7 +23,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { isStrictlyUnderGitTop, resolvePathForRepo } from "../repo-paths.js";
+import { registerBatchCommitTool } from "./batch-commit-tool.js";
 import { spawnGitAsync } from "./git.js";
+import { captureTool } from "./test-harness.js";
 
 // ---------------------------------------------------------------------------
 // Mirrors the SHA extraction regex from batch-commit-tool.ts
@@ -215,4 +217,99 @@ describe("batch_commit integration", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Execute handler: end-to-end via fake server harness
+// ---------------------------------------------------------------------------
+
+describe("batch_commit execute handler", () => {
+  test("happy path: single commit returns markdown with sha and success header", async () => {
+    const dir = makeRepo();
+    writeFileSync(join(dir, "base.ts"), "const b = 0;\n");
+    gitCmd(dir, "add", "base.ts");
+    gitCmd(dir, "commit", "-m", "chore: base");
+    writeFileSync(join(dir, "new.ts"), "export const x = 1;\n");
+
+    const run = captureTool(registerBatchCommitTool);
+    const text = await run({
+      workspaceRoot: dir,
+      commits: [{ message: "feat: add new", files: ["new.ts"] }],
+    });
+    expect(text).toContain("1/1 committed");
+    expect(text).toContain("feat: add new");
+  });
+
+  test("json format returns structured result with ok:true", async () => {
+    const dir = makeRepo();
+    writeFileSync(join(dir, "base.ts"), "const b = 0;\n");
+    gitCmd(dir, "add", "base.ts");
+    gitCmd(dir, "commit", "-m", "chore: base");
+    writeFileSync(join(dir, "a.ts"), "const a = 1;\n");
+
+    const run = captureTool(registerBatchCommitTool);
+    const text = await run({
+      workspaceRoot: dir,
+      format: "json",
+      commits: [{ message: "feat: json", files: ["a.ts"] }],
+    });
+    const parsed = JSON.parse(text) as { ok: boolean; committed: number; total: number };
+    expect(parsed.ok).toBe(true);
+    expect(parsed.committed).toBe(1);
+    expect(parsed.total).toBe(1);
+  });
+
+  test("path_escapes_repository: dotdot path → error in json response", async () => {
+    const dir = makeRepo();
+
+    const run = captureTool(registerBatchCommitTool);
+    const text = await run({
+      workspaceRoot: dir,
+      format: "json",
+      commits: [{ message: "bad", files: ["../../etc/passwd"] }],
+    });
+    const parsed = JSON.parse(text) as { ok: boolean; results: Array<{ error: string }> };
+    expect(parsed.ok).toBe(false);
+    expect(parsed.results[0]?.error).toBe("path_escapes_repository");
+  });
+
+  test("non-git workspaceRoot → not_a_git_repository error", async () => {
+    const plain = mkdtempSync(join(tmpdir(), "mcp-plain-"));
+
+    const run = captureTool(registerBatchCommitTool);
+    const text = await run({
+      workspaceRoot: plain,
+      format: "json",
+      commits: [{ message: "noop", files: ["x.ts"] }],
+    });
+    const parsed = JSON.parse(text) as { error: string };
+    expect(parsed.error).toBe("not_a_git_repository");
+  });
+
+  test("multiple commits: stops on first failure, reports partial progress", async () => {
+    const dir = makeRepo();
+    writeFileSync(join(dir, "base.ts"), "const b = 0;\n");
+    gitCmd(dir, "add", "base.ts");
+    gitCmd(dir, "commit", "-m", "chore: base");
+    writeFileSync(join(dir, "ok.ts"), "const ok = 1;\n");
+
+    const run = captureTool(registerBatchCommitTool);
+    const text = await run({
+      workspaceRoot: dir,
+      format: "json",
+      commits: [
+        { message: "feat: ok", files: ["ok.ts"] },
+        { message: "feat: bad", files: ["nonexistent.ts"] },
+      ],
+    });
+    const parsed = JSON.parse(text) as {
+      ok: boolean;
+      committed: number;
+      results: Array<{ ok: boolean; error?: string }>;
+    };
+    expect(parsed.ok).toBe(false);
+    expect(parsed.committed).toBe(1);
+    expect(parsed.results[0]?.ok).toBe(true);
+    expect(parsed.results[1]?.ok).toBe(false);
+  });
+});
+
 let _seq = 0;

src/server/git-diff-summary-tool.test.ts

@@ -19,8 +19,9 @@ import { type ExecSyncOptionsWithStringEncoding, execFileSync } from "node:child
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, matchesGlob } from "node:path";
-
 import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
+import { registerGitDiffSummaryTool } from "./git-diff-summary-tool.js";
+import { captureTool } from "./test-harness.js";
 
 // ---------------------------------------------------------------------------
 // Local copies of private helpers (mirrors git-diff-summary-tool.ts)
@@ -507,3 +508,110 @@ describe("git diff integration", () => {
     expect(matchesAnyPattern("src/index.ts", DEFAULT_EXCLUDE_PATTERNS)).toBe(false);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Execute handler: end-to-end via fake server harness
+// ---------------------------------------------------------------------------
+
+describe("git_diff_summary execute handler", () => {
+  test("unstaged changes appear in markdown output", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "foo.ts", "const x = 1;\n", "chore: initial");
+    writeFileSync(join(dir, "foo.ts"), "const x = 2;\n");
+
+    const run = captureTool(registerGitDiffSummaryTool);
+    const text = await run({ workspaceRoot: dir });
+    expect(text).toContain("foo.ts");
+  });
+
+  test("json format returns structured DiffSummary", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "a.ts", "const a = 1;\n", "chore: initial");
+    writeFileSync(join(dir, "a.ts"), "const a = 99;\n");
+
+    const run = captureTool(registerGitDiffSummaryTool);
+    const text = await run({ workspaceRoot: dir, format: "json" });
+    const parsed = JSON.parse(text) as {
+      range: string;
+      totalFiles: number;
+      files: Array<{ path: string; status: string }>;
+    };
+    expect(parsed.totalFiles).toBe(1);
+    expect(parsed.files[0]?.path).toBe("a.ts");
+    expect(parsed.files[0]?.status).toBe("modified");
+    expect(parsed.range).toBe("unstaged changes");
+  });
+
+  test("staged range shows only staged files", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "staged.ts", "const s = 1;\n", "chore: initial");
+    writeFileSync(join(dir, "staged.ts"), "const s = 2;\n");
+    gitCmd(dir, "add", "staged.ts");
+    writeFileSync(join(dir, "unstaged.ts"), "const u = 9;\n");
+
+    const run = captureTool(registerGitDiffSummaryTool);
+    const text = await run({ workspaceRoot: dir, format: "json", range: "staged" });
+    const parsed = JSON.parse(text) as {
+      range: string;
+      files: Array<{ path: string }>;
+    };
+    expect(parsed.range).toBe("staged changes");
+    const paths = parsed.files.map((f) => f.path);
+    expect(paths).toContain("staged.ts");
+    expect(paths).not.toContain("unstaged.ts");
+  });
+
+  test("fileFilter restricts output to matching files only", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "foo.ts", "const f = 1;\n", "chore: initial");
+    addCommit(dir, "bar.md", "# Doc\n", "docs: add readme");
+    writeFileSync(join(dir, "foo.ts"), "const f = 2;\n");
+    writeFileSync(join(dir, "bar.md"), "# Updated\n");
+
+    const run = captureTool(registerGitDiffSummaryTool);
+    const text = await run({ workspaceRoot: dir, format: "json", fileFilter: "*.ts" });
+    const parsed = JSON.parse(text) as { files: Array<{ path: string }> };
+    const paths = parsed.files.map((f) => f.path);
+    expect(paths).toContain("foo.ts");
+    expect(paths).not.toContain("bar.md");
+  });
+
+  test("clean working tree returns empty files array", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "clean.ts", "const c = 1;\n", "chore: initial");
+
+    const run = captureTool(registerGitDiffSummaryTool);
+    const text = await run({ workspaceRoot: dir, format: "json" });
+    const parsed = JSON.parse(text) as { totalFiles: number; files: unknown[] };
+    expect(parsed.totalFiles).toBe(0);
+    expect(parsed.files).toHaveLength(0);
+  });
+
+  test("non-git workspaceRoot → not_a_git_repository error", async () => {
+    const plain = mkdtempSync(join(tmpdir(), "mcp-plain-diff-"));
+
+    const run = captureTool(registerGitDiffSummaryTool);
+    const text = await run({ workspaceRoot: plain, format: "json" });
+    const parsed = JSON.parse(text) as { error: string };
+    expect(parsed.error).toBe("not_a_git_repository");
+  });
+
+  test("maxLinesPerFile truncates long diffs", async () => {
+    const dir = makeRepo();
+    addCommit(
+      dir,
+      "big.ts",
+      `${Array.from({ length: 5 }, (_, i) => `const v${i} = ${i};`).join("\n")}\n`,
+      "chore: initial",
+    );
+    writeFileSync(
+      join(dir, "big.ts"),
+      `${Array.from({ length: 5 }, (_, i) => `const v${i} = ${i * 10};`).join("\n")}\n`,
+    );
+
+    const run = captureTool(registerGitDiffSummaryTool);
+    const text = await run({ workspaceRoot: dir, format: "json", maxLinesPerFile: 2 });
+    const parsed = JSON.parse(text) as { files: Array<{ truncated: boolean }> };
+    expect(parsed.files[0]?.truncated).toBe(true);
+  });
+});

src/server/git-log-tool.test.ts

@@ -24,6 +24,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { gitTopLevel, spawnGitAsync } from "./git.js";
+import { registerGitLogTool } from "./git-log-tool.js";
+import { captureTool } from "./test-harness.js";
 
 // ---------------------------------------------------------------------------
 // Separators — must match git-log-tool.ts constants
@@ -307,3 +309,91 @@ describe("git_log integration", () => {
     expect(records[0]?.[2]).toBe("fix: handle 100% edge case");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Execute handler: end-to-end via fake server harness
+// ---------------------------------------------------------------------------
+
+// JSON output shape: { groups: [{ workspace_root, repo, commits, truncated? }] }
+// Commits use GIT_AUTHOR_DATE=2025-01-01 — must pass since beyond 7-day default.
+const SINCE_WIDE = "2.years";
+
+describe("git_log execute handler", () => {
+  test("returns commits in json format", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "a.txt", "feat: commit A");
+    addCommit(dir, "b.txt", "feat: commit B");
+
+    const run = captureTool(registerGitLogTool);
+    const text = await run({ workspaceRoot: dir, format: "json", since: SINCE_WIDE });
+    const parsed = JSON.parse(text) as {
+      groups: Array<{ commits: Array<{ subject: string }> }>;
+    };
+    const commits = parsed.groups[0]?.commits ?? [];
+    expect(commits.length).toBeGreaterThanOrEqual(2);
+    const subjects = commits.map((c) => c.subject);
+    expect(subjects).toContain("feat: commit B");
+    expect(subjects).toContain("feat: commit A");
+  });
+
+  test("markdown output contains commit subjects", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "x.txt", "chore: markdown test");
+
+    const run = captureTool(registerGitLogTool);
+    const text = await run({ workspaceRoot: dir, since: SINCE_WIDE });
+    expect(text).toContain("chore: markdown test");
+  });
+
+  test("maxCommits caps number of commits returned", async () => {
+    const dir = makeRepo();
+    for (let i = 1; i <= 5; i++) {
+      addCommit(dir, `f${i}.txt`, `chore: commit ${i}`);
+    }
+
+    const run = captureTool(registerGitLogTool);
+    const text = await run({
+      workspaceRoot: dir,
+      format: "json",
+      since: SINCE_WIDE,
+      maxCommits: 3,
+    });
+    const parsed = JSON.parse(text) as {
+      groups: Array<{ commits: Array<{ subject: string }>; truncated?: boolean }>;
+    };
+    const group = parsed.groups[0];
+    expect(group?.commits.length).toBe(3);
+    expect(group?.truncated).toBe(true);
+  });
+
+  test("non-git workspaceRoot → not_a_git_repo error in group", async () => {
+    const plain = mkdtempSync(join(tmpdir(), "mcp-plain-log-"));
+
+    const run = captureTool(registerGitLogTool);
+    const text = await run({ workspaceRoot: plain, format: "json" });
+    const parsed = JSON.parse(text) as {
+      groups: Array<{ error?: string }>;
+    };
+    expect(parsed.groups[0]?.error).toBe("not_a_git_repo");
+  });
+
+  test("paths filter limits commits to those touching a specific file", async () => {
+    const dir = makeRepo();
+    addCommit(dir, "important.ts", "feat: touch important");
+    addCommit(dir, "other.ts", "chore: unrelated");
+
+    const run = captureTool(registerGitLogTool);
+    const text = await run({
+      workspaceRoot: dir,
+      format: "json",
+      since: SINCE_WIDE,
+      paths: ["important.ts"],
+    });
+    const parsed = JSON.parse(text) as {
+      groups: Array<{ commits: Array<{ subject: string }> }>;
+    };
+    const commits = parsed.groups[0]?.commits ?? [];
+    expect(commits.length).toBe(1);
+    expect(commits[0]?.subject).toContain("important");
+  });
+});