edsger 0.54.0 → 0.55.0

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

@@ -1,517 +1,11 @@
 /**
- * Product Chat MCP server — registers product-level tools with the Claude Agent SDK.
+ * Chat (product) MCP server — CLI entry point.
  *
- * Unlike the issue chat tools which operate on a single issue's lifecycle
- * (stories, tests, workflow), these tools operate at the product level:
- * listing issues, creating issues, managing tasks, and team coordination.
- */
-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 product-level chat tools.
+ * Tool implementations live in `edsger-tools`. This shim adapts the
+ * CLI's `callMcpEndpoint` transport into `ToolDeps`.
  */
+import { createChatProductMcpServer } from 'edsger-tools';
+import { getToolDeps } from '../../tools/bootstrap.js';
 export function createProductChatMcpServer() {
-    return createSdkMcpServer({
-        name: 'edsger-product-chat',
-        version: '1.0.0',
-        tools: [
-            tool('list_issues', 'List all issues for the product, optionally filtered by status. Use this to answer questions about product progress, blocked issues, etc.', {
-                product_id: z.string().describe('Product ID'),
-                status: z
-                    .string()
-                    .optional()
-                    .describe('Filter by status (e.g., backlog, ready_for_ai, in_progress, shipped)'),
-            }, async (args) => {
-                const params = {
-                    product_id: args.product_id,
-                };
-                if (args.status) {
-                    params.status = args.status;
-                }
-                const result = await callMcpEndpoint('issues/list', params);
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('create_issue', 'Create a new issue for the product. Use when the user describes new work to be added.', {
-                product_id: z.string().describe('Product ID'),
-                name: z.string().describe('Issue name'),
-                description: z.string().describe('Issue description'),
-            }, async (args) => {
-                const result = await callMcpEndpoint('issues/create', {
-                    product_id: args.product_id,
-                    name: args.name,
-                    description: args.description,
-                });
-                return {
-                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-                };
-            }),
-            tool('get_issue_details', 'Get detailed information about a specific issue, including its status, workflow, user stories, and 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_product_overview', 'Get a full product overview: issues by status, task counts, team size. Use this for summary questions.', {
-                product_id: z.string().describe('Product ID'),
-            }, async (args) => {
-                const [issuesResult, membersResult] = await Promise.all([
-                    callMcpEndpoint('issues/list', {
-                        product_id: args.product_id,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }),
-                    callMcpEndpoint('tasks/product_members', {
-                        product_id: args.product_id,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }),
-                ]);
-                const issues = issuesResult?.issues || [];
-                const byStatus = {};
-                for (const f of issues) {
-                    byStatus[f.status] = (byStatus[f.status] || 0) + 1;
-                }
-                let members = [];
-                try {
-                    const membersData = membersResult?.content?.[0]?.text
-                        ? JSON.parse(membersResult.content[0].text)
-                        : membersResult?.members || membersResult || [];
-                    members = Array.isArray(membersData) ? membersData : [];
-                }
-                catch {
-                    members = [];
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                total_issues: issues.length,
-                                issues_by_status: byStatus,
-                                team_size: members.length,
-                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                issues: issues.map((f) => ({
-                                    id: f.id,
-                                    name: f.name,
-                                    status: f.status,
-                                })),
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }),
-            tool('list_checklists', 'List all checklists for the product. 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. "create_issue", "list_blocked")'),
-                })),
-            }, 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_chat_history', 'Retrieve older chat messages from the channel. Use when you need more context about earlier discussions.', {
-                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.', {
-                product_id: z.string().describe('Product ID'),
-                name: z.string().describe('Short task name'),
-                description: z.string().optional().describe('Detailed description'),
-                executor: z.enum(['ai', 'human']).describe('Who should do this'),
-                assigned_to: z.string().optional().describe('User ID to assign to'),
-                issue_id: z.string().optional().describe('Related issue ID'),
-                action_url: z
-                    .string()
-                    .optional()
-                    .describe('URL where the assignee should take action'),
-                priority: z
-                    .number()
-                    .optional()
-                    .describe('1=low, 2=medium, 3=high, 4=urgent'),
-            }, async (args) => {
-                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;
-                const actionUrl = args.action_url ||
-                    (args.issue_id
-                        ? `/products/${args.product_id}/issues/${args.issue_id}`
-                        : `/products/${args.product_id}`);
-                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.', {
-                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) }],
-                };
-            }),
-        ],
-    });
+    return createChatProductMcpServer(getToolDeps());
 }

package/dist/phases/chat-processor/tools.d.ts

@@ -1,12 +1,8 @@
 /**
- * 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.
+ * Tool implementations live in `edsger-tools`. This shim adapts the
+ * CLI's `callMcpEndpoint` transport into `ToolDeps`.
  */
-/**
- * Create an in-process MCP server with chat-specific tools.
- * Pass the returned config to query() options.mcpServers.
- */
-export declare function createChatMcpServer(): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+import type { McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
+export declare function createChatMcpServer(): McpSdkServerConfigWithInstance;