@getforgeai/cli 0.1.0-beta.1

package/dist/mcp/tools/forge-create-task-group.js

@@ -0,0 +1,22 @@
+import { ForgeCreateTaskGroupInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeCreateTaskGroupInputSchema.shape;
+export function registerForgeCreateTaskGroup(server, context) {
+    server.registerTool("forge_create_task_group", {
+        description: "Create a task group in the current project. Returns the created group's id and name. Use this to organize tasks into logical groups before creating tasks.",
+        inputSchema: {
+            name: shape.name.describe("Group name"),
+            description: shape.description.describe("Group description"),
+            order: shape.order.describe("Display order (auto-assigned if omitted)"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "create task group", () => context.socketClient.emitTaskGroupCreate({
+            projectId: context.projectId,
+            workflowId: context.workflowId,
+            name: params.name,
+            description: params.description,
+            order: params.order,
+        }));
+    });
+}
+//# sourceMappingURL=forge-create-task-group.js.map

package/dist/mcp/tools/forge-create-task.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeCreateTask(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-create-task.d.ts.map

package/dist/mcp/tools/forge-create-task.js

@@ -0,0 +1,28 @@
+import { ForgeCreateTaskInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeCreateTaskInputSchema.shape;
+export function registerForgeCreateTask(server, context) {
+    server.registerTool("forge_create_task", {
+        description: "Create a task in the current project. Optionally assign it to a task group by name. Returns the created task's id and title.",
+        inputSchema: {
+            title: shape.title.describe("Task title"),
+            description: shape.description.describe("Task description"),
+            priority: shape.priority.describe("Task priority"),
+            storyPoints: shape.storyPoints.describe("Story points estimate"),
+            groupName: shape.groupName.describe("Task group name to assign this task to"),
+            order: shape.order.describe("Display order (auto-assigned if omitted)"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "create task", () => context.socketClient.emitTaskCreate({
+            projectId: context.projectId,
+            workflowId: context.workflowId,
+            title: params.title,
+            description: params.description,
+            priority: params.priority,
+            storyPoints: params.storyPoints,
+            groupName: params.groupName,
+            order: params.order,
+        }));
+    });
+}
+//# sourceMappingURL=forge-create-task.js.map

package/dist/mcp/tools/forge-delete-task-group.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeDeleteTaskGroup(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-delete-task-group.d.ts.map

package/dist/mcp/tools/forge-delete-task-group.js

@@ -0,0 +1,17 @@
+import { ForgeDeleteTaskGroupInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeDeleteTaskGroupInputSchema.shape;
+export function registerForgeDeleteTaskGroup(server, context) {
+    server.registerTool("forge_delete_task_group", {
+        description: "Delete a task group by name (most recently created match). Tasks in the group are orphaned (moved to ungrouped), not deleted.",
+        inputSchema: {
+            name: shape.name.describe("Group name to find and delete"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "delete task group", () => context.socketClient.emitMcpTaskGroupDelete({
+            projectId: context.projectId,
+            name: params.name,
+        }));
+    });
+}
+//# sourceMappingURL=forge-delete-task-group.js.map

package/dist/mcp/tools/forge-delete-task.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeDeleteTask(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-delete-task.d.ts.map

package/dist/mcp/tools/forge-delete-task.js

@@ -0,0 +1,17 @@
+import { ForgeDeleteTaskInputSchema } from "@getforgeai/protocol";
+import { executeSocketEmit } from "../mcp-response.js";
+const shape = ForgeDeleteTaskInputSchema.shape;
+export function registerForgeDeleteTask(server, context) {
+    server.registerTool("forge_delete_task", {
+        description: "Delete a task by name (most recently created match). This permanently removes the task and its dependencies.",
+        inputSchema: {
+            name: shape.name.describe("Task title to find and delete"),
+        },
+    }, async (params) => {
+        return executeSocketEmit(context, "delete task", () => context.socketClient.emitMcpTaskDelete({
+            projectId: context.projectId,
+            name: params.name,
+        }));
+    });
+}
+//# sourceMappingURL=forge-delete-task.js.map

package/dist/mcp/tools/forge-get-task.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeGetTask(server: McpServer, context: McpSessionContext): void;
+//# sourceMappingURL=forge-get-task.d.ts.map

package/dist/mcp/tools/forge-get-task.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { mcpSuccess, handleRestError } from "../mcp-response.js";
+export function registerForgeGetTask(server, context) {
+    server.registerTool("forge_get_task", {
+        description: "Fetch a task from ForgeAI Cloud with full context (description, acceptance criteria, checkpoints, handoff context)",
+        inputSchema: { taskId: z.string().min(1).describe("Task ID to fetch") },
+    }, async ({ taskId }) => {
+        try {
+            const task = await context.restClient.getTask(taskId);
+            return mcpSuccess(task);
+        }
+        catch (error) {
+            return handleRestError(error, taskId);
+        }
+    });
+}
+//# sourceMappingURL=forge-get-task.js.map

package/dist/mcp/tools/forge-merge-back.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeMergeBack(server: McpServer, _context: McpSessionContext): void;
+//# sourceMappingURL=forge-merge-back.d.ts.map

package/dist/mcp/tools/forge-merge-back.js

@@ -0,0 +1,179 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { mcpSuccess, mcpError } from "../mcp-response.js";
+import { MCP_ERROR_CODE } from "../types.js";
+const execFileAsync = promisify(execFile);
+/** Maximum output bytes to include in conflict details. */
+const MAX_CONFLICT_OUTPUT = 10 * 1024; // 10 KB
+function truncate(text, maxBytes) {
+    if (text.length <= maxBytes)
+        return text;
+    return text.slice(0, maxBytes) + "\n\n--- truncated ---";
+}
+/**
+ * Run a git command in the given repo path and return stdout.
+ * Throws on non-zero exit.
+ */
+async function git(repoPath, args) {
+    const { stdout } = await execFileAsync("git", args, { cwd: repoPath });
+    return stdout.trim();
+}
+/**
+ * Get the list of conflicted files from `git diff --name-only --diff-filter=U`.
+ */
+async function getConflictedFiles(repoPath) {
+    try {
+        const output = await git(repoPath, [
+            "diff",
+            "--name-only",
+            "--diff-filter=U",
+        ]);
+        return output
+            .split("\n")
+            .map((f) => f.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get conflict markers content for a specific file (limited output).
+ */
+async function getConflictContent(repoPath, filePath) {
+    try {
+        const { stdout } = await execFileAsync("git", ["diff", filePath], {
+            cwd: repoPath,
+        });
+        return truncate(stdout, MAX_CONFLICT_OUTPUT);
+    }
+    catch {
+        return "(could not read conflict diff)";
+    }
+}
+export function registerForgeMergeBack(server, _context) {
+    server.registerTool("forge_merge_back", {
+        description: "Merge a child branch into a parent branch. Fetches latest remote state, checks out the parent branch, and performs `git merge`. Returns conflict details if the merge fails so the agent can resolve or call forge_ask_human.",
+        inputSchema: {
+            childBranch: z
+                .string()
+                .min(1)
+                .describe("The child branch to merge (source)"),
+            parentBranch: z
+                .string()
+                .min(1)
+                .describe("The parent branch to merge into (target)"),
+            repoPath: z
+                .string()
+                .min(1)
+                .describe("Absolute path to the git repository"),
+        },
+    }, async ({ childBranch, parentBranch, repoPath }) => {
+        try {
+            // 1. Fetch latest state for both branches
+            try {
+                await git(repoPath, ["fetch", "origin", parentBranch]);
+            }
+            catch {
+                // Remote may not be available — use local state
+            }
+            try {
+                await git(repoPath, ["fetch", "origin", childBranch]);
+            }
+            catch {
+                // Remote may not be available — use local state
+            }
+            // 2. Checkout parent branch
+            try {
+                await git(repoPath, ["checkout", parentBranch]);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return mcpError({
+                    error: MCP_ERROR_CODE.VALIDATION_ERROR,
+                    message: `Failed to checkout parent branch "${parentBranch}": ${message}`,
+                    hint: "Ensure the parent branch exists and the working tree is clean.",
+                });
+            }
+            // 3. Pull latest parent (fast-forward if possible)
+            try {
+                await git(repoPath, ["pull", "--ff-only", "origin", parentBranch]);
+            }
+            catch {
+                // May fail if no remote tracking or no new commits — not fatal
+            }
+            // 4. Attempt merge
+            try {
+                const mergeOutput = await git(repoPath, [
+                    "merge",
+                    childBranch,
+                    "--no-edit",
+                ]);
+                // Merge succeeded — push to remote
+                let pushed = false;
+                try {
+                    await git(repoPath, ["push", "origin", parentBranch]);
+                    pushed = true;
+                }
+                catch {
+                    // Push failed — merge is local only, agent can push later
+                }
+                return mcpSuccess({
+                    success: true,
+                    childBranch,
+                    parentBranch,
+                    pushed,
+                    message: `Successfully merged "${childBranch}" into "${parentBranch}".${pushed ? " Pushed to remote." : " Push to remote failed — push manually."}`,
+                    mergeOutput,
+                });
+            }
+            catch (mergeError) {
+                // 5. Merge failed — check if it's a conflict
+                const conflictedFiles = await getConflictedFiles(repoPath);
+                if (conflictedFiles.length > 0) {
+                    // Gather conflict details for the agent
+                    const conflicts = await Promise.all(conflictedFiles.map(async (file) => ({
+                        file,
+                        diff: await getConflictContent(repoPath, file),
+                    })));
+                    return mcpError({
+                        error: "MERGE_CONFLICT",
+                        message: `Merge of "${childBranch}" into "${parentBranch}" resulted in ${conflictedFiles.length} conflicted file(s).`,
+                        conflictedFiles,
+                        conflicts,
+                        hint: "Resolve the conflicts manually in the listed files, then run `git add <file>` and `git commit` to complete the merge. If you cannot resolve, call forge_ask_human for help.",
+                        repoPath,
+                    });
+                }
+                // Not a conflict — some other merge error
+                const message = mergeError instanceof Error
+                    ? mergeError.message
+                    : String(mergeError);
+                // Abort the failed merge to leave repo in clean state
+                try {
+                    await git(repoPath, ["merge", "--abort"]);
+                }
+                catch {
+                    // Abort may fail if no merge in progress
+                }
+                return mcpError({
+                    error: MCP_ERROR_CODE.VALIDATION_ERROR,
+                    message: `Merge failed: ${message}`,
+                    childBranch,
+                    parentBranch,
+                    hint: "The merge was aborted. Check branch names and repository state.",
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Unexpected error during merge: ${message}`,
+                hint: "Check that the repository path is valid and accessible.",
+            });
+        }
+    });
+}
+//# sourceMappingURL=forge-merge-back.js.map

package/dist/mcp/tools/forge-release-merge.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeReleaseMerge(server: McpServer, _context: McpSessionContext): void;
+//# sourceMappingURL=forge-release-merge.d.ts.map

package/dist/mcp/tools/forge-release-merge.js

@@ -0,0 +1,159 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { mcpSuccess, mcpError } from "../mcp-response.js";
+import { MCP_ERROR_CODE } from "../types.js";
+const execFileAsync = promisify(execFile);
+export function registerForgeReleaseMerge(server, _context) {
+    server.registerTool("forge_release_merge", {
+        description: "Create a release branch from a target branch and merge selected workflow branches into it sequentially. Returns the merge result for each branch, including conflict details if any.",
+        inputSchema: {
+            version: z.string().min(1).describe("Release version (e.g. 'v1.0.0')"),
+            targetBranch: z
+                .string()
+                .min(1)
+                .describe("Target branch to create release from (e.g. 'main')"),
+            workflowBranches: z
+                .array(z.string().min(1))
+                .min(1)
+                .describe("List of workflow branch names to merge into the release branch"),
+            repoPath: z
+                .string()
+                .min(1)
+                .describe("Absolute path to the git repository"),
+        },
+    }, async ({ version, targetBranch, workflowBranches, repoPath }) => {
+        const releaseBranch = `release/${version}`;
+        // 1. Fetch the latest target branch from remote
+        try {
+            await execFileAsync("git", ["fetch", "origin", targetBranch], {
+                cwd: repoPath,
+            });
+        }
+        catch {
+            // Remote may not be available — use local ref
+        }
+        // 2. Create the release branch from origin/targetBranch
+        try {
+            // Check if release branch already exists
+            try {
+                const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", releaseBranch], { cwd: repoPath });
+                if (stdout.trim()) {
+                    // Release branch already exists — check it out
+                    await execFileAsync("git", ["checkout", releaseBranch], {
+                        cwd: repoPath,
+                    });
+                }
+            }
+            catch {
+                // Branch doesn't exist — create it
+                let baseRef = targetBranch;
+                try {
+                    await execFileAsync("git", ["rev-parse", "--verify", `origin/${targetBranch}`], { cwd: repoPath });
+                    baseRef = `origin/${targetBranch}`;
+                }
+                catch {
+                    // origin ref not available, use local
+                }
+                await execFileAsync("git", ["checkout", "-b", releaseBranch, baseRef], { cwd: repoPath });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Failed to create release branch "${releaseBranch}": ${message}`,
+            });
+        }
+        // 3. Merge each workflow branch sequentially
+        const results = [];
+        for (const branch of workflowBranches) {
+            // Fetch the workflow branch from remote
+            try {
+                await execFileAsync("git", ["fetch", "origin", branch], {
+                    cwd: repoPath,
+                });
+            }
+            catch {
+                // Use local ref if remote fetch fails
+            }
+            // Determine the ref to merge (prefer origin/ if available)
+            let mergeRef = branch;
+            try {
+                await execFileAsync("git", ["rev-parse", "--verify", `origin/${branch}`], { cwd: repoPath });
+                mergeRef = `origin/${branch}`;
+            }
+            catch {
+                // Use local ref
+            }
+            try {
+                await execFileAsync("git", ["merge", mergeRef, "--no-edit"], {
+                    cwd: repoPath,
+                });
+                results.push({ branch, status: "merged" });
+            }
+            catch (error) {
+                // Check if it's a merge conflict
+                try {
+                    const { stdout: conflictOutput } = await execFileAsync("git", ["diff", "--name-only", "--diff-filter=U"], { cwd: repoPath });
+                    const conflictFiles = conflictOutput
+                        .split("\n")
+                        .map((f) => f.trim())
+                        .filter(Boolean);
+                    if (conflictFiles.length > 0) {
+                        results.push({
+                            branch,
+                            status: "conflict",
+                            conflictFiles,
+                            error: `Merge conflict in ${conflictFiles.length} file(s)`,
+                        });
+                        // Return immediately on conflict — agent needs to resolve before continuing
+                        return mcpSuccess({
+                            releaseBranch,
+                            targetBranch,
+                            version,
+                            mergeResults: results,
+                            hasConflicts: true,
+                            conflictBranch: branch,
+                            conflictFiles,
+                            message: `Merge conflict detected when merging "${branch}". Resolve conflicts in the listed files, then run git add and git commit to continue.`,
+                        });
+                    }
+                }
+                catch {
+                    // Could not determine conflict files
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({
+                    branch,
+                    status: "failed",
+                    error: message,
+                });
+                return mcpError({
+                    error: MCP_ERROR_CODE.NETWORK_ERROR,
+                    message: `Failed to merge branch "${branch}": ${message}`,
+                    releaseBranch,
+                    mergeResults: results,
+                });
+            }
+        }
+        // 4. Push the release branch to remote
+        try {
+            await execFileAsync("git", ["push", "-u", "origin", releaseBranch], {
+                cwd: repoPath,
+            });
+        }
+        catch {
+            // Non-fatal — branch exists locally, can be pushed later
+        }
+        return mcpSuccess({
+            releaseBranch,
+            targetBranch,
+            version,
+            mergeResults: results,
+            hasConflicts: false,
+            message: `Successfully created release branch "${releaseBranch}" and merged ${results.length} workflow branch(es).`,
+        });
+    });
+}
+//# sourceMappingURL=forge-release-merge.js.map

package/dist/mcp/tools/forge-release-notes.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeReleaseNotes(server: McpServer, _context: McpSessionContext): void;
+//# sourceMappingURL=forge-release-notes.d.ts.map

package/dist/mcp/tools/forge-release-notes.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { mcpSuccess } from "../mcp-response.js";
+export function registerForgeReleaseNotes(server, _context) {
+    server.registerTool("forge_release_notes", {
+        description: "Generate markdown release notes from workflow and task data. Groups tasks by workflow for a structured changelog.",
+        inputSchema: {
+            version: z.string().min(1).describe("Release version (e.g. 'v1.0.0')"),
+            workflowNames: z
+                .array(z.string().min(1))
+                .min(1)
+                .describe("List of workflow names included in the release"),
+            taskTitles: z
+                .array(z.string().min(1))
+                .optional()
+                .describe("Optional flat list of task titles. If provided alongside workflowNames, tasks are listed under a general section."),
+        },
+    }, async ({ version, workflowNames, taskTitles }) => {
+        const lines = [];
+        lines.push(`# Release ${version}`);
+        lines.push("");
+        lines.push(`_Released on ${new Date().toISOString().split("T")[0]}_`);
+        lines.push("");
+        // Workflows section
+        lines.push("## Included Workflows");
+        lines.push("");
+        for (const name of workflowNames) {
+            lines.push(`### ${name}`);
+            lines.push("");
+        }
+        // Tasks section (flat list if provided)
+        if (taskTitles && taskTitles.length > 0) {
+            lines.push("## Changes");
+            lines.push("");
+            for (const title of taskTitles) {
+                lines.push(`- ${title}`);
+            }
+            lines.push("");
+        }
+        lines.push("---");
+        lines.push(`*Generated by ForgeAI*`);
+        const markdown = lines.join("\n");
+        return mcpSuccess({
+            version,
+            markdown,
+            workflowCount: workflowNames.length,
+            taskCount: taskTitles?.length ?? 0,
+            message: `Generated release notes for ${version} with ${workflowNames.length} workflow(s) and ${taskTitles?.length ?? 0} task(s).`,
+        });
+    });
+}
+//# sourceMappingURL=forge-release-notes.js.map

package/dist/mcp/tools/forge-release-tag.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpSessionContext } from "../types.js";
+export declare function registerForgeReleaseTag(server: McpServer, _context: McpSessionContext): void;
+//# sourceMappingURL=forge-release-tag.d.ts.map

package/dist/mcp/tools/forge-release-tag.js

@@ -0,0 +1,125 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { mcpSuccess, mcpError } from "../mcp-response.js";
+import { MCP_ERROR_CODE } from "../types.js";
+const execFileAsync = promisify(execFile);
+export function registerForgeReleaseTag(server, _context) {
+    server.registerTool("forge_release_tag", {
+        description: "Merge a release branch into the target branch, create an annotated git tag, and push both to remote. Used during the RELEASING phase after human approval.",
+        inputSchema: {
+            version: z
+                .string()
+                .min(1)
+                .describe("Release version for the tag (e.g. 'v1.0.0')"),
+            targetBranch: z
+                .string()
+                .min(1)
+                .describe("Target branch to merge into (e.g. 'main')"),
+            releaseBranch: z
+                .string()
+                .min(1)
+                .describe("Release branch to merge from (e.g. 'release/v1.0.0')"),
+            repoPath: z
+                .string()
+                .min(1)
+                .describe("Absolute path to the git repository"),
+        },
+    }, async ({ version, targetBranch, releaseBranch, repoPath }) => {
+        // 1. Checkout target branch
+        try {
+            await execFileAsync("git", ["fetch", "origin", targetBranch], {
+                cwd: repoPath,
+            });
+        }
+        catch {
+            // Remote may not be available
+        }
+        try {
+            await execFileAsync("git", ["checkout", targetBranch], {
+                cwd: repoPath,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Failed to checkout "${targetBranch}": ${message}`,
+            });
+        }
+        // 2. Pull latest target branch
+        try {
+            await execFileAsync("git", ["pull", "origin", targetBranch], {
+                cwd: repoPath,
+            });
+        }
+        catch {
+            // Non-fatal — continue with local state
+        }
+        // 3. Merge release branch into target
+        let mergeCommit;
+        try {
+            await execFileAsync("git", ["merge", releaseBranch, "--no-edit"], {
+                cwd: repoPath,
+            });
+            const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+                cwd: repoPath,
+            });
+            mergeCommit = stdout.trim();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Failed to merge "${releaseBranch}" into "${targetBranch}": ${message}`,
+            });
+        }
+        // 4. Create annotated tag
+        const tagName = version;
+        try {
+            await execFileAsync("git", ["tag", "-a", tagName, "-m", `Release ${version}`], { cwd: repoPath });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Failed to create tag "${tagName}": ${message}`,
+            });
+        }
+        // 5. Push target branch to remote
+        try {
+            await execFileAsync("git", ["push", "origin", targetBranch], {
+                cwd: repoPath,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Failed to push "${targetBranch}" to remote: ${message}`,
+            });
+        }
+        // 6. Push tag to remote
+        try {
+            await execFileAsync("git", ["push", "origin", tagName], {
+                cwd: repoPath,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return mcpError({
+                error: MCP_ERROR_CODE.NETWORK_ERROR,
+                message: `Failed to push tag "${tagName}" to remote: ${message}`,
+            });
+        }
+        return mcpSuccess({
+            tagName,
+            mergeCommit,
+            targetBranch,
+            releaseBranch,
+            version,
+            message: `Successfully merged "${releaseBranch}" into "${targetBranch}", created tag "${tagName}", and pushed to remote.`,
+        });
+    });
+}
+//# sourceMappingURL=forge-release-tag.js.map