@lioneltay/worktree-mcp 0.0.1

package/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "worktree-mcp",
+  "version": "0.0.1",
+  "description": "Manage git worktrees from Claude Code",
+  "author": {
+    "name": "lioneltay"
+  },
+  "repository": "https://github.com/lioneltay/agent-forge/tree/main/packages/claude-plugins/worktree-mcp",
+  "license": "MIT"
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "worktree": {
+      "command": "npx",
+      "args": ["-y", "@lioneltay/worktree-mcp"]
+    }
+  }
+}

package/README.md

@@ -0,0 +1,70 @@
+# @lioneltay/worktree-mcp
+
+MCP server for managing git worktrees so AI agents can create isolated workspaces for parallel development.
+
+## Install
+
+Add the MCP server to Claude Code:
+
+```bash
+claude mcp add worktree npx -y @lioneltay/worktree-mcp
+```
+
+Or add it manually to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "worktree": {
+      "command": "npx",
+      "args": ["-y", "@lioneltay/worktree-mcp"]
+    }
+  }
+}
+```
+
+## Claude Code Plugin
+
+You can also install as a plugin:
+
+```bash
+# 1. Add the marketplace
+claude plugin marketplace add lioneltay/agent-forge
+
+# 2. Install the plugin
+claude plugin install worktree-mcp@agent-forge
+```
+
+## Tools
+
+### `create_worktree`
+
+Create a new git worktree.
+
+**Input:**
+- `branch` (string, required) — Branch name to checkout or create
+- `newBranch` (boolean, optional) — Create a new branch
+- `from` (string, optional) — Base branch/commit for new branch
+- `name` (string, optional) — Custom folder name
+
+**Returns:** The created worktree name and path.
+
+### `list_worktrees`
+
+List all managed worktrees with status.
+
+**Returns:** JSON array of worktree objects with name, path, branch, status, ahead/behind counts, and change counts.
+
+### `remove_worktree`
+
+Remove a git worktree.
+
+**Input:**
+- `name` (string, required) — Worktree name to remove
+- `force` (boolean, optional) — Force removal with uncommitted changes
+
+**Returns:** Confirmation message.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { create, list, remove, status } from "@lioneltay/worktree-manager";
+const server = new McpServer({
+    name: "worktree-mcp",
+    version: "0.0.1",
+});
+server.registerTool("create_worktree", {
+    description: "Create a new git worktree. Worktrees allow parallel work on multiple branches without stashing or switching.",
+    inputSchema: {
+        branch: z.string().describe("Branch name to checkout or create"),
+        from: z
+            .string()
+            .optional()
+            .describe("Base branch/commit to create a new branch from (only used when branch doesn't exist yet)"),
+    },
+}, async ({ branch, from }) => {
+    try {
+        let result;
+        let created = false;
+        try {
+            result = await create(branch, { from });
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.includes("not found")) {
+                result = await create(branch, { newBranch: true, from });
+                created = true;
+            }
+            else {
+                throw e;
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: created
+                        ? `Created new branch '${branch}' and worktree '${result.name}' at ${result.path}`
+                        : `Checked out existing branch '${branch}' into worktree '${result.name}' at ${result.path}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+server.registerTool("list_worktrees", {
+    description: "List all managed git worktrees with their status, branch, and change counts.",
+    inputSchema: {},
+}, async () => {
+    try {
+        const worktrees = await list();
+        if (worktrees.length === 0) {
+            return {
+                content: [{ type: "text", text: "No worktrees found." }],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(worktrees, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to list worktrees: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+/**
+ * Resolve a worktree name or branch name to the actual worktree name.
+ * Tries the input as-is first, then normalizes it (strip origin/, replace /\ with --).
+ */
+async function resolveWorktreeName(input) {
+    // Try exact match first
+    const exact = await status(input);
+    if (exact)
+        return input;
+    // Normalize: strip origin/ prefix, replace /\ with --
+    const normalized = input.replace(/^origin\//, "").replace(/[/\\]/g, "--");
+    if (normalized !== input) {
+        const found = await status(normalized);
+        if (found)
+            return normalized;
+    }
+    return input; // Let remove() throw its own "not found" error
+}
+server.registerTool("remove_worktree", {
+    description: "Remove a git worktree. Accepts the worktree name or branch name. Fails if the worktree has uncommitted changes unless force is true.",
+    inputSchema: {
+        name: z.string().describe("Worktree name or branch name (e.g. 'feature--foo' or 'feature/foo')"),
+        force: z
+            .boolean()
+            .optional()
+            .describe("Force removal even if there are uncommitted changes"),
+    },
+}, async ({ name, force }) => {
+    try {
+        const resolved = await resolveWorktreeName(name);
+        await remove(resolved, { force });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Removed worktree '${resolved}'.`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to remove worktree: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@lioneltay/worktree-mcp",
+  "version": "0.0.1",
+  "description": "MCP server for managing git worktrees",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lioneltay/agent-forge",
+    "directory": "packages/claude-plugins/worktree-mcp"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "worktree-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    ".claude-plugin",
+    ".mcp.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@lioneltay/worktree-manager": "workspace:*",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "typescript": "^5.7.3"
+  }
+}