ralph-mcp 1.0.0

package/dist/tools/merge.js

@@ -0,0 +1,384 @@
+import { z } from "zod";
+import { removeWorktree, abortMerge, } from "../utils/worktree.js";
+import { generateMergeAgentPrompt, startMergeAgent, } from "../utils/agent.js";
+import { syncMainToBranch, runQualityChecks, generateCommitMessage, updateTodoDoc, updateProjectStatus, handleSchemaConflict, } from "../utils/merge-helpers.js";
+import { execSync } from "child_process";
+import { deleteMergeQueueByExecutionId, findExecutionByBranch, findExecutionById, insertMergeQueueItem, listExecutions, listMergeQueue, listUserStoriesByExecutionId, updateExecution, updateMergeQueueItem, } from "../store/state.js";
+export const mergeInputSchema = z.object({
+    branch: z.string().describe("Branch name to merge (e.g., ralph/task1-agent)"),
+    force: z.boolean().default(false).describe("Skip verification checks"),
+    skipQualityChecks: z.boolean().default(false).describe("Skip type check and build"),
+    onConflict: z
+        .enum(["auto_theirs", "auto_ours", "notify", "agent"])
+        .optional()
+        .describe("Override conflict resolution strategy"),
+});
+export async function merge(input) {
+    // Find execution
+    const exec = await findExecutionByBranch(input.branch);
+    if (!exec) {
+        throw new Error(`No execution found for branch: ${input.branch}`);
+    }
+    // Get completed stories for commit message
+    const stories = await listUserStoriesByExecutionId(exec.id);
+    const completedStories = stories
+        .filter((s) => s.passes)
+        .map((s) => ({ id: s.storyId, title: s.title }));
+    // Check if all stories are complete (unless force)
+    if (!input.force) {
+        const { get } = await import("./get.js");
+        const status = await get({ branch: input.branch });
+        if (status.progress.completed < status.progress.total) {
+            throw new Error(`Cannot merge: ${status.progress.completed}/${status.progress.total} stories complete. Use force=true to override.`);
+        }
+    }
+    // Update status to merging
+    await updateExecution(exec.id, { status: "merging", updatedAt: new Date() });
+    const onConflict = input.onConflict || exec.onConflict || "agent";
+    try {
+        // Step 1: Sync main to feature branch (in worktree)
+        if (exec.worktreePath) {
+            console.log(">>> Syncing main to feature branch...");
+            const syncResult = await syncMainToBranch(exec.worktreePath, exec.branch);
+            if (!syncResult.success) {
+                if (syncResult.hasConflicts && syncResult.conflictFiles) {
+                    // Try to handle schema conflicts automatically
+                    const hasSchemaConflict = syncResult.conflictFiles.some((f) => f.includes("schema.prisma"));
+                    if (hasSchemaConflict) {
+                        console.log(">>> Attempting to resolve schema.prisma conflict...");
+                        const schemaResolved = await handleSchemaConflict(exec.worktreePath);
+                        if (!schemaResolved) {
+                            throw new Error(`Failed to resolve schema.prisma conflict during sync`);
+                        }
+                        // Continue with remaining conflicts if any
+                        const remainingConflicts = syncResult.conflictFiles.filter((f) => !f.includes("schema.prisma"));
+                        if (remainingConflicts.length > 0) {
+                            throw new Error(`Sync conflicts in: ${remainingConflicts.join(", ")}`);
+                        }
+                    }
+                    else {
+                        throw new Error(syncResult.message);
+                    }
+                }
+                else {
+                    throw new Error(syncResult.message);
+                }
+            }
+        }
+        // Step 2: Run quality checks (unless skipped)
+        if (!input.skipQualityChecks && exec.worktreePath) {
+            console.log(">>> Running quality checks...");
+            const qualityResult = await runQualityChecks(exec.worktreePath);
+            if (!qualityResult.success) {
+                const failedChecks = [];
+                if (!qualityResult.typeCheck.success)
+                    failedChecks.push("typeCheck");
+                if (!qualityResult.build.success)
+                    failedChecks.push("build");
+                await updateExecution(exec.id, { status: "failed", updatedAt: new Date() });
+                return {
+                    success: false,
+                    branch: input.branch,
+                    cleanedUp: false,
+                    qualityChecks: {
+                        typeCheck: qualityResult.typeCheck.success,
+                        build: qualityResult.build.success,
+                    },
+                    message: `Quality checks failed: ${failedChecks.join(", ")}. Fix issues before merging.`,
+                };
+            }
+        }
+        // Step 3: Generate commit message
+        const commitMessage = generateCommitMessage(exec.branch, exec.description, completedStories);
+        // Step 4: Attempt merge to main
+        console.log(">>> Merging to main...");
+        const mergeResult = await mergeBranchWithMessage(exec.projectRoot, exec.branch, commitMessage, onConflict);
+        if (mergeResult.success) {
+            // Step 5: Update docs
+            const docsUpdated = [];
+            if (updateTodoDoc(exec.projectRoot, exec.branch, exec.description)) {
+                docsUpdated.push("docs/TODO.md");
+            }
+            if (mergeResult.commitHash &&
+                updateProjectStatus(exec.projectRoot, exec.branch, exec.description, mergeResult.commitHash)) {
+                docsUpdated.push("docs/PROJECT-STATUS.md");
+            }
+            // Commit doc updates if any
+            if (docsUpdated.length > 0) {
+                try {
+                    execSync(`git add ${docsUpdated.join(" ")} && git commit --amend --no-edit`, {
+                        cwd: exec.projectRoot,
+                    });
+                }
+                catch {
+                    // Ignore if no changes or amend fails
+                }
+            }
+            // Step 6: Clean up worktree
+            let cleanedUp = false;
+            if (exec.worktreePath) {
+                try {
+                    await removeWorktree(exec.projectRoot, exec.worktreePath);
+                    cleanedUp = true;
+                }
+                catch (e) {
+                    console.error("Failed to remove worktree:", e);
+                }
+            }
+            // Update status
+            await updateExecution(exec.id, { status: "completed", updatedAt: new Date() });
+            return {
+                success: true,
+                branch: input.branch,
+                commitHash: mergeResult.commitHash,
+                cleanedUp,
+                conflictResolution: "auto",
+                qualityChecks: input.skipQualityChecks
+                    ? undefined
+                    : { typeCheck: true, build: true },
+                docsUpdated: docsUpdated.length > 0 ? docsUpdated : undefined,
+                mergedStories: completedStories.map((s) => s.id),
+                message: `Successfully merged ${input.branch} to main`,
+            };
+        }
+        // Handle conflicts
+        if (mergeResult.hasConflicts && mergeResult.conflictFiles) {
+            // Try schema conflict resolution first
+            const hasSchemaConflict = mergeResult.conflictFiles.some((f) => f.includes("schema.prisma"));
+            if (hasSchemaConflict) {
+                console.log(">>> Attempting to resolve schema.prisma conflict...");
+                const schemaResolved = await handleSchemaConflict(exec.projectRoot);
+                if (schemaResolved) {
+                    // Check if there are remaining conflicts
+                    const remainingConflicts = mergeResult.conflictFiles.filter((f) => !f.includes("schema.prisma"));
+                    if (remainingConflicts.length === 0) {
+                        // Complete the merge
+                        try {
+                            execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
+                                cwd: exec.projectRoot,
+                            });
+                            const commitHash = execSync("git rev-parse HEAD", {
+                                cwd: exec.projectRoot,
+                                encoding: "utf-8",
+                            }).trim();
+                            // Clean up
+                            let cleanedUp = false;
+                            if (exec.worktreePath) {
+                                try {
+                                    await removeWorktree(exec.projectRoot, exec.worktreePath);
+                                    cleanedUp = true;
+                                }
+                                catch (e) {
+                                    console.error("Failed to remove worktree:", e);
+                                }
+                            }
+                            await updateExecution(exec.id, { status: "completed", updatedAt: new Date() });
+                            return {
+                                success: true,
+                                branch: input.branch,
+                                commitHash,
+                                cleanedUp,
+                                conflictResolution: "auto",
+                                mergedStories: completedStories.map((s) => s.id),
+                                message: `Successfully merged ${input.branch} (schema conflict auto-resolved)`,
+                            };
+                        }
+                        catch {
+                            // Fall through to agent resolution
+                        }
+                    }
+                }
+            }
+            if (onConflict === "notify") {
+                await updateExecution(exec.id, { status: "failed", updatedAt: new Date() });
+                return {
+                    success: false,
+                    branch: input.branch,
+                    cleanedUp: false,
+                    conflictResolution: "pending",
+                    message: `Merge conflicts detected in: ${mergeResult.conflictFiles.join(", ")}. Manual resolution required.`,
+                };
+            }
+            if (onConflict === "agent") {
+                const prompt = generateMergeAgentPrompt(exec.projectRoot, exec.branch, exec.description, mergeResult.conflictFiles, exec.prdPath);
+                const agentResult = await startMergeAgent(exec.projectRoot, prompt);
+                if (agentResult.success) {
+                    let cleanedUp = false;
+                    if (exec.worktreePath) {
+                        try {
+                            await removeWorktree(exec.projectRoot, exec.worktreePath);
+                            cleanedUp = true;
+                        }
+                        catch (e) {
+                            console.error("Failed to remove worktree:", e);
+                        }
+                    }
+                    const commitHash = execSync("git rev-parse HEAD", {
+                        cwd: exec.projectRoot,
+                        encoding: "utf-8",
+                    }).trim();
+                    await updateExecution(exec.id, { status: "completed", updatedAt: new Date() });
+                    return {
+                        success: true,
+                        branch: input.branch,
+                        commitHash,
+                        cleanedUp,
+                        conflictResolution: "agent",
+                        mergedStories: completedStories.map((s) => s.id),
+                        message: `Merge conflicts resolved by agent for ${input.branch}`,
+                    };
+                }
+                else {
+                    await abortMerge(exec.projectRoot);
+                    await updateExecution(exec.id, { status: "failed", updatedAt: new Date() });
+                    return {
+                        success: false,
+                        branch: input.branch,
+                        cleanedUp: false,
+                        conflictResolution: "pending",
+                        message: `Merge agent failed: ${agentResult.output}`,
+                    };
+                }
+            }
+        }
+        throw new Error("Unexpected merge state");
+    }
+    catch (error) {
+        await updateExecution(exec.id, { status: "failed", updatedAt: new Date() });
+        throw error;
+    }
+}
+/**
+ * Merge branch with custom commit message
+ */
+async function mergeBranchWithMessage(projectRoot, branch, commitMessage, onConflict) {
+    const { exec: execAsync } = await import("child_process");
+    const { promisify } = await import("util");
+    const execPromise = promisify(execAsync);
+    // Checkout main and pull
+    await execPromise("git checkout main && git pull", { cwd: projectRoot });
+    // Build merge strategy
+    let mergeStrategy = "";
+    if (onConflict === "auto_theirs") {
+        mergeStrategy = "-X theirs";
+    }
+    else if (onConflict === "auto_ours") {
+        mergeStrategy = "-X ours";
+    }
+    try {
+        // Use heredoc-style commit message to handle special characters
+        const escapedMessage = commitMessage.replace(/'/g, "'\\''");
+        await execPromise(`git merge --no-ff ${mergeStrategy} "${branch}" -m '${escapedMessage}'`, { cwd: projectRoot });
+        const { stdout: hash } = await execPromise("git rev-parse HEAD", {
+            cwd: projectRoot,
+        });
+        return {
+            success: true,
+            commitHash: hash.trim(),
+            hasConflicts: false,
+        };
+    }
+    catch {
+        // Check for conflicts
+        const { stdout: status } = await execPromise("git status --porcelain", {
+            cwd: projectRoot,
+        });
+        const conflictFiles = status
+            .split("\n")
+            .filter((line) => line.startsWith("UU ") || line.startsWith("AA "))
+            .map((line) => line.slice(3));
+        if (conflictFiles.length > 0) {
+            return {
+                success: false,
+                hasConflicts: true,
+                conflictFiles,
+            };
+        }
+        throw new Error("Merge failed for unknown reason");
+    }
+}
+// Merge queue management
+export const mergeQueueInputSchema = z.object({
+    action: z
+        .enum(["list", "add", "remove", "process"])
+        .default("list")
+        .describe("Queue action"),
+    branch: z.string().optional().describe("Branch for add/remove actions"),
+});
+export async function mergeQueueAction(input) {
+    const queue = await listMergeQueue();
+    const current = queue.find((q) => q.status === "merging");
+    if (input.action === "list") {
+        const execs = await listExecutions();
+        const execById = new Map(execs.map((e) => [e.id, e]));
+        return {
+            queue: queue.map((q) => {
+                const exec = execById.get(q.executionId);
+                return exec?.branch || q.executionId;
+            }),
+            current: current
+                ? execById.get(current.executionId)?.branch
+                : undefined,
+            message: `${queue.length} items in merge queue`,
+        };
+    }
+    if (input.action === "add" && input.branch) {
+        const exec = await findExecutionByBranch(input.branch);
+        if (!exec) {
+            throw new Error(`No execution found for branch: ${input.branch}`);
+        }
+        const maxPosition = queue.length > 0
+            ? Math.max(...queue.map((q) => q.position))
+            : 0;
+        await insertMergeQueueItem({
+            executionId: exec.id,
+            position: maxPosition + 1,
+            status: "pending",
+            createdAt: new Date(),
+        });
+        return {
+            queue: [...queue.map((q) => q.executionId), exec.id],
+            message: `Added ${input.branch} to merge queue at position ${maxPosition + 1}`,
+        };
+    }
+    if (input.action === "remove" && input.branch) {
+        const exec = await findExecutionByBranch(input.branch);
+        if (exec) {
+            await deleteMergeQueueByExecutionId(exec.id);
+        }
+        return {
+            queue: queue
+                .filter((q) => q.executionId !== exec?.id)
+                .map((q) => q.executionId),
+            message: `Removed ${input.branch} from merge queue`,
+        };
+    }
+    if (input.action === "process") {
+        // Process next item in queue
+        const next = queue.find((q) => q.status === "pending");
+        if (!next) {
+            return {
+                queue: [],
+                message: "No pending items in merge queue",
+            };
+        }
+        const exec = await findExecutionById(next.executionId);
+        if (exec) {
+            // Update queue status
+            await updateMergeQueueItem(next.id, { status: "merging" });
+            // Perform merge
+            const result = await merge({ branch: exec.branch, force: false, skipQualityChecks: false });
+            // Update queue status
+            await updateMergeQueueItem(next.id, { status: result.success ? "completed" : "failed" });
+            return {
+                queue: queue.slice(1).map((q) => q.executionId),
+                current: exec.branch,
+                message: result.message,
+            };
+        }
+    }
+    return {
+        queue: queue.map((q) => q.executionId),
+        message: "Unknown action",
+    };
+}

package/dist/tools/set-agent-id.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const setAgentIdInputSchema: z.ZodObject<{
+    branch: z.ZodString;
+    agentTaskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    branch: string;
+    agentTaskId: string;
+}, {
+    branch: string;
+    agentTaskId: string;
+}>;
+export type SetAgentIdInput = z.infer<typeof setAgentIdInputSchema>;
+export interface SetAgentIdResult {
+    success: boolean;
+    branch: string;
+    agentTaskId: string;
+}
+export declare function setAgentId(input: SetAgentIdInput): Promise<SetAgentIdResult>;

package/dist/tools/set-agent-id.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { findExecutionByBranch, updateExecution } from "../store/state.js";
+export const setAgentIdInputSchema = z.object({
+    branch: z.string().describe("Branch name"),
+    agentTaskId: z.string().describe("Claude Task agent ID"),
+});
+export async function setAgentId(input) {
+    // Find execution
+    const exec = await findExecutionByBranch(input.branch);
+    if (!exec) {
+        throw new Error(`No execution found for branch: ${input.branch}`);
+    }
+    // Update agent task ID and status
+    await updateExecution(exec.id, {
+        agentTaskId: input.agentTaskId,
+        status: "running",
+        updatedAt: new Date(),
+    });
+    return {
+        success: true,
+        branch: input.branch,
+        agentTaskId: input.agentTaskId,
+    };
+}

package/dist/tools/start.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const startInputSchema: z.ZodObject<{
+    prdPath: z.ZodString;
+    projectRoot: z.ZodOptional<z.ZodString>;
+    worktree: z.ZodDefault<z.ZodBoolean>;
+    autoStart: z.ZodDefault<z.ZodBoolean>;
+    autoMerge: z.ZodDefault<z.ZodBoolean>;
+    notifyOnComplete: z.ZodDefault<z.ZodBoolean>;
+    onConflict: z.ZodDefault<z.ZodEnum<["auto_theirs", "auto_ours", "notify", "agent"]>>;
+}, "strip", z.ZodTypeAny, {
+    prdPath: string;
+    onConflict: "auto_theirs" | "auto_ours" | "notify" | "agent";
+    autoMerge: boolean;
+    notifyOnComplete: boolean;
+    worktree: boolean;
+    autoStart: boolean;
+    projectRoot?: string | undefined;
+}, {
+    prdPath: string;
+    projectRoot?: string | undefined;
+    onConflict?: "auto_theirs" | "auto_ours" | "notify" | "agent" | undefined;
+    autoMerge?: boolean | undefined;
+    notifyOnComplete?: boolean | undefined;
+    worktree?: boolean | undefined;
+    autoStart?: boolean | undefined;
+}>;
+export type StartInput = z.infer<typeof startInputSchema>;
+export interface StartResult {
+    executionId: string;
+    branch: string;
+    worktreePath: string | null;
+    agentPrompt: string | null;
+    stories: Array<{
+        storyId: string;
+        title: string;
+        description: string;
+        acceptanceCriteria: string[];
+        priority: number;
+        passes: boolean;
+    }>;
+}
+export declare function start(input: StartInput): Promise<StartResult>;

package/dist/tools/start.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { randomUUID } from "crypto";
+import { parsePrdFile } from "../utils/prd-parser.js";
+import { createWorktree } from "../utils/worktree.js";
+import { generateAgentPrompt } from "../utils/agent.js";
+import { resolve, basename } from "path";
+import { findExecutionByBranch, insertExecution, insertUserStories, } from "../store/state.js";
+export const startInputSchema = z.object({
+    prdPath: z.string().describe("Path to the PRD markdown file"),
+    projectRoot: z.string().optional().describe("Project root directory (defaults to cwd)"),
+    worktree: z.boolean().default(true).describe("Create a worktree for isolation"),
+    autoStart: z.boolean().default(true).describe("Generate agent prompt for auto-start"),
+    autoMerge: z.boolean().default(false).describe("Auto add to merge queue when all stories pass"),
+    notifyOnComplete: z.boolean().default(true).describe("Show Windows notification when all stories complete"),
+    onConflict: z
+        .enum(["auto_theirs", "auto_ours", "notify", "agent"])
+        .default("agent")
+        .describe("Conflict resolution strategy for merge"),
+});
+export async function start(input) {
+    const projectRoot = input.projectRoot || process.cwd();
+    const prdPath = resolve(projectRoot, input.prdPath);
+    // Parse PRD file
+    const prd = parsePrdFile(prdPath);
+    // Check if execution already exists for this branch
+    const existing = await findExecutionByBranch(prd.branchName);
+    if (existing) {
+        throw new Error(`Execution already exists for branch ${prd.branchName}. Use ralph_get to check status or ralph_stop to stop it.`);
+    }
+    // Create worktree if requested
+    let worktreePath = null;
+    if (input.worktree) {
+        worktreePath = await createWorktree(projectRoot, prd.branchName);
+    }
+    // Create execution record
+    const executionId = randomUUID();
+    const now = new Date();
+    const projectName = basename(projectRoot);
+    await insertExecution({
+        id: executionId,
+        project: projectName,
+        branch: prd.branchName,
+        description: prd.description,
+        prdPath: prdPath,
+        projectRoot: projectRoot,
+        worktreePath: worktreePath,
+        status: "pending",
+        agentTaskId: null,
+        onConflict: input.onConflict,
+        autoMerge: input.autoMerge,
+        notifyOnComplete: input.notifyOnComplete,
+        createdAt: now,
+        updatedAt: now,
+    });
+    // Create user story records
+    const storyRecords = prd.userStories.map((story) => ({
+        id: `${executionId}:${story.id}`,
+        executionId: executionId,
+        storyId: story.id,
+        title: story.title,
+        description: story.description,
+        acceptanceCriteria: story.acceptanceCriteria,
+        priority: story.priority,
+        passes: false,
+        notes: "",
+    }));
+    if (storyRecords.length > 0) {
+        await insertUserStories(storyRecords);
+    }
+    // Generate agent prompt if auto-start
+    let agentPrompt = null;
+    if (input.autoStart) {
+        agentPrompt = generateAgentPrompt(prd.branchName, prd.description, worktreePath || projectRoot, storyRecords.map((s) => ({
+            storyId: s.storyId,
+            title: s.title,
+            description: s.description,
+            acceptanceCriteria: s.acceptanceCriteria,
+            priority: s.priority,
+            passes: s.passes,
+        })));
+    }
+    return {
+        executionId,
+        branch: prd.branchName,
+        worktreePath,
+        agentPrompt,
+        stories: storyRecords.map((s) => ({
+            storyId: s.storyId,
+            title: s.title,
+            description: s.description,
+            acceptanceCriteria: s.acceptanceCriteria,
+            priority: s.priority,
+            passes: s.passes,
+        })),
+    };
+}

package/dist/tools/status.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const statusInputSchema: z.ZodObject<{
+    project: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["pending", "running", "completed", "failed", "stopped", "merging"]>>;
+}, "strip", z.ZodTypeAny, {
+    project?: string | undefined;
+    status?: "pending" | "running" | "completed" | "failed" | "stopped" | "merging" | undefined;
+}, {
+    project?: string | undefined;
+    status?: "pending" | "running" | "completed" | "failed" | "stopped" | "merging" | undefined;
+}>;
+export type StatusInput = z.infer<typeof statusInputSchema>;
+export interface ExecutionStatus {
+    branch: string;
+    description: string;
+    status: string;
+    progress: string;
+    completedStories: number;
+    totalStories: number;
+    worktreePath: string | null;
+    agentTaskId: string | null;
+    lastActivity: string;
+    createdAt: string;
+}
+export interface StatusResult {
+    executions: ExecutionStatus[];
+    summary: {
+        total: number;
+        running: number;
+        completed: number;
+        failed: number;
+        pending: number;
+    };
+}
+export declare function status(input: StatusInput): Promise<StatusResult>;

package/dist/tools/status.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { listExecutions, listUserStoriesByExecutionId } from "../store/state.js";
+export const statusInputSchema = z.object({
+    project: z.string().optional().describe("Filter by project name"),
+    status: z
+        .enum(["pending", "running", "completed", "failed", "stopped", "merging"])
+        .optional()
+        .describe("Filter by status"),
+});
+export async function status(input) {
+    const allExecutions = await listExecutions();
+    // Filter in memory (simpler than building dynamic where clauses)
+    let filtered = allExecutions;
+    if (input.project) {
+        filtered = filtered.filter((e) => e.project === input.project);
+    }
+    if (input.status) {
+        filtered = filtered.filter((e) => e.status === input.status);
+    }
+    // Get story counts for each execution
+    const executionStatuses = [];
+    for (const exec of filtered) {
+        const stories = await listUserStoriesByExecutionId(exec.id);
+        const completedStories = stories.filter((s) => s.passes).length;
+        const totalStories = stories.length;
+        executionStatuses.push({
+            branch: exec.branch,
+            description: exec.description,
+            status: exec.status,
+            progress: `${completedStories}/${totalStories} US`,
+            completedStories,
+            totalStories,
+            worktreePath: exec.worktreePath,
+            agentTaskId: exec.agentTaskId,
+            lastActivity: exec.updatedAt.toISOString(),
+            createdAt: exec.createdAt.toISOString(),
+        });
+    }
+    // Sort by last activity (most recent first)
+    executionStatuses.sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
+    // Calculate summary
+    const summary = {
+        total: executionStatuses.length,
+        running: executionStatuses.filter((e) => e.status === "running").length,
+        completed: executionStatuses.filter((e) => e.status === "completed").length,
+        failed: executionStatuses.filter((e) => e.status === "failed").length,
+        pending: executionStatuses.filter((e) => e.status === "pending").length,
+    };
+    return {
+        executions: executionStatuses,
+        summary,
+    };
+}

package/dist/tools/stop.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const stopInputSchema: z.ZodObject<{
+    branch: z.ZodString;
+    cleanup: z.ZodDefault<z.ZodBoolean>;
+    deleteRecord: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    branch: string;
+    cleanup: boolean;
+    deleteRecord: boolean;
+}, {
+    branch: string;
+    cleanup?: boolean | undefined;
+    deleteRecord?: boolean | undefined;
+}>;
+export type StopInput = z.infer<typeof stopInputSchema>;
+export interface StopResult {
+    success: boolean;
+    branch: string;
+    previousStatus: string;
+    cleanedUp: boolean;
+    deleted: boolean;
+    message: string;
+}
+export declare function stop(input: StopInput): Promise<StopResult>;