1// mcp-server/github/index.ts
2import { MCPServer } from '@modelcontextprotocol/sdk';
3import { Octokit } from '@octokit/rest';
4
5const octokit = new Octokit({
6  auth: process.env.GITHUB_TOKEN,
7});
8
9const server = new MCPServer({
10  name: 'github-mcp',
11  version: '1.0.0',
12});
13
14// Tool: Get PR details
15server.tool({
16  name: 'get_pr_details',
17  description: 'Get pull request details from GitHub',
18  parameters: {
19    type: 'object',
20    properties: {
21      owner: { type: 'string', description: 'Repository owner' },
22      repo: { type: 'string', description: 'Repository name' },
23      pr_number: { type: 'number', description: 'PR number' },
24    },
25    required: ['owner', 'repo', 'pr_number'],
26  },
27  handler: async ({ owner, repo, pr_number }) => {
28    const { data } = await octokit.pulls.get({
29      owner,
30      repo,
31      pull_number: pr_number,
32    });
33    
34    return {
35      title: data.title,
36      state: data.state,
37      author: data.user?.login,
38      created_at: data.created_at,
39      commits: data.commits,
40      additions: data.additions,
41      deletions: data.deletions,
42      changed_files: data.changed_files,
43    };
44  },
45});
46
47// Tool: Create issue
48server.tool({
49  name: 'create_issue',
50  description: 'Create a new GitHub issue',
51  parameters: {
52    type: 'object',
53    properties: {
54      owner: { type: 'string' },
55      repo: { type: 'string' },
56      title: { type: 'string' },
57      body: { type: 'string' },
58      labels: { type: 'array', items: { type: 'string' } },
59    },
60    required: ['owner', 'repo', 'title', 'body'],
61  },
62  handler: async ({ owner, repo, title, body, labels = [] }) => {
63    const { data } = await octokit.issues.create({
64      owner,
65      repo,
66      title,
67      body,
68      labels,
69    });
70    
71    return {
72      issue_number: data.number,
73      url: data.html_url,
74    };
75  },
76});
77
78server.listen(3000);
79console.log('GitHub MCP server running on port 3000');

1// AI Agent using MCP tools
2import OpenAI from 'openai';
3import { MCPClient } from '@modelcontextprotocol/sdk';
4
5const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
6const mcpClient = new MCPClient();
7
8// Connect to MCP servers
9await mcpClient.connect('github', 'http://localhost:3000');
10await mcpClient.connect('jira', 'http://localhost:3001');
11await mcpClient.connect('slack', 'http://localhost:3002');
12
13// AI Agent workflow
14async function handleSlackCommand(command: string) {
15  const messages = [
16    {
17      role: 'system',
18      content: `You are an AI assistant that helps with GitHub, Jira, and Slack.
19                You have access to MCP tools for these services.
20                Available tools:
21                - get_pr_details (GitHub)
22                - create_issue (GitHub)
23                - create_jira_ticket (Jira)
24                - send_slack_message (Slack)`,
25    },
26    {
27      role: 'user',
28      content: command,
29    },
30  ];
31  
32  const response = await openai.chat.completions.create({
33    model: 'gpt-4-turbo-preview',
34    messages,
35    tools: mcpClient.getAvailableTools(),
36    tool_choice: 'auto',
37  });
38  
39  const message = response.choices[0].message;
40  
41  // Execute tool calls if any
42  if (message.tool_calls) {
43    for (const toolCall of message.tool_calls) {
44      const result = await mcpClient.callTool(
45        toolCall.function.name,
46        JSON.parse(toolCall.function.arguments)
47      );
48      
49      console.log(`Tool ${toolCall.function.name} result:`, result);
50    }
51  }
52  
53  return message.content;
54}
55
56// Example usage
57const result = await handleSlackCommand(
58  'Create a Jira ticket for the bug in PR #123 from myorg/myrepo'
59);
60
61console.log('Agent response:', result);

1// Automated workflow: PR merged -> Jira update -> Slack notification
2import { MCPClient } from '@modelcontextprotocol/sdk';
3
4const mcpClient = new MCPClient();
5
6// Connect to all services
7await Promise.all([
8  mcpClient.connect('github', process.env.GITHUB_MCP_URL!),
9  mcpClient.connect('jira', process.env.JIRA_MCP_URL!),
10  mcpClient.connect('slack', process.env.SLACK_MCP_URL!),
11]);
12
13// Workflow: Handle PR merge event
14export async function handlePRMerge({
15  owner,
16  repo,
17  pr_number,
18  pr_title,
19}: {
20  owner: string;
21  repo: string;
22  pr_number: number;
23  pr_title: string;
24}) {
25  try {
26    // 1. Get PR details from GitHub
27    const prDetails = await mcpClient.callTool('get_pr_details', {
28      owner,
29      repo,
30      pr_number,
31    });
32    
33    console.log('✅ PR details:', prDetails);
34    
35    // 2. Extract Jira ticket ID from PR title
36    const jiraMatch = pr_title.match(/\[(\w+-)\d+\]/);
37    
38    if (jiraMatch) {
39      const ticketId = jiraMatch[0].replace(/[\[\]]/g, '');
40      
41      // 3. Update Jira ticket
42      await mcpClient.callTool('update_jira_ticket', {
43        ticket_id: ticketId,
44        status: 'Done',
45        comment: `PR #${pr_number} merged: ${prDetails.title}\n\nChanges: +${prDetails.additions} -${prDetails.deletions}`,
46      });
47      
48      console.log('✅ Jira ticket updated:', ticketId);
49    }
50    
51    // 4. Send Slack notification
52    await mcpClient.callTool('send_slack_message', {
53      channel: '#engineering',
54      text: `🎉 PR merged: *${pr_title}*`,
55      blocks: [
56        {
57          type: 'section',
58          text: {
59            type: 'mrkdwn',
60            text: `*<https://github.com/${owner}/${repo}/pull/${pr_number}|PR #${pr_number}>* by ${prDetails.author}`,
61          },
62        },
63        {
64          type: 'context',
65          elements: [
66            {
67              type: 'mrkdwn',
68              text: `📊 ${prDetails.changed_files} files | +${prDetails.additions} -${prDetails.deletions}`,
69            },
70          ],
71        },
72      ],
73    });
74    
75    console.log('✅ Slack notification sent');
76    
77    return { success: true };
78  } catch (error) {
79    console.error('❌ Workflow failed:', error);
80    throw error;
81  }
82}
83
84// GitHub webhook handler
85export async function handleGitHubWebhook(event: any) {
86  if (event.action === 'closed' && event.pull_request.merged) {
87    await handlePRMerge({
88      owner: event.repository.owner.login,
89      repo: event.repository.name,
90      pr_number: event.pull_request.number,
91      pr_title: event.pull_request.title,
92    });
93  }
94}