@vibegrid/mcp 0.3.2 → 0.4.0-beta.0

package/dist/index.js

@@ -1525,26 +1525,37 @@ var AGENT_TYPES3 = [
 function registerSessionTools(server) {
   server.tool(
     "list_sessions",
-    "List all active terminal sessions. Requires the VibeGrid app to be running.",
+    'List terminal sessions. Filter by status: "active" (running terminals), "recent" (past sessions), or "archived".',
     {
-      project_name: V.name.optional().describe("Filter by project name")
+      filter: z4.enum(["active", "recent", "archived"]).optional().describe("Session filter (default: active)"),
+      project_name: V.name.optional().describe("Filter by project name"),
+      project_path: V.absolutePath.optional().describe("Filter by project path (for recent sessions)")
     },
     async (args) => {
+      const filter = args.filter ?? "active";
       try {
-        let sessions = await rpcCall("terminal:listActive");
-        if (args.project_name) {
-          sessions = sessions.filter((s) => s.projectName === args.project_name);
+        if (filter === "active") {
+          let sessions = await rpcCall("terminal:listActive");
+          if (args.project_name) {
+            sessions = sessions.filter((s) => s.projectName === args.project_name);
+          }
+          const summary = sessions.map((s) => ({
+            id: s.id,
+            agentType: s.agentType,
+            projectName: s.projectName,
+            status: s.status,
+            displayName: s.displayName,
+            branch: s.branch,
+            pid: s.pid
+          }));
+          return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+        } else if (filter === "recent") {
+          const sessions = await rpcCall("sessions:getRecent", args.project_path);
+          return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
+        } else {
+          const sessions = await rpcCall("session:listArchived");
+          return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
         }
-        const summary = sessions.map((s) => ({
-          id: s.id,
-          agentType: s.agentType,
-          projectName: s.projectName,
-          status: s.status,
-          displayName: s.displayName,
-          branch: s.branch,
-          pid: s.pid
-        }));
-        return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
       } catch (err) {
         return {
           content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
@@ -1554,41 +1565,8 @@ function registerSessionTools(server) {
     }
   );
   server.tool(
-    "list_recent_sessions",
-    "List recent session history for a project. Requires the VibeGrid app to be running.",
-    {
-      project_path: V.absolutePath.optional().describe("Filter by project path")
-    },
-    async (args) => {
-      try {
-        const sessions = await rpcCall("sessions:getRecent", args.project_path);
-        return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "list_archived_sessions",
-    "List archived sessions. Requires the VibeGrid app to be running.",
-    async () => {
-      try {
-        const sessions = await rpcCall("session:listArchived");
-        return { content: [{ type: "text", text: JSON.stringify(sessions, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "launch_agent",
-    "Launch an AI agent in a new terminal session. Requires the VibeGrid app to be running.",
+    "launch_session",
+    "Launch an AI agent session (interactive terminal or headless). Requires the VibeGrid app to be running.",
     {
       agent_type: z4.enum(AGENT_TYPES3).describe("Agent type to launch"),
       project_name: V.name.describe("Project name"),
@@ -1596,7 +1574,8 @@ function registerSessionTools(server) {
       prompt: V.prompt.optional().describe("Initial prompt to send to the agent"),
       branch: V.shortText.optional().describe("Git branch to checkout"),
       use_worktree: z4.boolean().optional().describe("Create a git worktree"),
-      display_name: V.shortText.optional().describe("Display name for the session")
+      display_name: V.shortText.optional().describe("Display name for the session"),
+      headless: z4.boolean().optional().describe("Launch as headless (no UI) session")
     },
     async (args) => {
       const payload = {
@@ -1608,8 +1587,10 @@ function registerSessionTools(server) {
         ...args.use_worktree && { useWorktree: args.use_worktree },
         ...args.display_name && { displayName: args.display_name }
       };
+      const rpcMethod = args.headless ? "headless:create" : "terminal:create";
+      const label = args.headless ? "headless" : "terminal";
       try {
-        const session = await rpcCall("terminal:create", payload);
+        const session = await rpcCall(rpcMethod, payload);
         return {
           content: [
             {
@@ -1633,7 +1614,7 @@ function registerSessionTools(server) {
           content: [
             {
               type: "text",
-              text: `Error launching agent: ${err instanceof Error ? err.message : err}`
+              text: `Error launching ${label} agent: ${err instanceof Error ? err.message : err}`
             }
           ],
           isError: true
@@ -1642,95 +1623,24 @@ function registerSessionTools(server) {
     }
   );
   server.tool(
-    "launch_headless",
-    "Launch a headless (no UI) agent session. Requires the VibeGrid app to be running.",
+    "kill_session",
+    "Kill a terminal or headless session. Requires the VibeGrid app to be running.",
     {
-      agent_type: z4.enum(AGENT_TYPES3).describe("Agent type to launch"),
-      project_name: V.name.describe("Project name"),
-      project_path: V.absolutePath.describe("Absolute path to project directory"),
-      prompt: V.prompt.optional().describe("Initial prompt to send to the agent"),
-      branch: V.shortText.optional().describe("Git branch to checkout"),
-      use_worktree: z4.boolean().optional().describe("Create a git worktree"),
-      display_name: V.shortText.optional().describe("Display name for the session")
+      id: V.id.describe("Session ID to kill"),
+      headless: z4.boolean().optional().describe("Kill a headless session instead of a terminal")
     },
     async (args) => {
-      const payload = {
-        agentType: args.agent_type,
-        projectName: args.project_name,
-        projectPath: args.project_path,
-        ...args.prompt && { initialPrompt: args.prompt },
-        ...args.branch && { branch: args.branch },
-        ...args.use_worktree && { useWorktree: args.use_worktree },
-        ...args.display_name && { displayName: args.display_name }
-      };
-      try {
-        const session = await rpcCall("headless:create", payload);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  id: session.id,
-                  agentType: session.agentType,
-                  projectName: session.projectName,
-                  pid: session.pid,
-                  status: session.status
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error launching headless agent: ${err instanceof Error ? err.message : err}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "kill_session",
-    "Kill a terminal session. Requires the VibeGrid app to be running.",
-    { id: V.id.describe("Session ID to kill") },
-    async (args) => {
-      try {
-        await rpcCall("terminal:kill", args.id);
-        return { content: [{ type: "text", text: `Killed session: ${args.id}` }] };
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error killing session: ${err instanceof Error ? err.message : err}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "kill_headless",
-    "Kill a headless agent session. Requires the VibeGrid app to be running.",
-    { id: V.id.describe("Headless session ID to kill") },
-    async (args) => {
+      const rpcMethod = args.headless ? "headless:kill" : "terminal:kill";
+      const label = args.headless ? "headless session" : "session";
       try {
-        await rpcCall("headless:kill", args.id);
-        return { content: [{ type: "text", text: `Killed headless session: ${args.id}` }] };
+        await rpcCall(rpcMethod, args.id);
+        return { content: [{ type: "text", text: `Killed ${label}: ${args.id}` }] };
       } catch (err) {
         return {
           content: [
             {
               type: "text",
-              text: `Error killing headless session: ${err instanceof Error ? err.message : err}`
+              text: `Error killing ${label}: ${err instanceof Error ? err.message : err}`
             }
           ],
           isError: true
@@ -1747,7 +1657,9 @@ function registerSessionTools(server) {
     },
     async (args) => {
       try {
-        await rpcNotify("terminal:write", { id: args.id, data: args.data });
+        const trimmed = args.data.replace(/[\r\n]+$/, "");
+        const data = trimmed + "\r";
+        await rpcNotify("terminal:write", { id: args.id, data });
         return { content: [{ type: "text", text: `Wrote to session: ${args.id}` }] };
       } catch (err) {
         return {
@@ -1955,460 +1867,66 @@ function registerWorkflowTools(server) {
   );
   server.tool(
     "list_workflow_runs",
-    "List execution history for a workflow",
+    "List workflow execution history. Filter by workflow_id or task_id.",
     {
-      workflow_id: V.id.describe("Workflow ID"),
+      workflow_id: V.id.optional().describe("Filter by workflow ID"),
+      task_id: V.id.optional().describe("Filter by task ID (runs triggered by this task)"),
       limit: z5.number().int().min(1).max(100).optional().describe("Max results (default: 20)")
     },
     async (args) => {
-      const runs = listWorkflowRuns(args.workflow_id, args.limit ?? 20);
-      return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
-    }
-  );
-  server.tool(
-    "list_workflow_runs_by_task",
-    "List workflow executions triggered by a specific task",
-    {
-      task_id: V.id.describe("Task ID"),
-      limit: z5.number().int().min(1).max(100).optional().describe("Max results (default: 20)")
-    },
-    async (args) => {
-      const runs = listWorkflowRunsByTask(args.task_id, args.limit ?? 20);
-      return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
-    }
-  );
-  server.tool(
-    "get_scheduler_log",
-    "Get scheduler execution log for a workflow. Requires the VibeGrid app to be running.",
-    {
-      workflow_id: V.id.optional().describe("Workflow ID (omit for all workflows)")
-    },
-    async (args) => {
-      try {
-        const log2 = await rpcCall("scheduler:getLog", args.workflow_id);
-        return { content: [{ type: "text", text: JSON.stringify(log2, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "get_next_scheduled_run",
-    "Get the next scheduled run time for a workflow. Requires the VibeGrid app to be running.",
-    {
-      workflow_id: V.id.describe("Workflow ID")
-    },
-    async (args) => {
-      try {
-        const nextRun = await rpcCall("scheduler:getNextRun", args.workflow_id);
+      if (args.workflow_id && args.task_id) {
         return {
-          content: [
-            {
-              type: "text",
-              text: nextRun ? JSON.stringify({ nextRun }, null, 2) : "No scheduled run (workflow may be manual or disabled)"
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
+          content: [{ type: "text", text: "Error: provide workflow_id or task_id, not both" }],
           isError: true
         };
       }
-    }
-  );
-}
-
-// src/tools/git.ts
-import { z as z6 } from "zod";
-
-// ../server/src/git-utils.ts
-import { execFileSync } from "child_process";
-import path5 from "path";
-import fs4 from "fs";
-import crypto3 from "crypto";
-var EXEC_OPTS = {
-  encoding: "utf-8",
-  stdio: ["pipe", "pipe", "pipe"]
-};
-function getGitBranch(projectPath) {
-  try {
-    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 3e3
-    }).trim();
-    return branch && branch !== "HEAD" ? branch : null;
-  } catch {
-    return null;
-  }
-}
-function listBranches(projectPath) {
-  try {
-    const output = execFileSync("git", ["branch", "--format=%(refname:short)"], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 5e3
-    }).trim();
-    return output ? output.split("\n").map((b) => b.trim()).filter(Boolean) : [];
-  } catch {
-    return [];
-  }
-}
-function listRemoteBranches(projectPath) {
-  try {
-    execFileSync("git", ["fetch", "--prune"], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 15e3
-    });
-    const output = execFileSync("git", ["branch", "-r", "--format=%(refname:short)"], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 5e3
-    }).trim();
-    return output ? output.split("\n").map((b) => b.trim().replace(/^origin\//, "")).filter((b) => b && b !== "HEAD") : [];
-  } catch {
-    return [];
-  }
-}
-function createWorktree(projectPath, branch) {
-  const projectName = path5.basename(projectPath);
-  const shortId = crypto3.randomUUID().slice(0, 8);
-  const baseDir = path5.join(path5.dirname(projectPath), ".vibegrid-worktrees", projectName);
-  const worktreeDir = path5.join(baseDir, `${branch}-${shortId}`);
-  fs4.mkdirSync(baseDir, { recursive: true });
-  const localBranches = listBranches(projectPath);
-  if (localBranches.includes(branch)) {
-    try {
-      execFileSync("git", ["worktree", "add", worktreeDir, branch], {
-        cwd: projectPath,
-        ...EXEC_OPTS,
-        timeout: 3e4
-      });
-    } catch {
-      const newBranch = `${branch}-worktree-${shortId}`;
-      execFileSync("git", ["worktree", "add", "-b", newBranch, worktreeDir, branch], {
-        cwd: projectPath,
-        ...EXEC_OPTS,
-        timeout: 3e4
-      });
-      return { worktreePath: worktreeDir, branch: newBranch };
-    }
-  } else {
-    execFileSync("git", ["worktree", "add", "-b", branch, worktreeDir], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 3e4
-    });
-  }
-  return { worktreePath: worktreeDir, branch };
-}
-function isWorktreeDirty(worktreePath) {
-  try {
-    const output = execFileSync("git", ["status", "--porcelain"], {
-      cwd: worktreePath,
-      ...EXEC_OPTS,
-      timeout: 5e3
-    }).trim();
-    return output.length > 0;
-  } catch {
-    return true;
-  }
-}
-function getGitDiffStat(cwd) {
-  try {
-    const output = execFileSync("git", ["diff", "HEAD", "--numstat"], {
-      cwd,
-      ...EXEC_OPTS,
-      timeout: 1e4
-    }).trim();
-    if (!output) return { filesChanged: 0, insertions: 0, deletions: 0 };
-    let insertions = 0;
-    let deletions = 0;
-    let filesChanged = 0;
-    for (const line of output.split("\n")) {
-      const parts = line.split("	");
-      if (parts[0] === "-") {
-        filesChanged++;
-        continue;
-      }
-      insertions += parseInt(parts[0], 10) || 0;
-      deletions += parseInt(parts[1], 10) || 0;
-      filesChanged++;
-    }
-    return { filesChanged, insertions, deletions };
-  } catch {
-    return null;
-  }
-}
-function getGitDiffFull(cwd) {
-  try {
-    const stat = getGitDiffStat(cwd);
-    if (!stat) return null;
-    const MAX_DIFF_SIZE = 500 * 1024;
-    let rawDiff = execFileSync("git", ["diff", "HEAD", "-U3"], {
-      cwd,
-      ...EXEC_OPTS,
-      timeout: 15e3,
-      maxBuffer: MAX_DIFF_SIZE * 2
-    });
-    if (rawDiff.length > MAX_DIFF_SIZE) {
-      rawDiff = rawDiff.slice(0, MAX_DIFF_SIZE) + "\n\n... diff truncated (too large) ...\n";
-    }
-    const numstatOutput = execFileSync("git", ["diff", "HEAD", "--numstat"], {
-      cwd,
-      ...EXEC_OPTS,
-      timeout: 1e4
-    }).trim();
-    const fileStats = /* @__PURE__ */ new Map();
-    if (numstatOutput) {
-      for (const line of numstatOutput.split("\n")) {
-        const parts = line.split("	");
-        if (parts.length >= 3) {
-          const ins = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
-          const del = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
-          fileStats.set(parts.slice(2).join("	"), { insertions: ins, deletions: del });
-        }
-      }
-    }
-    const fileDiffs = [];
-    const diffSections = rawDiff.split(/^diff --git /m).filter(Boolean);
-    for (const section of diffSections) {
-      const fullSection = "diff --git " + section;
-      const plusMatch = fullSection.match(/^\+\+\+ b\/(.+)$/m);
-      const minusMatch = fullSection.match(/^--- a\/(.+)$/m);
-      const filePath = plusMatch?.[1] || minusMatch?.[1]?.replace(/^\/dev\/null$/, "") || "unknown";
-      let status = "modified";
-      if (fullSection.includes("--- /dev/null")) {
-        status = "added";
-      } else if (fullSection.includes("+++ /dev/null")) {
-        status = "deleted";
-      } else if (fullSection.includes("rename from")) {
-        status = "renamed";
-      }
-      const stats = fileStats.get(filePath) || { insertions: 0, deletions: 0 };
-      fileDiffs.push({
-        filePath,
-        status,
-        insertions: stats.insertions,
-        deletions: stats.deletions,
-        diff: fullSection
-      });
-    }
-    return { stat, files: fileDiffs };
-  } catch {
-    return null;
-  }
-}
-function gitCommit(cwd, message, includeUnstaged) {
-  try {
-    if (includeUnstaged) {
-      execFileSync("git", ["add", "-A"], { cwd, ...EXEC_OPTS, timeout: 1e4 });
-    }
-    execFileSync("git", ["commit", "-m", message], {
-      cwd,
-      ...EXEC_OPTS,
-      timeout: 15e3
-    });
-    return { success: true };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { success: false, error: msg };
-  }
-}
-function gitPush(cwd) {
-  try {
-    execFileSync("git", ["push"], { cwd, ...EXEC_OPTS, timeout: 3e4 });
-    return { success: true };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { success: false, error: msg };
-  }
-}
-function listWorktrees(projectPath) {
-  try {
-    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
-      cwd: projectPath,
-      ...EXEC_OPTS,
-      timeout: 5e3
-    }).trim();
-    if (!output) return [];
-    const worktrees = [];
-    const blocks = output.split("\n\n");
-    for (const block of blocks) {
-      const lines = block.split("\n");
-      const wtPath = lines.find((l) => l.startsWith("worktree "))?.replace("worktree ", "");
-      const branchLine = lines.find((l) => l.startsWith("branch "));
-      const branch = branchLine?.replace("branch refs/heads/", "") || "detached";
-      if (wtPath) {
-        worktrees.push({ path: wtPath, branch, isMain: worktrees.length === 0 });
-      }
-    }
-    return worktrees;
-  } catch {
-    return [];
-  }
-}
-
-// src/tools/git.ts
-function registerGitTools(server) {
-  server.tool(
-    "list_branches",
-    "List git branches for a project",
-    { project_path: V.absolutePath.describe("Absolute path to project directory") },
-    async (args) => {
-      try {
-        const local = listBranches(args.project_path);
-        const current = getGitBranch(args.project_path);
-        return {
-          content: [{ type: "text", text: JSON.stringify({ current, branches: local }, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error listing branches: ${err}` }],
-          isError: true
-        };
+      if (args.task_id) {
+        const runs = listWorkflowRunsByTask(args.task_id, args.limit ?? 20);
+        return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
       }
-    }
-  );
-  server.tool(
-    "list_remote_branches",
-    "List remote git branches for a project",
-    { project_path: V.absolutePath.describe("Absolute path to project directory") },
-    async (args) => {
-      try {
-        const remote = listRemoteBranches(args.project_path);
-        return { content: [{ type: "text", text: JSON.stringify(remote, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error listing remote branches: ${err}` }],
-          isError: true
-        };
+      if (args.workflow_id) {
+        const runs = listWorkflowRuns(args.workflow_id, args.limit ?? 20);
+        return { content: [{ type: "text", text: JSON.stringify(runs, null, 2) }] };
       }
+      return {
+        content: [{ type: "text", text: "Error: provide either workflow_id or task_id" }],
+        isError: true
+      };
     }
   );
   server.tool(
-    "get_diff",
-    "Get git diff for a project (staged and unstaged changes)",
-    { project_path: V.absolutePath.describe("Absolute path to project directory") },
+    "get_workflow_schedule",
+    "Get scheduler info for a workflow: execution log or next scheduled run. Requires the VibeGrid app to be running.",
+    {
+      workflow_id: V.id.optional().describe("Workflow ID (required for next_run, optional for log)"),
+      info: z5.enum(["log", "next_run"]).optional().describe("What to retrieve (default: log)")
+    },
     async (args) => {
+      const info = args.info ?? "log";
       try {
-        const result = getGitDiffFull(args.project_path);
-        if (!result) {
+        if (info === "next_run") {
+          if (!args.workflow_id) {
+            return {
+              content: [{ type: "text", text: "Error: workflow_id is required for next_run" }],
+              isError: true
+            };
+          }
+          const nextRun = await rpcCall("scheduler:getNextRun", args.workflow_id);
           return {
-            content: [{ type: "text", text: "No changes detected or not a git repository" }]
+            content: [
+              {
+                type: "text",
+                text: nextRun ? JSON.stringify({ nextRun }, null, 2) : "No scheduled run (workflow may be manual or disabled)"
+              }
+            ]
           };
+        } else {
+          const log2 = await rpcCall("scheduler:getLog", args.workflow_id);
+          return { content: [{ type: "text", text: JSON.stringify(log2, null, 2) }] };
         }
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-      } catch (err) {
-        return { content: [{ type: "text", text: `Error getting diff: ${err}` }], isError: true };
-      }
-    }
-  );
-  server.tool(
-    "get_diff_stat",
-    "Get a summary of git changes (files changed, insertions, deletions)",
-    { project_path: V.absolutePath.describe("Absolute path to project directory") },
-    async (args) => {
-      try {
-        const result = getGitDiffStat(args.project_path);
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
       } catch (err) {
         return {
-          content: [{ type: "text", text: `Error getting diff stat: ${err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "git_commit",
-    "Create a git commit",
-    {
-      project_path: V.absolutePath.describe("Absolute path to project directory"),
-      message: V.description.describe("Commit message"),
-      include_unstaged: z6.boolean().optional().describe("Stage all changes before committing")
-    },
-    async (args) => {
-      try {
-        const result = gitCommit(args.project_path, args.message, args.include_unstaged ?? false);
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error committing: ${err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "git_push",
-    "Push commits to the remote repository",
-    { project_path: V.absolutePath.describe("Absolute path to project directory") },
-    async (args) => {
-      try {
-        const result = gitPush(args.project_path);
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error pushing: ${err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "list_worktrees",
-    "List git worktrees for a project",
-    { project_path: V.absolutePath.describe("Absolute path to project directory") },
-    async (args) => {
-      try {
-        const worktrees = listWorktrees(args.project_path);
-        return { content: [{ type: "text", text: JSON.stringify(worktrees, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error listing worktrees: ${err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "create_worktree",
-    "Create a git worktree for a branch",
-    {
-      project_path: V.absolutePath.describe("Absolute path to project directory"),
-      branch: V.shortText.describe("Branch name for the worktree")
-    },
-    async (args) => {
-      try {
-        const worktreePath = createWorktree(args.project_path, args.branch);
-        return {
-          content: [{ type: "text", text: JSON.stringify({ path: worktreePath }, null, 2) }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error creating worktree: ${err}` }],
-          isError: true
-        };
-      }
-    }
-  );
-  server.tool(
-    "worktree_dirty",
-    "Check if a worktree has uncommitted changes",
-    { worktree_path: V.absolutePath.describe("Absolute path to the worktree") },
-    async (args) => {
-      try {
-        const dirty = isWorktreeDirty(args.worktree_path);
-        return { content: [{ type: "text", text: JSON.stringify({ dirty }, null, 2) }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error checking worktree: ${err}` }],
+          content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : err}` }],
           isError: true
         };
       }
@@ -2429,8 +1947,8 @@ function registerConfigTools(server) {
 }
 
 // src/tools/workspaces.ts
-import crypto4 from "crypto";
-import { z as z7 } from "zod";
+import crypto3 from "crypto";
+import { z as z6 } from "zod";
 function registerWorkspaceTools(server) {
   server.tool("list_workspaces", "List all workspaces", async () => {
     const workspaces = dbListWorkspaces();
@@ -2448,7 +1966,7 @@ function registerWorkspaceTools(server) {
       const existing = dbListWorkspaces();
       const maxOrder = existing.reduce((max, w) => Math.max(max, w.order), 0);
       const workspace = {
-        id: crypto4.randomUUID(),
+        id: crypto3.randomUUID(),
         name: args.name,
         order: maxOrder + 1,
         ...args.icon && { icon: args.icon },
@@ -2467,7 +1985,7 @@ function registerWorkspaceTools(server) {
       name: V.name.optional().describe("New name"),
       icon: V.shortText.optional().describe("Lucide icon name"),
       icon_color: V.hexColor.optional().describe("Hex color for icon"),
-      order: z7.number().int().min(0).optional().describe("Sort order")
+      order: z6.number().int().min(0).optional().describe("Sort order")
     },
     async (args) => {
       const existing = dbListWorkspaces();
@@ -2517,7 +2035,6 @@ function registerWorkspaceTools(server) {
 // src/server.ts
 function createMcpServer(version) {
   const server = new McpServer({ name: "vibegrid", version }, { capabilities: { tools: {} } });
-  registerGitTools(server);
   registerConfigTools(server);
   registerProjectTools(server);
   registerTaskTools(server);
@@ -2536,7 +2053,7 @@ console.warn = (...args) => _origError("[mcp:warn]", ...args);
 console.error = (...args) => _origError("[mcp:error]", ...args);
 async function main() {
   configManager.init();
-  const version = true ? "0.3.2" : createRequire(import.meta.url)("../package.json").version;
+  const version = true ? "0.4.0-beta.0" : createRequire(import.meta.url)("../package.json").version;
   const server = createMcpServer(version);
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibegrid/mcp",
-  "version": "0.3.2",
+  "version": "0.4.0-beta.0",
   "description": "VibeGrid MCP server — task management, git, and workflow tools for AI coding agents",
   "type": "module",
   "license": "MIT",