git-mob-mcp-server 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createGitMobServer } from "./gitMobServerFactory.js";
 (async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-mob-mcp-server",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MCP Server for git-mob CLI app",
   "main": "dist/index.js",
   "type": "module",
@@ -25,6 +25,7 @@
   },
   "publishConfig": {
     "access": "public",
+    "provenance": true,
     "registry": "https://registry.npmjs.org/",
     "tag": "latest"
   },

package/dist/clients/gitMobClient.test.js

@@ -1,114 +0,0 @@
-import { describe, test, expect, beforeEach, jest } from "@jest/globals";
-import * as gitMobClient from "./gitMobClient";
-import { runCliCommand } from "../helpers/index.js";
-jest.mock("../helpers/index.js", () => ({
-    runCliCommand: jest.fn(),
-}));
-const mockRunCmd = runCliCommand;
-describe("[clients] gitMobClient", () => {
-    beforeEach(() => {
-        jest.resetAllMocks();
-    });
-    test("setupGlobal", async () => {
-        mockRunCmd.mockResolvedValue({ ok: true, value: "Setup complete" });
-        const result = await gitMobClient.setupGlobal();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", [
-            "setup",
-            "--global",
-        ]);
-        expect(result).toEqual({ ok: true, value: "Setup complete" });
-    });
-    test("setupLocal", async () => {
-        mockRunCmd.mockResolvedValue({ ok: true, value: "Setup complete" });
-        const result = await gitMobClient.setupLocal();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", ["setup", "--local"]);
-        expect(result).toEqual({ ok: true, value: "Setup complete" });
-    });
-    test("addCoauthor", async () => {
-        mockRunCmd.mockResolvedValue({
-            ok: true,
-            value: "Alice Bob <alice@example.com>",
-        });
-        const result = await gitMobClient.addCoauthor("ab", "Alice Bob", "alice@example.com");
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", [
-            "coauthor",
-            "--add",
-            "ab",
-            "Alice Bob",
-            "alice@example.com",
-        ]);
-        expect(result).toEqual({
-            ok: true,
-            value: "Alice Bob <alice@example.com>",
-        });
-    });
-    test("deleteCoauthor", async () => {
-        mockRunCmd.mockResolvedValue({ ok: true, value: "" });
-        const result = await gitMobClient.deleteCoauthor("ab");
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", [
-            "coauthor",
-            "--delete",
-            "ab",
-        ]);
-        expect(result).toEqual({ ok: true, value: "" });
-    });
-    test("listCoauthors", async () => {
-        const coauthorList = "leo Leo Messi <leo.messi@arg.com>\nab Alice Bob <alice@example.com>";
-        mockRunCmd.mockResolvedValue({ ok: true, value: coauthorList });
-        const result = await gitMobClient.listCoauthors();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", [
-            "coauthor",
-            "--list",
-        ]);
-        expect(result).toEqual({ ok: true, value: coauthorList });
-    });
-    test("setMobSession", async () => {
-        const session = "leo Leo Messi <leo.messi@arg.com>\nab Alice Bob <alice@example.com>";
-        mockRunCmd.mockResolvedValue({ ok: true, value: session });
-        const result = await gitMobClient.setMobSession(["ab", "cd"]);
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", [
-            "--with",
-            "ab",
-            "cd",
-        ]);
-        expect(result).toEqual({ ok: true, value: session });
-    });
-    test("clearMobSession", async () => {
-        mockRunCmd.mockResolvedValue({ ok: true, value: "" });
-        const result = await gitMobClient.clearMobSession();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", ["--clear"]);
-        expect(result).toEqual({ ok: true, value: "" });
-    });
-    test("listMobSessionCoauthors", async () => {
-        const coauthors = "leo Leo Messi <leo.messi@arg.com>\nab Alice Bob <alice@example.com>";
-        mockRunCmd.mockResolvedValue({ ok: true, value: coauthors });
-        const result = await gitMobClient.listMobSessionCoauthors();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", ["--list"]);
-        expect(result).toEqual({ ok: true, value: coauthors });
-    });
-    test("listMobSessionCoauthorTrailers", async () => {
-        const trailers = "Co-authored-by: Leo Messi <leo.messi@arg.com>\nCo-authored-by: Alice Bob <alice@example.com>";
-        mockRunCmd.mockResolvedValue({ ok: true, value: trailers });
-        const result = await gitMobClient.listMobSessionCoauthorTrailers();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", ["--trailers"]);
-        expect(result).toEqual({ ok: true, value: trailers });
-    });
-    test("getVersion", async () => {
-        mockRunCmd.mockResolvedValue({ ok: true, value: "git-mob-tool 1.6.2" });
-        const result = await gitMobClient.getVersion();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", ["--version"]);
-        expect(result).toEqual({ ok: true, value: "git-mob-tool 1.6.2" });
-    });
-    test("getHelp (no command)", async () => {
-        mockRunCmd.mockResolvedValue({ ok: true, value: "help" });
-        const result = await gitMobClient.getHelp();
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", ["help"]);
-        expect(result).toEqual({ ok: true, value: "help" });
-    });
-    test("getHelp (with command)", async () => {
-        mockRunCmd.mockResolvedValue({ ok: true, value: "help setup" });
-        const result = await gitMobClient.getHelp("setup");
-        expect(runCliCommand).toHaveBeenCalledWith("git-mob", ["help", "setup"]);
-        expect(result).toEqual({ ok: true, value: "help setup" });
-    });
-});

package/dist/gitMobServerFactory.test.js

@@ -1,58 +0,0 @@
-import { describe, it, expect, jest } from "@jest/globals";
-import * as helpers from "./helpers/index.js";
-import * as resources from "./resources/index.js";
-import * as tools from "./tools/index.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { createGitMobServer } from "./gitMobServerFactory.js";
-jest.mock("./helpers/index.js", () => ({
-    registerGitMobTool: jest.fn(),
-    registerGitMobResource: jest.fn(),
-    registerGtMobResourceAsTool: jest.fn(),
-}));
-jest.mock("@modelcontextprotocol/sdk/server/mcp.js", () => {
-    const actual = jest.requireActual("@modelcontextprotocol/sdk/server/mcp.js");
-    return {
-        ...actual,
-        McpServer: jest.fn().mockImplementation((meta, opts) => ({ meta, opts })),
-    };
-});
-describe("gitMobServerFactory: createGitMobServer", () => {
-    const mockMCPServer = McpServer;
-    it("should create an instance of McpServer for Git Mob", () => {
-        createGitMobServer();
-        expect(mockMCPServer).toHaveBeenCalledWith({ name: "Git Mob", version: "1.0.0" }, {
-            capabilities: {
-                tools: {},
-                resources: {},
-            },
-        });
-    });
-    it("should register all resources", async () => {
-        const { registerGitMobResource } = helpers;
-        const server = createGitMobServer();
-        expect(registerGitMobResource).toHaveBeenCalledWith(server, resources.gitMobVersion);
-        expect(registerGitMobResource).toHaveBeenCalledWith(server, resources.gitMobHelp);
-        expect(registerGitMobResource).toHaveBeenCalledWith(server, resources.teamMembers);
-        expect(registerGitMobResource).toHaveBeenCalledWith(server, resources.mobSessionCoauthors);
-        expect(registerGitMobResource).toHaveBeenCalledWith(server, resources.mobSessionCoauthorTrailers);
-    });
-    it("should register all resources as tools", async () => {
-        const { registerGtMobResourceAsTool } = helpers;
-        const server = createGitMobServer();
-        expect(registerGtMobResourceAsTool).toHaveBeenCalledWith(server, resources.gitMobVersion);
-        expect(registerGtMobResourceAsTool).toHaveBeenCalledWith(server, resources.gitMobHelp);
-        expect(registerGtMobResourceAsTool).toHaveBeenCalledWith(server, resources.teamMembers);
-        expect(registerGtMobResourceAsTool).toHaveBeenCalledWith(server, resources.mobSessionCoauthors);
-        expect(registerGtMobResourceAsTool).toHaveBeenCalledWith(server, resources.mobSessionCoauthorTrailers);
-    });
-    it("should register all tools", async () => {
-        const { registerGitMobTool } = helpers;
-        const server = createGitMobServer();
-        expect(registerGitMobTool).toHaveBeenCalledWith(server, tools.setupGitMobGlobally);
-        expect(registerGitMobTool).toHaveBeenCalledWith(server, tools.setupGitMobLocally);
-        expect(registerGitMobTool).toHaveBeenCalledWith(server, tools.addTeamMember);
-        expect(registerGitMobTool).toHaveBeenCalledWith(server, tools.deleteTeamMember);
-        expect(registerGitMobTool).toHaveBeenCalledWith(server, tools.setMobSessionCoauthors);
-        expect(registerGitMobTool).toHaveBeenCalledWith(server, tools.clearMobSession);
-    });
-});

package/dist/helpers/registerGitMobResource.test.js

@@ -1,36 +0,0 @@
-import { describe, it, expect, jest } from "@jest/globals";
-import { registerGitMobResource } from "./registerGitMobResource";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-describe("[helpers] registerGitMobResource", () => {
-    it("should register given git mob resource with the given server", () => {
-        const mockServer = {
-            resource: jest.fn(),
-        };
-        const name = "test_resource";
-        const template = new ResourceTemplate("gitmob://test-resource", {
-            list: undefined,
-        });
-        const metadata = {
-            description: "This is a test resource for testing purposes.",
-            mimeType: "text/plain",
-        };
-        const readCallback = async (uri) => {
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: "hello world",
-                    },
-                ],
-            };
-        };
-        const testResource = {
-            name,
-            template,
-            metadata,
-            readCallback,
-        };
-        registerGitMobResource(mockServer, testResource);
-        expect(mockServer.resource).toHaveBeenCalledWith(testResource.name, testResource.template, testResource.metadata, testResource.readCallback);
-    });
-});

package/dist/helpers/registerGitMobResourceAsTool.test.js

@@ -1,63 +0,0 @@
-import { describe, it, expect, jest } from "@jest/globals";
-import { registerGtMobResourceAsTool } from "./registerGitMobResourceAsTool";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-describe("[helpers] registerGtMobResourceAsTool", () => {
-    const RESOURCE_CALLBACK_CONTENT = "hello world";
-    const arrangeMockServerAndTestResource = () => {
-        const mockServer = {
-            registerTool: jest.fn(),
-        };
-        const name = "test_resource";
-        const template = new ResourceTemplate("gitmob://test-resource", {
-            list: undefined,
-        });
-        const metadata = {
-            description: "This is a test resource for testing purposes.",
-            mimeType: "text/plain",
-        };
-        const readCallback = async (uri) => {
-            return {
-                contents: [
-                    {
-                        uri: uri.href,
-                        text: RESOURCE_CALLBACK_CONTENT,
-                    },
-                ],
-            };
-        };
-        const testResource = {
-            name,
-            template,
-            metadata,
-            readCallback,
-        };
-        return { mockServer, testResource };
-    };
-    it("should register a resource as a tool with the given server", async () => {
-        const { mockServer, testResource } = arrangeMockServerAndTestResource();
-        registerGtMobResourceAsTool(mockServer, testResource);
-        expect(mockServer.registerTool).toHaveBeenCalledWith(`get_${testResource.name}`, {
-            description: String(testResource.metadata.description),
-            inputSchema: {},
-            annotations: {
-                title: `get_${testResource.name}`,
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        }, expect.any(Function));
-    });
-    it("should have registered tool callback return the resource callback content when invoked", async () => {
-        const { mockServer, testResource } = arrangeMockServerAndTestResource();
-        const readCallBackSpy = jest.spyOn(testResource, "readCallback");
-        registerGtMobResourceAsTool(mockServer, testResource);
-        const toolCallback = mockServer.registerTool.mock
-            .calls[0][2];
-        const result = await toolCallback({}, {});
-        expect(readCallBackSpy).toHaveBeenCalled();
-        expect(result).toEqual({
-            content: [{ type: "text", text: RESOURCE_CALLBACK_CONTENT }],
-        });
-    });
-});

package/dist/helpers/registerGitMobTool.test.js

@@ -1,40 +0,0 @@
-import { describe, it, expect, jest } from "@jest/globals";
-import { registerGitMobTool } from "./registerGitMobTool";
-import { z } from "zod";
-describe("[helpers] registerGitMobTool", () => {
-    it("should register given git mob tool with the given server", () => {
-        const mockServer = {
-            registerTool: jest.fn(),
-        };
-        const name = "test_tool";
-        const description = "This is a tool for testing purposes.";
-        const inputSchema = {
-            foo: z.string(),
-            bar: z.string(),
-        };
-        const annotations = {
-            title: "Test me",
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        };
-        const callback = async ({ foo, bar }) => {
-            return { content: [{ type: "text", text: foo + bar }] };
-        };
-        const testTool = {
-            name,
-            description,
-            inputSchema,
-            annotations,
-            callback,
-        };
-        registerGitMobTool(mockServer, testTool);
-        expect(mockServer.registerTool).toHaveBeenCalledWith(testTool.name, {
-            description: testTool.description,
-            inputSchema: testTool.inputSchema,
-            outputSchema: testTool.outputSchema,
-            annotations: testTool.annotations,
-        }, testTool.callback);
-    });
-});

package/dist/helpers/runCliCommand.test.js

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { runCliCommand } from "./runCliCommand";
-describe("[helpers] runCliCommand", () => {
-    it("should return ok and stdout for a successful command", async () => {
-        const result = await runCliCommand("node", ["-e", "console.log('hello')"]);
-        expect(result.ok).toBe(true);
-        expect(result.value.trim()).toBe("hello");
-    });
-    it("should return ok and stderr for a command that writes to stderr but exits 0", async () => {
-        const result = await runCliCommand("node", [
-            "-e",
-            "console.error('err'); process.exit(0)",
-        ]);
-        expect(result.ok).toBe(true);
-        expect(result.value.trim()).toBe("err");
-    });
-    it("should return ok: false and stderr for a command that fails with stderr", async () => {
-        const result = await runCliCommand("node", [
-            "-e",
-            "console.error('fail'); process.exit(1)",
-        ]);
-        expect(result.ok).toBe(false);
-        expect(result.value.trim()).toBe("fail");
-    });
-    it("should return ok: false and stdout for a command that fails with stdout only", async () => {
-        const result = await runCliCommand("node", [
-            "-e",
-            "console.log('failout'); process.exit(1)",
-        ]);
-        expect(result.ok).toBe(false);
-        expect(result.value.trim()).toBe("failout");
-    });
-    it("should return ok: false and message for a non-existent command", async () => {
-        const result = await runCliCommand("nonexistent-cmd-xyz", []);
-        expect(result.ok).toBe(false);
-        expect(result.value.trim()).toBe("spawn nonexistent-cmd-xyz ENOENT");
-    });
-});

package/dist/index.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it, jest } from "@jest/globals";
-import { createGitMobServer } from "./gitMobServerFactory.js";
-// Mock StdioServerTransport from the MCP SDK
-const transport = {};
-const mockConnect = jest.fn();
-const mockStdioServerTransport = jest.fn().mockImplementation(() => transport);
-jest.mock("@modelcontextprotocol/sdk/server/stdio.js", () => ({
-    StdioServerTransport: mockStdioServerTransport,
-}));
-// Mock createGitMobServer to return a mock server with a connect method
-jest.mock("./gitMobServerFactory.js", () => ({
-    createGitMobServer: jest.fn(() => ({ connect: mockConnect })),
-}));
-describe("index.ts", () => {
-    it("should create a server, transport, and connect them", async () => {
-        // Dynamically import index.ts to run its top-level code
-        await import("./index.js");
-        expect(createGitMobServer).toHaveBeenCalled();
-        expect(mockStdioServerTransport).toHaveBeenCalled();
-        expect(mockConnect).toHaveBeenCalledWith(transport);
-    });
-});

package/dist/resources/gitMobHelp.test.js

@@ -1,23 +0,0 @@
-import resource from "./gitMobHelp";
-import { describe, it, expect } from "@jest/globals";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-describe("[resources] gitMobHelp", () => {
-    it("should have correct name", () => {
-        expect(resource.name).toBe("git_mob_help");
-    });
-    it("should have correct template", () => {
-        const template = new ResourceTemplate("gitmob://help", {
-            list: undefined,
-        });
-        expect(resource.template).toEqual(template);
-    });
-    it("should have correct metadata", () => {
-        const metadata = {
-            description: "Displays general help and usage information for the Git Mob CLI. " +
-                "You can optionally provide a command ('setup', 'coauthor', or 'help') " +
-                "to get detailed help for that specific command.",
-            mimeType: "text/plain",
-        };
-        expect(resource.metadata).toEqual(metadata);
-    });
-});

package/dist/resources/gitMobVersion.test.js

@@ -1,19 +0,0 @@
-import resource from "./gitMobVersion";
-import { describe, it, expect } from "@jest/globals";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-describe("[resources] gitMobVersion", () => {
-    it("should have correct name", () => {
-        expect(resource.name).toBe("git_mob_version");
-    });
-    it("should have correct template", () => {
-        const template = new ResourceTemplate("gitmob://version", { list: undefined });
-        expect(resource.template).toEqual(template);
-    });
-    it("should have correct metadata", () => {
-        const metadata = {
-            description: "The installed version of the Git Mob CLI.",
-            mimeType: "text/plain",
-        };
-        expect(resource.metadata).toEqual(metadata);
-    });
-});

package/dist/resources/mobSessionCoauthorTrailers.test.js

@@ -1,22 +0,0 @@
-import resource from "./mobSessionCoauthorTrailers";
-import { describe, it, expect } from "@jest/globals";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-describe("[resources] mobSessionCoauthorTrailers", () => {
-    it("should have correct name", () => {
-        expect(resource.name).toBe("mob_session_coauthor_trailers");
-    });
-    it("should have correct template", () => {
-        const template = new ResourceTemplate("gitmob://mob-session-coauthor-trailers", { list: undefined });
-        expect(resource.template).toEqual(template);
-    });
-    it("should have correct metadata", () => {
-        const metadata = {
-            description: "List of the git Co-authored-by trailers for the coauthors " +
-                "currently included in the active mob or pairing session. " +
-                "If Git Mob is setup, these Co-authored-by trailers will be automatically " +
-                "added to the commit's message when making commits during the session.",
-            mimeType: "text/plain",
-        };
-        expect(resource.metadata).toEqual(metadata);
-    });
-});

package/dist/resources/mobSessionCoauthors.test.js

@@ -1,21 +0,0 @@
-import resource from "./mobSessionCoauthors";
-import { describe, it, expect } from "@jest/globals";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-describe("[resources] mobSessionCoauthors", () => {
-    it("should have correct name", () => {
-        expect(resource.name).toBe("mob_session_coauthors");
-    });
-    it("should have correct template", () => {
-        const template = new ResourceTemplate("gitmob://mob-session-coauthors", { list: undefined });
-        expect(resource.template).toEqual(template);
-    });
-    it("should have correct metadata", () => {
-        const metadata = {
-            description: "List of all coauthors currently included in the active mob or pairing session. " +
-                "If Git Mob is setup, these coauthors will be automatically added as " +
-                "Co-authored-by trailers to the commit's message when making commits during the session.",
-            mimeType: "text/plain",
-        };
-        expect(resource.metadata).toEqual(metadata);
-    });
-});

package/dist/resources/teamMembers.test.js

@@ -1,22 +0,0 @@
-import resource from "./teamMembers";
-import { describe, it, expect } from "@jest/globals";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-describe("[resources] teamMembers", () => {
-    it("should have correct name", () => {
-        expect(resource.name).toBe("team_members");
-    });
-    it("should have correct template", () => {
-        const template = new ResourceTemplate("gitmob://team-members", { list: undefined });
-        expect(resource.template).toEqual(template);
-    });
-    it("should have correct metadata", () => {
-        const metadata = {
-            description: "List of all the team members that have been added to Git Mob. " +
-                "The team members can then be used in pairing / mobbing sessions as coauthors." +
-                "Each entry is formatted as: <key> <name> <email>." +
-                "Ask the user which team member(s) they want to pair or mob with.",
-            mimeType: "text/plain",
-        };
-        expect(resource.metadata).toEqual(metadata);
-    });
-});

package/dist/tools/addTeamMember.test.js

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import tool from "./addTeamMember.js";
-import { describe, it, expect } from "@jest/globals";
-describe("[tools] addTeamMember", () => {
-    it("should have correct name", () => {
-        expect(tool.name).toBe("add_team_member");
-    });
-    it("should have correct description", () => {
-        const description = "Adds a new team member using their key, name, and email. " +
-            "This member can then be used in a pairing or mobbing sessions as a cauthor. " +
-            "The first name is a good choice for the key." +
-            "Ask the user if they want mob or pair with this team member.";
-        expect(tool.description).toBe(description);
-    });
-    it("should have correct input schema", () => {
-        const inputSchema = {
-            key: z.string(),
-            name: z.string(),
-            email: z.string(),
-        };
-        expect(JSON.stringify(tool.inputSchema)).toEqual(JSON.stringify(inputSchema));
-    });
-    it("should have correct annotations", () => {
-        const annotations = {
-            title: "Add Team Member",
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        };
-        expect(tool.annotations).toEqual(annotations);
-    });
-});

package/dist/tools/clearMobSession.test.js

@@ -1,25 +0,0 @@
-import tool from "./clearMobSession.js";
-import { describe, it, expect } from "@jest/globals";
-describe("[tools] clearMobSession", () => {
-    it("should have correct name", () => {
-        expect(tool.name).toBe("clear_mob_session");
-    });
-    it("should have correct description", () => {
-        const description = "Clears the active mob or pairing session.";
-        expect(tool.description).toBe(description);
-    });
-    it("should have correct input schema", () => {
-        const inputSchema = {};
-        expect(JSON.stringify(tool.inputSchema)).toEqual(JSON.stringify(inputSchema));
-    });
-    it("should have correct annotations", () => {
-        const annotations = {
-            title: "Clear Mob Session",
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        };
-        expect(tool.annotations).toEqual(annotations);
-    });
-});

package/dist/tools/deleteTeamMember.test.js

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import tool from "./deleteTeamMember.js";
-import { describe, it, expect } from "@jest/globals";
-describe("[tools] deleteTeamMember", () => {
-    it("should have correct name", () => {
-        expect(tool.name).toBe("delete_team_member");
-    });
-    it("should have correct description", () => {
-        const description = "Deletes a team member by their key. " +
-            "User can only delete a team member they have added previously. " +
-            "If user did not specify a key, show them list of existing team members and ask them to select one.";
-        expect(tool.description).toBe(description);
-    });
-    it("should have correct input schema", () => {
-        const inputSchema = {
-            key: z.string(),
-        };
-        expect(JSON.stringify(tool.inputSchema)).toEqual(JSON.stringify(inputSchema));
-    });
-    it("should have correct annotations", () => {
-        const annotations = {
-            title: "Delete Team Member",
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: true,
-            openWorldHint: false,
-        };
-        expect(tool.annotations).toEqual(annotations);
-    });
-});

package/dist/tools/setMobSessionCoauthors.test.js

@@ -1,31 +0,0 @@
-import { z } from "zod";
-import tool from "./setMobSessionCoauthors.js";
-import { describe, it, expect } from "@jest/globals";
-describe("[tools] setMobSessionCoauthors", () => {
-    it("should have correct name", () => {
-        expect(tool.name).toBe("set_mob_session_coauthors");
-    });
-    it("should have correct description", () => {
-        const description = "Sets the active pairing or mob session by specifying the " +
-            "keys of the team members to include as coauthors. " +
-            "If Git Mob is setup, these coauthors will be automatically added as " +
-            "Co-authored-by trailers to the commit's message when making commits during the session.";
-        expect(tool.description).toBe(description);
-    });
-    it("should have correct input schema", () => {
-        const inputSchema = {
-            coauthorKeys: z.array(z.string()).min(1),
-        };
-        expect(JSON.stringify(tool.inputSchema)).toEqual(JSON.stringify(inputSchema));
-    });
-    it("should have correct annotations", () => {
-        const annotations = {
-            title: "Set Mob or Pairing Session Coauthors using Team Members",
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: true,
-            openWorldHint: false,
-        };
-        expect(tool.annotations).toEqual(annotations);
-    });
-});

package/dist/tools/setupGitMobGlobally.test.js

@@ -1,29 +0,0 @@
-import tool from "./setupGitMobGlobally.js";
-import { describe, it, expect } from "@jest/globals";
-describe("[tools] setupGitMobGlobally", () => {
-    it("should have correct name", () => {
-        expect(tool.name).toBe("setup_git_mob_globally");
-    });
-    it("should have correct description", () => {
-        const description = "Configures the Git Mob CLI globally for all repositories on your system. " +
-            "This one-time setup installs a global prepare-commit-msg git hook, which automatically " +
-            "appends Co-authored-by trailers to commit messages during mob or pairing sessions. " +
-            "If a repository overrides the core.hooksPath git configuration (e.g., when using " +
-            "Husky), the setupGitMobLocally tool needs to be invoked in addition to this. ";
-        expect(tool.description).toBe(description);
-    });
-    it("should have correct input schema", () => {
-        const inputSchema = {};
-        expect(JSON.stringify(tool.inputSchema)).toEqual(JSON.stringify(inputSchema));
-    });
-    it("should have correct annotations", () => {
-        const annotations = {
-            title: "Setup Git Mob Globally",
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: false,
-        };
-        expect(tool.annotations).toEqual(annotations);
-    });
-});

package/dist/tools/setupGitMobLocally.test.js

@@ -1,30 +0,0 @@
-import tool from "./setupGitMobLocally.js";
-import { describe, it, expect } from "@jest/globals";
-describe("[tools] setupGitMobLocally", () => {
-    it("should have correct name", () => {
-        expect(tool.name).toBe("setup_git_mob_locally");
-    });
-    it("should have correct description", () => {
-        const description = "Sets up the Git Mob CLI for the current repository by installing a local " +
-            "prepare-commit-msg git hook. This hook delegates to the global " +
-            "prepare-commit-msg hook configured by setupGitMobGlobally. Use this tool " +
-            "only if your repository overrides the core.hooksPath git " +
-            "configuration (e.g., when using Husky). Note: You must run " +
-            "setupGitMobGlobally at least once before using this tool.";
-        expect(tool.description).toBe(description);
-    });
-    it("should have correct input schema", () => {
-        const inputSchema = {};
-        expect(JSON.stringify(tool.inputSchema)).toEqual(JSON.stringify(inputSchema));
-    });
-    it("should have correct annotations", () => {
-        const annotations = {
-            title: "Setup Git Mob Locally",
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: false,
-        };
-        expect(tool.annotations).toEqual(annotations);
-    });
-});