gitlab-mcp 0.1.4 → 1.0.0

package/build/index.js

@@ -1,1641 +0,0 @@
-#!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import fetch from "node-fetch";
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-import fs from "fs";
-import path from "path";
-import { config } from "dotenv";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import express from "express";
-import { GitLabForkSchema, GitLabReferenceSchema, GitLabRepositorySchema, GitLabIssueSchema, GitLabMergeRequestSchema, GitLabContentSchema, GitLabCreateUpdateFileResponseSchema, GitLabSearchResponseSchema, GitLabTreeSchema, GitLabCommitSchema, GitLabNamespaceSchema, GitLabNamespaceExistsResponseSchema, GitLabProjectSchema, CreateOrUpdateFileSchema, SearchRepositoriesSchema, CreateRepositorySchema, GetFileContentsSchema, PushFilesSchema, CreateIssueSchema, CreateMergeRequestSchema, ForkRepositorySchema, CreateBranchSchema, GitLabMergeRequestDiffSchema, GetMergeRequestSchema, GetMergeRequestDiffsSchema, UpdateMergeRequestSchema, ListIssuesSchema, GetIssueSchema, UpdateIssueSchema, DeleteIssueSchema, GitLabIssueLinkSchema, GitLabIssueWithLinkDetailsSchema, ListIssueLinksSchema, GetIssueLinkSchema, CreateIssueLinkSchema, DeleteIssueLinkSchema, ListNamespacesSchema, GetNamespaceSchema, VerifyNamespaceSchema, GetProjectSchema, ListProjectsSchema, ListLabelsSchema, GetLabelSchema, CreateLabelSchema, UpdateLabelSchema, DeleteLabelSchema, CreateNoteSchema, ListGroupProjectsSchema, 
-// Discussion Schemas
-GitLabDiscussionNoteSchema, // Added
-GitLabDiscussionSchema, UpdateMergeRequestNoteSchema, // Added
-ListMergeRequestDiscussionsSchema, } from "./schemas.js";
-// Load .env from the current working directory
-config({ path: path.resolve(process.cwd(), ".env") });
-const argv = yargs(hideBin(process.argv)).argv;
-const isSSE = argv.mode === "sse";
-const port = argv.port ?? 3044;
-/**
- * Read version from package.json
- */
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJsonPath = path.resolve(__dirname, "../package.json");
-let SERVER_VERSION = "unknown";
-try {
-    if (fs.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-        SERVER_VERSION = packageJson.version || SERVER_VERSION;
-    }
-}
-catch (error) {
-    console.error("Warning: Could not read version from package.json:", error);
-}
-const server = new Server({
-    name: "better-gitlab-mcp-server",
-    version: SERVER_VERSION,
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-const GITLAB_PERSONAL_ACCESS_TOKEN = process.env.GITLAB_PERSONAL_ACCESS_TOKEN;
-const GITLAB_READ_ONLY_MODE = process.env.GITLAB_READ_ONLY_MODE === "true";
-// Define all available tools
-const allTools = [
-    {
-        name: "create_or_update_file",
-        description: "Create or update a single file in a GitLab project",
-        inputSchema: zodToJsonSchema(CreateOrUpdateFileSchema),
-    },
-    {
-        name: "search_repositories",
-        description: "Search for GitLab projects",
-        inputSchema: zodToJsonSchema(SearchRepositoriesSchema),
-    },
-    {
-        name: "create_repository",
-        description: "Create a new GitLab project",
-        inputSchema: zodToJsonSchema(CreateRepositorySchema),
-    },
-    {
-        name: "get_file_contents",
-        description: "Get the contents of a file or directory from a GitLab project",
-        inputSchema: zodToJsonSchema(GetFileContentsSchema),
-    },
-    {
-        name: "push_files",
-        description: "Push multiple files to a GitLab project in a single commit",
-        inputSchema: zodToJsonSchema(PushFilesSchema),
-    },
-    {
-        name: "create_issue",
-        description: "Create a new issue in a GitLab project",
-        inputSchema: zodToJsonSchema(CreateIssueSchema),
-    },
-    {
-        name: "create_merge_request",
-        description: "Create a new merge request in a GitLab project",
-        inputSchema: zodToJsonSchema(CreateMergeRequestSchema),
-    },
-    {
-        name: "fork_repository",
-        description: "Fork a GitLab project to your account or specified namespace",
-        inputSchema: zodToJsonSchema(ForkRepositorySchema),
-    },
-    {
-        name: "create_branch",
-        description: "Create a new branch in a GitLab project",
-        inputSchema: zodToJsonSchema(CreateBranchSchema),
-    },
-    {
-        name: "get_merge_request",
-        description: "Get details of a merge request",
-        inputSchema: zodToJsonSchema(GetMergeRequestSchema),
-    },
-    {
-        name: "get_merge_request_diffs",
-        description: "Get the changes/diffs of a merge request",
-        inputSchema: zodToJsonSchema(GetMergeRequestDiffsSchema),
-    },
-    {
-        name: "update_merge_request",
-        description: "Update a merge request",
-        inputSchema: zodToJsonSchema(UpdateMergeRequestSchema),
-    },
-    {
-        name: "create_note",
-        description: "Create a new note (comment) to an issue or merge request",
-        inputSchema: zodToJsonSchema(CreateNoteSchema),
-    },
-    {
-        name: "list_merge_request_discussions",
-        description: "List discussion items for a merge request",
-        inputSchema: zodToJsonSchema(ListMergeRequestDiscussionsSchema),
-    },
-    {
-        name: "update_merge_request_note",
-        description: "Modify an existing merge request thread note",
-        inputSchema: zodToJsonSchema(UpdateMergeRequestNoteSchema),
-    },
-    {
-        name: "list_issues",
-        description: "List issues in a GitLab project with filtering options",
-        inputSchema: zodToJsonSchema(ListIssuesSchema),
-    },
-    {
-        name: "get_issue",
-        description: "Get details of a specific issue in a GitLab project",
-        inputSchema: zodToJsonSchema(GetIssueSchema),
-    },
-    {
-        name: "update_issue",
-        description: "Update an issue in a GitLab project",
-        inputSchema: zodToJsonSchema(UpdateIssueSchema),
-    },
-    {
-        name: "delete_issue",
-        description: "Delete an issue from a GitLab project",
-        inputSchema: zodToJsonSchema(DeleteIssueSchema),
-    },
-    {
-        name: "list_issue_links",
-        description: "List all issue links for a specific issue",
-        inputSchema: zodToJsonSchema(ListIssueLinksSchema),
-    },
-    {
-        name: "get_issue_link",
-        description: "Get a specific issue link",
-        inputSchema: zodToJsonSchema(GetIssueLinkSchema),
-    },
-    {
-        name: "create_issue_link",
-        description: "Create an issue link between two issues",
-        inputSchema: zodToJsonSchema(CreateIssueLinkSchema),
-    },
-    {
-        name: "delete_issue_link",
-        description: "Delete an issue link",
-        inputSchema: zodToJsonSchema(DeleteIssueLinkSchema),
-    },
-    {
-        name: "list_namespaces",
-        description: "List all namespaces available to the current user",
-        inputSchema: zodToJsonSchema(ListNamespacesSchema),
-    },
-    {
-        name: "get_namespace",
-        description: "Get details of a namespace by ID or path",
-        inputSchema: zodToJsonSchema(GetNamespaceSchema),
-    },
-    {
-        name: "verify_namespace",
-        description: "Verify if a namespace path exists",
-        inputSchema: zodToJsonSchema(VerifyNamespaceSchema),
-    },
-    {
-        name: "get_project",
-        description: "Get details of a specific project",
-        inputSchema: zodToJsonSchema(GetProjectSchema),
-    },
-    {
-        name: "list_projects",
-        description: "List projects accessible by the current user",
-        inputSchema: zodToJsonSchema(ListProjectsSchema),
-    },
-    {
-        name: "list_labels",
-        description: "List labels for a project",
-        inputSchema: zodToJsonSchema(ListLabelsSchema),
-    },
-    {
-        name: "get_label",
-        description: "Get a single label from a project",
-        inputSchema: zodToJsonSchema(GetLabelSchema),
-    },
-    {
-        name: "create_label",
-        description: "Create a new label in a project",
-        inputSchema: zodToJsonSchema(CreateLabelSchema),
-    },
-    {
-        name: "update_label",
-        description: "Update an existing label in a project",
-        inputSchema: zodToJsonSchema(UpdateLabelSchema),
-    },
-    {
-        name: "delete_label",
-        description: "Delete a label from a project",
-        inputSchema: zodToJsonSchema(DeleteLabelSchema),
-    },
-    {
-        name: "list_group_projects",
-        description: "List projects in a GitLab group with filtering options",
-        inputSchema: zodToJsonSchema(ListGroupProjectsSchema),
-    },
-];
-// Define which tools are read-only
-const readOnlyTools = [
-    "search_repositories",
-    "get_file_contents",
-    "get_merge_request",
-    "get_merge_request_diffs",
-    "list_merge_request_discussions",
-    "list_issues",
-    "get_issue",
-    "list_issue_links",
-    "get_issue_link",
-    "list_namespaces",
-    "get_namespace",
-    "verify_namespace",
-    "get_project",
-    "list_projects",
-    "list_labels",
-    "get_label",
-    "list_group_projects",
-];
-/**
- * Smart URL handling for GitLab API
- *
- * @param {string | undefined} url - Input GitLab API URL
- * @returns {string} Normalized GitLab API URL with /api/v4 path
- */
-function normalizeGitLabApiUrl(url) {
-    if (!url) {
-        return "https://gitlab.com/api/v4";
-    }
-    // Remove trailing slash if present
-    let normalizedUrl = url.endsWith("/") ? url.slice(0, -1) : url;
-    // Check if URL already has /api/v4
-    if (!normalizedUrl.endsWith("/api/v4") &&
-        !normalizedUrl.endsWith("/api/v4/")) {
-        // Append /api/v4 if not already present
-        normalizedUrl = `${normalizedUrl}/api/v4`;
-    }
-    return normalizedUrl;
-}
-// Use the normalizeGitLabApiUrl function to handle various URL formats
-const GITLAB_API_URL = normalizeGitLabApiUrl(process.env.GITLAB_API_URL || "");
-if (!GITLAB_PERSONAL_ACCESS_TOKEN) {
-    console.error("GITLAB_PERSONAL_ACCESS_TOKEN environment variable is not set");
-    process.exit(1);
-}
-/**
- * Common headers for GitLab API requests
- */
-const DEFAULT_HEADERS = {
-    Accept: "application/json",
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-};
-/**
- * Utility function for handling GitLab API errors
- *
- * @param {import("node-fetch").Response} response - The response from GitLab API
- * @throws {Error} Throws an error with response details if the request failed
- */
-async function handleGitLabError(response) {
-    if (!response.ok) {
-        const errorBody = await response.text();
-        // Check specifically for Rate Limit error
-        if (response.status === 403 &&
-            errorBody.includes("User API Key Rate limit exceeded")) {
-            console.error("GitLab API Rate Limit Exceeded:", errorBody);
-            console.log("User API Key Rate limit exceeded. Please try again later.");
-            throw new Error(`GitLab API Rate Limit Exceeded: ${errorBody}`);
-        }
-        else {
-            // Handle other API errors
-            throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-        }
-    }
-}
-/**
- * Create a fork of a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {string} [namespace] - The namespace to fork the project to
- * @returns {Promise<GitLabFork>} The created fork
- */
-async function forkProject(projectId, namespace) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/fork`);
-    if (namespace) {
-        url.searchParams.append("namespace", namespace);
-    }
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: DEFAULT_HEADERS,
-    });
-    if (response.status === 409) {
-        throw new Error("Project already exists in the target namespace");
-    }
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabForkSchema.parse(data);
-}
-/**
- * Create a new branch in a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {z.infer<typeof CreateBranchOptionsSchema>} options - Branch creation options
- * @returns {Promise<GitLabReference>} The created branch reference
- */
-async function createBranch(projectId, options) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/repository/branches`);
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify({
-            branch: options.name,
-            ref: options.ref,
-        }),
-    });
-    await handleGitLabError(response);
-    return GitLabReferenceSchema.parse(await response.json());
-}
-/**
- * Get the default branch for a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @returns {Promise<string>} The name of the default branch
- */
-async function getDefaultBranchRef(projectId) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}`);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const project = GitLabRepositorySchema.parse(await response.json());
-    return project.default_branch ?? "main";
-}
-/**
- * Get the contents of a file from a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {string} filePath - The path of the file to get
- * @param {string} [ref] - The name of the branch, tag or commit
- * @returns {Promise<GitLabContent>} The file content
- */
-async function getFileContents(projectId, filePath, ref) {
-    const encodedPath = encodeURIComponent(filePath);
-    if (!ref) {
-        ref = await getDefaultBranchRef(projectId);
-    }
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/repository/files/${encodedPath}`);
-    url.searchParams.append("ref", ref);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    if (response.status === 404) {
-        throw new Error(`File not found: ${filePath}`);
-    }
-    await handleGitLabError(response);
-    const data = await response.json();
-    const parsedData = GitLabContentSchema.parse(data);
-    if (!Array.isArray(parsedData) && parsedData.content) {
-        parsedData.content = Buffer.from(parsedData.content, "base64").toString("utf8");
-        parsedData.encoding = "utf8";
-    }
-    return parsedData;
-}
-/**
- * Create a new issue in a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {z.infer<typeof CreateIssueOptionsSchema>} options - Issue creation options
- * @returns {Promise<GitLabIssue>} The created issue
- */
-async function createIssue(projectId, options) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues`);
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify({
-            title: options.title,
-            description: options.description,
-            assignee_ids: options.assignee_ids,
-            milestone_id: options.milestone_id,
-            labels: options.labels?.join(","),
-        }),
-    });
-    if (response.status === 400) {
-        const errorBody = await response.text();
-        throw new Error(`Invalid request: ${errorBody}`);
-    }
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabIssueSchema.parse(data);
-}
-/**
- * List issues in a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {Object} options - Options for listing issues
- * @returns {Promise<GitLabIssue[]>} List of issues
- */
-async function listIssues(projectId, options = {}) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues`);
-    // Add all query parameters
-    Object.entries(options).forEach(([key, value]) => {
-        if (value !== undefined) {
-            if (key === "label_name" && Array.isArray(value)) {
-                // Handle array of labels
-                url.searchParams.append(key, value.join(","));
-            }
-            else {
-                url.searchParams.append(key, value.toString());
-            }
-        }
-    });
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return z.array(GitLabIssueSchema).parse(data);
-}
-/**
- * Get a single issue from a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} issueIid - The internal ID of the project issue
- * @returns {Promise<GitLabIssue>} The issue
- */
-async function getIssue(projectId, issueIid) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues/${issueIid}`);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabIssueSchema.parse(data);
-}
-/**
- * Update an issue in a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} issueIid - The internal ID of the project issue
- * @param {Object} options - Update options for the issue
- * @returns {Promise<GitLabIssue>} The updated issue
- */
-async function updateIssue(projectId, issueIid, options) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues/${issueIid}`);
-    // Convert labels array to comma-separated string if present
-    const body = { ...options };
-    if (body.labels && Array.isArray(body.labels)) {
-        body.labels = body.labels.join(",");
-    }
-    const response = await fetch(url.toString(), {
-        method: "PUT",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify(body),
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabIssueSchema.parse(data);
-}
-/**
- * Delete an issue from a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} issueIid - The internal ID of the project issue
- * @returns {Promise<void>}
- */
-async function deleteIssue(projectId, issueIid) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues/${issueIid}`);
-    const response = await fetch(url.toString(), {
-        method: "DELETE",
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-}
-/**
- * List all issue links for a specific issue
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} issueIid - The internal ID of the project issue
- * @returns {Promise<GitLabIssueWithLinkDetails[]>} List of issues with link details
- */
-async function listIssueLinks(projectId, issueIid) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues/${issueIid}/links`);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return z.array(GitLabIssueWithLinkDetailsSchema).parse(data);
-}
-/**
- * Get a specific issue link
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} issueIid - The internal ID of the project issue
- * @param {number} issueLinkId - The ID of the issue link
- * @returns {Promise<GitLabIssueLink>} The issue link
- */
-async function getIssueLink(projectId, issueIid, issueLinkId) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues/${issueIid}/links/${issueLinkId}`);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabIssueLinkSchema.parse(data);
-}
-/**
- * Create an issue link between two issues
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} issueIid - The internal ID of the project issue
- * @param {string} targetProjectId - The ID or URL-encoded path of the target project
- * @param {number} targetIssueIid - The internal ID of the target project issue
- * @param {string} linkType - The type of the relation (relates_to, blocks, is_blocked_by)
- * @returns {Promise<GitLabIssueLink>} The created issue link
- */
-async function createIssueLink(projectId, issueIid, targetProjectId, targetIssueIid, linkType = "relates_to") {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues/${issueIid}/links`);
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify({
-            target_project_id: targetProjectId,
-            target_issue_iid: targetIssueIid,
-            link_type: linkType,
-        }),
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabIssueLinkSchema.parse(data);
-}
-/**
- * Delete an issue link
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} issueIid - The internal ID of the project issue
- * @param {number} issueLinkId - The ID of the issue link
- * @returns {Promise<void>}
- */
-async function deleteIssueLink(projectId, issueIid, issueLinkId) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/issues/${issueIid}/links/${issueLinkId}`);
-    const response = await fetch(url.toString(), {
-        method: "DELETE",
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-}
-/**
- * Create a new merge request in a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {z.infer<typeof CreateMergeRequestOptionsSchema>} options - Merge request creation options
- * @returns {Promise<GitLabMergeRequest>} The created merge request
- */
-async function createMergeRequest(projectId, options) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/merge_requests`);
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-        },
-        body: JSON.stringify({
-            title: options.title,
-            description: options.description,
-            source_branch: options.source_branch,
-            target_branch: options.target_branch,
-            allow_collaboration: options.allow_collaboration,
-            draft: options.draft,
-        }),
-    });
-    if (response.status === 400) {
-        const errorBody = await response.text();
-        throw new Error(`Invalid request: ${errorBody}`);
-    }
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-    }
-    const data = await response.json();
-    return GitLabMergeRequestSchema.parse(data);
-}
-/**
- * List merge request discussion items
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} mergeRequestIid - The IID of a merge request
- * @returns {Promise<GitLabDiscussion[]>} List of discussions
- */
-async function listMergeRequestDiscussions(projectId, mergeRequestIid) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/merge_requests/${mergeRequestIid}/discussions`);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    // Ensure the response is parsed as an array of discussions
-    return z.array(GitLabDiscussionSchema).parse(data);
-}
-/**
- * Modify an existing merge request thread note
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} mergeRequestIid - The IID of a merge request
- * @param {string} discussionId - The ID of a thread
- * @param {number} noteId - The ID of a thread note
- * @param {string} body - The new content of the note
- * @param {boolean} [resolved] - Resolve/unresolve state
- * @returns {Promise<GitLabDiscussionNote>} The updated note
- */
-async function updateMergeRequestNote(projectId, mergeRequestIid, discussionId, noteId, body, resolved) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/merge_requests/${mergeRequestIid}/discussions/${discussionId}/notes/${noteId}`);
-    const payload = { body };
-    if (resolved !== undefined) {
-        payload.resolved = resolved;
-    }
-    const response = await fetch(url.toString(), {
-        method: "PUT",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify(payload),
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabDiscussionNoteSchema.parse(data);
-}
-/**
- * Create or update a file in a GitLab project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {string} filePath - The path of the file to create or update
- * @param {string} content - The content of the file
- * @param {string} commitMessage - The commit message
- * @param {string} branch - The branch name
- * @param {string} [previousPath] - The previous path of the file in case of rename
- * @returns {Promise<GitLabCreateUpdateFileResponse>} The file update response
- */
-async function createOrUpdateFile(projectId, filePath, content, commitMessage, branch, previousPath, last_commit_id, commit_id) {
-    const encodedPath = encodeURIComponent(filePath);
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/repository/files/${encodedPath}`);
-    const body = {
-        branch,
-        content,
-        commit_message: commitMessage,
-        encoding: "text",
-        ...(previousPath ? { previous_path: previousPath } : {}),
-    };
-    // Check if file exists
-    let method = "POST";
-    try {
-        // Get file contents to check existence and retrieve commit IDs
-        const fileData = await getFileContents(projectId, filePath, branch);
-        method = "PUT";
-        // If fileData is not an array, it's a file content object with commit IDs
-        if (!Array.isArray(fileData)) {
-            // Use commit IDs from the file data if not provided in parameters
-            if (!commit_id && fileData.commit_id) {
-                body.commit_id = fileData.commit_id;
-            }
-            else if (commit_id) {
-                body.commit_id = commit_id;
-            }
-            if (!last_commit_id && fileData.last_commit_id) {
-                body.last_commit_id = fileData.last_commit_id;
-            }
-            else if (last_commit_id) {
-                body.last_commit_id = last_commit_id;
-            }
-        }
-    }
-    catch (error) {
-        if (!(error instanceof Error && error.message.includes("File not found"))) {
-            throw error;
-        }
-        // File doesn't exist, use POST - no need for commit IDs for new files
-        // But still use any provided as parameters if they exist
-        if (commit_id) {
-            body.commit_id = commit_id;
-        }
-        if (last_commit_id) {
-            body.last_commit_id = last_commit_id;
-        }
-    }
-    const response = await fetch(url.toString(), {
-        method,
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-        },
-        body: JSON.stringify(body),
-    });
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-    }
-    const data = await response.json();
-    return GitLabCreateUpdateFileResponseSchema.parse(data);
-}
-/**
- * Create a tree structure in a GitLab project repository
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {FileOperation[]} files - Array of file operations
- * @param {string} [ref] - The name of the branch, tag or commit
- * @returns {Promise<GitLabTree>} The created tree
- */
-async function createTree(projectId, files, ref) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/repository/tree`);
-    if (ref) {
-        url.searchParams.append("ref", ref);
-    }
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-        },
-        body: JSON.stringify({
-            files: files.map((file) => ({
-                file_path: file.path,
-                content: file.content,
-                encoding: "text",
-            })),
-        }),
-    });
-    if (response.status === 400) {
-        const errorBody = await response.text();
-        throw new Error(`Invalid request: ${errorBody}`);
-    }
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-    }
-    const data = await response.json();
-    return GitLabTreeSchema.parse(data);
-}
-/**
- * Create a commit in a GitLab project repository
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {string} message - The commit message
- * @param {string} branch - The branch name
- * @param {FileOperation[]} actions - Array of file operations for the commit
- * @returns {Promise<GitLabCommit>} The created commit
- */
-async function createCommit(projectId, message, branch, actions) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/repository/commits`);
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-        },
-        body: JSON.stringify({
-            branch,
-            commit_message: message,
-            actions: actions.map((action) => ({
-                action: "create",
-                file_path: action.path,
-                content: action.content,
-                encoding: "text",
-            })),
-        }),
-    });
-    if (response.status === 400) {
-        const errorBody = await response.text();
-        throw new Error(`Invalid request: ${errorBody}`);
-    }
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-    }
-    const data = await response.json();
-    return GitLabCommitSchema.parse(data);
-}
-/**
- * Search for GitLab projects
- * 프로젝트 검색
- *
- * @param {string} query - The search query
- * @param {number} [page=1] - The page number
- * @param {number} [perPage=20] - Number of items per page
- * @returns {Promise<GitLabSearchResponse>} The search results
- */
-async function searchProjects(query, page = 1, perPage = 20) {
-    const url = new URL(`${GITLAB_API_URL}/projects`);
-    url.searchParams.append("search", query);
-    url.searchParams.append("page", page.toString());
-    url.searchParams.append("per_page", perPage.toString());
-    url.searchParams.append("order_by", "id");
-    url.searchParams.append("sort", "desc");
-    const response = await fetch(url.toString(), {
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-        },
-    });
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-    }
-    const projects = (await response.json());
-    const totalCount = response.headers.get("x-total");
-    const totalPages = response.headers.get("x-total-pages");
-    // GitLab API doesn't return these headers for results > 10,000
-    const count = totalCount ? parseInt(totalCount) : projects.length;
-    return GitLabSearchResponseSchema.parse({
-        count,
-        total_pages: totalPages ? parseInt(totalPages) : Math.ceil(count / perPage),
-        current_page: page,
-        items: projects,
-    });
-}
-/**
- * Create a new GitLab repository
- * 새 저장소 생성
- *
- * @param {z.infer<typeof CreateRepositoryOptionsSchema>} options - Repository creation options
- * @returns {Promise<GitLabRepository>} The created repository
- */
-async function createRepository(options) {
-    const response = await fetch(`${GITLAB_API_URL}/projects`, {
-        method: "POST",
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`,
-        },
-        body: JSON.stringify({
-            name: options.name,
-            description: options.description,
-            visibility: options.visibility,
-            initialize_with_readme: options.initialize_with_readme,
-            default_branch: "main",
-            path: options.name.toLowerCase().replace(/\s+/g, "-"),
-        }),
-    });
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
-    }
-    const data = await response.json();
-    return GitLabRepositorySchema.parse(data);
-}
-/**
- * Get merge request details
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} mergeRequestIid - The internal ID of the merge request
- * @returns {Promise<GitLabMergeRequest>} The merge request details
- */
-async function getMergeRequest(projectId, mergeRequestIid) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/merge_requests/${mergeRequestIid}`);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    return GitLabMergeRequestSchema.parse(await response.json());
-}
-/**
- * Get merge request changes/diffs
- * MR 변경사항 조회 함수 (Function to retrieve merge request changes)
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} mergeRequestIid - The internal ID of the merge request
- * @param {string} [view] - The view type for the diff (inline or parallel)
- * @returns {Promise<GitLabMergeRequestDiff[]>} The merge request diffs
- */
-async function getMergeRequestDiffs(projectId, mergeRequestIid, view) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/merge_requests/${mergeRequestIid}/changes`);
-    if (view) {
-        url.searchParams.append("view", view);
-    }
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = (await response.json());
-    return z.array(GitLabMergeRequestDiffSchema).parse(data.changes);
-}
-/**
- * Update a merge request
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {number} mergeRequestIid - The internal ID of the merge request
- * @param {Object} options - The update options
- * @returns {Promise<GitLabMergeRequest>} The updated merge request
- */
-async function updateMergeRequest(projectId, mergeRequestIid, options) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/merge_requests/${mergeRequestIid}`);
-    const response = await fetch(url.toString(), {
-        method: "PUT",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify(options),
-    });
-    await handleGitLabError(response);
-    return GitLabMergeRequestSchema.parse(await response.json());
-}
-/**
- * Create a new note (comment) on an issue or merge request
- * (New function: createNote - Function to add a note (comment) to an issue or merge request)
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {"issue" | "merge_request"} noteableType - The type of the item to add a note to (issue or merge_request)
- * @param {number} noteableIid - The internal ID of the issue or merge request
- * @param {string} body - The content of the note
- * @returns {Promise<any>} The created note
- */
-async function createNote(projectId, noteableType, noteableIid, body) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/${noteableType}s/${noteableIid}/notes` // Using plural form (issues/merge_requests) as per GitLab API documentation
-    );
-    const response = await fetch(url.toString(), {
-        method: "POST",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify({ body }),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
-    }
-    return await response.json();
-}
-/**
- * List all namespaces
- *
- * @param {Object} options - Options for listing namespaces
- * @param {string} [options.search] - Search query to filter namespaces
- * @param {boolean} [options.owned_only] - Only return namespaces owned by the authenticated user
- * @param {boolean} [options.top_level_only] - Only return top-level namespaces
- * @returns {Promise<GitLabNamespace[]>} List of namespaces
- */
-async function listNamespaces(options) {
-    const url = new URL(`${GITLAB_API_URL}/namespaces`);
-    if (options.search) {
-        url.searchParams.append("search", options.search);
-    }
-    if (options.owned_only) {
-        url.searchParams.append("owned_only", "true");
-    }
-    if (options.top_level_only) {
-        url.searchParams.append("top_level_only", "true");
-    }
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return z.array(GitLabNamespaceSchema).parse(data);
-}
-/**
- * Get details on a namespace
- *
- * @param {string} id - The ID or URL-encoded path of the namespace
- * @returns {Promise<GitLabNamespace>} The namespace details
- */
-async function getNamespace(id) {
-    const url = new URL(`${GITLAB_API_URL}/namespaces/${encodeURIComponent(id)}`);
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabNamespaceSchema.parse(data);
-}
-/**
- * Verify if a namespace exists
- *
- * @param {string} namespacePath - The path of the namespace to check
- * @param {number} [parentId] - The ID of the parent namespace
- * @returns {Promise<GitLabNamespaceExistsResponse>} The verification result
- */
-async function verifyNamespaceExistence(namespacePath, parentId) {
-    const url = new URL(`${GITLAB_API_URL}/namespaces/${encodeURIComponent(namespacePath)}/exists`);
-    if (parentId) {
-        url.searchParams.append("parent_id", parentId.toString());
-    }
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabNamespaceExistsResponseSchema.parse(data);
-}
-/**
- * Get a single project
- *
- * @param {string} projectId - The ID or URL-encoded path of the project
- * @param {Object} options - Options for getting project details
- * @param {boolean} [options.license] - Include project license data
- * @param {boolean} [options.statistics] - Include project statistics
- * @param {boolean} [options.with_custom_attributes] - Include custom attributes in response
- * @returns {Promise<GitLabProject>} Project details
- */
-async function getProject(projectId, options = {}) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}`);
-    if (options.license) {
-        url.searchParams.append("license", "true");
-    }
-    if (options.statistics) {
-        url.searchParams.append("statistics", "true");
-    }
-    if (options.with_custom_attributes) {
-        url.searchParams.append("with_custom_attributes", "true");
-    }
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const data = await response.json();
-    return GitLabRepositorySchema.parse(data);
-}
-/**
- * List projects
- *
- * @param {Object} options - Options for listing projects
- * @returns {Promise<GitLabProject[]>} List of projects
- */
-async function listProjects(options = {}) {
-    // Construct the query parameters
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(options)) {
-        if (value !== undefined && value !== null) {
-            if (typeof value === "boolean") {
-                params.append(key, value ? "true" : "false");
-            }
-            else {
-                params.append(key, String(value));
-            }
-        }
-    }
-    // Make the API request
-    const response = await fetch(`${GITLAB_API_URL}/projects?${params.toString()}`, {
-        method: "GET",
-        headers: DEFAULT_HEADERS,
-    });
-    // Handle errors
-    await handleGitLabError(response);
-    // Parse and return the data
-    const data = await response.json();
-    return z.array(GitLabProjectSchema).parse(data);
-}
-/**
- * List labels for a project
- *
- * @param projectId The ID or URL-encoded path of the project
- * @param options Optional parameters for listing labels
- * @returns Array of GitLab labels
- */
-async function listLabels(projectId, options = {}) {
-    // Construct the URL with project path
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/labels`);
-    // Add query parameters
-    Object.entries(options).forEach(([key, value]) => {
-        if (value !== undefined) {
-            if (typeof value === "boolean") {
-                url.searchParams.append(key, value ? "true" : "false");
-            }
-            else {
-                url.searchParams.append(key, String(value));
-            }
-        }
-    });
-    // Make the API request
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    // Handle errors
-    await handleGitLabError(response);
-    // Parse and return the data
-    const data = await response.json();
-    return data;
-}
-/**
- * Get a single label from a project
- *
- * @param projectId The ID or URL-encoded path of the project
- * @param labelId The ID or name of the label
- * @param includeAncestorGroups Whether to include ancestor groups
- * @returns GitLab label
- */
-async function getLabel(projectId, labelId, includeAncestorGroups) {
-    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/labels/${encodeURIComponent(String(labelId))}`);
-    // Add query parameters
-    if (includeAncestorGroups !== undefined) {
-        url.searchParams.append("include_ancestor_groups", includeAncestorGroups ? "true" : "false");
-    }
-    // Make the API request
-    const response = await fetch(url.toString(), {
-        headers: DEFAULT_HEADERS,
-    });
-    // Handle errors
-    await handleGitLabError(response);
-    // Parse and return the data
-    const data = await response.json();
-    return data;
-}
-/**
- * Create a new label in a project
- *
- * @param projectId The ID or URL-encoded path of the project
- * @param options Options for creating the label
- * @returns Created GitLab label
- */
-async function createLabel(projectId, options) {
-    // Make the API request
-    const response = await fetch(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/labels`, {
-        method: "POST",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify(options),
-    });
-    // Handle errors
-    await handleGitLabError(response);
-    // Parse and return the data
-    const data = await response.json();
-    return data;
-}
-/**
- * Update an existing label in a project
- *
- * @param projectId The ID or URL-encoded path of the project
- * @param labelId The ID or name of the label to update
- * @param options Options for updating the label
- * @returns Updated GitLab label
- */
-async function updateLabel(projectId, labelId, options) {
-    // Make the API request
-    const response = await fetch(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/labels/${encodeURIComponent(String(labelId))}`, {
-        method: "PUT",
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify(options),
-    });
-    // Handle errors
-    await handleGitLabError(response);
-    // Parse and return the data
-    const data = await response.json();
-    return data;
-}
-/**
- * Delete a label from a project
- *
- * @param projectId The ID or URL-encoded path of the project
- * @param labelId The ID or name of the label to delete
- */
-async function deleteLabel(projectId, labelId) {
-    // Make the API request
-    const response = await fetch(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/labels/${encodeURIComponent(String(labelId))}`, {
-        method: "DELETE",
-        headers: DEFAULT_HEADERS,
-    });
-    // Handle errors
-    await handleGitLabError(response);
-}
-/**
- * List all projects in a GitLab group
- *
- * @param {z.infer<typeof ListGroupProjectsSchema>} options - Options for listing group projects
- * @returns {Promise<GitLabProject[]>} Array of projects in the group
- */
-async function listGroupProjects(options) {
-    const url = new URL(`${GITLAB_API_URL}/groups/${encodeURIComponent(options.group_id)}/projects`);
-    // Add optional parameters to URL
-    if (options.include_subgroups)
-        url.searchParams.append("include_subgroups", "true");
-    if (options.search)
-        url.searchParams.append("search", options.search);
-    if (options.order_by)
-        url.searchParams.append("order_by", options.order_by);
-    if (options.sort)
-        url.searchParams.append("sort", options.sort);
-    if (options.page)
-        url.searchParams.append("page", options.page.toString());
-    if (options.per_page)
-        url.searchParams.append("per_page", options.per_page.toString());
-    if (options.archived !== undefined)
-        url.searchParams.append("archived", options.archived.toString());
-    if (options.visibility)
-        url.searchParams.append("visibility", options.visibility);
-    if (options.with_issues_enabled !== undefined)
-        url.searchParams.append("with_issues_enabled", options.with_issues_enabled.toString());
-    if (options.with_merge_requests_enabled !== undefined)
-        url.searchParams.append("with_merge_requests_enabled", options.with_merge_requests_enabled.toString());
-    if (options.min_access_level !== undefined)
-        url.searchParams.append("min_access_level", options.min_access_level.toString());
-    if (options.with_programming_language)
-        url.searchParams.append("with_programming_language", options.with_programming_language);
-    if (options.starred !== undefined)
-        url.searchParams.append("starred", options.starred.toString());
-    if (options.statistics !== undefined)
-        url.searchParams.append("statistics", options.statistics.toString());
-    if (options.with_custom_attributes !== undefined)
-        url.searchParams.append("with_custom_attributes", options.with_custom_attributes.toString());
-    if (options.with_security_reports !== undefined)
-        url.searchParams.append("with_security_reports", options.with_security_reports.toString());
-    const response = await fetch(url.toString(), {
-        method: "GET",
-        headers: DEFAULT_HEADERS,
-    });
-    await handleGitLabError(response);
-    const projects = await response.json();
-    return GitLabProjectSchema.array().parse(projects);
-}
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    // If read-only mode is enabled, filter out write operations
-    const tools = GITLAB_READ_ONLY_MODE
-        ? allTools.filter((tool) => readOnlyTools.includes(tool.name))
-        : allTools;
-    return {
-        tools,
-    };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    try {
-        if (!request.params.arguments) {
-            throw new Error("Arguments are required");
-        }
-        switch (request.params.name) {
-            case "fork_repository": {
-                const forkArgs = ForkRepositorySchema.parse(request.params.arguments);
-                try {
-                    const forkedProject = await forkProject(forkArgs.project_id, forkArgs.namespace);
-                    return {
-                        content: [
-                            { type: "text", text: JSON.stringify(forkedProject, null, 2) },
-                        ],
-                    };
-                }
-                catch (forkError) {
-                    console.error("Error forking repository:", forkError);
-                    let forkErrorMessage = "Failed to fork repository";
-                    if (forkError instanceof Error) {
-                        forkErrorMessage = `${forkErrorMessage}: ${forkError.message}`;
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({ error: forkErrorMessage }, null, 2),
-                            },
-                        ],
-                    };
-                }
-            }
-            case "create_branch": {
-                const args = CreateBranchSchema.parse(request.params.arguments);
-                let ref = args.ref;
-                if (!ref) {
-                    ref = await getDefaultBranchRef(args.project_id);
-                }
-                const branch = await createBranch(args.project_id, {
-                    name: args.branch,
-                    ref,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(branch, null, 2) }],
-                };
-            }
-            case "search_repositories": {
-                const args = SearchRepositoriesSchema.parse(request.params.arguments);
-                const results = await searchProjects(args.search, args.page, args.per_page);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-                };
-            }
-            case "create_repository": {
-                const args = CreateRepositorySchema.parse(request.params.arguments);
-                const repository = await createRepository(args);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(repository, null, 2) },
-                    ],
-                };
-            }
-            case "get_file_contents": {
-                const args = GetFileContentsSchema.parse(request.params.arguments);
-                const contents = await getFileContents(args.project_id, args.file_path, args.ref);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(contents, null, 2) }],
-                };
-            }
-            case "create_or_update_file": {
-                const args = CreateOrUpdateFileSchema.parse(request.params.arguments);
-                const result = await createOrUpdateFile(args.project_id, args.file_path, args.content, args.commit_message, args.branch, args.previous_path, args.last_commit_id, args.commit_id);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case "push_files": {
-                const args = PushFilesSchema.parse(request.params.arguments);
-                const result = await createCommit(args.project_id, args.commit_message, args.branch, args.files.map((f) => ({ path: f.file_path, content: f.content })));
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
-            }
-            case "create_issue": {
-                const args = CreateIssueSchema.parse(request.params.arguments);
-                const { project_id, ...options } = args;
-                const issue = await createIssue(project_id, options);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
-                };
-            }
-            case "create_merge_request": {
-                const args = CreateMergeRequestSchema.parse(request.params.arguments);
-                const { project_id, ...options } = args;
-                const mergeRequest = await createMergeRequest(project_id, options);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(mergeRequest, null, 2) },
-                    ],
-                };
-            }
-            case "update_merge_request_note": {
-                const args = UpdateMergeRequestNoteSchema.parse(request.params.arguments);
-                const note = await updateMergeRequestNote(args.project_id, args.merge_request_iid, args.discussion_id, args.note_id, args.body, args.resolved // Pass resolved if provided
-                );
-                return {
-                    content: [{ type: "text", text: JSON.stringify(note, null, 2) }],
-                };
-            }
-            case "get_merge_request": {
-                const args = GetMergeRequestSchema.parse(request.params.arguments);
-                const mergeRequest = await getMergeRequest(args.project_id, args.merge_request_iid);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(mergeRequest, null, 2) },
-                    ],
-                };
-            }
-            case "get_merge_request_diffs": {
-                const args = GetMergeRequestDiffsSchema.parse(request.params.arguments);
-                const diffs = await getMergeRequestDiffs(args.project_id, args.merge_request_iid, args.view);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(diffs, null, 2) }],
-                };
-            }
-            case "update_merge_request": {
-                const args = UpdateMergeRequestSchema.parse(request.params.arguments);
-                const { project_id, merge_request_iid, ...options } = args;
-                const mergeRequest = await updateMergeRequest(project_id, merge_request_iid, options);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(mergeRequest, null, 2) },
-                    ],
-                };
-            }
-            case "list_merge_request_discussions": {
-                const args = ListMergeRequestDiscussionsSchema.parse(request.params.arguments);
-                const discussions = await listMergeRequestDiscussions(args.project_id, args.merge_request_iid);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(discussions, null, 2) },
-                    ],
-                };
-            }
-            case "list_namespaces": {
-                const args = ListNamespacesSchema.parse(request.params.arguments);
-                const url = new URL(`${GITLAB_API_URL}/namespaces`);
-                if (args.search) {
-                    url.searchParams.append("search", args.search);
-                }
-                if (args.page) {
-                    url.searchParams.append("page", args.page.toString());
-                }
-                if (args.per_page) {
-                    url.searchParams.append("per_page", args.per_page.toString());
-                }
-                if (args.owned) {
-                    url.searchParams.append("owned", args.owned.toString());
-                }
-                const response = await fetch(url.toString(), {
-                    headers: DEFAULT_HEADERS,
-                });
-                await handleGitLabError(response);
-                const data = await response.json();
-                const namespaces = z.array(GitLabNamespaceSchema).parse(data);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(namespaces, null, 2) },
-                    ],
-                };
-            }
-            case "get_namespace": {
-                const args = GetNamespaceSchema.parse(request.params.arguments);
-                const url = new URL(`${GITLAB_API_URL}/namespaces/${encodeURIComponent(args.namespace_id)}`);
-                const response = await fetch(url.toString(), {
-                    headers: DEFAULT_HEADERS,
-                });
-                await handleGitLabError(response);
-                const data = await response.json();
-                const namespace = GitLabNamespaceSchema.parse(data);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(namespace, null, 2) }],
-                };
-            }
-            case "verify_namespace": {
-                const args = VerifyNamespaceSchema.parse(request.params.arguments);
-                const url = new URL(`${GITLAB_API_URL}/namespaces/${encodeURIComponent(args.path)}/exists`);
-                const response = await fetch(url.toString(), {
-                    headers: DEFAULT_HEADERS,
-                });
-                await handleGitLabError(response);
-                const data = await response.json();
-                const namespaceExists = GitLabNamespaceExistsResponseSchema.parse(data);
-                return {
-                    content: [
-                        { type: "text", text: JSON.stringify(namespaceExists, null, 2) },
-                    ],
-                };
-            }
-            case "get_project": {
-                const args = GetProjectSchema.parse(request.params.arguments);
-                const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(args.project_id)}`);
-                const response = await fetch(url.toString(), {
-                    headers: DEFAULT_HEADERS,
-                });
-                await handleGitLabError(response);
-                const data = await response.json();
-                const project = GitLabProjectSchema.parse(data);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(project, null, 2) }],
-                };
-            }
-            case "list_projects": {
-                const args = ListProjectsSchema.parse(request.params.arguments);
-                const projects = await listProjects(args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(projects, null, 2) }],
-                };
-            }
-            case "create_note": {
-                const args = CreateNoteSchema.parse(request.params.arguments);
-                const { project_id, noteable_type, noteable_iid, body } = args;
-                const note = await createNote(project_id, noteable_type, noteable_iid, body);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(note, null, 2) }],
-                };
-            }
-            case "list_issues": {
-                const args = ListIssuesSchema.parse(request.params.arguments);
-                const { project_id, ...options } = args;
-                const issues = await listIssues(project_id, options);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(issues, null, 2) }],
-                };
-            }
-            case "get_issue": {
-                const args = GetIssueSchema.parse(request.params.arguments);
-                const issue = await getIssue(args.project_id, args.issue_iid);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
-                };
-            }
-            case "update_issue": {
-                const args = UpdateIssueSchema.parse(request.params.arguments);
-                const { project_id, issue_iid, ...options } = args;
-                const issue = await updateIssue(project_id, issue_iid, options);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
-                };
-            }
-            case "delete_issue": {
-                const args = DeleteIssueSchema.parse(request.params.arguments);
-                await deleteIssue(args.project_id, args.issue_iid);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({ status: "success", message: "Issue deleted successfully" }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case "list_issue_links": {
-                const args = ListIssueLinksSchema.parse(request.params.arguments);
-                const links = await listIssueLinks(args.project_id, args.issue_iid);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(links, null, 2) }],
-                };
-            }
-            case "get_issue_link": {
-                const args = GetIssueLinkSchema.parse(request.params.arguments);
-                const link = await getIssueLink(args.project_id, args.issue_iid, args.issue_link_id);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(link, null, 2) }],
-                };
-            }
-            case "create_issue_link": {
-                const args = CreateIssueLinkSchema.parse(request.params.arguments);
-                const link = await createIssueLink(args.project_id, args.issue_iid, args.target_project_id, args.target_issue_iid, args.link_type);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(link, null, 2) }],
-                };
-            }
-            case "delete_issue_link": {
-                const args = DeleteIssueLinkSchema.parse(request.params.arguments);
-                await deleteIssueLink(args.project_id, args.issue_iid, args.issue_link_id);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                status: "success",
-                                message: "Issue link deleted successfully",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case "list_labels": {
-                const args = ListLabelsSchema.parse(request.params.arguments);
-                const labels = await listLabels(args.project_id, args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(labels, null, 2) }],
-                };
-            }
-            case "get_label": {
-                const args = GetLabelSchema.parse(request.params.arguments);
-                const label = await getLabel(args.project_id, args.label_id, args.include_ancestor_groups);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(label, null, 2) }],
-                };
-            }
-            case "create_label": {
-                const args = CreateLabelSchema.parse(request.params.arguments);
-                const label = await createLabel(args.project_id, args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(label, null, 2) }],
-                };
-            }
-            case "update_label": {
-                const args = UpdateLabelSchema.parse(request.params.arguments);
-                const { project_id, label_id, ...options } = args;
-                const label = await updateLabel(project_id, label_id, options);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(label, null, 2) }],
-                };
-            }
-            case "delete_label": {
-                const args = DeleteLabelSchema.parse(request.params.arguments);
-                await deleteLabel(args.project_id, args.label_id);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({ status: "success", message: "Label deleted successfully" }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case "list_group_projects": {
-                const args = ListGroupProjectsSchema.parse(request.params.arguments);
-                const projects = await listGroupProjects(args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(projects, null, 2) }],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${request.params.name}`);
-        }
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            throw new Error(`Invalid arguments: ${error.errors
-                .map((e) => `${e.path.join(".")}: ${e.message}`)
-                .join(", ")}`);
-        }
-        throw error;
-    }
-});
-/**
- * Initialize and run the server
- */
-async function runServer() {
-    if (isSSE) {
-        const app = express();
-        let transport;
-        app.get("/sse", async (req, res) => {
-            console.log("Establishing new SSE connection");
-            transport = new SSEServerTransport("/messages", res);
-            await server.connect(transport);
-        });
-        app.post("/messages", async (req, res) => {
-            await transport?.handlePostMessage(req, res);
-        });
-        app.listen(port, () => {
-            console.log(`HTTP server listening on port ${port}`);
-            console.log(`SSE endpoint available at http://localhost:${port}/sse`);
-            console.log(`Message endpoint available at http://localhost:${port}/messages`);
-        });
-    }
-    else {
-        try {
-            console.error("========================");
-            console.error(`GitLab MCP Server v${SERVER_VERSION}`);
-            console.error(`API URL: ${GITLAB_API_URL}`);
-            console.error("========================");
-            const transport = new StdioServerTransport();
-            await server.connect(transport);
-            console.error("GitLab MCP Server running on stdio");
-        }
-        catch (error) {
-            console.error("Error initializing server:", error);
-            process.exit(1);
-        }
-    }
-}
-runServer().catch((error) => {
-    console.error("Fatal error in main():", error);
-    process.exit(1);
-});