@zereight/mcp-gitlab 2.1.70 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "2.1.70",
+  "version": "2.2.1",
   "mcpName": "io.github.zereight/gitlab-mcp",
   "description": "GitLab MCP server for projects, merge requests, issues, pipelines, wiki, releases, and more",
   "keywords": [
@@ -44,10 +44,10 @@
     "npm": ">=9.0.0"
   },
   "scripts": {
-    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+    "build": "node -e \"require('fs').rmSync('build',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
     "prepare": "npm run build",
     "dev": "npm run build && node build/index.js",
-    "watch": "tsc --watch",
+    "watch": "tsc -p tsconfig.build.json --watch",
     "deploy": "npm publish --access public",
     "changelog": "auto-changelog -p",
     "test": "npm run test:all",

package/build/scripts/check-skill-sync.js

@@ -1,143 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * Verify skills/gitlab-mcp/ stays in sync with tools/registry.ts.
- *
- * Run with: npm run check:skill-sync
- */
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { TOOLSET_DEFINITIONS, allTools, destructiveTools, DEFAULT_TOOLSET_IDS, } from "../tools/registry.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = join(__dirname, "..");
-const SKILL_PATH = join(REPO_ROOT, "skills", "gitlab-mcp", "SKILL.md");
-const REF_DIR = join(REPO_ROOT, "skills", "gitlab-mcp", "reference");
-// Response field names in reference docs — not MCP tools.
-const REFERENCE_FIELD_ALLOWLIST = new Set([
-    "after",
-    "allow_multiple",
-    "deleted_file",
-    "excluded_file_patterns",
-    "group_id",
-    "new_file",
-    "new_path",
-    "old_path",
-    "name",
-    "page",
-    "per_page",
-    "pipeline_id",
-    "job_inputs",
-    "project_id",
-    "renamed_file",
-]);
-function fail(message) {
-    console.error(`::error::${message}`);
-    process.exit(1);
-}
-function parseToolsetTable(skill) {
-    const rows = new Map();
-    const rowRe = /^\| ([a-z_]+) \((\d+) tools?\) \| (yes|no) \|/gm;
-    let match;
-    while ((match = rowRe.exec(skill)) !== null) {
-        rows.set(match[1], {
-            count: Number(match[2]),
-            isDefault: match[3] === "yes",
-        });
-    }
-    return rows;
-}
-function parseIntroCounts(skill) {
-    const match = skill.match(/providing (\d+) tools: (\d+) tools across (\d+) toolsets/);
-    if (!match) {
-        fail("skills/gitlab-mcp/SKILL.md intro line is missing or malformed");
-    }
-    return {
-        totalTools: Number(match[1]),
-        uniqueInToolsets: Number(match[2]),
-        toolsetCount: Number(match[3]),
-    };
-}
-function parseDestructiveTools(skill) {
-    const section = skill.match(/## Destructive Tools[^\n]*\n\n(`[^`]+`(?:, `[^`]+`)*)$/m);
-    if (!section) {
-        fail("skills/gitlab-mcp/SKILL.md destructive tools section is missing or malformed");
-    }
-    return new Set([...section[1].matchAll(/`([a-z_]+)`/g)].map((m) => m[1]));
-}
-function collectReferenceToolNames() {
-    const toolNames = new Set();
-    for (const file of readdirSync(REF_DIR).filter((name) => name.endsWith(".md"))) {
-        const text = readFileSync(join(REF_DIR, file), "utf8");
-        for (const match of text.matchAll(/`([a-z][a-z0-9_]*)`/g)) {
-            const name = match[1];
-            if (!REFERENCE_FIELD_ALLOWLIST.has(name)) {
-                toolNames.add(name);
-            }
-        }
-    }
-    return toolNames;
-}
-const skill = readFileSync(SKILL_PATH, "utf8");
-const errors = [];
-const registryCounts = Object.fromEntries(TOOLSET_DEFINITIONS.map((definition) => [definition.id, definition.tools.size]));
-const skillRows = parseToolsetTable(skill);
-if (skillRows.size !== TOOLSET_DEFINITIONS.length) {
-    errors.push(`toolset table has ${skillRows.size} rows; registry has ${TOOLSET_DEFINITIONS.length}`);
-}
-for (const definition of TOOLSET_DEFINITIONS) {
-    const row = skillRows.get(definition.id);
-    if (!row) {
-        errors.push(`missing toolset row for ${definition.id}`);
-        continue;
-    }
-    const actualCount = registryCounts[definition.id];
-    if (row.count !== actualCount) {
-        errors.push(`${definition.id}: skill says ${row.count}, registry has ${actualCount}`);
-    }
-    const expectedDefault = DEFAULT_TOOLSET_IDS.has(definition.id);
-    if (row.isDefault !== expectedDefault) {
-        errors.push(`${definition.id}: skill default=${row.isDefault}, registry default=${expectedDefault}`);
-    }
-}
-for (const id of skillRows.keys()) {
-    if (!registryCounts[id]) {
-        errors.push(`unknown toolset in skill table: ${id}`);
-    }
-}
-const uniqueInToolsets = new Set(TOOLSET_DEFINITIONS.flatMap((definition) => [...definition.tools]))
-    .size;
-const intro = parseIntroCounts(skill);
-if (intro.totalTools !== allTools.length) {
-    errors.push(`intro total tools: skill says ${intro.totalTools}, registry has ${allTools.length}`);
-}
-if (intro.uniqueInToolsets !== uniqueInToolsets) {
-    errors.push(`intro unique toolset tools: skill says ${intro.uniqueInToolsets}, registry has ${uniqueInToolsets}`);
-}
-if (intro.toolsetCount !== TOOLSET_DEFINITIONS.length) {
-    errors.push(`intro toolset count: skill says ${intro.toolsetCount}, registry has ${TOOLSET_DEFINITIONS.length}`);
-}
-const skillDestructive = parseDestructiveTools(skill);
-for (const tool of skillDestructive) {
-    if (!destructiveTools.has(tool)) {
-        errors.push(`destructive list includes non-destructive tool: ${tool}`);
-    }
-}
-for (const tool of destructiveTools) {
-    if (!skillDestructive.has(tool)) {
-        errors.push(`destructive list missing registry tool: ${tool}`);
-    }
-}
-const registryToolNames = new Set(allTools.map((tool) => tool.name));
-for (const tool of collectReferenceToolNames()) {
-    if (!registryToolNames.has(tool)) {
-        errors.push(`reference mentions unknown tool: ${tool}`);
-    }
-}
-if (errors.length > 0) {
-    console.error("skills/gitlab-mcp/ is out of sync with tools/registry.ts:");
-    for (const error of errors) {
-        console.error(`- ${error}`);
-    }
-    process.exit(1);
-}
-console.log("skills/gitlab-mcp/ is in sync with tools/registry.ts");

package/build/scripts/generate-server-card.js

@@ -1,39 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { allTools } from "../tools/registry.js";
-async function main() {
-    const pkgPath = path.resolve(process.cwd(), "package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-    const serverCard = {
-        serverInfo: {
-            name: pkg.mcpName || pkg.name,
-            version: pkg.version,
-        },
-        authentication: {
-            required: true,
-            schemes: ["bearer", "oauth2"],
-        },
-        tools: allTools.map(t => {
-            const tool = { ...t };
-            if (tool.inputSchema &&
-                typeof tool.inputSchema === "object" &&
-                "$schema" in tool.inputSchema) {
-                const schema = { ...tool.inputSchema };
-                delete schema["$schema"];
-                tool.inputSchema = schema;
-            }
-            return tool;
-        }),
-        resources: [],
-        prompts: [],
-    };
-    const outDir = path.resolve(process.cwd(), ".well-known", "mcp");
-    fs.mkdirSync(outDir, { recursive: true });
-    const outFile = path.join(outDir, "server-card.json");
-    fs.writeFileSync(outFile, JSON.stringify(serverCard, null, 2), "utf8");
-    console.log(`Successfully generated ${outFile} (${allTools.length} tools)`);
-}
-main().catch(err => {
-    console.error("Failed to generate server card:", err);
-    process.exit(1);
-});

package/build/scripts/generate-tool-coverage.js

@@ -1,58 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * Generate docs/reference/tool-coverage.md from tools/registry.ts + test/ MCP calls.
- *
- * Detection rules live in ./tool-coverage/coverage.ts (AST-scoped): a tool is
- * invoked when test source sends that name as a `callTool*` argument, as the
- * `name` of a first-argument params object (`client.callTool({ name })`), or as
- * the `name` of a `params` object inside a `tools/call` payload literal.
- *
- * Name-only mentions (toolset tables, description-quality) do not count.
- * callTool(variable) loops are missed unless the name is also a literal in that call.
- *
- * Run with: npm run docs:tools
- */
-import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import { fileURLToPath } from "node:url";
-import { allTools, TOOLSET_DEFINITIONS } from "../tools/registry.js";
-import { assertDetectorHealthy, buildCoverageMarkdown, collectInvocations, countInvoked, groupToolsByToolset, percent, SKIP_FILES, } from "./tool-coverage/coverage.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = join(__dirname, "..");
-const TEST_DIR = join(REPO_ROOT, "test");
-const OUT_PATH = join(REPO_ROOT, "docs", "reference", "tool-coverage.md");
-function walkTestFiles(dir) {
-    const out = [];
-    for (const name of readdirSync(dir)) {
-        const full = join(dir, name);
-        const stat = statSync(full);
-        if (stat.isDirectory()) {
-            out.push(...walkTestFiles(full));
-            continue;
-        }
-        if (/\.(ts|js)$/.test(name) && !SKIP_FILES.has(name)) {
-            out.push(full);
-        }
-    }
-    return out;
-}
-function repoPath(abs) {
-    return relative(REPO_ROOT, abs).split("\\").join("/");
-}
-function readScannedFiles() {
-    return walkTestFiles(TEST_DIR).map(abs => ({
-        path: repoPath(abs),
-        text: readFileSync(abs, "utf8"),
-    }));
-}
-function main() {
-    const toolNames = allTools.map(tool => tool.name);
-    const toolNameSet = new Set(toolNames);
-    const hits = collectInvocations(readScannedFiles(), toolNameSet);
-    const invokedCount = countInvoked(toolNames, hits);
-    assertDetectorHealthy(hits, invokedCount);
-    const grouped = groupToolsByToolset(toolNames, TOOLSET_DEFINITIONS);
-    writeFileSync(OUT_PATH, buildCoverageMarkdown(toolNames, hits, grouped));
-    console.log(`generated docs/reference/tool-coverage.md — ${invokedCount}/${toolNames.length} (${percent(invokedCount, toolNames.length)})`);
-}
-main();