@zereight/mcp-gitlab 2.1.6 → 2.1.8

package/build/test/test-ci-lint.js

@@ -0,0 +1,191 @@
+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-ci-lint-test-token";
+const TEST_PROJECT_ID = "123";
+async function callTool(toolName, args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+                USE_PIPELINE: "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;
+                    resolve(content ? JSON.parse(content) : response.result);
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: toolName, arguments: args },
+        }) + "\n");
+    });
+}
+async function listToolNames(env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+        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 {
+                    resolve(response.result.tools.map((tool) => tool.name));
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/list",
+            params: {},
+        }) + "\n");
+    });
+}
+describe("GitLab CI lint tools", () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9260);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        mockGitLab.addMockHandler("post", `/projects/${TEST_PROJECT_ID}/ci/lint`, (req, res) => {
+            assert.strictEqual(req.body.content, "stages: [test]\ntest:\n  script: echo ok");
+            assert.strictEqual(req.body.dry_run, true);
+            assert.strictEqual(req.body.include_jobs, true);
+            assert.strictEqual(req.body.ref, "main");
+            res.json({
+                valid: true,
+                errors: [],
+                warnings: [],
+                merged_yaml: "test:\n  script: echo ok\n",
+                includes: [],
+                jobs: [{ name: "test", stage: "test" }],
+            });
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/ci/lint`, (req, res) => {
+            assert.strictEqual(req.query.content_ref, "feature/test");
+            assert.strictEqual(req.query.dry_run, "true");
+            assert.strictEqual(req.query.dry_run_ref, "main");
+            assert.strictEqual(req.query.include_jobs, "true");
+            res.json({
+                valid: true,
+                errors: [],
+                warnings: [],
+                merged_yaml: "include-job:\n  script: echo included\n",
+                includes: [{ type: "local", location: "include.yml" }],
+                jobs: [{ name: "include-job", stage: "test" }],
+            });
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test("validate_ci_lint posts CI YAML content and returns lint result", async () => {
+        const result = await callTool("validate_ci_lint", {
+            project_id: TEST_PROJECT_ID,
+            content: "stages: [test]\ntest:\n  script: echo ok",
+            dry_run: true,
+            include_jobs: true,
+            ref: "main",
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.strictEqual(result.valid, true);
+        assert.deepStrictEqual(result.errors, []);
+        assert.strictEqual(result.jobs[0].name, "test");
+    });
+    test("validate_ci_lint surfaces invalid lint responses", async () => {
+        mockGitLab.addMockHandler("post", `/projects/999/ci/lint`, (req, res) => {
+            res.json({
+                valid: false,
+                errors: ["jobs config should contain at least one visible job"],
+                warnings: [],
+            });
+        });
+        const result = await callTool("validate_ci_lint", {
+            project_id: "999",
+            content: ".hidden:\n  script: echo hidden",
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.strictEqual(result.valid, false);
+        assert.deepStrictEqual(result.errors, ["jobs config should contain at least one visible job"]);
+    });
+    test("validate_project_ci_lint sends GET query parameters", async () => {
+        const result = await callTool("validate_project_ci_lint", {
+            project_id: TEST_PROJECT_ID,
+            content_ref: "feature/test",
+            dry_run: true,
+            dry_run_ref: "main",
+            include_jobs: true,
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.strictEqual(result.valid, true);
+        assert.strictEqual(result.includes[0].location, "include.yml");
+        assert.strictEqual(result.jobs[0].name, "include-job");
+    });
+    test("CI lint tools are visible by default in read-only mode", async () => {
+        const tools = await listToolNames({
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+            GITLAB_READ_ONLY_MODE: "true",
+        });
+        assert.ok(tools.includes("validate_ci_lint"));
+        assert.ok(tools.includes("validate_project_ci_lint"));
+    });
+});

package/build/test/test-tags.js

@@ -0,0 +1,206 @@
+import { after, before, describe, test } 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-tags";
+const TEST_PROJECT_ID = "123";
+const TEST_TAG_NAME = "v1.0.0";
+function buildTag(overrides = {}) {
+    return {
+        name: TEST_TAG_NAME,
+        message: "Annotated release tag",
+        target: "abc123def4567890",
+        commit: {
+            id: "abc123def4567890",
+            short_id: "abc123de",
+            title: "Release v1.0.0",
+            created_at: "2026-03-13T10:00:00.000Z",
+            parent_ids: ["1111111111111111"],
+            message: "Release v1.0.0",
+            author_name: "Test User",
+            author_email: "test@example.com",
+            authored_date: "2026-03-13T09:55:00.000Z",
+            committer_name: "Test User",
+            committer_email: "test@example.com",
+            committed_date: "2026-03-13T10:00:00.000Z",
+        },
+        release: {
+            tag_name: TEST_TAG_NAME,
+            description: "Release notes",
+        },
+        protected: false,
+        created_at: "2026-03-13T10:00:00.000Z",
+        ...overrides,
+    };
+}
+async function callTool(toolName, args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+        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);
+                    return;
+                }
+                const content = response.result?.content?.[0]?.text;
+                if (!content) {
+                    resolve(response.result);
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(content));
+                }
+                catch {
+                    resolve(content);
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: toolName, arguments: args },
+        }) + "\n");
+    });
+}
+describe("tag tools", () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(20000, 50);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/tags`, (req, res) => {
+            assert.strictEqual(req.query.search, "^v");
+            assert.strictEqual(req.query.order_by, "version");
+            assert.strictEqual(req.query.sort, "desc");
+            assert.strictEqual(req.query.page, "2");
+            assert.strictEqual(req.query.per_page, "10");
+            res.json([buildTag()]);
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/tags/${encodeURIComponent(TEST_TAG_NAME)}`, (_req, res) => {
+            res.json(buildTag());
+        });
+        mockGitLab.addMockHandler("post", `/projects/${TEST_PROJECT_ID}/repository/tags`, (req, res) => {
+            assert.deepStrictEqual(req.body, {
+                tag_name: TEST_TAG_NAME,
+                ref: "main",
+                message: "Release tag",
+            });
+            res.json(buildTag({ created_at: null }));
+        });
+        mockGitLab.addMockHandler("delete", `/projects/${TEST_PROJECT_ID}/repository/tags/${encodeURIComponent(TEST_TAG_NAME)}`, (_req, res) => {
+            res.status(204).send();
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/repository/tags/${encodeURIComponent(TEST_TAG_NAME)}/signature`, (_req, res) => {
+            res.json({
+                signature_type: "X509",
+                verification_status: "unverified",
+                x509_certificate: {
+                    id: 1,
+                    subject: "CN=Test User,O=Example",
+                    subject_key_identifier: "A1725E379E7B25B2",
+                    email: null,
+                    serial_number: 123456789,
+                    certificate_status: "good",
+                    x509_issuer: {
+                        id: 1,
+                        subject: "CN=Example CA,O=Example",
+                        subject_key_identifier: "C6411E6F5B9E2CFD",
+                        crl_url: null,
+                    },
+                },
+            });
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    const env = () => ({
+        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        GITLAB_TOOLSETS: "tags",
+    });
+    test("list_tags returns parsed tags with query filters", async () => {
+        const result = await callTool("list_tags", {
+            project_id: TEST_PROJECT_ID,
+            search: "^v",
+            order_by: "version",
+            sort: "desc",
+            page: 2,
+            per_page: 10,
+        }, env());
+        assert.ok(Array.isArray(result));
+        assert.strictEqual(result.length, 1);
+        assert.strictEqual(result[0].name, TEST_TAG_NAME);
+    });
+    test("get_tag returns a single tag", async () => {
+        const result = await callTool("get_tag", { project_id: TEST_PROJECT_ID, tag_name: TEST_TAG_NAME }, env());
+        assert.strictEqual(result.name, TEST_TAG_NAME);
+        assert.strictEqual(result.commit.short_id, "abc123de");
+    });
+    test("create_tag posts the expected payload", async () => {
+        const result = await callTool("create_tag", {
+            project_id: TEST_PROJECT_ID,
+            tag_name: TEST_TAG_NAME,
+            ref: "main",
+            message: "Release tag",
+        }, env());
+        assert.strictEqual(result.name, TEST_TAG_NAME);
+        assert.strictEqual(result.release.description, "Release notes");
+        assert.strictEqual(result.created_at, null);
+    });
+    test("delete_tag returns a success payload", async () => {
+        const result = await callTool("delete_tag", { project_id: TEST_PROJECT_ID, tag_name: TEST_TAG_NAME }, env());
+        assert.deepStrictEqual(result, {
+            status: "success",
+            message: `Tag '${TEST_TAG_NAME}' deleted successfully`,
+        });
+    });
+    test("get_tag_signature returns signature data", async () => {
+        const result = await callTool("get_tag_signature", { project_id: TEST_PROJECT_ID, tag_name: TEST_TAG_NAME }, env());
+        assert.deepStrictEqual(result, {
+            signature_type: "X509",
+            verification_status: "unverified",
+            x509_certificate: {
+                id: 1,
+                subject: "CN=Test User,O=Example",
+                subject_key_identifier: "A1725E379E7B25B2",
+                email: null,
+                serial_number: 123456789,
+                certificate_status: "good",
+                x509_issuer: {
+                    id: 1,
+                    subject: "CN=Example CA,O=Example",
+                    subject_key_identifier: "C6411E6F5B9E2CFD",
+                    crl_url: null,
+                },
+            },
+        });
+    });
+});

package/build/test/test-todos.js

@@ -0,0 +1,195 @@
+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-todos-test-token";
+async function callTool(toolName, args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+        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;
+                    resolve(content ? JSON.parse(content) : response.result);
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: args === undefined ? { name: toolName } : { name: toolName, arguments: args },
+        }) + "\n");
+    });
+}
+async function listToolNames(env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...env,
+            },
+        });
+        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 {
+                    resolve(response.result.tools.map((tool) => tool.name));
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/list",
+            params: {},
+        }) + "\n");
+    });
+}
+function todoFixture(id, state = "pending") {
+    return {
+        id,
+        project: { id: 123, path_with_namespace: "group/project" },
+        author: { id: 1, username: "root" },
+        action_name: "marked",
+        target_type: "MergeRequest",
+        target: { id: 34, iid: 7, project_id: 123, title: "Review this MR" },
+        target_url: "https://gitlab.example.com/group/project/-/merge_requests/7",
+        body: "Review this MR",
+        state,
+        created_at: "2026-01-01T00:00:00.000Z",
+        updated_at: "2026-01-01T00:00:00.000Z",
+    };
+}
+describe("GitLab todos tools", () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort(9250);
+        mockGitLab = new MockGitLabServer({
+            port: mockPort,
+            validTokens: [MOCK_TOKEN],
+        });
+        mockGitLab.addMockHandler("get", "/todos", (req, res) => {
+            assert.strictEqual(req.query.state, "pending");
+            assert.strictEqual(req.query.action, "assigned");
+            assert.strictEqual(req.query.project_id, "123");
+            assert.strictEqual(req.query.page, "2");
+            assert.strictEqual(req.query.per_page, "5");
+            res.json([todoFixture(102)]);
+        });
+        mockGitLab.addMockHandler("post", "/todos/102/mark_as_done", (req, res) => {
+            res.json(todoFixture(102, "done"));
+        });
+        mockGitLab.addMockHandler("post", "/todos/mark_as_done", (req, res) => {
+            res.status(204).send();
+        });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    test("list_todos sends filters and returns todos", async () => {
+        const result = await callTool("list_todos", {
+            state: "pending",
+            action: "assigned",
+            project_id: 123,
+            page: 2,
+            per_page: 5,
+        }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.ok(Array.isArray(result));
+        assert.strictEqual(result[0].id, 102);
+        assert.strictEqual(result[0].state, "pending");
+    });
+    test("mark_todo_done marks one todo done", async () => {
+        const result = await callTool("mark_todo_done", { id: 102 }, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.strictEqual(result.id, 102);
+        assert.strictEqual(result.state, "done");
+    });
+    test("mark_all_todos_done reports success", async () => {
+        const result = await callTool("mark_all_todos_done", {}, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.deepStrictEqual(result, {
+            status: "success",
+            message: "All pending to-do items marked as done",
+        });
+    });
+    test("mark_all_todos_done accepts omitted arguments", async () => {
+        const result = await callTool("mark_all_todos_done", undefined, {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.deepStrictEqual(result, {
+            status: "success",
+            message: "All pending to-do items marked as done",
+        });
+    });
+    test("todo tools are visible in the default issues toolset", async () => {
+        const tools = await listToolNames({
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+        });
+        assert.ok(tools.includes("list_todos"));
+        assert.ok(tools.includes("mark_todo_done"));
+        assert.ok(tools.includes("mark_all_todos_done"));
+    });
+    test("read-only mode keeps list_todos and hides todo mutations", async () => {
+        const tools = await listToolNames({
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+            GITLAB_READ_ONLY_MODE: "true",
+        });
+        assert.ok(tools.includes("list_todos"));
+        assert.ok(!tools.includes("mark_todo_done"));
+        assert.ok(!tools.includes("mark_all_todos_done"));
+    });
+});

package/build/test/test-toolset-filtering.js

@@ -17,20 +17,23 @@ const MCP_PORT_BASE = 3200;
 // Known tool counts per toolset (from TOOLSET_DEFINITIONS)
 const TOOLSET_TOOL_COUNTS = {
     merge_requests: 40,
-    issues: 20,
+    issues: 23,
     repositories: 7,
     branches: 4,
     projects: 8,
     labels: 5,
+    ci: 2,
     pipelines: 19,
     milestones: 9,
     wiki: 10,
     releases: 7,
+    tags: 5,
     users: 5,
     search: 3,
     workitems: 18,
     webhooks: 3,
 };
+const LEGACY_PIPELINE_TOOL_COUNT = TOOLSET_TOOL_COUNTS.pipelines + TOOLSET_TOOL_COUNTS.ci;
 const DEFAULT_TOOLSETS = [
     "merge_requests",
     "issues",
@@ -38,9 +41,19 @@ const DEFAULT_TOOLSETS = [
     "branches",
     "projects",
     "labels",
+    "ci",
     "users",
 ];
-const NON_DEFAULT_TOOLSETS = ["pipelines", "milestones", "wiki", "releases", "workitems", "webhooks", "search"];
+const NON_DEFAULT_TOOLSETS = [
+    "pipelines",
+    "milestones",
+    "wiki",
+    "releases",
+    "tags",
+    "workitems",
+    "webhooks",
+    "search",
+];
 // discover_tools meta-tool is always force-injected (Step 5.5)
 const DISCOVER_TOOLS_COUNT = 1;
 const DEFAULT_TOOL_COUNT = DEFAULT_TOOLSETS.reduce((sum, id) => sum + TOOLSET_TOOL_COUNTS[id], 0) + DISCOVER_TOOLS_COUNT;
@@ -48,15 +61,17 @@ const ALL_TOOLSET_TOOL_COUNT = Object.values(TOOLSET_TOOL_COUNTS).reduce((sum, c
 // Representative tools per toolset for spot-checking
 const TOOLSET_SAMPLE_TOOLS = {
     merge_requests: ["merge_merge_request", "create_merge_request_thread", "list_draft_notes"],
-    issues: ["create_issue", "list_issues", "create_note"],
+    issues: ["create_issue", "list_issues", "create_note", "list_todos"],
     repositories: ["search_repositories", "get_file_contents", "push_files"],
     branches: ["create_branch", "list_commits"],
     projects: ["get_project", "list_namespaces", "list_group_iterations"],
     labels: ["list_labels", "create_label"],
+    ci: ["validate_ci_lint", "validate_project_ci_lint"],
     pipelines: ["list_pipelines", "create_pipeline", "cancel_pipeline_job", "list_deployments", "list_job_artifacts"],
     milestones: ["list_milestones", "create_milestone", "get_milestone_burndown_events"],
     wiki: ["list_wiki_pages", "create_wiki_page", "list_group_wiki_pages", "create_group_wiki_page"],
     releases: ["list_releases", "create_release", "download_release_asset"],
+    tags: ["list_tags", "create_tag", "get_tag_signature"],
     users: ["get_users", "upload_markdown", "download_attachment"],
     search: ["search_code", "search_project_code", "search_group_code"],
     webhooks: ["list_webhooks", "list_webhook_events", "get_webhook_event"],
@@ -249,7 +264,7 @@ describe("Toolset Filtering", { concurrency: 1 }, () => {
         });
         after(() => cleanupServers([server]));
         test("returns issue tools + all pipeline tools + discover_tools", () => {
-            assert.strictEqual(tools.length, TOOLSET_TOOL_COUNTS.issues + TOOLSET_TOOL_COUNTS.pipelines + DISCOVER_TOOLS_COUNT);
+            assert.strictEqual(tools.length, TOOLSET_TOOL_COUNTS.issues + LEGACY_PIPELINE_TOOL_COUNT + DISCOVER_TOOLS_COUNT);
         });
         test("includes all pipeline tools via legacy flag", () => {
             assertContainsAll(tools, TOOLSET_SAMPLE_TOOLS.pipelines, "pipelines");
@@ -286,6 +301,7 @@ describe("Toolset Filtering", { concurrency: 1 }, () => {
             "list_issue_links",
             "list_issue_discussions",
             "get_issue_link",
+            "list_todos",
             "list_issue_emoji_reactions",
             "list_issue_note_emoji_reactions",
         ];
@@ -293,6 +309,8 @@ describe("Toolset Filtering", { concurrency: 1 }, () => {
             "create_issue",
             "update_issue",
             "delete_issue",
+            "mark_todo_done",
+            "mark_all_todos_done",
             "create_issue_note",
             "update_issue_note",
             "create_issue_link",
@@ -385,7 +403,7 @@ describe("Toolset Filtering", { concurrency: 1 }, () => {
         });
         after(() => cleanupServers([server]));
         test("returns exactly pipeline tool count + discover_tools (no duplicates)", () => {
-            assert.strictEqual(tools.length, TOOLSET_TOOL_COUNTS.pipelines + DISCOVER_TOOLS_COUNT);
+            assert.strictEqual(tools.length, LEGACY_PIPELINE_TOOL_COUNT + DISCOVER_TOOLS_COUNT);
         });
     });
     // ---- 12. GITLAB_TOOLS with tool already in enabled toolset (no dupes) ----