@zereight/mcp-gitlab 2.0.22 → 2.0.24

package/build/schemas.js

@@ -792,12 +792,12 @@ export const GitLabDiscussionNoteSchema = z.object({
     position: z
         .object({
         // Only present for DiffNote
-        base_sha: z.string().optional(),
-        start_sha: z.string().optional(),
-        head_sha: z.string().optional(),
+        base_sha: z.string().nullable().optional(),
+        start_sha: z.string().nullable().optional(),
+        head_sha: z.string().nullable().optional(),
         old_path: z.string().nullable().optional().describe("File path before change"),
         new_path: z.string().nullable().optional().describe("File path after change"),
-        position_type: z.enum(["text", "image", "file"]).optional(),
+        position_type: z.enum(["text", "image", "file"]).nullable().optional(),
         new_line: z
             .number()
             .nullable()
@@ -808,11 +808,11 @@ export const GitLabDiscussionNoteSchema = z.object({
             .nullable()
             .optional()
             .describe("Line number in the original file (before changes). Used for deleted lines and context lines. Null for newly added lines."),
-        line_range: LineRangeSchema.nullable().optional(), // For multi-line diff notes
-        width: z.number().optional(), // For image diff notes
-        height: z.number().optional(), // For image diff notes
-        x: z.number().optional(), // For image diff notes
-        y: z.number().optional(), // For image diff notes
+        line_range: LineRangeSchema.nullable().optional(), // Accept any value for line_range including null
+        width: z.number().nullable().optional(), // For image diff notes
+        height: z.number().nullable().optional(), // For image diff notes
+        x: z.number().nullable().optional(), // For image diff notes
+        y: z.number().nullable().optional(), // For image diff notes
     })
         .passthrough() // Allow additional fields
         .optional(),
@@ -1003,7 +1003,7 @@ export const GetBranchDiffsSchema = ProjectParamsSchema.extend({
     excluded_file_patterns: z
         .array(z.string())
         .optional()
-        .describe('Array of regex patterns to exclude files from the diff results. Each pattern is a JavaScript-compatible regular expression that matches file paths to ignore. Examples: ["^test/mocks/", "\\.spec\\.ts$", "package-lock\\.json"]'),
+        .describe('Array of regex patterns to exclude files from the diff results. Each pattern is a JavaScript-compatible regular expression that matches file paths to ignore. Examples: ["^vendor/", "^test/mocks/", "\\.spec\\.ts$", "package-lock\\.json"]'),
 });
 export const GetMergeRequestSchema = ProjectParamsSchema.extend({
     merge_request_iid: z.coerce.string().optional().describe("The IID of a merge request"),
@@ -1039,8 +1039,61 @@ export const MergeMergeRequestSchema = ProjectParamsSchema.extend({
     squash_commit_message: z.string().optional().describe("Custom squash commit message"),
     squash: z.boolean().optional().default(false).describe("Squash commits into a single commit when merging"),
 });
+// Merge Request Approval schemas
+export const ApproveMergeRequestSchema = ProjectParamsSchema.extend({
+    merge_request_iid: z.coerce.string().describe("The IID of the merge request to approve"),
+    sha: z.string().optional().describe("The HEAD of the merge request. Optional, but used to ensure the merge request hasn't changed since you last reviewed it"),
+    approval_password: z.string().optional().describe("Current user's password. Required if 'Require user re-authentication to approve' is enabled in the project settings"),
+});
+export const UnapproveMergeRequestSchema = ProjectParamsSchema.extend({
+    merge_request_iid: z.coerce.string().describe("The IID of the merge request to unapprove"),
+});
+// Merge Request Approval State response schema
+export const GitLabApprovalUserSchema = z.object({
+    id: z.coerce.string(),
+    username: z.string(),
+    name: z.string(),
+    state: z.string(),
+    avatar_url: z.string().nullable().optional(),
+    web_url: z.string(),
+});
+export const GitLabApprovalRuleSchema = z.object({
+    id: z.coerce.string(),
+    name: z.string(),
+    rule_type: z.string(),
+    eligible_approvers: z.array(GitLabApprovalUserSchema).optional(),
+    approvals_required: z.number(),
+    users: z.array(GitLabApprovalUserSchema).optional(),
+    groups: z.array(z.object({
+        id: z.coerce.string(),
+        name: z.string(),
+        path: z.string(),
+        full_path: z.string(),
+        avatar_url: z.string().nullable().optional(),
+        web_url: z.string(),
+    })).optional(),
+    contains_hidden_groups: z.boolean().optional(),
+    approved_by: z.array(GitLabApprovalUserSchema).optional(),
+    source_rule: z.object({
+        id: z.coerce.string().optional(),
+        name: z.string().optional(),
+        rule_type: z.string().optional(),
+    }).nullable().optional(),
+    approved: z.boolean().optional(),
+});
+export const GitLabMergeRequestApprovalStateSchema = z.object({
+    approval_rules_overwritten: z.boolean().optional(),
+    rules: z.array(GitLabApprovalRuleSchema).optional(),
+});
+export const GetMergeRequestApprovalStateSchema = ProjectParamsSchema.extend({
+    merge_request_iid: z.coerce.string().describe("The IID of the merge request"),
+});
 export const GetMergeRequestDiffsSchema = GetMergeRequestSchema.extend({
     view: z.enum(["inline", "parallel"]).optional().describe("Diff view type"),
+    excluded_file_patterns: z
+        .array(z.string())
+        .optional()
+        .describe('Array of regex patterns to exclude files from the diff results. Each pattern is a JavaScript-compatible regular expression that matches file paths to ignore. Examples: ["^vendor/", "^test/mocks/", "\\.spec\\.ts$", "package-lock\\.json"]'),
 });
 export const ListMergeRequestDiffsSchema = GetMergeRequestSchema.extend({
     page: z.number().optional().describe("Page number for pagination (default: 1)"),
@@ -1049,6 +1102,16 @@ export const ListMergeRequestDiffsSchema = GetMergeRequestSchema.extend({
         .optional()
         .describe("Present diffs in the unified diff format. Default is false. Introduced in GitLab 16.5."),
 });
+// Merge Request Versions API operation schemas
+export const ListMergeRequestVersionsSchema = ProjectParamsSchema.extend({
+    merge_request_iid: z.coerce.string().describe("The internal ID of the merge request"),
+});
+export const GetMergeRequestVersionSchema = ListMergeRequestVersionsSchema.extend({
+    version_id: z.coerce.string().describe("The ID of the merge request diff version"),
+    unidiff: z.boolean()
+        .optional()
+        .describe("Present diffs in the unified diff format. Default is false. Introduced in GitLab 16.5."),
+});
 export const CreateNoteSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or namespace/project_path"),
     noteable_type: z
@@ -1418,6 +1481,7 @@ export const MergeRequestThreadPositionCreateSchema = z.object({
     x: z.number().optional().describe("IMAGE DIFFS ONLY: X coordinate on the image (for position_type='image')."),
     y: z.number().optional().describe("IMAGE DIFFS ONLY: Y coordinate on the image (for position_type='image')."),
 });
+// Schema for creating/sending position to GitLab API (stricter)
 export const MergeRequestThreadPositionSchema = z.object({
     base_sha: z
         .string()
@@ -1454,18 +1518,22 @@ export const MergeRequestThreadPositionSchema = z.object({
     line_range: LineRangeSchema.nullable().optional().describe("MULTILINE COMMENTS: Specify start/end line positions for commenting on multiple lines. Alternative to single old_line/new_line."),
     width: z
         .number()
+        .nullable()
         .optional()
         .describe("IMAGE DIFFS ONLY: Width of the image (for position_type='image')."),
     height: z
         .number()
+        .nullable()
         .optional()
         .describe("IMAGE DIFFS ONLY: Height of the image (for position_type='image')."),
     x: z
         .number()
+        .nullable()
         .optional()
         .describe("IMAGE DIFFS ONLY: X coordinate on the image (for position_type='image')."),
     y: z
         .number()
+        .nullable()
         .optional()
         .describe("IMAGE DIFFS ONLY: Y coordinate on the image (for position_type='image')."),
 });
@@ -1502,7 +1570,7 @@ export const ListDraftNotesSchema = ProjectParamsSchema.extend({
 export const CreateDraftNoteSchema = ProjectParamsSchema.extend({
     merge_request_iid: z.coerce.string().describe("The IID of a merge request"),
     body: z.string().describe("The content of the draft note"),
-    position: MergeRequestThreadPositionCreateSchema.optional().describe("Position when creating a diff note"),
+    position: MergeRequestThreadPositionSchema.optional().describe("Position when creating a diff note"),
     resolve_discussion: z.boolean().optional().describe("Whether to resolve the discussion when publishing"),
 });
 // Update draft note schema
@@ -1510,7 +1578,7 @@ export const UpdateDraftNoteSchema = ProjectParamsSchema.extend({
     merge_request_iid: z.coerce.string().describe("The IID of a merge request"),
     draft_note_id: z.coerce.string().describe("The ID of the draft note"),
     body: z.string().optional().describe("The content of the draft note"),
-    position: MergeRequestThreadPositionCreateSchema.optional().describe("Position when creating a diff note"),
+    position: MergeRequestThreadPositionSchema.optional().describe("Position when creating a diff note"),
     resolve_discussion: z.boolean().optional().describe("Whether to resolve the discussion when publishing"),
 });
 // Delete draft note schema
@@ -1659,6 +1727,10 @@ export const ListProjectMembersSchema = z.object({
     query: z.string().optional().describe("Search for members by name or username"),
     user_ids: z.array(z.number()).optional().describe("Filter by user IDs"),
     skip_users: z.array(z.number()).optional().describe("User IDs to exclude"),
+    include_inheritance: z
+        .boolean()
+        .optional()
+        .describe("Include inherited members. Defaults to false."),
     per_page: z.number().optional().describe("Number of items per page (default: 20, max: 100)"),
     page: z.number().optional().describe("Page number for pagination (default: 1)"),
 });
@@ -1785,6 +1857,22 @@ export const GetProjectEventsSchema = z.object({
     page: z.number().optional().describe("Returns the specified results page. Default: 1"),
     per_page: z.number().optional().describe("Number of results per page. Default: 20"),
 });
+// Merge Request Versions schemas - Response schemas based on GitLab API documentation
+export const GitLabMergeRequestVersionSchema = z.object({
+    id: z.number(),
+    head_commit_sha: z.string(),
+    base_commit_sha: z.string(),
+    start_commit_sha: z.string(),
+    created_at: z.string(),
+    merge_request_id: z.number(),
+    state: z.string(),
+    real_size: z.string(),
+    patch_id_sha: z.string(),
+});
+export const GitLabMergeRequestVersionDetailSchema = GitLabMergeRequestVersionSchema.extend({
+    commits: z.array(GitLabCommitSchema),
+    diffs: z.array(GitLabDiffSchema),
+});
 // GraphQL generic execution schema
 export const ExecuteGraphQLSchema = z.object({
     query: z.string().describe("GraphQL query string"),

package/build/test/test-list-project-members.js

@@ -0,0 +1,132 @@
+import { describe, test, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { spawn } from 'child_process';
+import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
+const MOCK_TOKEN = 'glpat-mock-token-12345';
+const TEST_PROJECT_ID = '123';
+const directMembers = [
+    {
+        id: 1,
+        username: 'direct-user',
+        name: 'Direct User',
+        state: 'active',
+        avatar_url: null,
+        web_url: 'https://gitlab.mock/users/1',
+        access_level: 30,
+        created_at: '2024-01-01T00:00:00Z'
+    }
+];
+const inheritedMembers = [
+    {
+        id: 2,
+        username: 'inherited-user',
+        name: 'Inherited User',
+        state: 'active',
+        avatar_url: null,
+        web_url: 'https://gitlab.mock/users/2',
+        access_level: 20,
+        created_at: '2024-01-02T00:00:00Z'
+    }
+];
+async function callListProjectMembers(args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('node', ['build/index.js'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                ...env,
+                GITLAB_READ_ONLY_MODE: 'true'
+            }
+        });
+        let output = '';
+        let errorOutput = '';
+        proc.stdout?.on('data', d => output += d);
+        proc.stderr?.on('data', d => errorOutput += d);
+        proc.on('close', (code) => {
+            if (code !== 0)
+                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
+            const line = output.split('\n').find(l => l.startsWith('{'));
+            if (!line)
+                return reject(new Error('No JSON output found'));
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(response.error);
+                }
+                else {
+                    const content = response.result?.content?.[0]?.text;
+                    if (content) {
+                        try {
+                            resolve(JSON.parse(content));
+                        }
+                        catch (e) {
+                            reject(new Error(`Failed to parse tool output JSON: ${content}`));
+                        }
+                    }
+                    else {
+                        resolve(response.result);
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0", id: 1, method: "tools/call",
+            params: { name: "list_project_members", arguments: args }
+        }) + '\n');
+    });
+}
+describe('list_project_members', () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    let directEndpointHit = false;
+    let inheritedEndpointHit = false;
+    before(async () => {
+        const mockPort = await findMockServerPort(9000);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN]
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/members`, (req, res) => {
+            directEndpointHit = true;
+            res.json(directMembers);
+        });
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/members/all`, (req, res) => {
+            inheritedEndpointHit = true;
+            res.json([...directMembers, ...inheritedMembers]);
+        });
+    });
+    beforeEach(() => {
+        directEndpointHit = false;
+        inheritedEndpointHit = false;
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test('lists direct project members', async () => {
+        const members = await callListProjectMembers({ project_id: TEST_PROJECT_ID }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(members), 'Response should be an array');
+        assert.strictEqual(members.length, 1, 'Should return direct members');
+        assert.strictEqual(members[0].username, 'direct-user');
+        assert.strictEqual(directEndpointHit, true, 'Direct members endpoint should be called');
+        assert.strictEqual(inheritedEndpointHit, false, 'Inherited members endpoint should not be called');
+    });
+    test('lists project members including inheritance', async () => {
+        const members = await callListProjectMembers({ project_id: TEST_PROJECT_ID, include_inheritance: true }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(members), 'Response should be an array');
+        assert.strictEqual(members.length, 2, 'Should return inherited members');
+        assert.strictEqual(members[1].username, 'inherited-user');
+        assert.strictEqual(inheritedEndpointHit, true, 'Inherited members endpoint should be called');
+        assert.strictEqual(directEndpointHit, false, 'Direct members endpoint should not be called');
+    });
+});

package/build/test/test-merge-request-approvals.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env npx ts-node
+/**
+ * Test script for merge request approval tools
+ *
+ * Usage:
+ *   GITLAB_PERSONAL_ACCESS_TOKEN=<token> GITLAB_PROJECT_ID=<project> npx ts-node test/test-merge-request-approvals.ts
+ *
+ * Optional: Set MERGE_REQUEST_IID to test a specific merge request
+ */
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const GITLAB_TOKEN = process.env.GITLAB_PERSONAL_ACCESS_TOKEN || process.env.GITLAB_TOKEN;
+const GITLAB_PROJECT_ID = process.env.GITLAB_PROJECT_ID;
+const GITLAB_API_URL = process.env.GITLAB_API_URL || "https://gitlab.com/api/v4";
+const MERGE_REQUEST_IID = process.env.MERGE_REQUEST_IID;
+async function sendMcpRequest(serverProcess, method, params) {
+    return new Promise((resolve, reject) => {
+        const request = {
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method,
+            params,
+        };
+        let responseData = "";
+        const onData = (data) => {
+            responseData += data.toString();
+            const lines = responseData.split("\n");
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const parsed = JSON.parse(line);
+                        serverProcess.stdout?.off("data", onData);
+                        resolve(parsed);
+                        return;
+                    }
+                    catch {
+                        // Continue accumulating data
+                    }
+                }
+            }
+        };
+        serverProcess.stdout?.on("data", onData);
+        serverProcess.stdin?.write(JSON.stringify(request) + "\n");
+        setTimeout(() => {
+            serverProcess.stdout?.off("data", onData);
+            reject(new Error("Request timeout"));
+        }, 30000);
+    });
+}
+async function runTests() {
+    console.log("=== Merge Request Approval Tools Test ===\n");
+    if (!GITLAB_TOKEN) {
+        console.error("Error: GITLAB_PERSONAL_ACCESS_TOKEN or GITLAB_TOKEN environment variable is required");
+        process.exit(1);
+    }
+    if (!GITLAB_PROJECT_ID) {
+        console.error("Error: GITLAB_PROJECT_ID environment variable is required");
+        process.exit(1);
+    }
+    console.log(`GitLab API URL: ${GITLAB_API_URL}`);
+    console.log(`Project ID: ${GITLAB_PROJECT_ID}`);
+    console.log(`Merge Request IID: ${MERGE_REQUEST_IID || "(will find one)"}\n`);
+    // Start the MCP server
+    const serverPath = path.join(__dirname, "..", "build", "index.js");
+    const serverProcess = spawn("node", [serverPath], {
+        env: {
+            ...process.env,
+            GITLAB_PERSONAL_ACCESS_TOKEN: GITLAB_TOKEN,
+            GITLAB_API_URL,
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    serverProcess.stderr?.on("data", data => {
+        const msg = data.toString();
+        if (!msg.includes("GitLab MCP Server running")) {
+            console.error("Server stderr:", msg);
+        }
+    });
+    // Wait for server to start
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    try {
+        // Initialize the MCP connection
+        console.log("1. Initializing MCP connection...");
+        await sendMcpRequest(serverProcess, "initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" },
+        });
+        console.log("   ✓ Connected\n");
+        // Find a merge request to test with
+        let mrIid = MERGE_REQUEST_IID;
+        if (!mrIid) {
+            console.log("2. Finding an open merge request...");
+            const listResponse = await sendMcpRequest(serverProcess, "tools/call", {
+                name: "list_merge_requests",
+                arguments: {
+                    project_id: GITLAB_PROJECT_ID,
+                    state: "opened",
+                    per_page: 1,
+                },
+            });
+            if (listResponse.error) {
+                console.error("   ✗ Error:", listResponse.error.message);
+                process.exit(1);
+            }
+            const mrs = JSON.parse(listResponse.result?.content?.[0]?.text || "[]");
+            if (mrs.length === 0) {
+                console.log("   ⚠ No open merge requests found. Create one to test approval tools.");
+                process.exit(0);
+            }
+            mrIid = mrs[0].iid;
+            console.log(`   ✓ Found MR !${mrIid}: ${mrs[0].title}\n`);
+        }
+        // Test get_merge_request_approval_state
+        console.log("3. Testing get_merge_request_approval_state...");
+        const approvalStateResponse = await sendMcpRequest(serverProcess, "tools/call", {
+            name: "get_merge_request_approval_state",
+            arguments: {
+                project_id: GITLAB_PROJECT_ID,
+                merge_request_iid: mrIid,
+            },
+        });
+        if (approvalStateResponse.error) {
+            console.error("   ✗ Error:", approvalStateResponse.error.message);
+        }
+        else {
+            const state = JSON.parse(approvalStateResponse.result?.content?.[0]?.text || "{}");
+            console.log("   ✓ Got approval state");
+            console.log(`     Rules: ${state.rules?.length || 0}`);
+            // Show details for each rule
+            for (const rule of state.rules || []) {
+                const approvedBy = rule.approved_by || [];
+                const approvedNames = approvedBy.map((u) => u.name).join(", ") || "none";
+                const status = rule.approved ? "✓ APPROVED" : "○ pending";
+                console.log(`\n     Rule: "${rule.name}"`);
+                console.log(`       Status: ${status}`);
+                console.log(`       Required: ${rule.approvals_required} approval(s)`);
+                console.log(`       Approved by: ${approvedNames} (${approvedBy.length}/${rule.approvals_required})`);
+            }
+            console.log();
+        }
+        // Test approve_merge_request
+        console.log("4. Testing approve_merge_request...");
+        const approveResponse = await sendMcpRequest(serverProcess, "tools/call", {
+            name: "approve_merge_request",
+            arguments: {
+                project_id: GITLAB_PROJECT_ID,
+                merge_request_iid: mrIid,
+            },
+        });
+        if (approveResponse.error) {
+            console.log("   ✗ Approve error:", approveResponse.error);
+        }
+        else {
+            console.log("   ✓ Approved successfully");
+        }
+        // Wait 3 seconds before unapproving
+        console.log("\n   Waiting 3 seconds...");
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        // Test unapprove_merge_request
+        console.log("\n5. Testing unapprove_merge_request...");
+        const unapproveResponse = await sendMcpRequest(serverProcess, "tools/call", {
+            name: "unapprove_merge_request",
+            arguments: {
+                project_id: GITLAB_PROJECT_ID,
+                merge_request_iid: mrIid,
+            },
+        });
+        if (unapproveResponse.error) {
+            console.log("   ✗ Unapprove error:", unapproveResponse.error);
+        }
+        else {
+            console.log("   ✓ Unapproved successfully");
+        }
+        console.log("\n=== Tests Complete ===");
+    }
+    finally {
+        serverProcess.kill();
+    }
+}
+runTests().catch(error => {
+    console.error("Test failed:", error);
+    process.exit(1);
+});

package/build/test/test-mr-diffs-filter.js

@@ -0,0 +1,132 @@
+import { describe, test, before, after } from 'node:test';
+import assert from 'node:assert';
+import { spawn } from 'child_process';
+import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
+const MOCK_TOKEN = 'glpat-mock-token-12345';
+const TEST_PROJECT_ID = '123';
+const TEST_MR_IID = '1';
+// Helper to call get_merge_request_diffs
+async function callGetMergeRequestDiffs(args = {}, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('node', ['build/index.js'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                ...env,
+                GITLAB_READ_ONLY_MODE: 'true'
+            }
+        });
+        let output = '';
+        let errorOutput = '';
+        proc.stdout?.on('data', d => output += d);
+        proc.stderr?.on('data', d => errorOutput += d);
+        proc.on('close', (code) => {
+            if (code !== 0)
+                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
+            // Find the JSON line in stdout
+            const line = output.split('\n').find(l => l.startsWith('{'));
+            if (!line)
+                return reject(new Error('No JSON output found'));
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(response.error);
+                }
+                else {
+                    // Parse the tool result content
+                    const content = response.result?.content?.[0]?.text;
+                    if (content) {
+                        try {
+                            resolve(JSON.parse(content));
+                        }
+                        catch (e) {
+                            reject(new Error(`Failed to parse tool output JSON: ${content}`));
+                        }
+                    }
+                    else {
+                        resolve(response.result);
+                    }
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0", id: 1, method: "tools/call",
+            params: { name: "get_merge_request_diffs", arguments: args }
+        }) + '\n');
+    });
+}
+describe('get_merge_request_diffs with excluded_file_patterns', () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9100);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN]
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test('returns all diffs without filtering', async () => {
+        const diffs = await callGetMergeRequestDiffs({ project_id: TEST_PROJECT_ID, merge_request_iid: TEST_MR_IID }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 4, 'Should return 4 diffs');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'vendor/package/file.js');
+        assert.strictEqual(diffs[2].new_path, 'README.md');
+        assert.strictEqual(diffs[3].new_path, 'package-lock.json');
+    });
+    test('filters out vendor folder with ^vendor/ pattern', async () => {
+        const diffs = await callGetMergeRequestDiffs({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            excluded_file_patterns: ['^vendor/']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 3, 'Should return 3 diffs (vendor filtered out)');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'README.md');
+        assert.strictEqual(diffs[2].new_path, 'package-lock.json');
+    });
+    test('filters out package-lock.json with package-lock pattern', async () => {
+        const diffs = await callGetMergeRequestDiffs({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            excluded_file_patterns: ['package-lock\\.json']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 3, 'Should return 3 diffs (package-lock.json filtered out)');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'vendor/package/file.js');
+        assert.strictEqual(diffs[2].new_path, 'README.md');
+    });
+    test('filters multiple patterns at once', async () => {
+        const diffs = await callGetMergeRequestDiffs({
+            project_id: TEST_PROJECT_ID,
+            merge_request_iid: TEST_MR_IID,
+            excluded_file_patterns: ['^vendor/', 'package-lock\\.json']
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN
+        });
+        assert.ok(Array.isArray(diffs), 'Response should be an array');
+        assert.strictEqual(diffs.length, 2, 'Should return 2 diffs (vendor and package-lock filtered out)');
+        assert.strictEqual(diffs[0].new_path, 'src/index.ts');
+        assert.strictEqual(diffs[1].new_path, 'README.md');
+    });
+});