gd-gitlab-mcp 0.1.0

package/dist/services/gitlab.service.js

@@ -0,0 +1,477 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLabService = exports.GitLabApiError = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../utils");
+// ─── Error types ─────────────────────────────────────────────────────────────
+class GitLabApiError extends Error {
+    constructor(message, status, detail) {
+        super(message);
+        this.status = status;
+        this.detail = detail;
+        this.name = 'GitLabApiError';
+    }
+}
+exports.GitLabApiError = GitLabApiError;
+function mapAxiosError(error) {
+    const status = error.response?.status;
+    const data = error.response?.data;
+    const detail = typeof data?.message === 'string' ? data.message :
+        typeof data?.error === 'string' ? data.error :
+            error.message;
+    if (status === 401)
+        throw new GitLabApiError('Authentication failed — check your GitLab PAT', 401, detail);
+    if (status === 403)
+        throw new GitLabApiError('Access denied — token lacks required permissions', 403, detail);
+    if (status === 404)
+        throw new GitLabApiError('Resource not found on GitLab', 404, detail);
+    if (status === 409)
+        throw new GitLabApiError('Conflict — resource already exists or state mismatch', 409, detail);
+    if (status === 422)
+        throw new GitLabApiError(`Unprocessable entity: ${detail}`, 422, detail);
+    if (status === 429) {
+        const retryAfter = error.response?.headers?.['retry-after'];
+        const suffix = retryAfter ? ` Retry after ${retryAfter}s.` : '';
+        throw new GitLabApiError(`Rate limit exceeded.${suffix}`, 429, detail);
+    }
+    if (status && status >= 500)
+        throw new GitLabApiError(`GitLab server error (${status})`, status, detail);
+    if (error.code === 'ECONNABORTED' || error.code === 'ERR_CANCELED') {
+        throw new GitLabApiError('Request timed out', 408, detail);
+    }
+    throw new GitLabApiError(`Request failed: ${error.message}`, status ?? 0, detail);
+}
+// ─── Retry with exponential backoff ──────────────────────────────────────────
+const RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+async function withRetry(label, fn, maxAttempts = 3) {
+    let lastErr;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            const retryable = err instanceof GitLabApiError && RETRYABLE_STATUSES.has(err.status);
+            if (!retryable || attempt === maxAttempts - 1)
+                throw err;
+            const delay = Math.min(500 * 2 ** attempt, 8000);
+            (0, utils_1.logger)('warn', `${label}: retryable error on attempt ${attempt + 1}/${maxAttempts}, retrying in ${delay}ms`, err.message);
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    throw lastErr;
+}
+class TTLCache {
+    constructor(ttlMs) {
+        this.ttlMs = ttlMs;
+        this.store = new Map();
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry || Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        this.store.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+    }
+    invalidate(key) {
+        this.store.delete(key);
+    }
+}
+// ─── In-flight request deduplicator ──────────────────────────────────────────
+class Deduplicator {
+    constructor() {
+        this.inflight = new Map();
+    }
+    run(key, fn) {
+        const existing = this.inflight.get(key);
+        if (existing)
+            return existing;
+        const promise = fn().finally(() => this.inflight.delete(key));
+        this.inflight.set(key, promise);
+        return promise;
+    }
+}
+// ─── Service ──────────────────────────────────────────────────────────────────
+const DEFAULT_TIMEOUT = 15000;
+const DIFF_TIMEOUT = 45000;
+class GitLabService {
+    constructor(token) {
+        // Per-instance caches (one per user session/PAT)
+        this.projectCache = new TTLCache(5 * 60000);
+        this.projectDeduplicator = new Deduplicator();
+        if (!token) {
+            throw new Error('GitLab token is required per request. Provide user PAT via header.');
+        }
+        this.client = axios_1.default.create({
+            baseURL: process.env.GITLAB_BASE_URL + '/api/v4',
+            headers: { 'PRIVATE-TOKEN': token },
+            timeout: DEFAULT_TIMEOUT,
+        });
+        // Map axios errors to GitLabApiError
+        this.client.interceptors.response.use((res) => res, (err) => { mapAxiosError(err); });
+    }
+    // ── Projects ────────────────────────────────────────────────────────────────
+    async searchProjects(query, perPage = 20) {
+        return withRetry('searchProjects', async () => {
+            const { data } = await this.client.get('/projects', {
+                params: {
+                    search: query,
+                    simple: true,
+                    membership: true,
+                    per_page: perPage,
+                    order_by: 'last_activity_at',
+                    sort: 'desc',
+                },
+            });
+            return data;
+        });
+    }
+    async getProjectById(projectId) {
+        return withRetry('getProjectById', async () => {
+            const { data } = await this.client.get(`/projects/${encodeURIComponent(projectId)}`);
+            return data;
+        });
+    }
+    async resolveProject(queryOrId) {
+        if (!queryOrId?.trim())
+            return null;
+        const query = queryOrId.trim();
+        const cacheKey = `resolve:${query}`;
+        const cached = this.projectCache.get(cacheKey);
+        if (cached !== undefined) {
+            (0, utils_1.logger)('debug', `resolveProject cache hit: ${query}`);
+            return cached;
+        }
+        return this.projectDeduplicator.run(cacheKey, async () => {
+            // Check cache again inside deduplicator (another concurrent call may have populated it)
+            const hit = this.projectCache.get(cacheKey);
+            if (hit !== undefined)
+                return hit;
+            let result = null;
+            if (/^\d+$/.test(query)) {
+                try {
+                    result = await this.getProjectById(query);
+                }
+                catch {
+                    // fall through to search
+                }
+            }
+            if (!result) {
+                const projects = await this.searchProjects(query, 50);
+                if (projects.length > 0) {
+                    const q = query.toLowerCase();
+                    result =
+                        projects.find((p) => [p.name, p.path, p.path_with_namespace].some((f) => f?.toLowerCase() === q)) ??
+                            projects.find((p) => [p.name, p.path, p.path_with_namespace].some((f) => f?.toLowerCase().startsWith(q))) ??
+                            projects[0];
+                }
+            }
+            this.projectCache.set(cacheKey, result);
+            return result;
+        });
+    }
+    async listUserRepositories(options = {}) {
+        return withRetry('listUserRepositories', async () => {
+            const scope = options.scope ?? 'owned';
+            const { data } = await this.client.get('/projects', {
+                params: {
+                    owned: scope === 'owned' ? true : undefined,
+                    membership: scope === 'membership' ? true : undefined,
+                    simple: true,
+                    per_page: options.perPage ?? 50,
+                    page: options.page ?? 1,
+                    order_by: 'last_activity_at',
+                    sort: 'desc',
+                },
+            });
+            return data;
+        });
+    }
+    // ── Merge Requests ──────────────────────────────────────────────────────────
+    async listMergeRequests(projectId, options = {}) {
+        return withRetry('listMergeRequests', async () => {
+            const { data } = await this.client.get(`/projects/${projectId}/merge_requests`, {
+                params: {
+                    state: options.state ?? 'opened',
+                    source_branch: options.sourceBranch,
+                    target_branch: options.targetBranch,
+                    author_username: options.authorUsername,
+                    reviewer_username: options.reviewerUsername,
+                    search: options.search,
+                    per_page: options.perPage,
+                    page: options.page,
+                },
+            });
+            return data;
+        });
+    }
+    async listMergeRequestsByProjectQuery(projectQuery) {
+        const project = await this.resolveProject(projectQuery);
+        if (!project)
+            throw new Error(`Project not found for query: ${projectQuery}`);
+        const mergeRequests = await this.listMergeRequests(String(project.id));
+        return { project, mergeRequests };
+    }
+    async getMergeRequest(projectId, iid) {
+        return withRetry('getMergeRequest', async () => {
+            const { data } = await this.client.get(`/projects/${projectId}/merge_requests/${iid}`);
+            return data;
+        });
+    }
+    async getMergeRequestChanges(projectId, iid) {
+        return withRetry('getMergeRequestChanges', async () => {
+            const { data } = await this.client.get(`/projects/${projectId}/merge_requests/${iid}/changes`, { timeout: DIFF_TIMEOUT });
+            return data.changes;
+        });
+    }
+    async getMergeRequestApprovals(projectId, iid) {
+        try {
+            const { data } = await this.client.get(`/projects/${projectId}/merge_requests/${iid}/approvals`);
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getMergeRequestDetail(projectId, iid) {
+        const [mergeRequest, approvals] = await Promise.all([
+            this.getMergeRequest(projectId, iid),
+            this.getMergeRequestApprovals(projectId, iid),
+        ]);
+        return { projectId, mergeRequestIid: iid, mergeRequest, approvals };
+    }
+    async getMergeRequestDiscussions(projectId, iid) {
+        return withRetry('getMergeRequestDiscussions', async () => {
+            const { data } = await this.client.get(`/projects/${projectId}/merge_requests/${iid}/discussions`, { params: { per_page: 100 } });
+            return data;
+        });
+    }
+    async getMergeReadiness(projectId, iid) {
+        const mergeRequest = (await this.getMergeRequest(projectId, iid));
+        const approvals = await this.getMergeRequestApprovals(projectId, iid);
+        const sourceBranch = String(mergeRequest.source_branch ?? '').trim();
+        const detailedMergeStatus = String(mergeRequest.detailed_merge_status ?? '').trim();
+        const draft = Boolean(mergeRequest.draft ?? mergeRequest.work_in_progress);
+        const hasConflicts = Boolean(mergeRequest.has_conflicts);
+        const blockingDiscussionsResolved = mergeRequest.blocking_discussions_resolved === undefined
+            ? true
+            : Boolean(mergeRequest.blocking_discussions_resolved);
+        const mergeStatusBlocked = [
+            'cannot_be_merged', 'cannot_be_merged_recheck', 'not_open',
+            'broken_status', 'commits_status', 'locked_lfs_files',
+        ].includes(detailedMergeStatus);
+        const headPipeline = mergeRequest.head_pipeline && typeof mergeRequest.head_pipeline === 'object'
+            ? mergeRequest.head_pipeline
+            : null;
+        const latestPipeline = headPipeline ? null
+            : sourceBranch ? await this.getLatestPipeline(projectId, sourceBranch)
+                : null;
+        const pipelineStatus = (headPipeline ? String(headPipeline.status ?? '') : String(latestPipeline?.status ?? '')).trim();
+        const pipelinePassedOrNotRequired = !pipelineStatus || pipelineStatus === 'success' || pipelineStatus === 'skipped';
+        const approvalsRequired = approvals?.approvals_required;
+        const approvalsLeft = approvals?.approvals_left;
+        const approvalsSatisfied = approvalsLeft === undefined ? true : approvalsLeft <= 0;
+        const checks = {
+            isOpen: String(mergeRequest.state ?? '') === 'opened',
+            notDraft: !draft,
+            noConflicts: !hasConflicts,
+            mergeStatusAllowed: !mergeStatusBlocked,
+            noBlockingDiscussions: blockingDiscussionsResolved,
+            approvalsSatisfied,
+            pipelinePassedOrNotRequired,
+        };
+        const reasons = [];
+        if (!checks.isOpen)
+            reasons.push('Merge request is not in opened state');
+        if (!checks.notDraft)
+            reasons.push('Merge request is draft/work in progress');
+        if (!checks.noConflicts)
+            reasons.push('Merge request has conflicts');
+        if (!checks.mergeStatusAllowed)
+            reasons.push(`Detailed merge status is blocking: ${detailedMergeStatus}`);
+        if (!checks.noBlockingDiscussions)
+            reasons.push('Blocking discussions are unresolved');
+        if (!checks.approvalsSatisfied) {
+            reasons.push(`Approvals not satisfied (required: ${String(approvalsRequired ?? 'unknown')}, left: ${String(approvalsLeft ?? 'unknown')})`);
+        }
+        if (!checks.pipelinePassedOrNotRequired) {
+            reasons.push(`Pipeline not passed (status: ${pipelineStatus || 'unknown'})`);
+        }
+        return {
+            projectId,
+            mergeRequestIid: iid,
+            readyToMerge: Object.values(checks).every(Boolean),
+            reasons,
+            checks,
+            summary: {
+                state: mergeRequest.state,
+                detailedMergeStatus,
+                sourceBranch,
+                targetBranch: mergeRequest.target_branch,
+                approvalsRequired,
+                approvalsLeft,
+                pipelineStatus: pipelineStatus || null,
+            },
+            mergeRequest,
+            approvals,
+            pipeline: headPipeline ?? latestPipeline,
+        };
+    }
+    async commentMergeRequest(projectId, iid, body) {
+        return withRetry('commentMergeRequest', async () => {
+            const { data } = await this.client.post(`/projects/${projectId}/merge_requests/${iid}/notes`, { body });
+            return data;
+        });
+    }
+    async createMergeRequest(projectId, payload) {
+        return withRetry('createMergeRequest', async () => {
+            const { data } = await this.client.post(`/projects/${projectId}/merge_requests`, {
+                source_branch: payload.sourceBranch,
+                target_branch: payload.targetBranch,
+                title: payload.title,
+                description: payload.description,
+                remove_source_branch: payload.removeSourceBranch,
+                squash: payload.squash,
+                draft: payload.draft,
+            });
+            return data;
+        });
+    }
+    async mergeMergeRequest(projectId, iid, payload = {}) {
+        return withRetry('mergeMergeRequest', async () => {
+            const { data } = await this.client.put(`/projects/${projectId}/merge_requests/${iid}/merge`, {
+                squash: payload.squash,
+                should_remove_source_branch: payload.shouldRemoveSourceBranch,
+                merge_when_pipeline_succeeds: payload.mergeWhenPipelineSucceeds,
+                sha: payload.sha,
+                merge_commit_message: payload.mergeCommitMessage,
+                squash_commit_message: payload.squashCommitMessage,
+            });
+            return data;
+        });
+    }
+    async closeMergeRequest(projectId, iid) {
+        return withRetry('closeMergeRequest', async () => {
+            const { data } = await this.client.put(`/projects/${projectId}/merge_requests/${iid}`, {
+                state_event: 'close',
+            });
+            return data;
+        });
+    }
+    async approveMergeRequest(projectId, iid, sha) {
+        return withRetry('approveMergeRequest', async () => {
+            const { data } = await this.client.post(`/projects/${projectId}/merge_requests/${iid}/approve`, sha ? { sha } : {});
+            return data;
+        });
+    }
+    async unapproveMergeRequest(projectId, iid) {
+        return withRetry('unapproveMergeRequest', async () => {
+            const { data } = await this.client.post(`/projects/${projectId}/merge_requests/${iid}/unapprove`);
+            return data;
+        });
+    }
+    // ── Pipelines ───────────────────────────────────────────────────────────────
+    async runPipeline(projectId, ref, variables = {}) {
+        return withRetry('runPipeline', async () => {
+            const { data } = await this.client.post(`/projects/${projectId}/pipeline`, {
+                ref,
+                variables: Object.entries(variables).map(([key, value]) => ({ key, value })),
+            });
+            return data;
+        });
+    }
+    async runStagingPipeline(projectId, staging, options = {}) {
+        let ref = options.ref?.trim();
+        if (!ref && options.mergeRequestIid) {
+            const mr = await this.getMergeRequest(projectId, String(options.mergeRequestIid));
+            ref = mr.source_branch;
+        }
+        if (!ref) {
+            const project = await this.getProjectById(projectId);
+            ref = project.default_branch;
+        }
+        if (!ref)
+            throw new Error('Cannot resolve branch ref for pipeline. Provide ref or mergeRequestIid.');
+        const pipeline = await this.runPipeline(projectId, ref, { STAGING: String(staging) });
+        return { projectId, ref, staging, pipeline };
+    }
+    async getPipeline(projectId, pipelineId) {
+        return withRetry('getPipeline', async () => {
+            const { data } = await this.client.get(`/projects/${projectId}/pipelines/${pipelineId}`);
+            return data;
+        });
+    }
+    async listPipelines(projectId, options = {}) {
+        return withRetry('listPipelines', async () => {
+            const { data } = await this.client.get(`/projects/${projectId}/pipelines`, {
+                params: {
+                    ref: options.ref,
+                    per_page: options.perPage ?? 20,
+                    order_by: 'id',
+                    sort: 'desc',
+                },
+            });
+            return data;
+        });
+    }
+    async getLatestPipeline(projectId, ref) {
+        const pipelines = await this.listPipelines(projectId, { ref, perPage: 1 });
+        return pipelines.length > 0 ? pipelines[0] : null;
+    }
+    async getPipelineStatus(projectId, options = {}) {
+        if (options.pipelineId) {
+            const pipeline = await this.getPipeline(projectId, options.pipelineId);
+            return { projectId, source: 'pipelineId', pipeline };
+        }
+        let ref = options.ref?.trim();
+        if (!ref && options.mergeRequestIid) {
+            const mr = await this.getMergeRequest(projectId, String(options.mergeRequestIid));
+            ref = mr.source_branch;
+        }
+        if (!ref) {
+            const project = await this.getProjectById(projectId);
+            ref = project.default_branch;
+        }
+        const latestPipeline = await this.getLatestPipeline(projectId, ref || undefined);
+        return { projectId, source: 'latest', ref, pipeline: latestPipeline };
+    }
+    async listPipelineJobs(projectId, pipelineId, scopes) {
+        return withRetry('listPipelineJobs', async () => {
+            const { data } = await this.client.get(`/projects/${projectId}/pipelines/${pipelineId}/jobs`, {
+                params: {
+                    per_page: 100,
+                    ...(scopes?.length ? { scope: scopes } : {}),
+                },
+                // GitLab accepts repeated scope params — axios serializes arrays with repeat keys
+                paramsSerializer: (params) => {
+                    const parts = [];
+                    for (const [key, val] of Object.entries(params)) {
+                        if (Array.isArray(val)) {
+                            for (const v of val)
+                                parts.push(`${key}[]=${encodeURIComponent(String(v))}`);
+                        }
+                        else if (val !== undefined) {
+                            parts.push(`${key}=${encodeURIComponent(String(val))}`);
+                        }
+                    }
+                    return parts.join('&');
+                },
+            });
+            return data;
+        });
+    }
+    async retryJob(projectId, jobId) {
+        return withRetry('retryJob', async () => {
+            const { data } = await this.client.post(`/projects/${projectId}/jobs/${jobId}/retry`);
+            return data;
+        });
+    }
+}
+exports.GitLabService = GitLabService;

package/dist/services/review.service.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewService = void 0;
+class ReviewService {
+    constructor(gitlab) {
+        this.gitlab = gitlab;
+    }
+    async analyzeDiff(diff) {
+        const issues = [];
+        const lines = diff ? diff.split('\n').length : 0;
+        if (lines > 500) {
+            issues.push(`Large diff: ${lines} lines (consider splitting into smaller MRs)`);
+        }
+        if (/console\.log\(/.test(diff)) {
+            issues.push('Found `console.log` statements — consider removing or using a logger');
+        }
+        if (/TODO/.test(diff)) {
+            issues.push('Found `TODO` comments — ensure follow-up issues are created');
+        }
+        if (/eval\(/.test(diff)) {
+            issues.push('Use of `eval()` detected — this is dangerous');
+        }
+        if (issues.length === 0)
+            return 'Automated review: No obvious issues found.';
+        return ['Automated review:'].concat(issues.map((s, i) => `${i + 1}. ${s}`)).join('\n');
+    }
+    async runAndComment(projectId, iid) {
+        const changes = await this.gitlab.getMergeRequestChanges(projectId, iid);
+        const combined = (changes || []).map((c) => c.diff || '').join('\n');
+        const result = await this.analyzeDiff(combined);
+        await this.gitlab.commentMergeRequest(projectId, iid, result);
+        return result;
+    }
+}
+exports.ReviewService = ReviewService;

package/dist/tools/getDiff.tool.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiff = getDiff;
+const gitlab_service_1 = require("../services/gitlab.service");
+async function getDiff(projectId, mrIid) {
+    const gitlab = new gitlab_service_1.GitLabService();
+    const pid = String(projectId);
+    const iid = String(mrIid);
+    return gitlab.getMergeRequestChanges(pid, iid);
+}

package/dist/tools/listMR.tool.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listMR = listMR;
+const gitlab_service_1 = require("../services/gitlab.service");
+async function listMR(projectId) {
+    if (!projectId)
+        throw new Error('projectId is required');
+    const gitlab = new gitlab_service_1.GitLabService();
+    return gitlab.listMergeRequests(String(projectId));
+}

package/dist/tools/reviewMR.tool.js

@@ -0,0 +1,23 @@
+"use strict";
+// src/tools/reviewMR.tool.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewMRTool = void 0;
+const gitlab_service_1 = require("../services/gitlab.service");
+const review_service_1 = require("../services/review.service");
+exports.reviewMRTool = {
+    name: "review_merge_request",
+    description: "Review a GitLab merge request",
+    parameters: {
+        projectId: "string",
+        mergeRequestIid: "string",
+    },
+    execute: async ({ projectId, mergeRequestIid }) => {
+        const gitlab = new gitlab_service_1.GitLabService();
+        const reviewer = new review_service_1.ReviewService(gitlab);
+        const changes = await gitlab.getMergeRequestChanges(projectId, mergeRequestIid);
+        const combinedDiff = (changes || []).map((c) => c.diff || "").join("\n");
+        const result = await reviewer.analyzeDiff(combinedDiff);
+        await gitlab.commentMergeRequest(projectId, mergeRequestIid, result);
+        return result;
+    },
+};

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = logger;
+const LEVEL_PRIORITY = { debug: 0, info: 1, warn: 2, error: 3 };
+const configuredLevel = process.env.LOG_LEVEL &&
+    ['debug', 'info', 'warn', 'error'].includes(process.env.LOG_LEVEL)
+    ? process.env.LOG_LEVEL
+    : 'info';
+function logger(level, message, ...args) {
+    if (LEVEL_PRIORITY[level] < LEVEL_PRIORITY[configuredLevel])
+        return;
+    const ts = new Date().toISOString();
+    const tag = level.toUpperCase().padEnd(5);
+    const line = `[${ts}] [gitlab-mcp] [${tag}] ${message}`;
+    const fn = level === 'error' ? console.error : level === 'warn' ? console.warn : console.log;
+    args.length ? fn(line, ...args) : fn(line);
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "gd-gitlab-mcp",
+  "version": "0.1.0",
+  "description": "GitLab MCP server — HTTP and stdio transport",
+  "main": "dist/server.js",
+  "bin": {
+    "gd-gitlab-mcp": "dist/server.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/server.js",
+    "start:stdio": "node dist/server.js --stdio",
+    "dev": "ts-node-dev -r dotenv/config --respawn --transpile-only --ignore-watch node_modules --watch src src/server.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.2",
+    "axios": "^1.4.0",
+    "dotenv": "^16.0.0"
+  },
+  "devDependencies": {
+    "ts-node": "^10.9.1",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.0"
+  }
+}