@zereight/mcp-gitlab 2.1.10 → 2.1.12

package/build/schemas.js

@@ -248,6 +248,17 @@ export const GetPipelineSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
     pipeline_id: z.coerce.string().describe("The ID of the pipeline"),
 });
+export const GitLabMergeRequestPipelineSchema = z.object({
+    id: z.coerce.string(),
+    sha: z.string(),
+    ref: z.string(),
+    status: z.string(),
+    project_id: z.coerce.string().optional(),
+    source: z.string().optional(),
+    created_at: z.string().optional(),
+    updated_at: z.string().optional(),
+    web_url: z.string().optional(),
+});
 // Schema for listing jobs in a pipeline
 export const ListPipelineJobsSchema = z
     .object({
@@ -514,6 +525,76 @@ export const GitLabUsersResponseSchema = z.record(z.string(), z
     web_url: z.string(),
 })
     .nullable());
+export const GetUserSchema = z.object({
+    user_id: z.coerce.string().describe("The ID of the user"),
+});
+export const GitLabUserFullSchema = z.object({
+    id: z.coerce.string(),
+    username: z.string(),
+    name: z.string(),
+    state: z.string(),
+    avatar_url: z.string().nullable(),
+    web_url: z.string(),
+    created_at: z.string(),
+    bio: z.string().nullable(),
+    location: z.string().nullable(),
+    public_email: z.string().nullable(),
+    website_url: z.string().nullable(),
+    organization: z.string().nullable(),
+    job_title: z.string().nullable(),
+    pronouns: z.string().nullable(),
+    bot: z.boolean().optional(),
+    work_information: z.string().nullable(),
+    followers: z.number().optional(),
+    following: z.number().optional(),
+    is_followed: z.boolean().optional(),
+    local_time: z.string().nullable().optional(),
+    last_sign_in_at: z.string().nullable().optional(),
+    confirmed_at: z.string().nullable().optional(),
+    last_activity_on: z.string().nullable().optional(),
+    email: z.string().nullable().optional(),
+    theme_id: z.number().nullable().optional(),
+    color_scheme_id: z.number().nullable().optional(),
+    projects_limit: z.number().nullable().optional(),
+    current_sign_in_at: z.string().nullable().optional(),
+    identities: z.array(z.object({
+        provider: z.string(),
+        extern_uid: z.string(),
+    })).optional(),
+    can_create_group: z.boolean().nullable().optional(),
+    can_create_project: z.boolean().nullable().optional(),
+    two_factor_enabled: z.boolean().nullable().optional(),
+    external: z.boolean().nullable().optional(),
+    private_profile: z.boolean().nullable().optional(),
+    is_admin: z.boolean().nullable().optional(),
+}).passthrough();
+export const WhoAmISchema = z.object({});
+export const GitLabCurrentUserSchema = z.object({
+    id: z.coerce.string(),
+    username: z.string(),
+    name: z.string(),
+    state: z.string(),
+    avatar_url: z.string().nullable(),
+    web_url: z.string(),
+    created_at: z.string(),
+    bio: z.string().nullable(),
+    location: z.string().nullable(),
+    public_email: z.string().nullable(),
+    website_url: z.string().nullable(),
+    organization: z.string().nullable(),
+    job_title: z.string().nullable(),
+    email: z.string().nullable(),
+    last_sign_in_at: z.string().nullable(),
+    confirmed_at: z.string().nullable(),
+    last_activity_on: z.string().nullable(),
+    is_admin: z.boolean().optional(),
+    can_create_group: z.boolean().optional(),
+    can_create_project: z.boolean().optional(),
+    identities: z.array(z.object({
+        provider: z.string(),
+        extern_uid: z.string(),
+    })).optional(),
+}).passthrough();
 // Namespace related schemas
 // Base schema for project-related operations
 const ProjectParamsSchema = z.object({
@@ -1391,6 +1472,37 @@ export const CreateBranchSchema = ProjectParamsSchema.extend({
     branch: z.string().describe("Name for the new branch"),
     ref: z.string().optional().describe("Source branch/commit for new branch"),
 });
+export const GetBranchSchema = ProjectParamsSchema.extend({
+    branch_name: z.string().describe("Name of the branch"),
+});
+export const ListBranchesSchema = ProjectParamsSchema.extend({
+    search: z.string().optional().describe("Search term to filter branches by name"),
+}).merge(PaginationOptionsSchema);
+export const DeleteBranchSchema = ProjectParamsSchema.extend({
+    branch_name: z.string().describe("Name of the branch to delete"),
+});
+export const GitLabBranchSchema = z.object({
+    name: z.string(),
+    commit: z.object({
+        id: z.string(),
+        short_id: z.string(),
+        title: z.string(),
+        author_name: z.string(),
+        author_email: z.string(),
+        authored_date: z.string(),
+        committer_name: z.string(),
+        committer_email: z.string(),
+        committed_date: z.string(),
+        web_url: z.string(),
+    }),
+    merged: z.boolean(),
+    protected: z.boolean(),
+    developers_can_push: z.boolean(),
+    developers_can_merge: z.boolean(),
+    can_push: z.boolean(),
+    default: z.boolean(),
+    web_url: z.string().optional(),
+});
 export const GetBranchDiffsSchema = ProjectParamsSchema.extend({
     from: z.string().describe("The base branch or commit SHA to compare from"),
     to: z.string().describe("The target branch or commit SHA to compare to"),
@@ -1541,6 +1653,17 @@ export const GetMergeRequestApprovalStateSchema = ProjectParamsSchema.extend({
 export const GetMergeRequestConflictsSchema = ProjectParamsSchema.extend({
     merge_request_iid: z.coerce.string().describe("The IID of the merge request"),
 });
+export const ListMergeRequestPipelinesSchema = ProjectParamsSchema.extend({
+    merge_request_iid: z
+        .preprocess(value => (value === undefined || value === null ? value : String(value)), z
+        .string({
+        required_error: "merge_request_iid is required",
+        invalid_type_error: "merge_request_iid is required",
+    })
+        .refine(value => value.trim().length > 0, "merge_request_iid is required")
+        .transform(value => value.trim()))
+        .describe("The internal ID of the merge request"),
+}).merge(PaginationOptionsSchema);
 export const GetMergeRequestDiffsSchema = GetMergeRequestSchema.extend({
     view: z.enum(["inline", "parallel"]).optional().describe("Diff view type"),
     excluded_file_patterns: z
@@ -1747,6 +1870,22 @@ export const DeleteIssueSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
     issue_iid: z.coerce.string().describe("The internal ID of the project issue"),
 });
+export const UpdateIssueDescriptionPatchSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    issue_iid: z.coerce.string().describe("The internal ID of the project issue"),
+    patch_type: z.enum(["search_replace", "unified_diff"]).describe("Type of patch format to apply"),
+    patch: z
+        .string()
+        .min(1)
+        .max(50000)
+        .describe("The patch content to apply to the issue description"),
+    dry_run: z.coerce.boolean().optional().describe("If true, preview changes without updating the issue"),
+    create_note: z.coerce.boolean().optional().describe("If true, add a note summarizing the change after update"),
+    allow_multiple: z
+        .coerce.boolean()
+        .optional()
+        .describe("For search_replace: allow multiple matches to all be replaced (default: false — fail on duplicate)"),
+});
 // Issue links related schemas
 export const GitLabIssueLinkSchema = z.object({
     source_issue: GitLabIssueSchema,
@@ -3141,3 +3280,4 @@ export const GetWebhookEventSchema = z
     .refine(data => (data.project_id || data.group_id) && !(data.project_id && data.group_id), {
     message: "Provide exactly one of project_id or group_id",
 });
+export const HealthCheckSchema = z.object({});

package/build/test/schema-tests.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env ts-node
-import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateCommitStatusSchema, ListCommitStatusesSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, ListLabelsSchema, GitLabMergeRequestSchema, GitLabTreeItemSchema, GetMergeRequestSchema, GetRepositoryTreeSchema } from '../schemas.js';
+import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateCommitStatusSchema, ListCommitStatusesSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, ListLabelsSchema, GitLabMergeRequestSchema, GitLabTreeItemSchema, GetMergeRequestSchema, ListMergeRequestPipelinesSchema, GetRepositoryTreeSchema, GitLabUserFullSchema } from '../schemas.js';
 function runGetFileContentsSchemaTests() {
     console.log('🧪 Testing GetFileContentsSchema...');
     const cases = [
@@ -609,6 +609,60 @@ function runGetMergeRequestSchemaTests() {
     console.log(`\nResults: ${passed} passed, ${failed} failed`);
     return { passed, failed };
 }
+function runListMergeRequestPipelinesSchemaTests() {
+    console.log('\n🧪 Testing ListMergeRequestPipelinesSchema...');
+    const cases = [
+        {
+            name: 'schema:list_merge_request_pipelines:minimal-required-fields',
+            input: { project_id: 'my/project', merge_request_iid: '42' },
+            expected: { project_id: 'my/project', merge_request_iid: '42' },
+        },
+        {
+            name: 'schema:list_merge_request_pipelines:coerces-pagination',
+            input: { project_id: 123, merge_request_iid: 42, page: '2', per_page: '10' },
+            expected: { project_id: '123', merge_request_iid: '42', page: 2, per_page: 10 },
+        },
+        {
+            name: 'schema:list_merge_request_pipelines:reject-missing-merge-request-iid',
+            input: { project_id: 'my/project' },
+            shouldFail: true,
+        },
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = { name: testCase.name, status: 'failed' };
+        const parsed = ListMergeRequestPipelinesSchema.safeParse(testCase.input);
+        if (testCase.shouldFail) {
+            result.status = parsed.success ? 'failed' : 'passed';
+            if (parsed.success)
+                result.error = 'Expected schema validation to fail';
+        }
+        else if (parsed.success) {
+            const expected = testCase.expected || {};
+            const matches = Object.entries(expected).every(([key, value]) => {
+                const actual = parsed.data[key];
+                return actual === value;
+            });
+            result.status = matches ? 'passed' : 'failed';
+            if (!matches)
+                result.error = `Unexpected parsed result: ${JSON.stringify(parsed.data)}`;
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
 function runGitLabMergeRequestSchemaTests() {
     console.log('\n🧪 Testing GitLabMergeRequestSchema...');
     const baseMergeRequest = {
@@ -1068,6 +1122,87 @@ function runGetRepositoryTreeSchemaTests() {
     console.log(`\nResults: ${passed} passed, ${failed} failed`);
     return { passed, failed };
 }
+function runGitLabUserFullSchemaTests() {
+    console.log('🧪 Testing GitLabUserFullSchema...');
+    const adminResponse = {
+        id: 1,
+        username: 'root',
+        name: 'Administrator',
+        state: 'active',
+        avatar_url: 'https://gitlab.example.com/uploads/-/system/user/avatar/1/avatar.png',
+        web_url: 'https://gitlab.example.com/root',
+        created_at: '2012-09-22T16:50:56.000Z',
+        bio: null,
+        location: null,
+        public_email: '',
+        website_url: '',
+        organization: null,
+        job_title: null,
+        pronouns: null,
+        work_information: null,
+        followers: 0,
+        following: 0,
+        is_followed: false,
+        local_time: null,
+        last_sign_in_at: null,
+        confirmed_at: '2012-09-22T16:50:56.000Z',
+        last_activity_on: '2026-05-12',
+        email: 'admin@example.com',
+        theme_id: 1,
+        color_scheme_id: 1,
+        projects_limit: 100000,
+        current_sign_in_at: '2026-05-12T08:14:22.885Z',
+        identities: [],
+        can_create_group: true,
+        can_create_project: true,
+        two_factor_enabled: false,
+        external: false,
+        private_profile: false,
+        is_admin: true,
+    };
+    const cases = [
+        {
+            name: 'schema:user_full:admin-response-no-bot',
+            input: { ...adminResponse },
+            shouldFail: false,
+        },
+        {
+            name: 'schema:user_full:admin-response-with-bot',
+            input: { ...adminResponse, bot: false },
+            shouldFail: false,
+        },
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = { name: testCase.name, status: 'failed' };
+        const parsed = GitLabUserFullSchema.safeParse(testCase.input);
+        if (testCase.shouldFail) {
+            if (parsed.success) {
+                result.error = 'Expected schema validation to fail';
+            }
+            else {
+                result.status = 'passed';
+            }
+        }
+        else if (parsed.success) {
+            result.status = 'passed';
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
 if (import.meta.url === `file://${process.argv[1]}`) {
     const getFileContentsResult = runGetFileContentsSchemaTests();
     const fileContentResult = runGitLabFileContentSchemaTests();
@@ -1075,6 +1210,7 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     const commitStatusResult = runCommitStatusSchemaTests();
     const createIssueNoteResult = runCreateIssueNoteSchemaTests();
     const getMergeRequestResult = runGetMergeRequestSchemaTests();
+    const listMergeRequestPipelinesResult = runListMergeRequestPipelinesSchemaTests();
     const gitLabMergeRequestResult = runGitLabMergeRequestSchemaTests();
     const emojiReactionResult = runEmojiReactionSchemaTests();
     const repositorySchemaResult = runGitLabRepositorySchemaTests();
@@ -1082,8 +1218,9 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     const listLabelsResult = runListLabelsSchemaTests();
     const treeItemResult = runGitLabTreeItemSchemaTests();
     const repositoryTreeResult = runGetRepositoryTreeSchemaTests();
-    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + commitStatusResult.passed + createIssueNoteResult.passed + getMergeRequestResult.passed + gitLabMergeRequestResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + listLabelsResult.passed + treeItemResult.passed + repositoryTreeResult.passed;
-    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + commitStatusResult.failed + createIssueNoteResult.failed + getMergeRequestResult.failed + gitLabMergeRequestResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + listLabelsResult.failed + treeItemResult.failed + repositoryTreeResult.failed;
+    const gitLabUserFullResult = runGitLabUserFullSchemaTests();
+    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + commitStatusResult.passed + createIssueNoteResult.passed + getMergeRequestResult.passed + listMergeRequestPipelinesResult.passed + gitLabMergeRequestResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + listLabelsResult.passed + treeItemResult.passed + repositoryTreeResult.passed + gitLabUserFullResult.passed;
+    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + commitStatusResult.failed + createIssueNoteResult.failed + getMergeRequestResult.failed + listMergeRequestPipelinesResult.failed + gitLabMergeRequestResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + listLabelsResult.failed + treeItemResult.failed + repositoryTreeResult.failed + gitLabUserFullResult.failed;
     console.log(`\nTotal Results: ${totalPassed} passed, ${totalFailed} failed`);
     if (totalFailed > 0) {
         process.exit(1);

package/build/test/test-issue-description-patch.js

@@ -0,0 +1,256 @@
+/**
+ * Tests for the update_issue_description_patch tool.
+ * Tests search_replace, unified_diff, dry_run, create_note, and edge cases.
+ */
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert";
+import { launchServer, cleanupServers, TransportMode, HOST, } from "./utils/server-launcher.js";
+import { MockGitLabServer, findMockServerPort, } from "./utils/mock-gitlab-server.js";
+import { CustomHeaderClient } from "./clients/custom-header-client.js";
+import { parseSearchReplaceBlocks, applySearchReplace, applyUnifiedDiff, } from "../utils/patch-helper.js";
+const MOCK_TOKEN = "glpat-patch-test-token-12345";
+// ---- Unit tests for patch helper ----
+describe("parseSearchReplaceBlocks", () => {
+    test("parses a single block", () => {
+        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\nold text\n=======\nnew text\n>>>>>>> REPLACE");
+        assert.strictEqual(blocks.length, 1);
+        assert.strictEqual(blocks[0].search, "old text");
+        assert.strictEqual(blocks[0].replace, "new text");
+    });
+    test("parses multiple blocks", () => {
+        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\nfirst\n=======\nfirst new\n>>>>>>> REPLACE\n<<<<<<< SEARCH\nsecond\n=======\nsecond new\n>>>>>>> REPLACE");
+        assert.strictEqual(blocks.length, 2);
+    });
+    test("handles empty content", () => {
+        const blocks = parseSearchReplaceBlocks("");
+        assert.strictEqual(blocks.length, 0);
+    });
+    test("ignores text outside blocks", () => {
+        const blocks = parseSearchReplaceBlocks("prefix\n<<<<<<< SEARCH\nx\n=======\ny\n>>>>>>> REPLACE\nsuffix");
+        assert.strictEqual(blocks.length, 1);
+    });
+    test("rejects malformed block with missing REPLACE marker", () => {
+        assert.throws(() => parseSearchReplaceBlocks("<<<<<<< SEARCH\nfirst\n=======\nfirst new\n>>>>>>> REPLACE\n" +
+            "<<<<<<< SEARCH\nsecond\n=======\nsecond new\n>>>>>>> TYPO"), /malformed|Marker|marker/);
+    });
+    test("rejects block with missing ======= marker", () => {
+        assert.throws(() => parseSearchReplaceBlocks("<<<<<<< SEARCH\nfoo\n\nbar\n>>>>>>> REPLACE"), /malformed|Marker|marker/);
+    });
+    test("allows prose around valid blocks", () => {
+        const blocks = parseSearchReplaceBlocks("# Some notes\n\n<<<<<<< SEARCH\nfoo\n=======\nbar\n>>>>>>> REPLACE\n\nMore context");
+        assert.strictEqual(blocks.length, 1);
+    });
+});
+describe("applySearchReplace", () => {
+    test("replaces single occurrence", () => {
+        const result = applySearchReplace("Status: In progress\nDone.", [
+            { search: "Status: In progress", replace: "Status: Done" },
+        ]);
+        assert.strictEqual(result.description, "Status: Done\nDone.");
+        assert.strictEqual(result.changes, 1);
+        assert.ok(result.summary.includes("Status: In progress"));
+        assert.ok(result.preview.includes("-Status: In progress"));
+    });
+    test("fails on no match", () => {
+        assert.throws(() => applySearchReplace("Some text.", [{ search: "Nonexistent", replace: "x" }]), /Search text not found/);
+    });
+    test("rejects empty SEARCH body", () => {
+        assert.throws(() => applySearchReplace("Some text.", [{ search: "", replace: "x" }], true), /Empty SEARCH/);
+    });
+    test("fails on duplicate without allowMultiple", () => {
+        assert.throws(() => applySearchReplace("x\ny\nx\n", [{ search: "x", replace: "z" }]), /matches 2 times/);
+    });
+    test("replaces all with allowMultiple", () => {
+        const result = applySearchReplace("x\ny\nx\n", [{ search: "x", replace: "z" }], true);
+        assert.strictEqual(result.changes, 2);
+        assert.strictEqual(result.description, "z\ny\nz\n");
+    });
+    test("fails on identical replacement", () => {
+        assert.throws(() => applySearchReplace("Keep this.", [{ search: "Keep this.", replace: "Keep this." }]), /did not change/);
+    });
+    test("preserves leading blank line in SEARCH block", () => {
+        const source = "\n\nStatus: In progress\n";
+        const result = applySearchReplace(source, [
+            { search: "\n\nStatus: In progress", replace: "\n\nStatus: Done" },
+        ]);
+        assert.strictEqual(result.description, "\n\nStatus: Done\n");
+    });
+    test("preserves leading blank line when patch starts with blank line", () => {
+        const blocks = parseSearchReplaceBlocks("<<<<<<< SEARCH\n\nfoo\n=======\n\nbar\n>>>>>>> REPLACE");
+        assert.strictEqual(blocks.length, 1);
+        assert.strictEqual(blocks[0].search, "\nfoo");
+        assert.strictEqual(blocks[0].replace, "\nbar");
+    });
+    test("replacement with leading blank line works", () => {
+        const result = applySearchReplace("Header\n\nContent\n", [
+            { search: "Content", replace: "\nNewContent" },
+        ]);
+        assert.strictEqual(result.description, "Header\n\n\nNewContent\n");
+    });
+});
+describe("applyUnifiedDiff", () => {
+    test("applies simple diff", () => {
+        const source = "Line 1\nLine 2\nLine 3\n";
+        const patch = "--- old\n+++ new\n@@ -1,3 +1,3 @@\n Line 1\n-Line 2\n+Line 2 modified\n Line 3\n";
+        const result = applyUnifiedDiff(source, patch);
+        assert.ok(result.description.includes("Line 2 modified"));
+    });
+    test("fails on non-matching diff", () => {
+        const source = "AAA\nBBB\n";
+        const patch = "--- old\n+++ new\n@@ -1,2 +1,2 @@\n-XXX\n+YYY\n BBB\n";
+        assert.throws(() => applyUnifiedDiff(source, patch), /could not be applied/);
+    });
+    test("fails on malformed patch", () => {
+        assert.throws(() => applyUnifiedDiff("text", "not a patch"), /no valid hunks/i);
+    });
+});
+// ---- Integration tests via MCP client ----
+describe("update_issue_description_patch MCP tool", () => {
+    let mockGitLab;
+    let server;
+    let client;
+    const MOCK_PORT_BASE = 9600;
+    const MCP_PORT_BASE = 3600;
+    let portCounter = 0;
+    async function launchMcp(mockGitLabUrl, extraEnv = {}) {
+        const port = MCP_PORT_BASE + portCounter++ * 10;
+        return launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port,
+            timeout: 10000,
+            env: {
+                STREAMABLE_HTTP: "true",
+                REMOTE_AUTHORIZATION: "true",
+                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                GITLAB_ACCESS_TOKEN: MOCK_TOKEN,
+                ...extraEnv,
+            },
+        });
+    }
+    async function getClient(port) {
+        const client = new CustomHeaderClient({
+            headers: {
+                authorization: `Bearer ${MOCK_TOKEN}`,
+            },
+        });
+        await client.connect(`http://${HOST}:${port}/mcp`);
+        return client;
+    }
+    before(async () => {
+        const mockPort = await findMockServerPort(MOCK_PORT_BASE);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        await mockGitLab.start();
+        const mockGitLabUrl = mockGitLab.getUrl();
+        server = await launchMcp(mockGitLabUrl, { GITLAB_TOOLSETS: "issues" });
+        client = await getClient(server.port ?? 0);
+    });
+    after(async () => {
+        await client?.disconnect();
+        cleanupServers([server]);
+        await mockGitLab?.stop();
+    });
+    test("tool appears in tool list", async () => {
+        const result = await client.listTools();
+        const names = result.tools.map((t) => t.name);
+        assert.ok(names.includes("update_issue_description_patch"), "tool should be in list");
+    });
+    test("dry_run: search_replace returns preview without modifying", async () => {
+        // Get current description
+        const getResult = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issue = JSON.parse(getResult.content[0]?.text || "{}");
+        const originalDesc = issue.description;
+        // Dry-run
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\n${originalDesc}\n=======\nShould NOT persist\n>>>>>>> REPLACE`,
+            dry_run: true,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "preview");
+        assert.strictEqual(data.dry_run, true);
+        assert.strictEqual(data.changes, 1);
+        // Verify NOT updated
+        const getAgain = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issueAgain = JSON.parse(getAgain.content[0]?.text || "{}");
+        assert.strictEqual(issueAgain.description, originalDesc, "should be unchanged after dry_run");
+    });
+    test("search_replace: applies the patch", async () => {
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\nDescription for issue 1\n=======\nPatched description\n>>>>>>> REPLACE`,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "success");
+        assert.strictEqual(data.changes, 1);
+        // Verify persisted
+        const getResult = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issue = JSON.parse(getResult.content[0]?.text || "{}");
+        assert.strictEqual(issue.description, "Patched description");
+    });
+    test("create_note: note is attempted after update", async () => {
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\nPatched description\n=======\nDescription with note\n>>>>>>> REPLACE`,
+            create_note: true,
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "success");
+        assert.ok(data.note !== undefined, "note result should be present");
+    });
+    test("search_replace: fails on no match", async () => {
+        try {
+            await client.callTool("update_issue_description_patch", {
+                project_id: "test/project",
+                issue_iid: "1",
+                patch_type: "search_replace",
+                patch: `<<<<<<< SEARCH\nNonExistentText_{UNIQUE}_\n=======\nShould fail\n>>>>>>> REPLACE`,
+            });
+            assert.fail("Should have thrown");
+        }
+        catch (err) {
+            const msg = err.message ?? String(err);
+            assert.ok(msg.includes("not found"), `Error should mention 'not found': ${msg}`);
+        }
+    });
+    test("unified_diff: applies the patch", async () => {
+        // Set known state
+        await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "search_replace",
+            patch: `<<<<<<< SEARCH\nDescription with note\n=======\nLine 1\nLine 2\nLine 3\n>>>>>>> REPLACE`,
+        });
+        const result = await client.callTool("update_issue_description_patch", {
+            project_id: "test/project",
+            issue_iid: "1",
+            patch_type: "unified_diff",
+            patch: "--- old\n+++ new\n@@ -1,3 +1,3 @@\n Line 1\n-Line 2\n+Line 2 changed\n Line 3\n",
+        });
+        const data = JSON.parse(result.content[0]?.text || "{}");
+        assert.strictEqual(data.status, "success");
+        const getResult = await client.callTool("get_issue", {
+            project_id: "test/project",
+            issue_iid: "1",
+        });
+        const issue = JSON.parse(getResult.content[0]?.text || "{}");
+        assert.ok(issue.description.includes("Line 2 changed"));
+    });
+});