CI/CD Pipeline MCP Integration

name: CI Suite and AI Failure Triage

on:
  pull_request:
    branches: [main, develop]

jobs:
  test-and-diagnose:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      actions: read

    steps:
      - name: Checkout Code
        uses: actions/checkout@v4
        with:
          fetch-depth: 50 # Required for diff inspection against base branch

      - name: Setup Node.js Environment
        uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: 'npm'

      - name: Install Dependencies
        run: npm ci

      - name: Run Test Suite with JUnit Reporter
        id: test_step
        run: npm test -- --reporter=junit --outputFile=reports/junit.xml
        continue-on-error: true

      - name: Execute MCP CI Triage Agent
        if: steps.test_step.outcome == 'failure'
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
          REPO_NAME: ${{ github.repository }}
        run: |
          node scripts/run-mcp-ci-triage.mjs
          exit 1

{
  "mcpServers": {
    "ci-diagnostic-local": {
      "command": "node",
      "args": ["/Users/developer/repo/scripts/ci-diagnostic-mcp.mjs"],
      "env": {
        "JUNIT_REPORT_PATH": "/Users/developer/repo/reports/junit.xml"
      }
    }
  }
}

{
  "mcpServers": {
    "ci-diagnostic-local": {
      "command": "node",
      "args": ["./scripts/ci-diagnostic-mcp.mjs"]
    }
  }
}

[mcp_servers.ci_diagnostic]
command = "node"
args = ["./scripts/ci-diagnostic-mcp.mjs"]

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
import fs from 'fs';
import { XMLParser } from 'fast-xml-parser';
import { execSync } from 'child_process';

const server = new Server(
  { name: 'ci-diagnostic-mcp', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'inspect_junit_failures',
        description: 'Parse JUnit XML reports to extract failing test names, assertion messages, and stack traces.',
        inputSchema: {
          type: 'object',
          properties: {
            report_path: {
              type: 'string',
              description: 'Relative path to JUnit XML report',
              default: 'reports/junit.xml'
            }
          }
        }
      },
      {
        name: 'get_pr_git_diff',
        description: 'Extract git diff between base branch and current commit, filtered to source files.',
        inputSchema: {
          type: 'object',
          properties: {
            base_branch: {
              type: 'string',
              description: 'Base target branch name',
              default: 'origin/main'
            }
          }
        }
      }
    ]
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'inspect_junit_failures') {
    const filePath = (args?.report_path as string) || 'reports/junit.xml';
    if (!fs.existsSync(filePath)) {
      return {
        isError: true,
        content: [{ type: 'text', text: `Report not found at path: ${filePath}` }]
      };
    }

    const xmlData = fs.readFileSync(filePath, 'utf8');
    const parser = new XMLParser({ ignoreAttributes: false });
    const parsed = parser.parse(xmlData);

    const testcases = parsed.testsuites?.testsuite?.testcase || [];
    const casesArray = Array.isArray(testcases) ? testcases : [testcases];

    const failures = [];
    for (const tc of casesArray) {
      if (tc.failure) {
        failures.push({
          name: tc['@_name'],
          classname: tc['@_classname'],
          message: tc.failure['@_message'] || 'Assertion failed',
          stack_trace: (tc.failure['#text'] || '').split('\n').slice(0, 15).join('\n')
        });
      }
    }

    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(failures, null, 2)
        }
      ]
    };
  }

  if (name === 'get_pr_git_diff') {
    const base = (args?.base_branch as string) || 'origin/main';
    try {
      const diffOutput = execSync(
        `git diff ${base}...HEAD --stat -p -- '*.ts' '*.js' '*.py'`,
        { maxBuffer: 1024 * 1024 * 2 }
      ).toString();

      return {
        content: [
          {
            type: 'text',
            text: diffOutput.slice(0, 15000)
          }
        ]
      };
    } catch (err: any) {
      return {
        isError: true,
        content: [{ type: 'text', text: `Failed to compute diff: ${err.message}` }]
      };
    }
  }

  throw new Error(`Tool ${name} is not recognized.`);
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main().catch((err) => {
  process.stderr.write(`Fatal MCP Server Error: ${err.message}\n`);
  process.exit(1);
});

{
  "jsonrpc": "2.0",
  "id": "ci-triage-101",
  "method": "tools/call",
  "params": {
    "name": "inspect_junit_failures",
    "arguments": {
      "report_path": "reports/junit.xml"
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": "ci-triage-101",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "[\n  {\n    \"name\": \"should calculate tax correctly for EU accounts\",\n    \"classname\": \"tests/billing/tax.test.ts\",\n    \"message\": \"Expected 20.0 but received 0.0\",\n    \"stack_trace\": \"AssertionError: Expected 20.0 but received 0.0\\n    at Object.test (tests/billing/tax.test.ts:44:12)\"\n  }\n]"
      }
    ]
  }
}

### 🤖 Automated Regression Diagnosis

**Root Cause Analysis:**
The unit test `tests/billing/tax.test.ts` failed because commit `9c8a1b` modified `src/billing/calculator.ts` (line 32) to skip VAT computation when `countryCode === 'DE'`.

**Suggested Remediation:**
```typescript
// src/billing/calculator.ts:32
- if (isEU && countryCode !== 'DE') {
+ if (isEU) {
    return applyEUVAT(amount, countryCode);
  }

---

## 7. Common Production Errors and Troubleshooting

When embedding MCP tools into automated CI pipelines, watch for the following common issues:

### Error: Shallow Clone Git History Failure

* **Symptom**: `fatal: ambiguous argument 'origin/main...HEAD': unknown revision or path`.
* **Root Cause**: Modern CI runners default to a shallow checkout depth of 1 (`fetch-depth: 1`) to speed up pipeline setup. The runner does not possess the commit history needed to compute branch differences.
* **Resolution**: In your GitHub Actions checkout step, specify `fetch-depth: 50` or `fetch-depth: 0` to ensure git history is available.

### Error: Unchecked JSON-RPC Stdout Pollution

* **Symptom**: Host parser throws `SyntaxError: Unexpected token in JSON at position 0`.
* **Root Cause**: Helper scripts or third-party libraries writing diagnostic messages directly to `console.log()` corrupt the stdio transport stream.
* **Resolution**: Always route non-protocol diagnostics to standard error:

```javascript
process.stderr.write("Diagnostic status: parsing JUnit XML report...\n");

* text=auto eol=lf