@type-crafter/mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -7,6 +7,27 @@ import { parse as parseYaml } from 'yaml';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 const execAsync = promisify(exec);
+// Type guards
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isSpecInfo(value) {
+    return (isRecord(value) &&
+        typeof value.version === 'string' &&
+        typeof value.title === 'string');
+}
+function isExecError(error) {
+    return error instanceof Error;
+}
+function isGenerateTypesArgs(value) {
+    return (isRecord(value) &&
+        typeof value.language === 'string' &&
+        typeof value.specFilePath === 'string' &&
+        typeof value.outputDirectory === 'string');
+}
+function isSpecFilePathArgs(value) {
+    return isRecord(value) && typeof value.specFilePath === 'string';
+}
 // Helper function to read YAML files
 async function readYaml(filePath) {
     const fileContent = await fs.readFile(filePath, 'utf-8');
@@ -14,29 +35,27 @@ async function readYaml(filePath) {
 }
 // Helper function to validate spec structure
 function validateSpecData(data) {
-    if (typeof data !== 'object' || data === null) {
+    if (!isRecord(data)) {
         return { valid: false };
     }
-    const spec = data;
     // Check for required info
-    if (typeof spec.info !== 'object' || spec.info === null) {
+    if (!isRecord(data.info)) {
         return { valid: false };
     }
-    const info = spec.info;
-    if (typeof info.version !== 'string' || typeof info.title !== 'string') {
+    if (!isSpecInfo(data.info)) {
         return { valid: false };
     }
     // At least one of types or groupedTypes must exist
-    const hasTypes = typeof spec.types === 'object' && spec.types !== null;
-    const hasGroupedTypes = typeof spec.groupedTypes === 'object' && spec.groupedTypes !== null;
-    if (!hasTypes && !hasGroupedTypes) {
+    const types = isRecord(data.types) ? data.types : undefined;
+    const groupedTypes = isRecord(data.groupedTypes) ? data.groupedTypes : undefined;
+    if (typeof types === 'undefined' && typeof groupedTypes === 'undefined') {
         return { valid: false };
     }
     return {
         valid: true,
-        info: { version: info.version, title: info.title },
-        types: hasTypes ? spec.types : undefined,
-        groupedTypes: hasGroupedTypes ? spec.groupedTypes : undefined,
+        info: data.info,
+        types,
+        groupedTypes,
     };
 }
 // Create server instance
@@ -48,40 +67,87 @@ const server = new McpServer({
         tools: {},
     },
 });
+// Schema definitions for all tools
+const generateTypesSchema = {
+    type: 'object',
+    properties: {
+        language: {
+            type: 'string',
+            description: 'Target language for type generation',
+            enum: ['typescript', 'typescript-with-decoders'],
+        },
+        specFilePath: {
+            type: 'string',
+            description: 'Path to the YAML specification file',
+        },
+        outputDirectory: {
+            type: 'string',
+            description: 'Directory where generated types will be written',
+        },
+        typesWriterMode: {
+            type: 'string',
+            description: 'Writer mode for types: SingleFile or Files',
+            enum: ['SingleFile', 'Files'],
+        },
+        groupedTypesWriterMode: {
+            type: 'string',
+            description: 'Writer mode for grouped types: FolderWithFiles or SingleFile',
+            enum: ['FolderWithFiles', 'SingleFile'],
+        },
+    },
+    required: ['language', 'specFilePath', 'outputDirectory'],
+    additionalProperties: false,
+};
+const validateSpecSchema = {
+    type: 'object',
+    properties: {
+        specFilePath: {
+            type: 'string',
+            description: 'Path to the YAML specification file to validate',
+        },
+    },
+    required: ['specFilePath'],
+    additionalProperties: false,
+};
+const listLanguagesSchema = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+};
+const getSpecInfoSchema = {
+    type: 'object',
+    properties: {
+        specFilePath: {
+            type: 'string',
+            description: 'Path to the YAML specification file',
+        },
+    },
+    required: ['specFilePath'],
+    additionalProperties: false,
+};
+const getSpecRulesSchema = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+};
 // Register generate-types tool
 server.registerTool('generate-types', {
     description: 'Generate type definitions from a YAML specification file. Supports TypeScript and TypeScript with decoders. ' +
         'The YAML spec should follow the Type Crafter format with info, types, and/or groupedTypes sections.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            language: {
-                type: 'string',
-                description: 'Target language for type generation',
-                enum: ['typescript', 'typescript-with-decoders'],
-            },
-            specFilePath: {
-                type: 'string',
-                description: 'Path to the YAML specification file',
-            },
-            outputDirectory: {
-                type: 'string',
-                description: 'Directory where generated types will be written',
-            },
-            typesWriterMode: {
-                type: 'string',
-                description: 'Writer mode for types: SingleFile or Files',
-                enum: ['SingleFile', 'Files'],
-            },
-            groupedTypesWriterMode: {
-                type: 'string',
-                description: 'Writer mode for grouped types: FolderWithFiles or SingleFile',
-                enum: ['FolderWithFiles', 'SingleFile'],
-            },
-        },
-        required: ['language', 'specFilePath', 'outputDirectory'],
-    },
+    // @ts-expect-error - MCP SDK schema type mismatch
+    inputSchema: generateTypesSchema,
 }, async (args) => {
+    if (!isGenerateTypesArgs(args)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Error: Invalid arguments provided',
+                },
+            ],
+            isError: true,
+        };
+    }
     const { language, specFilePath, outputDirectory, typesWriterMode = 'SingleFile', groupedTypesWriterMode = 'SingleFile', } = args;
     // Validate language
     if (!['typescript', 'typescript-with-decoders'].includes(language.toLowerCase())) {
@@ -128,13 +194,23 @@ server.registerTool('generate-types', {
         };
     }
     catch (error) {
-        const err = error;
-        const errorDetails = err.stderr ?? err.stdout ?? '';
+        if (!isExecError(error)) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: Unknown error occurred during type generation',
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const errorDetails = error.stderr ?? error.stdout ?? '';
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Error generating types: ${err.message}\n${errorDetails}`,
+                    text: `Error generating types: ${error.message}\n${errorDetails}`,
                 },
             ],
             isError: true,
@@ -145,17 +221,20 @@ server.registerTool('generate-types', {
 server.registerTool('validate-spec', {
     description: 'Validate a YAML specification file without generating types. ' +
         'Checks if the spec file is valid and can be processed by Type Crafter.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            specFilePath: {
-                type: 'string',
-                description: 'Path to the YAML specification file to validate',
-            },
-        },
-        required: ['specFilePath'],
-    },
+    // @ts-expect-error - MCP SDK schema type mismatch
+    inputSchema: validateSpecSchema,
 }, async (args) => {
+    if (!isSpecFilePathArgs(args)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Error: Invalid arguments provided',
+                },
+            ],
+            isError: true,
+        };
+    }
     const { specFilePath } = args;
     // Resolve path
     const resolvedSpecPath = path.resolve(specFilePath);
@@ -204,10 +283,8 @@ server.registerTool('validate-spec', {
 // Register list-languages tool
 server.registerTool('list-languages', {
     description: 'List all supported target languages for type generation',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
+    // @ts-expect-error - MCP SDK schema type mismatch
+    inputSchema: listLanguagesSchema,
 }, async () => {
     return {
         content: [
@@ -222,17 +299,20 @@ server.registerTool('list-languages', {
 server.registerTool('get-spec-info', {
     description: 'Get information about a YAML specification file including version, title, ' +
         'and counts of types and grouped types defined in the spec.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            specFilePath: {
-                type: 'string',
-                description: 'Path to the YAML specification file',
-            },
-        },
-        required: ['specFilePath'],
-    },
+    // @ts-expect-error - MCP SDK schema type mismatch
+    inputSchema: getSpecInfoSchema,
 }, async (args) => {
+    if (!isSpecFilePathArgs(args)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'Error: Invalid arguments provided',
+                },
+            ],
+            isError: true,
+        };
+    }
     const { specFilePath } = args;
     // Resolve path
     const resolvedSpecPath = path.resolve(specFilePath);
@@ -285,7 +365,7 @@ server.registerTool('get-spec-info', {
         infoText += 'Grouped Types:\n';
         Object.keys(validation.groupedTypes).forEach((groupName) => {
             const group = validation.groupedTypes?.[groupName];
-            if (typeof group !== 'undefined' && group !== null && typeof group === 'object' && !('$ref' in group)) {
+            if (isRecord(group) && !('$ref' in group)) {
                 const typeNames = Object.keys(group);
                 infoText += `  ${groupName} (${typeNames.length} types):\n`;
                 typeNames.forEach((typeName) => {
@@ -311,10 +391,8 @@ server.registerTool('get-spec-rules', {
     description: 'Get comprehensive rules and guidelines for writing Type Crafter YAML specification files. ' +
         'This provides LLMs with detailed information about the YAML spec format, type mappings, nullable types, ' +
         'references, composition, best practices, and common patterns. Use this before creating or modifying spec files.',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
+    // @ts-expect-error - MCP SDK schema type mismatch
+    inputSchema: getSpecRulesSchema,
 }, async () => {
     try {
         // Read the SPEC_RULES.md file from src directory
@@ -330,12 +408,22 @@ server.registerTool('get-spec-rules', {
         };
     }
     catch (error) {
-        const err = error;
+        if (!isExecError(error)) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Error: Unknown error occurred while reading spec rules',
+                    },
+                ],
+                isError: true,
+            };
+        }
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Error reading spec rules: ${err.message}`,
+                    text: `Error reading spec rules: ${error.message}`,
                 },
             ],
             isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@type-crafter/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "MCP server for Type Crafter - generate types from YAML specifications",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,7 +60,7 @@
     }
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@modelcontextprotocol/sdk": "^1.25.1",
     "yaml": "^2.3.2"
   },
   "devDependencies": {