@zereight/mcp-gitlab 2.1.4 → 2.1.5

package/build/test/schema-tests.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env ts-node
-import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, GitLabTreeItemSchema, GetRepositoryTreeSchema } from '../schemas.js';
+import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, GitLabTreeItemSchema, GetMergeRequestSchema, GetRepositoryTreeSchema } from '../schemas.js';
 function runGetFileContentsSchemaTests() {
     console.log('🧪 Testing GetFileContentsSchema...');
     const cases = [
@@ -371,6 +371,83 @@ function runCreateIssueNoteSchemaTests() {
     console.log(`\nResults: ${passed} passed, ${failed} failed`);
     return { passed, failed };
 }
+function runGetMergeRequestSchemaTests() {
+    console.log('\n🧪 Testing GetMergeRequestSchema...');
+    const cases = [
+        {
+            name: 'schema:get_merge_request:with-project-id-and-merge-request-iid',
+            input: { project_id: 'my/project', merge_request_iid: '42' },
+            expected: { project_id: 'my/project', merge_request_iid: '42' },
+        },
+        {
+            name: 'schema:get_merge_request:with-project-id-and-source-branch',
+            input: { project_id: 'my/project', source_branch: 'feature-branch' },
+            expected: { project_id: 'my/project', source_branch: 'feature-branch' },
+        },
+        {
+            name: 'schema:get_merge_request:with-all-params',
+            input: { project_id: 'my/project', merge_request_iid: '42', source_branch: 'feature-branch' },
+            expected: {
+                project_id: 'my/project',
+                merge_request_iid: '42',
+                source_branch: 'feature-branch',
+            },
+        },
+        {
+            name: 'schema:get_merge_request:coerced-merge-request-iid',
+            input: { project_id: 'my/project', merge_request_iid: 24 },
+            expected: { project_id: 'my/project', merge_request_iid: '24' },
+        },
+        {
+            name: 'schema:get_merge_request:coerced-source-branch',
+            input: { project_id: 'my/project', source_branch: 'feature' },
+            expected: { project_id: 'my/project', source_branch: 'feature' },
+        },
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = {
+            name: testCase.name,
+            status: 'failed'
+        };
+        const parsed = GetMergeRequestSchema.safeParse(testCase.input);
+        if (testCase.shouldFail) {
+            if (parsed.success) {
+                result.error = 'Expected schema validation to fail';
+            }
+            else {
+                result.status = 'passed';
+            }
+        }
+        else if (parsed.success) {
+            const expected = testCase.expected || {};
+            const matches = Object.entries(expected).every(([key, value]) => {
+                const actual = parsed.data[key];
+                return actual === value;
+            });
+            if (matches) {
+                result.status = 'passed';
+            }
+            else {
+                result.error = `Unexpected parsed result: ${JSON.stringify(parsed.data)}`;
+            }
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
 function runEmojiReactionSchemaTests() {
     console.log('\n🧪 Testing Emoji Reaction Schemas...');
     const cases = [
@@ -702,13 +779,14 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     const fileContentResult = runGitLabFileContentSchemaTests();
     const createPipelineResult = runCreatePipelineSchemaTests();
     const createIssueNoteResult = runCreateIssueNoteSchemaTests();
+    const getMergeRequestResult = runGetMergeRequestSchemaTests();
     const emojiReactionResult = runEmojiReactionSchemaTests();
     const repositorySchemaResult = runGitLabRepositorySchemaTests();
     const labelsCoercionResult = runLabelsCoercionSchemaTests();
     const treeItemResult = runGitLabTreeItemSchemaTests();
     const repositoryTreeResult = runGetRepositoryTreeSchemaTests();
-    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + createIssueNoteResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + treeItemResult.passed + repositoryTreeResult.passed;
-    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + createIssueNoteResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + treeItemResult.failed + repositoryTreeResult.failed;
+    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + createIssueNoteResult.passed + getMergeRequestResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + treeItemResult.passed + repositoryTreeResult.passed;
+    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + createIssueNoteResult.failed + getMergeRequestResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + treeItemResult.failed + repositoryTreeResult.failed;
     console.log(`\nTotal Results: ${totalPassed} passed, ${totalFailed} failed`);
     if (totalFailed > 0) {
         process.exit(1);

package/build/test/test-json-schema.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env ts-node
+import { z } from "zod";
+import { toJSONSchema } from "../utils/schema.js";
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message);
+    }
+}
+function runTests() {
+    console.log("Testing toJSONSchema utility...");
+    const results = [];
+    // Test 1: Required field extraction
+    try {
+        const schema = z.object({
+            requiredField: z.string(),
+            optionalField: z.string().optional(),
+        });
+        const result = toJSONSchema(schema);
+        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
+        assert(!result.required?.includes("optionalField"), "optionalField should NOT be in required array");
+        results.push({ name: "required field extraction", status: "passed" });
+    }
+    catch (error) {
+        results.push({
+            name: "required field extraction",
+            status: "failed",
+            error: error.message,
+        });
+    }
+    // Test 2: Nullable fields
+    try {
+        const schema = z.object({
+            nullableField: z.string().nullable(),
+            requiredField: z.string(),
+        });
+        const result = toJSONSchema(schema);
+        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
+        assert(!result.required?.includes("nullableField"), "nullableField should NOT be in required array");
+        results.push({ name: "nullable fields", status: "passed" });
+    }
+    catch (error) {
+        results.push({
+            name: "nullable fields",
+            status: "failed",
+            error: error.message,
+        });
+    }
+    // Test 3: Optional nullable fields
+    try {
+        const schema = z.object({
+            optionalNullable: z.string().optional().nullable(),
+            requiredField: z.string(),
+        });
+        const result = toJSONSchema(schema);
+        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
+        assert(!result.required?.includes("optionalNullable"), "optionalNullable should NOT be in required array");
+        results.push({ name: "optional nullable fields", status: "passed" });
+    }
+    catch (error) {
+        results.push({
+            name: "optional nullable fields",
+            status: "failed",
+            error: error.message,
+        });
+    }
+    // Test 4: Fields with defaults
+    try {
+        const schema = z.object({
+            fieldWithDefault: z.string().default("default-value"),
+            requiredField: z.string(),
+        });
+        const result = toJSONSchema(schema);
+        assert(result.required?.includes("requiredField"), "requiredField should be in required array");
+        assert(!result.required?.includes("fieldWithDefault"), "fieldWithDefault should NOT be in required array");
+        assert(result.properties.fieldWithDefault.default === "default-value", "default value should be preserved");
+        results.push({ name: "fields with defaults", status: "passed" });
+    }
+    catch (error) {
+        results.push({
+            name: "fields with defaults",
+            status: "failed",
+            error: error.message,
+        });
+    }
+    // Test 5: Nested objects with shared property names
+    try {
+        const schema = z.object({
+            foo: z.string(), // Required at root
+            nested: z.object({
+                foo: z.string().optional(), // Optional in nested, shares name with root
+            }),
+        });
+        const result = toJSONSchema(schema);
+        assert(result.required?.includes("foo"), "root foo should be in required array");
+        assert(result.required?.includes("nested"), "nested object should be in required array");
+        assert(result.properties.nested.required === undefined, "nested foo should NOT be in required array");
+        results.push({
+            name: "nested objects with shared property names",
+            status: "passed",
+        });
+    }
+    catch (error) {
+        results.push({
+            name: "nested objects with shared property names",
+            status: "failed",
+            error: error.message,
+        });
+    }
+    // Test 6: Coerced fields
+    try {
+        const schema = z.object({
+            coercedField: z.coerce.string(),
+            optionalCoercedField: z.coerce.string().optional(),
+        });
+        const result = toJSONSchema(schema);
+        assert(result.required?.includes("coercedField"), "coercedField should be in required array (z.coerce without optional)");
+        assert(!result.required?.includes("optionalCoercedField"), "optionalCoercedField should NOT be in required array (z.coerce with optional)");
+        results.push({ name: "coerced fields", status: "passed" });
+    }
+    catch (error) {
+        results.push({
+            name: "coerced fields",
+            status: "failed",
+            error: error.message,
+        });
+    }
+    // Print results
+    const passed = results.filter((r) => r.status === "passed").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    console.log("\nTest Results:");
+    console.log("=".repeat(50));
+    results.forEach((result) => {
+        if (result.status === "passed") {
+            console.log(`  ${result.name}: ${result.status}`);
+        }
+        else {
+            console.log(`  ${result.name}: ${result.status}`);
+            console.log(`    Error: ${result.error}`);
+        }
+    });
+    console.log("=".repeat(50));
+    console.log(`Total: ${results.length} tests`);
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${failed}`);
+    return { passed, failed };
+}
+// Run tests
+runTests();

package/build/utils/schema.js

@@ -1,12 +1,38 @@
+import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 /**
  * Convert a Zod schema to JSON Schema, fixing nullable/optional fields
- * so they are not marked as required.
+ * so they are not marked as required, and extracting required fields from the Zod schema.
  */
 export const toJSONSchema = (schema) => {
     const jsonSchema = zodToJsonSchema(schema, { $refStrategy: "none" });
+    // Extract required fields from Zod schema
+    const zodRequiredFields = (() => {
+        if (schema instanceof z.ZodObject) {
+            const shape = schema.shape;
+            const requiredFields = [];
+            Object.entries(shape).forEach(([key, fieldDef]) => {
+                const zodType = fieldDef;
+                const typeName = zodType._def?.typeName;
+                // Check if field is wrapped in zod required types
+                const isRequired = [
+                    "ZodOptional",
+                    "ZodNullable",
+                    "ZodDefault",
+                    "ZodEffects",
+                    "ZodCatch",
+                    "ZodBranded",
+                ].includes(typeName);
+                if (!isRequired) {
+                    requiredFields.push(key);
+                }
+            });
+            return requiredFields;
+        }
+        return [];
+    })();
     // Post-process to fix nullable/optional fields and strip verbose keys
-    function fixNullableOptional(obj) {
+    function fixNullableOptional(obj, isRoot = false) {
         if (obj && typeof obj === "object") {
             // Strip $schema (meta-only, not needed for tool input validation)
             delete obj.$schema;
@@ -15,6 +41,14 @@ export const toJSONSchema = (schema) => {
             // If this object has properties, process them
             if (obj.properties) {
                 const requiredSet = new Set(obj.required || []);
+                // Add required fields extracted from Zod schema (only for root object)
+                if (isRoot) {
+                    zodRequiredFields.forEach(field => {
+                        if (obj.properties[field]) {
+                            requiredSet.add(field);
+                        }
+                    });
+                }
                 Object.keys(obj.properties).forEach(key => {
                     const prop = obj.properties[key];
                     // Handle fields that can be null or omitted
@@ -25,8 +59,8 @@ export const toJSONSchema = (schema) => {
                     else if (Array.isArray(prop.type) && prop.type.includes("null")) {
                         requiredSet.delete(key);
                     }
-                    // Recursively process nested objects
-                    obj.properties[key] = fixNullableOptional(prop);
+                    // Recursively process nested objects (not root)
+                    obj.properties[key] = fixNullableOptional(prop, false);
                 });
                 // Normalize the required array after processing all properties
                 if (requiredSet.size > 0) {
@@ -39,11 +73,11 @@ export const toJSONSchema = (schema) => {
             // Process anyOf/allOf/oneOf
             ["anyOf", "allOf", "oneOf"].forEach(combiner => {
                 if (obj[combiner]) {
-                    obj[combiner] = obj[combiner].map(fixNullableOptional);
+                    obj[combiner] = obj[combiner].map((item) => fixNullableOptional(item, false));
                 }
             });
         }
         return obj;
     }
-    return fixNullableOptional(jsonSchema);
+    return fixNullableOptional(jsonSchema, true);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "mcpName": "io.github.zereight/gitlab-mcp",
   "description": "GitLab MCP server for projects, merge requests, issues, pipelines, wiki, releases, and more",
   "keywords": [
@@ -55,7 +55,7 @@
     "test:mcp-oauth": "npm run build && node --import tsx/esm --test test/mcp-oauth-tests.ts",
     "test:live": "node test/validate-api.js",
     "test:remote-auth": "npm run build && node --import tsx/esm --test test/remote-auth-simple-test.ts",
-    "test:schema": "tsx test/schema-tests.ts",
+    "test:schema": "tsx test/schema-tests.ts && tsx test/test-json-schema.ts",
     "test:oauth": "tsx test/oauth-tests.ts",
     "test:list-merge-requests": "npm run build && tsx test/test-list-merge-requests.ts",
     "test:approvals": "npm run build && tsx test/test-merge-request-approvals.ts",