git-mob-mcp-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mubashwer Salman Khurshid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# Git Mob MCP Server
+
+Node.js server implementing Model Context Protocol (MCP) for [`git mob` CLI app](https://github.com/Mubashwer/git-mob)
+
+Built using [@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/typescript-sdk)
+
+## Features
+
+- Setup git mob CLI globally or locally
+- Add / delete / list team members
+- Choose team members for pairing / mobbing session
+- Automatic appending of Co-authored-by  in for co-authors in commit messages during pairing / mobbing session
+
+## API
+
+### Resources
+- `git_mob_help`: Displays general help and usage information for the Git Mob CLI.
+- `git_mob_version`: The installed version of the Git Mob CLI.
+- `team_members`: List of all the team members that have been added to Git Mob.
+- `mob_session_coauthors`: List of all coauthors currently included in the active mob or pairing session.
+- `mob_session_coauthors` (trailers): List of the git Co-authored-by trailers for the coauthors currently included in the active mob or pairing session.
+
+### Tools
+- `add_team_member`: Adds a new team member using their key, name, and email.
+- `clear_mob_session`: Clears the active mob or pairing session.
+- `delete_team_member`: Deletes a team member by their key.
+- `set_mob_session_coauthors`: Sets the active pairing or mob session by specifying the keys of the team members to include as coauthors.
+- `setup_git_mob_globally`: Sets up git-mob globally for the user.
+- `setup_git_mob_locally`: Sets up git-mob locally for the current repository.
+
+Because dynamic resources are not yet supported in GitHub Copilot, the resources are also available as tools:
+- `get_git_mob_help`: Displays general help and usage information for the Git Mob CLI.
+- `get_git_mob_version`: The installed version of the Git Mob CLI.
+- `get_team_members`: List of all the team members that have been added to Git Mob.
+- `get_mob_session_coauthors`: List of all coauthors currently included in the active mob or pairing session.
+- `get_mob_session_coauthors` (trailers): List of the git Co-authored-by trailers for the coauthors currently included in the active mob or pairing session.
+
+## Usage with Claude Desktop
+Add this to your `claude_desktop_config.json`:
+
+
+### NPX
+
+```json
+{
+  "mcpServers": {
+    "gitMob": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "git-mob-mcp-server"
+      ]
+    }
+  }
+}
+```
+
+## Usage with VS Code
+
+For installation, add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing `Ctrl + Shift + P` and typing `Preferences: Open Settings (JSON)`.
+
+Optionally, you can add it to a file called `.vscode/mcp.json` in your workspace. This will allow you to share the configuration with others.
+
+> Note that the `mcp` key is not needed in the `.vscode/mcp.json` file.
+
+You can provide sandboxed directories to the server by mounting them to `/projects`. Adding the `ro` flag will make the directory readonly by the server.
+
+
+### NPX
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "gitMob": {
+        "command": "npx",
+        "args": [
+          "-y",
+          "git-mob-mcp-server",
+        ]
+      }
+    }
+  }
+}
+```
+
+## License
+
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

package/dist/clients/gitMobClient.js

@@ -0,0 +1,38 @@
+import { runCliCommand } from "../helpers/index.js";
+const GIT_MOB_CLI = "git-mob";
+export async function setupGlobal() {
+    return runCliCommand(GIT_MOB_CLI, ["setup", "--global"]);
+}
+export async function setupLocal() {
+    return runCliCommand(GIT_MOB_CLI, ["setup", "--local"]);
+}
+export async function addCoauthor(key, name, email) {
+    return runCliCommand(GIT_MOB_CLI, ["coauthor", "--add", key, name, email]);
+}
+export async function deleteCoauthor(key) {
+    return runCliCommand(GIT_MOB_CLI, ["coauthor", "--delete", key]);
+}
+export async function listCoauthors() {
+    return runCliCommand(GIT_MOB_CLI, ["coauthor", "--list"]);
+}
+export async function setMobSession(coauthorKeys) {
+    return runCliCommand(GIT_MOB_CLI, ["--with", ...coauthorKeys]);
+}
+export async function clearMobSession() {
+    return runCliCommand(GIT_MOB_CLI, ["--clear"]);
+}
+export async function listMobSessionCoauthors() {
+    return runCliCommand(GIT_MOB_CLI, ["--list"]);
+}
+export async function listMobSessionCoauthorTrailers() {
+    return runCliCommand(GIT_MOB_CLI, ["--trailers"]);
+}
+export async function getVersion() {
+    return runCliCommand(GIT_MOB_CLI, ["--version"]);
+}
+export async function getHelp(command) {
+    const args = ["help"];
+    if (command)
+        args.push(command);
+    return runCliCommand(GIT_MOB_CLI, args);
+}

package/dist/clients/gitMobClient.test.js

@@ -0,0 +1,114 @@
+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.js

@@ -0,0 +1,34 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as tools from "./tools/index.js";
+import * as resources from "./resources/index.js";
+import { registerGitMobTool, registerGitMobResource, registerGtMobResourceAsTool, } from "./helpers/index.js";
+export const createGitMobServer = () => {
+    const server = new McpServer({
+        name: "Git Mob",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+        },
+    });
+    registerGitMobResource(server, resources.gitMobVersion);
+    registerGitMobResource(server, resources.gitMobHelp);
+    registerGitMobResource(server, resources.teamMembers);
+    registerGitMobResource(server, resources.mobSessionCoauthors);
+    registerGitMobResource(server, resources.mobSessionCoauthorTrailers);
+    // Currently, Github Copilot does not support dynamic resources in MCP Server,
+    // so we register them as tools as well
+    registerGtMobResourceAsTool(server, resources.gitMobVersion);
+    registerGtMobResourceAsTool(server, resources.gitMobHelp);
+    registerGtMobResourceAsTool(server, resources.teamMembers);
+    registerGtMobResourceAsTool(server, resources.mobSessionCoauthors);
+    registerGtMobResourceAsTool(server, resources.mobSessionCoauthorTrailers);
+    registerGitMobTool(server, tools.setupGitMobGlobally);
+    registerGitMobTool(server, tools.setupGitMobLocally);
+    registerGitMobTool(server, tools.addTeamMember);
+    registerGitMobTool(server, tools.deleteTeamMember);
+    registerGitMobTool(server, tools.setMobSessionCoauthors);
+    registerGitMobTool(server, tools.clearMobSession);
+    return server;
+};

package/dist/gitMobServerFactory.test.js

@@ -0,0 +1,58 @@
+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/index.js

@@ -0,0 +1,4 @@
+export * from "./registerGitMobTool.js";
+export * from "./registerGitMobResource.js";
+export * from "./registerGitMobResourceAsTool.js";
+export * from "./runCliCommand.js";

package/dist/helpers/registerGitMobResource.js

@@ -0,0 +1,4 @@
+export const registerGitMobResource = (server, resource) => {
+    const { name, template, metadata, readCallback } = resource;
+    server.resource(name, template, metadata, readCallback);
+};

package/dist/helpers/registerGitMobResource.test.js

@@ -0,0 +1,36 @@
+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.js

@@ -0,0 +1,24 @@
+import { URL } from "node:url";
+export const registerGtMobResourceAsTool = (server, resource) => {
+    const { name, template, metadata, readCallback } = resource;
+    const toolName = `get_${name}`;
+    const annotations = {
+        title: toolName,
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    };
+    const toolCallback = async (args, extra) => {
+        const result = await readCallback(new URL(template.uriTemplate), args, extra);
+        const text = result.contents
+            .map((content) => (typeof content.text === "string" ? content.text : ""))
+            .join("\n");
+        return { content: [{ type: "text", text }] };
+    };
+    server.registerTool(toolName, {
+        description: String(metadata.description),
+        inputSchema: {},
+        annotations,
+    }, toolCallback);
+};

package/dist/helpers/registerGitMobResourceAsTool.test.js

@@ -0,0 +1,63 @@
+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.js

@@ -0,0 +1,9 @@
+export const registerGitMobTool = (server, tool) => {
+    const { name, description, inputSchema, outputSchema, annotations, callback, } = tool;
+    server.registerTool(name, {
+        description,
+        inputSchema,
+        outputSchema,
+        annotations,
+    }, callback);
+};

package/dist/helpers/registerGitMobTool.test.js

@@ -0,0 +1,40 @@
+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.js

@@ -0,0 +1,21 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+export async function runCliCommand(program, args) {
+    try {
+        const { stdout, stderr } = await execFileAsync(program, args);
+        return { ok: true, value: stdout || stderr || "" };
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null) {
+            const { stdout, stderr, message } = error;
+            if (stderr)
+                return { ok: false, value: stderr };
+            if (stdout)
+                return { ok: false, value: stdout };
+            if (message)
+                return { ok: false, value: message };
+        }
+        return { ok: false, value: String(error) };
+    }
+}

package/dist/helpers/runCliCommand.test.js

@@ -0,0 +1,38 @@
+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.js

@@ -0,0 +1,8 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createGitMobServer } from "./gitMobServerFactory.js";
+(async () => {
+    const server = createGitMobServer();
+    // Start receiving messages on stdin and sending messages on stdout
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+})();

package/dist/index.test.js

@@ -0,0 +1,22 @@
+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);
+    });
+});