edsger 0.53.0 → 0.54.1

package/dist/phases/chat-processor/tools.js

@@ -1,709 +1,11 @@
-/* eslint-disable max-lines -- tool definitions with schemas and handlers are clearer co-located in one file */
 /**
- * Chat MCP server — registers custom tools with the Claude Agent SDK.
+ * Chat (issue) MCP server — CLI entry point.
  *
- * Uses createSdkMcpServer + tool() so the SDK can discover and execute
- * these tools automatically. Claude Code's built-in tools (Read, Write,
- * Bash, Grep, Glob) are also available via the preset.
- */
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import { listChatMessages, sendAiMessage } from '../../api/chat.js';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-/**
- * Create an in-process MCP server with chat-specific tools.
- * Pass the returned config to query() options.mcpServers.
+ * Tool implementations live in `edsger-tools`. This shim adapts the
+ * CLI's `callMcpEndpoint` transport into `ToolDeps`.
  */
+import { createChatIssueMcpServer } from 'edsger-tools';
+import { getToolDeps } from '../../tools/bootstrap.js';
 export function createChatMcpServer() {
-    return createSdkMcpServer({
-        name: 'edsger-chat',
-        version: '1.0.0',
-        tools: [
-            tool('update_issue_status', 'Change the issue status (e.g., back to ready_for_ai, backlog). Use when the user wants to restart or change the workflow state.', {
-                issue_id: z.string().describe('Issue ID'),
-                status: z.string().describe('New status value'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('issues/update', {
-                    issue_id: args.issue_id,
-                    status: args.status,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('update_execution_mode', 'Change the issue execution mode (e.g., from_user_stories_analysis, from_code_implementation).', {
-                issue_id: z.string().describe('Issue ID'),
-                execution_mode: z
-                    .enum([
-                    'full_pipeline',
-                    'only_issue_analysis',
-                    'only_user_stories_analysis',
-                    'only_test_cases_analysis',
-                    'only_technical_design',
-                    'only_branch_planning',
-                    'only_code_implementation',
-                    'only_pr_splitting',
-                    'only_pr_execution',
-                    'only_functional_testing',
-                    'only_code_refine',
-                    'only_code_review',
-                    'from_issue_analysis',
-                    'from_user_stories_analysis',
-                    'from_test_cases_analysis',
-                    'from_technical_design',
-                    'from_branch_planning',
-                    'from_code_implementation',
-                    'from_pr_splitting',
-                    'from_pr_execution',
-                    'from_functional_testing',
-                    'from_code_review',
-                    'custom',
-                    'autonomous',
-                ])
-                    .describe('New execution mode'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('issues/update', {
-                    issue_id: args.issue_id,
-                    execution_mode: args.execution_mode,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('update_workflow', 'Modify workflow phases — reset phases to pending, skip phases, or reorder. Phase names must use snake_case (e.g., code_implementation, NOT code-implementation).', {
-                issue_id: z.string().describe('Issue ID'),
-                workflow: z
-                    .array(z.object({
-                    phase: z
-                        .string()
-                        .describe('Phase name in snake_case. Valid phases: issue_analysis, user_stories_analysis, test_cases_analysis, technical_design, branch_planning, code_implementation, pr_splitting, pr_execution, functional_testing, code_review, code_refine, autonomous'),
-                    status: z.enum(['pending', 'completed', 'skipped']),
-                }))
-                    .describe('Updated workflow array'),
-            }, async (args) => {
-                // Normalize phase names: kebab-case → snake_case
-                const normalizedWorkflow = args.workflow.map((p) => ({
-                    ...p,
-                    phase: p.phase.replace(/-/g, '_'),
-                }));
-                const result = await callMcpEndpoint('issues/update', {
-                    issue_id: args.issue_id,
-                    workflow: normalizedWorkflow,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('update_user_stories', 'Create, update, or delete user stories based on feedback. Always provide a reason explaining why the change is being made.', {
-                issue_id: z.string().describe('Issue ID'),
-                reason: z
-                    .string()
-                    .describe('Why this change is being made — e.g. user feedback, bug found, requirement changed. Required for audit trail.'),
-                actions: z.array(z.object({
-                    action: z.enum(['create', 'update', 'delete']),
-                    user_story_id: z
-                        .string()
-                        .optional()
-                        .describe('Required for update/delete'),
-                    title: z.string().optional(),
-                    description: z.string().optional(),
-                    status: z
-                        .enum(['draft', 'pending_approval', 'approved'])
-                        .optional(),
-                })),
-            }, async (args) => {
-                const results = [];
-                for (const action of args.actions) {
-                    try {
-                        if (action.action === 'create') {
-                            await callMcpEndpoint('user_stories/create', {
-                                issue_id: args.issue_id,
-                                user_stories: [
-                                    {
-                                        title: action.title,
-                                        description: action.description,
-                                        status: action.status || 'draft',
-                                    },
-                                ],
-                            });
-                            results.push({ action: 'create', success: true });
-                        }
-                        else if (action.action === 'delete' && action.user_story_id) {
-                            await callMcpEndpoint('user_stories/delete', {
-                                user_story_id: action.user_story_id,
-                            });
-                            results.push({ action: 'delete', success: true });
-                        }
-                        else if (action.action === 'update' && action.user_story_id) {
-                            await callMcpEndpoint('user_stories/update_status', {
-                                user_story_id: action.user_story_id,
-                                status: action.status || 'draft',
-                                reason: args.reason,
-                            });
-                            results.push({ action: 'update', success: true });
-                        }
-                    }
-                    catch (error) {
-                        const msg = error instanceof Error ? error.message : String(error);
-                        results.push({
-                            action: action.action,
-                            success: false,
-                            error: msg,
-                        });
-                    }
-                }
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ results }, null, 2) },
-                    ],
-                };
-            }),
-            tool('update_test_cases', 'Create, update, or delete test cases based on feedback. Always provide a reason explaining why the change is being made.', {
-                issue_id: z.string().describe('Issue ID'),
-                reason: z
-                    .string()
-                    .describe('Why this change is being made — e.g. user feedback, bug found, requirement changed. Required for audit trail.'),
-                actions: z.array(z.object({
-                    action: z.enum(['create', 'update', 'delete']),
-                    test_case_id: z
-                        .string()
-                        .optional()
-                        .describe('Required for update/delete'),
-                    name: z.string().optional(),
-                    description: z.string().optional(),
-                    is_critical: z.boolean().optional(),
-                    status: z
-                        .enum([
-                        'draft',
-                        'pending_approval',
-                        'in_progress',
-                        'done',
-                        'cancelled',
-                    ])
-                        .optional()
-                        .describe('Test case status. Cannot be set to approved — only humans can approve via the web UI.'),
-                })),
-            }, async (args) => {
-                const results = [];
-                for (const action of args.actions) {
-                    try {
-                        if (action.action === 'create') {
-                            await callMcpEndpoint('test_cases/create', {
-                                issue_id: args.issue_id,
-                                test_cases: [
-                                    {
-                                        name: action.name,
-                                        description: action.description,
-                                        is_critical: action.is_critical || false,
-                                    },
-                                ],
-                            });
-                            results.push({ action: 'create', success: true });
-                        }
-                        else if (action.action === 'delete' && action.test_case_id) {
-                            await callMcpEndpoint('test_cases/delete', {
-                                test_case_id: action.test_case_id,
-                            });
-                            results.push({ action: 'delete', success: true });
-                        }
-                        else if (action.action === 'update' && action.test_case_id) {
-                            const updateParams = {
-                                test_case_id: action.test_case_id,
-                                reason: args.reason,
-                            };
-                            if (action.name !== undefined) {
-                                updateParams.name = action.name;
-                            }
-                            if (action.description !== undefined) {
-                                updateParams.description = action.description;
-                            }
-                            if (action.is_critical !== undefined) {
-                                updateParams.is_critical = action.is_critical;
-                            }
-                            if (action.status !== undefined) {
-                                updateParams.status = action.status;
-                            }
-                            await callMcpEndpoint('test_cases/update', updateParams);
-                            results.push({ action: 'update', success: true });
-                        }
-                    }
-                    catch (error) {
-                        const msg = error instanceof Error ? error.message : String(error);
-                        results.push({
-                            action: action.action,
-                            success: false,
-                            error: msg,
-                        });
-                    }
-                }
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ results }, null, 2) },
-                    ],
-                };
-            }),
-            tool('list_checklists', 'List checklists for the product this issue belongs to. Each checklist can apply to multiple phases and is assigned to a specific role. Returns checklists with their items.', {
-                product_id: z.string().describe('Product ID'),
-                role: z
-                    .string()
-                    .optional()
-                    .describe('Filter by role (product_manager, developer, qa_engineer, technical_lead, ux_designer, devops_engineer, security_engineer)'),
-                phase: z
-                    .string()
-                    .optional()
-                    .describe('Filter by phase (e.g., code_implementation, code_review, technical_design)'),
-            }, async (args) => {
-                const params = {
-                    product_id: args.product_id,
-                };
-                if (args.role) {
-                    params.role = args.role;
-                }
-                if (args.phase) {
-                    params.phase = args.phase;
-                }
-                const result = await callMcpEndpoint('checklists/list', params);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('manage_checklists', 'Create, update, or delete checklists. A checklist belongs to a product, is assigned to a role, and applies to one or more phases (phases is an array). When creating, you can include items inline.', {
-                product_id: z.string().describe('Product ID'),
-                actions: z.array(z.object({
-                    action: z.enum(['create', 'update', 'delete']),
-                    checklist_id: z
-                        .string()
-                        .optional()
-                        .describe('Required for update/delete'),
-                    name: z
-                        .string()
-                        .optional()
-                        .describe('Checklist name (for create/update)'),
-                    description: z
-                        .string()
-                        .optional()
-                        .describe('Checklist description'),
-                    role: z
-                        .string()
-                        .optional()
-                        .describe('Role: product_manager, developer, qa_engineer, technical_lead, ux_designer, devops_engineer, security_engineer'),
-                    phases: z
-                        .array(z.string())
-                        .optional()
-                        .describe('Array of phases this checklist applies to (e.g., ["code_implementation", "code_review"]). A checklist can apply to multiple phases.'),
-                    is_active: z
-                        .boolean()
-                        .optional()
-                        .describe('Whether the checklist is active'),
-                    sort_order: z
-                        .number()
-                        .optional()
-                        .describe('Sort order for display'),
-                    items: z
-                        .array(z.object({
-                        title: z.string(),
-                        description: z.string().optional(),
-                        item_type: z
-                            .enum(['boolean', 'text', 'number', 'select'])
-                            .optional(),
-                        is_required: z.boolean().optional(),
-                    }))
-                        .optional()
-                        .describe('Items to create with the checklist (only for create action)'),
-                })),
-            }, 
-            // eslint-disable-next-line complexity -- handles multiple CRUD action types in a single tool handler
-            async (args) => {
-                const results = [];
-                for (const action of args.actions) {
-                    try {
-                        if (action.action === 'create') {
-                            if (!action.name || !action.role || !action.phases?.length) {
-                                results.push({
-                                    action: 'create',
-                                    success: false,
-                                    error: 'name, role, and phases are required for create',
-                                });
-                                continue;
-                            }
-                            const result = await callMcpEndpoint('checklists/create', {
-                                product_id: args.product_id,
-                                name: action.name,
-                                description: action.description || null,
-                                role: action.role,
-                                phases: action.phases,
-                                is_active: action.is_active ?? true,
-                                sort_order: action.sort_order ?? 0,
-                                items: action.items,
-                            });
-                            results.push({ action: 'create', success: true, data: result });
-                        }
-                        else if (action.action === 'update' && action.checklist_id) {
-                            const params = {
-                                checklist_id: action.checklist_id,
-                            };
-                            if (action.name !== undefined) {
-                                params.name = action.name;
-                            }
-                            if (action.description !== undefined) {
-                                params.description = action.description;
-                            }
-                            if (action.role !== undefined) {
-                                params.role = action.role;
-                            }
-                            if (action.phases !== undefined) {
-                                params.phases = action.phases;
-                            }
-                            if (action.is_active !== undefined) {
-                                params.is_active = action.is_active;
-                            }
-                            if (action.sort_order !== undefined) {
-                                params.sort_order = action.sort_order;
-                            }
-                            const result = await callMcpEndpoint('checklists/update', params);
-                            results.push({ action: 'update', success: true, data: result });
-                        }
-                        else if (action.action === 'delete' && action.checklist_id) {
-                            const result = await callMcpEndpoint('checklists/delete', {
-                                checklist_id: action.checklist_id,
-                            });
-                            results.push({ action: 'delete', success: true, data: result });
-                        }
-                        else {
-                            results.push({
-                                action: action.action,
-                                success: false,
-                                error: `Missing required checklist_id for ${action.action}`,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        const msg = error instanceof Error ? error.message : String(error);
-                        results.push({
-                            action: action.action,
-                            success: false,
-                            error: msg,
-                        });
-                    }
-                }
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ results }, null, 2) },
-                    ],
-                };
-            }),
-            tool('manage_checklist_items', 'Add, update, or delete items within a checklist. Each item has a title, type (boolean/text/number/select), and required flag.', {
-                actions: z.array(z.object({
-                    action: z.enum(['create', 'update', 'delete']),
-                    checklist_id: z
-                        .string()
-                        .optional()
-                        .describe('Checklist ID to add items to (required for create)'),
-                    item_id: z
-                        .string()
-                        .optional()
-                        .describe('Item ID (required for update/delete)'),
-                    title: z.string().optional().describe('Item title'),
-                    description: z.string().optional().describe('Item description'),
-                    item_type: z
-                        .enum(['boolean', 'text', 'number', 'select'])
-                        .optional()
-                        .describe('Item type (default: boolean)'),
-                    is_required: z
-                        .boolean()
-                        .optional()
-                        .describe('Whether this item is required'),
-                    sort_order: z.number().optional().describe('Sort order'),
-                    config: z
-                        .record(z.string(), z.unknown())
-                        .optional()
-                        .describe('Additional config (e.g., options for select type)'),
-                })),
-            }, 
-            // eslint-disable-next-line complexity -- handles multiple CRUD action types for checklist items
-            async (args) => {
-                const results = [];
-                for (const action of args.actions) {
-                    try {
-                        if (action.action === 'create' && action.checklist_id) {
-                            if (!action.title) {
-                                results.push({
-                                    action: 'create',
-                                    success: false,
-                                    error: 'title is required for create',
-                                });
-                                continue;
-                            }
-                            const result = await callMcpEndpoint('checklist_items/create', {
-                                checklist_id: action.checklist_id,
-                                items: [
-                                    {
-                                        title: action.title,
-                                        description: action.description || null,
-                                        item_type: action.item_type || 'boolean',
-                                        is_required: action.is_required ?? true,
-                                        sort_order: action.sort_order,
-                                        config: action.config,
-                                    },
-                                ],
-                            });
-                            results.push({ action: 'create', success: true, data: result });
-                        }
-                        else if (action.action === 'update' && action.item_id) {
-                            const params = {
-                                item_id: action.item_id,
-                            };
-                            if (action.title !== undefined) {
-                                params.title = action.title;
-                            }
-                            if (action.description !== undefined) {
-                                params.description = action.description;
-                            }
-                            if (action.item_type !== undefined) {
-                                params.item_type = action.item_type;
-                            }
-                            if (action.is_required !== undefined) {
-                                params.is_required = action.is_required;
-                            }
-                            if (action.sort_order !== undefined) {
-                                params.sort_order = action.sort_order;
-                            }
-                            if (action.config !== undefined) {
-                                params.config = action.config;
-                            }
-                            const result = await callMcpEndpoint('checklist_items/update', params);
-                            results.push({ action: 'update', success: true, data: result });
-                        }
-                        else if (action.action === 'delete' && action.item_id) {
-                            const result = await callMcpEndpoint('checklist_items/delete', {
-                                item_id: action.item_id,
-                            });
-                            results.push({ action: 'delete', success: true, data: result });
-                        }
-                        else {
-                            const missing = action.action === 'create' ? 'checklist_id' : 'item_id';
-                            results.push({
-                                action: action.action,
-                                success: false,
-                                error: `Missing required ${missing} for ${action.action}`,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        const msg = error instanceof Error ? error.message : String(error);
-                        results.push({
-                            action: action.action,
-                            success: false,
-                            error: msg,
-                        });
-                    }
-                }
-                return {
-                    content: [
-                        { type: 'text', text: JSON.stringify({ results }, null, 2) },
-                    ],
-                };
-            }),
-            tool('send_chat_message', 'Send a follow-up message to the chat. Use for explanations, summaries, or asking clarifying questions.', {
-                channel_id: z.string().describe('Chat channel ID'),
-                content: z.string().describe('Message content (markdown)'),
-                message_type: z
-                    .enum(['text', 'question', 'answer'])
-                    .optional()
-                    .describe('Type of message'),
-            }, async (args) => {
-                await sendAiMessage(args.channel_id, args.content, {}, {
-                    messageType: args.message_type || 'text',
-                });
-                return {
-                    content: [{ type: 'text', text: 'Message sent successfully.' }],
-                };
-            }),
-            tool('provide_options', 'Present 2-4 actionable options to the user. Each option has a label and description. The user will click one to respond.', {
-                channel_id: z.string().describe('Chat channel ID'),
-                prompt: z.string().describe('Question or context for the options'),
-                options: z.array(z.object({
-                    label: z.string().describe('Short option label'),
-                    description: z.string().describe('What this option does'),
-                    action_key: z
-                        .string()
-                        .describe('Machine-readable key (e.g. "continue", "add_tests")'),
-                })),
-            }, async (args) => {
-                await sendAiMessage(args.channel_id, args.prompt, { options: args.options }, { messageType: 'options' });
-                return {
-                    content: [{ type: 'text', text: 'Options presented to the user.' }],
-                };
-            }),
-            tool('get_issue_context', 'Fetch the full current state of an issue: status, workflow, user stories, test cases.', {
-                issue_id: z.string().describe('Issue ID'),
-            }, async (args) => {
-                const [issueResult, storiesResult, testCasesResult] = await Promise.all([
-                    callMcpEndpoint('issues/get', {
-                        issue_id: args.issue_id,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }),
-                    callMcpEndpoint('user_stories/list', {
-                        issue_id: args.issue_id,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }),
-                    callMcpEndpoint('test_cases/list', {
-                        issue_id: args.issue_id,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }),
-                ]);
-                const issue = issueResult?.issues?.[0] || {};
-                const result = {
-                    issue,
-                    user_stories: storiesResult?.user_stories || [],
-                    test_cases: testCasesResult?.test_cases || [],
-                    summary: {
-                        status: issue.status,
-                        execution_mode: issue.execution_mode,
-                        workflow_phases: (issue.workflow || []).map(
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        (p) => `${p.phase}: ${p.status}`),
-                    },
-                };
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('get_chat_history', 'Retrieve older chat messages from the channel. Use this when you need more context about what was discussed earlier — for example, to understand referenced bugs, prior decisions, or feedback the user gave in earlier messages.', {
-                channel_id: z.string().describe('Chat channel ID'),
-                limit: z
-                    .number()
-                    .optional()
-                    .describe('Number of messages to retrieve (default 50, max 100)'),
-                before: z
-                    .string()
-                    .optional()
-                    .describe('Fetch messages before this ISO timestamp for pagination'),
-            }, async (args) => {
-                const limit = Math.min(args.limit || 50, 100);
-                const messages = await listChatMessages(args.channel_id, {
-                    limit,
-                    ...(args.before ? { since: args.before } : {}),
-                });
-                const formatted = messages.map((m) => {
-                    const nonAiSender = m.sender_type === 'system' ? 'System' : m.sender_name || 'User';
-                    return {
-                        id: m.id,
-                        sender: m.sender_type === 'ai' ? 'AI' : nonAiSender,
-                        sender_type: m.sender_type,
-                        content: m.content,
-                        message_type: m.message_type,
-                        created_at: m.created_at,
-                    };
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({ messages: formatted, count: formatted.length }, null, 2),
-                        },
-                    ],
-                };
-            }),
-            tool('create_task', 'Create a task for a team member (human) or for AI to execute. Use this when the user asks to assign work, request reviews, or notify someone about something they need to do.', {
-                product_id: z.string().describe('Product ID'),
-                name: z
-                    .string()
-                    .describe('Short task name (e.g., "Review user stories for Login issue")'),
-                description: z
-                    .string()
-                    .optional()
-                    .describe('Detailed description of what needs to be done'),
-                executor: z
-                    .enum(['ai', 'human'])
-                    .describe('Who should do this: "ai" for automated work, "human" for manual review/approval'),
-                assigned_to: z
-                    .string()
-                    .optional()
-                    .describe('User ID to assign to (use list_product_members to look up)'),
-                issue_id: z.string().optional().describe('Related issue ID'),
-                action_url: z
-                    .string()
-                    .optional()
-                    .describe('URL where the assignee should take action. See prompt for URL patterns.'),
-                priority: z
-                    .number()
-                    .optional()
-                    .describe('1=low, 2=medium, 3=high, 4=urgent'),
-            }, async (args) => {
-                // Get next sequence number
-                const listResult = (await callMcpEndpoint('tasks/list_for_product', {
-                    product_id: args.product_id,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }));
-                const text = listResult?.content?.[0]?.text || '[]';
-                const existingTasks = JSON.parse(text);
-                const nextSequence = existingTasks.length + 1;
-                // Use explicit action_url if provided, otherwise auto-generate from issue_id
-                const actionUrl = args.action_url ||
-                    (args.issue_id
-                        ? `/products/${args.product_id}/issues/${args.issue_id}`
-                        : null);
-                const result = await callMcpEndpoint('tasks/create', {
-                    product_id: args.product_id,
-                    sequence: nextSequence,
-                    name: args.name,
-                    description: args.description || null,
-                    executor: args.executor,
-                    source: 'system',
-                    assigned_to: args.assigned_to || null,
-                    issue_id: args.issue_id || null,
-                    action_url: actionUrl,
-                    priority: args.priority || (args.executor === 'human' ? 3 : 2),
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('list_product_members', 'List all members of a product (owner + developers) with their names, emails, and IDs. Use this to look up a person by name before assigning tasks.', {
-                product_id: z.string().describe('Product ID'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('tasks/product_members', {
-                    product_id: args.product_id,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('trigger_phase_rerun', 'Reset a workflow phase to pending so it will re-run.', {
-                issue_id: z.string().describe('Issue ID'),
-                phase: z.string().describe('Phase name to reset'),
-            }, async (args) => {
-                const issueResult = (await callMcpEndpoint('issues/get', {
-                    issue_id: args.issue_id,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }));
-                const issue = issueResult?.issues?.[0];
-                if (!issue) {
-                    return {
-                        content: [{ type: 'text', text: 'Issue not found' }],
-                        isError: true,
-                    };
-                }
-                const workflow = issue.workflow || [];
-                const normalizedPhase = args.phase.replace(/-/g, '_');
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const updatedWorkflow = workflow.map((p) => p.phase === normalizedPhase
-                    ? { ...p, status: 'pending', executed_at: null }
-                    : p);
-                await callMcpEndpoint('issues/update', {
-                    issue_id: args.issue_id,
-                    workflow: updatedWorkflow,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Phase "${args.phase}" reset to pending.`,
-                        },
-                    ],
-                };
-            }),
-        ],
-    });
+    return createChatIssueMcpServer(getToolDeps());
 }