@type-crafter/mcp 0.6.0 → 1.1.0

package/dist/index.js

@@ -3,58 +3,81 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import fs from 'fs/promises';
 import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
 import { parse as parseYaml } from 'yaml';
-import { exec } from 'child_process';
-import { promisify } from 'util';
+import { randomUUID } from 'crypto';
 import { z } from 'zod';
-const execAsync = promisify(exec);
-// Zod schemas for all tools
-const generateTypesSchema = z.object({
-    language: z
-        .enum(['typescript', 'typescript-with-decoders'])
-        .describe('Target language for type generation'),
-    specFilePath: z.string().describe('Path to the YAML specification file'),
-    outputDirectory: z.string().describe('Directory where generated types will be written'),
-    typesWriterMode: z
-        .enum(['SingleFile', 'Files'])
-        .optional()
-        .describe('Writer mode for types: SingleFile or Files'),
-    groupedTypesWriterMode: z
-        .enum(['FolderWithFiles', 'SingleFile'])
+// ES module dirname workaround
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Session management
+const sessions = new Map();
+const SESSION_TTL_MS = 30 * 60 * 1000; // 30 minutes
+function createSession() {
+    const sessionId = randomUUID();
+    sessions.set(sessionId, { createdAt: new Date(), acknowledged: true });
+    return sessionId;
+}
+function isValidSession(sessionId) {
+    if (!sessionId)
+        return false;
+    const session = sessions.get(sessionId);
+    if (!session)
+        return false;
+    // Check if session is expired
+    const now = new Date();
+    if (now.getTime() - session.createdAt.getTime() > SESSION_TTL_MS) {
+        sessions.delete(sessionId);
+        return false;
+    }
+    return true;
+}
+// Clean up expired sessions periodically
+setInterval(() => {
+    const now = new Date();
+    for (const [id, session] of sessions.entries()) {
+        if (now.getTime() - session.createdAt.getTime() > SESSION_TTL_MS) {
+            sessions.delete(id);
+        }
+    }
+}, 5 * 60 * 1000); // Every 5 minutes
+// Zod schemas for tools
+const getWritingGuideSchema = z.object({});
+const getRulesSectionSchema = z.object({
+    sessionId: z
+        .string()
         .optional()
-        .describe('Writer mode for grouped types: FolderWithFiles or SingleFile'),
+        .describe('Session ID from get-writing-guide. Recommended but not required.'),
+    section: z
+        .enum(['structure', 'types', 'nullable', 'references', 'composition', 'patterns'])
+        .describe('The section to retrieve detailed rules for'),
 });
 const validateSpecSchema = z.object({
+    sessionId: z
+        .string()
+        .optional()
+        .describe('Session ID from get-writing-guide. Recommended but not required.'),
     specFilePath: z.string().describe('Path to the YAML specification file to validate'),
 });
-const listLanguagesSchema = z.object({});
 const getSpecInfoSchema = z.object({
     specFilePath: z.string().describe('Path to the YAML specification file'),
 });
-const getSpecRulesSchema = z.object({});
-const checkSpecSchema = z.object({
-    specFilePath: z.string().describe('Path to the YAML specification file to check for common mistakes'),
-});
+const listLanguagesSchema = z.object({});
 // 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');
+    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 to read doc files
+async function readDocFile(filename) {
+    const docPath = path.join(__dirname, 'docs', filename);
+    return fs.readFile(docPath, 'utf-8');
 }
 // Helper function to read YAML files
 async function readYaml(filePath) {
@@ -66,14 +89,12 @@ function validateSpecData(data) {
     if (!isRecord(data)) {
         return { valid: false };
     }
-    // Check for required info
     if (!isRecord(data.info)) {
         return { valid: false };
     }
     if (!isSpecInfo(data.info)) {
         return { valid: false };
     }
-    // At least one of types or groupedTypes must exist
     const types = isRecord(data.types) ? data.types : undefined;
     const groupedTypes = isRecord(data.groupedTypes) ? data.groupedTypes : undefined;
     if (typeof types === 'undefined' && typeof groupedTypes === 'undefined') {
@@ -86,122 +107,235 @@ function validateSpecData(data) {
         groupedTypes,
     };
 }
+function checkSpecContent(specContent, resolvedSpecPath) {
+    const issues = [];
+    const warnings = [];
+    let isTopFile = false;
+    let fileType = 'UNKNOWN';
+    // Parse YAML to determine file type
+    let specData;
+    try {
+        specData = parseYaml(specContent);
+        if (!isRecord(specData)) {
+            issues.push('Spec file root is not an object. Expected YAML object at root level.');
+        }
+        else {
+            if (isRecord(specData.info) && isSpecInfo(specData.info)) {
+                isTopFile = true;
+                fileType = 'TOP FILE';
+            }
+            else if (isRecord(specData.info)) {
+                isTopFile = false;
+                fileType = 'INCOMPLETE TOP FILE';
+                if (typeof specData.info.version !== 'string') {
+                    issues.push("Missing 'info.version' - Must be a string in semver format (e.g., '1.0.0').");
+                }
+                if (typeof specData.info.title !== 'string') {
+                    issues.push("Missing 'info.title' - Must be a string describing the spec.");
+                }
+            }
+            else {
+                isTopFile = false;
+                fileType = 'NON-TOP FILE';
+            }
+            const hasTypes = isRecord(specData.types);
+            const hasGroupedTypes = isRecord(specData.groupedTypes);
+            if (isTopFile && !hasTypes && !hasGroupedTypes) {
+                issues.push("Missing 'types' or 'groupedTypes' section - Top files must have at least one of these sections.");
+            }
+        }
+    }
+    catch (error) {
+        if (isExecError(error)) {
+            issues.push(`YAML parsing error: ${error.message}`);
+        }
+        else {
+            issues.push('YAML parsing error: Unable to parse spec file.');
+        }
+    }
+    const relativeFromCwd = path.relative(process.cwd(), resolvedSpecPath);
+    const suggestedPath = relativeFromCwd.startsWith('.') ? relativeFromCwd : `./${relativeFromCwd}`;
+    const lines = specContent.split('\n');
+    lines.forEach((line, index) => {
+        const lineNum = index + 1;
+        // Check for 'nullable: true'
+        if (line.match(/nullable\s*:\s*true/i)) {
+            issues.push(`Line ${lineNum}: Found 'nullable: true' - This property does NOT exist in Type Crafter. ` +
+                `Use the 'required' array to control nullability instead.`);
+        }
+        // Check for 'optional: true'
+        if (line.match(/optional\s*:\s*true/i)) {
+            issues.push(`Line ${lineNum}: Found 'optional: true' - This property does NOT exist in Type Crafter. ` +
+                `Use the 'required' array to control nullability instead.`);
+        }
+        // Check for property names with '?'
+        if (line.match(/^\s+[\w]+\?\s*:/)) {
+            issues.push(`Line ${lineNum}: Found property name with '?' suffix - This syntax is NOT supported. ` +
+                `Use the 'required' array instead.`);
+        }
+        // Check for type: [string, null] pattern
+        if (line.match(/type\s*:\s*\[.*,\s*null\]/)) {
+            issues.push(`Line ${lineNum}: Found 'type: [type, null]' pattern - This is NOT supported. ` +
+                `Use the 'required' array to control nullability instead.`);
+        }
+        // Check for top-level array types
+        if (line.match(/^\w+:\s*$/) && lines[index + 1]?.match(/^\s+type\s*:\s*array/)) {
+            warnings.push(`Line ${lineNum}: Possible top-level array type - Arrays cannot be top-level types. ` +
+                `They must be properties within objects.`);
+        }
+        // Check for '../' in $ref paths
+        if (line.match(/\$ref\s*:\s*['"].*\.\.\//)) {
+            issues.push(`Line ${lineNum}: Found relative path with '../' in $ref - Paths should be from project root, ` +
+                `not relative to the current file. Use './path/from/root/file.yaml#/Type' format.`);
+        }
+        // Check for # references in NON-TOP files
+        if (!isTopFile && fileType === 'NON-TOP FILE') {
+            const refMatch = line.match(/\$ref\s*:\s*['"]#\/([^'"]+)['"]/);
+            if (refMatch) {
+                const refPath = refMatch[1];
+                issues.push(`Line ${lineNum}: Found '#/${refPath}' reference in a NON-TOP FILE. ` +
+                    `Non-top files (files without 'info' section) MUST use complete file paths for ALL references. ` +
+                    `Use: $ref: '${suggestedPath}#/${refPath}'`);
+            }
+        }
+        // Check for missing './' prefix in external $ref
+        if (line.match(/\$ref\s*:\s*['"][^#'][^/]/)) {
+            const match = line.match(/\$ref\s*:\s*['"]([^'"]+)['"]/);
+            if (match && match[1] && !match[1].startsWith('#') && !match[1].startsWith('./')) {
+                warnings.push(`Line ${lineNum}: External $ref path should start with './' - ` +
+                    `Use './path/from/root/file.yaml#/Type' format.`);
+            }
+        }
+    });
+    return { issues, warnings, isTopFile, fileType };
+}
 // Create server instance
 const server = new McpServer({
-    name: 'type-crafter-mcp-server',
-    version: '0.1.0',
+    name: 'type-crafter-mcp',
+    version: '0.2.0',
 }, {
     capabilities: {
         tools: {},
     },
 });
-// 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: generateTypesSchema,
-}, async (args) => {
-    if (!isGenerateTypesArgs(args)) {
+// Tool 1: get-writing-guide
+server.registerTool('get-writing-guide', {
+    description: 'Get the Type Crafter YAML specification writing guide. ' +
+        'CALL THIS FIRST before writing any YAML specs. ' +
+        'Returns a sessionId that should be passed to other tools. ' +
+        'The guide includes common mistakes to avoid, quick reference, and links to detailed sections.',
+    inputSchema: getWritingGuideSchema,
+}, async () => {
+    try {
+        const sessionId = createSession();
+        const guideContent = await readDocFile('WRITING_GUIDE.md');
         return {
             content: [
                 {
                     type: 'text',
-                    text: 'Error: Invalid arguments provided',
+                    text: `SESSION: ${sessionId}\n\n` +
+                        `Save this sessionId and pass it to other Type Crafter tools.\n\n` +
+                        `---\n\n${guideContent}`,
                 },
             ],
-            isError: true,
         };
     }
-    const { language, specFilePath, outputDirectory, typesWriterMode = 'SingleFile', groupedTypesWriterMode = 'SingleFile', } = args;
-    // Validate language
-    if (!['typescript', 'typescript-with-decoders'].includes(language.toLowerCase())) {
+    catch (error) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Error: Unsupported language "${language}". Supported languages: typescript, typescript-with-decoders`,
+                    text: `Error reading writing guide: ${isExecError(error) ? error.message : 'Unknown error'}`,
                 },
             ],
             isError: true,
         };
     }
-    // Resolve paths
-    const resolvedSpecPath = path.resolve(specFilePath);
-    const resolvedOutputPath = path.resolve(outputDirectory);
-    // Check if spec file exists
-    try {
-        await fs.access(resolvedSpecPath);
-    }
-    catch {
+});
+// Tool 2: get-rules-section
+server.registerTool('get-rules-section', {
+    description: 'Get detailed rules for a specific topic. ' +
+        'Available sections: structure, types, nullable, references, composition, patterns. ' +
+        'Pass the sessionId from get-writing-guide for best experience.',
+    inputSchema: getRulesSectionSchema,
+}, async (args) => {
+    const parsed = getRulesSectionSchema.safeParse(args);
+    if (!parsed.success) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Error: Specification file not found at ${resolvedSpecPath}`,
+                    text: 'Error: Invalid arguments. Required: section (structure|types|nullable|references|composition|patterns)',
                 },
             ],
             isError: true,
         };
     }
-    // Use the type-crafter CLI to generate types
-    const cliCommand = `type-crafter generate ${language} "${resolvedSpecPath}" "${resolvedOutputPath}" ${typesWriterMode} ${groupedTypesWriterMode}`;
+    const { sessionId, section } = parsed.data;
+    // Check session - warn if not provided but don't block
+    let sessionWarning = '';
+    if (!sessionId) {
+        sessionWarning =
+            '** Note: No sessionId provided. Call get-writing-guide first to get the basics and a sessionId.\n\n';
+    }
+    else if (!isValidSession(sessionId)) {
+        sessionWarning =
+            '** Note: Invalid or expired sessionId. Consider calling get-writing-guide again.\n\n';
+    }
+    const sectionFileMap = {
+        structure: 'RULES_STRUCTURE.md',
+        types: 'RULES_TYPES.md',
+        nullable: 'RULES_NULLABLE.md',
+        references: 'RULES_REFERENCES.md',
+        composition: 'RULES_COMPOSITION.md',
+        patterns: 'RULES_PATTERNS.md',
+    };
     try {
-        const { stdout, stderr } = await execAsync(cliCommand);
-        const warningText = typeof stderr !== 'undefined' && stderr.length > 0 ? '\nWarnings:\n' + stderr : '';
+        const content = await readDocFile(sectionFileMap[section]);
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Successfully generated ${language} types from ${specFilePath}\nOutput saved to: ${outputDirectory}\n\n${stdout}${warningText}`,
+                    text: sessionWarning + content,
                 },
             ],
         };
     }
     catch (error) {
-        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: ${error.message}\n${errorDetails}`,
+                    text: `Error reading section '${section}': ${isExecError(error) ? error.message : 'Unknown error'}`,
                 },
             ],
             isError: true,
         };
     }
 });
-// Register validate-spec tool
+// Tool 3: validate-spec
 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.',
+    description: 'Validate a YAML specification file for correctness. ' +
+        'Checks structure AND common mistakes (nullable, optional, paths, etc.). ' +
+        'If validation fails with common mistakes, you likely need to read get-writing-guide first. ' +
+        'Pass sessionId from get-writing-guide for best experience.',
     inputSchema: validateSpecSchema,
 }, async (args) => {
-    if (!isSpecFilePathArgs(args)) {
+    const parsed = validateSpecSchema.safeParse(args);
+    if (!parsed.success) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: 'Error: Invalid arguments provided',
+                    text: 'Error: Invalid arguments. Required: specFilePath',
                 },
             ],
             isError: true,
         };
     }
-    const { specFilePath } = args;
-    // Resolve path
+    const { sessionId, specFilePath } = parsed.data;
     const resolvedSpecPath = path.resolve(specFilePath);
-    // Check if spec file exists
+    // Check if file exists
     try {
         await fs.access(resolvedSpecPath);
     }
@@ -216,68 +350,114 @@ server.registerTool('validate-spec', {
             isError: true,
         };
     }
-    // Try to read and validate the spec
-    const specFileData = await readYaml(resolvedSpecPath);
-    const validation = validateSpecData(specFileData);
-    if (!validation.valid || typeof validation.info === 'undefined') {
+    // Read spec content
+    let specContent;
+    try {
+        specContent = await fs.readFile(resolvedSpecPath, 'utf-8');
+    }
+    catch (error) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: 'Error: Invalid specification file. Neither types nor groupedTypes found!',
+                    text: `Error reading spec file: ${isExecError(error) ? error.message : 'Unknown error'}`,
                 },
             ],
             isError: true,
         };
     }
-    const typesCount = typeof validation.types !== 'undefined' ? Object.keys(validation.types).length : 0;
-    const groupedTypesCount = typeof validation.groupedTypes !== 'undefined'
-        ? Object.keys(validation.groupedTypes).length
-        : 0;
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `✓ Specification file is valid!\n\nInfo:\n  Version: ${validation.info.version}\n  Title: ${validation.info.title}\n  Types: ${typesCount}\n  Grouped Types: ${groupedTypesCount}`,
-            },
-        ],
-    };
-});
-// Register list-languages tool
-server.registerTool('list-languages', {
-    description: 'List all supported target languages for type generation',
-    inputSchema: listLanguagesSchema,
-}, async () => {
+    // Run checks
+    const checkResult = checkSpecContent(specContent, resolvedSpecPath);
+    const fileName = path.basename(resolvedSpecPath);
+    let response = `File: ${fileName}\nType: ${checkResult.fileType}\n\n`;
+    // Add file type explanation
+    if (checkResult.fileType === 'TOP FILE') {
+        response += 'This is a TOP FILE (has info section).\n';
+        response += '- Can use #/types/TypeName for same-file references\n';
+        response += '- Can be used with type-crafter generate CLI\n\n';
+    }
+    else if (checkResult.fileType === 'NON-TOP FILE') {
+        response += 'This is a NON-TOP FILE (no info section).\n';
+        response += '- MUST use full paths for ALL references\n';
+        response += '- Must be referenced from a top file\n\n';
+    }
+    // Check if there are issues and no session - suggest reading guide
+    const hasCommonMistakes = checkResult.issues.some((i) => i.includes('nullable') ||
+        i.includes('optional') ||
+        i.includes("'?'") ||
+        i.includes('../') ||
+        i.includes('NON-TOP FILE'));
+    if (hasCommonMistakes && !isValidSession(sessionId)) {
+        response +=
+            '** RECOMMENDATION: These errors suggest you may not have read the writing guide.\n' +
+                '** Call get-writing-guide first to learn the correct YAML format.\n\n';
+    }
+    if (checkResult.issues.length === 0 && checkResult.warnings.length === 0) {
+        // Also validate structure
+        const specData = await readYaml(resolvedSpecPath);
+        const structureValidation = validateSpecData(specData);
+        if (structureValidation.valid && structureValidation.info) {
+            const typesCount = structureValidation.types
+                ? Object.keys(structureValidation.types).length
+                : 0;
+            const groupedTypesCount = structureValidation.groupedTypes
+                ? Object.keys(structureValidation.groupedTypes).length
+                : 0;
+            response += 'VALID - Specification file is valid!\n\n';
+            response += `Version: ${structureValidation.info.version}\n`;
+            response += `Title: ${structureValidation.info.title}\n`;
+            response += `Types: ${typesCount}\n`;
+            response += `Grouped Types: ${groupedTypesCount}\n\n`;
+            response += 'You can now run: type-crafter generate <language> <spec-path> <output-dir>';
+            return {
+                content: [{ type: 'text', text: response }],
+            };
+        }
+    }
+    if (checkResult.issues.length > 0) {
+        response += 'ISSUES FOUND:\n\n';
+        checkResult.issues.forEach((issue, idx) => {
+            response += `${idx + 1}. ${issue}\n\n`;
+        });
+    }
+    if (checkResult.warnings.length > 0) {
+        response += 'WARNINGS:\n\n';
+        checkResult.warnings.forEach((warning, idx) => {
+            response += `${idx + 1}. ${warning}\n\n`;
+        });
+    }
+    if (checkResult.issues.length > 0 || checkResult.warnings.length > 0) {
+        response += '\nFor detailed rules, call get-rules-section with the relevant topic:\n';
+        response += '- nullable: How to control nullability with required array\n';
+        response += '- references: $ref syntax and path rules\n';
+        response += '- types: Object, enum, array definitions\n';
+        response += '- structure: Top file vs non-top file rules\n';
+    }
     return {
-        content: [
-            {
-                type: 'text',
-                text: 'Supported Languages:\n\n1. typescript - Generate TypeScript type definitions\n2. typescript-with-decoders - Generate TypeScript types with runtime decoders',
-            },
-        ],
+        content: [{ type: 'text', text: response }],
+        isError: checkResult.issues.length > 0,
     };
 });
-// Register get-spec-info tool
+// Tool 4: get-spec-info
 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.',
+        'and all types defined in the spec.',
     inputSchema: getSpecInfoSchema,
 }, async (args) => {
-    if (!isSpecFilePathArgs(args)) {
+    const parsed = getSpecInfoSchema.safeParse(args);
+    if (!parsed.success) {
         return {
             content: [
                 {
                     type: 'text',
-                    text: 'Error: Invalid arguments provided',
+                    text: 'Error: Invalid arguments. Required: specFilePath',
                 },
             ],
             isError: true,
         };
     }
-    const { specFilePath } = args;
-    // Resolve path
+    const { specFilePath } = parsed.data;
     const resolvedSpecPath = path.resolve(specFilePath);
-    // Check if spec file exists
     try {
         await fs.access(resolvedSpecPath);
     }
@@ -292,7 +472,6 @@ server.registerTool('get-spec-info', {
             isError: true,
         };
     }
-    // Read and validate the spec
     const specFileData = await readYaml(resolvedSpecPath);
     const validation = validateSpecData(specFileData);
     if (!validation.valid || typeof validation.info === 'undefined') {
@@ -300,7 +479,7 @@ server.registerTool('get-spec-info', {
             content: [
                 {
                     type: 'text',
-                    text: 'Error: Invalid specification file format',
+                    text: 'Error: Invalid specification file format. Missing info section or types/groupedTypes.',
                 },
             ],
             isError: true,
@@ -339,243 +518,40 @@ server.registerTool('get-spec-info', {
         });
     }
     return {
-        content: [
-            {
-                type: 'text',
-                text: infoText,
-            },
-        ],
+        content: [{ type: 'text', text: infoText }],
     };
 });
-// Register get-spec-rules tool
-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: getSpecRulesSchema,
+// Tool 5: list-languages
+server.registerTool('list-languages', {
+    description: 'List all supported target languages for type generation with the type-crafter CLI.',
+    inputSchema: listLanguagesSchema,
 }, async () => {
-    try {
-        // Read the SPEC_RULES.md file from src directory
-        const rulesPath = path.join(__dirname, '..', 'src', 'SPEC_RULES.md');
-        const rulesContent = await fs.readFile(rulesPath, 'utf-8');
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: rulesContent,
-                },
-            ],
-        };
-    }
-    catch (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: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
-// Register check-spec tool
-server.registerTool('check-spec', {
-    description: 'Check a YAML specification file for common mistakes and provide helpful feedback. ' +
-        'This tool detects issues like using nullable/optional properties, incorrect array definitions, ' +
-        'wrong file paths, and other common errors. Use this before generating types to catch mistakes early.',
-    inputSchema: checkSpecSchema,
-}, 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);
-    // Check if spec file exists
-    try {
-        await fs.access(resolvedSpecPath);
-    }
-    catch {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error: Specification file not found at ${resolvedSpecPath}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-    // Read the spec file
-    let specContent;
-    try {
-        specContent = await fs.readFile(resolvedSpecPath, 'utf-8');
-    }
-    catch (error) {
-        if (!isExecError(error)) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Error: Unknown error occurred while reading spec file',
-                    },
-                ],
-                isError: true,
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error reading spec file: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-    const issues = [];
-    const warnings = [];
-    // Check for common mistakes
-    const lines = specContent.split('\n');
-    lines.forEach((line, index) => {
-        const lineNum = index + 1;
-        // Check for 'nullable: true'
-        if (line.match(/nullable\s*:\s*true/i)) {
-            issues.push(`Line ${lineNum}: Found 'nullable: true' - This property does NOT exist in Type Crafter. ` +
-                `Use the 'required' array to control nullability instead.`);
-        }
-        // Check for 'optional: true'
-        if (line.match(/optional\s*:\s*true/i)) {
-            issues.push(`Line ${lineNum}: Found 'optional: true' - This property does NOT exist in Type Crafter. ` +
-                `Use the 'required' array to control optionality instead.`);
-        }
-        // Check for property names with '?'
-        if (line.match(/^\s+[\w]+\?\s*:/)) {
-            issues.push(`Line ${lineNum}: Found property name with '?' suffix - This syntax is NOT supported. ` +
-                `Use the 'required' array instead.`);
-        }
-        // Check for type: [string, null] pattern
-        if (line.match(/type\s*:\s*\[.*,\s*null\]/)) {
-            issues.push(`Line ${lineNum}: Found 'type: [type, null]' pattern - This is NOT supported. ` +
-                `Use the 'required' array to control nullability instead.`);
-        }
-        // Check for top-level array types (heuristic)
-        if (line.match(/^\w+:\s*$/) && lines[index + 1]?.match(/^\s+type\s*:\s*array/)) {
-            warnings.push(`Line ${lineNum}: Possible top-level array type - Arrays cannot be top-level types. ` +
-                `They must be properties within objects. Verify this is inside an object's properties.`);
-        }
-        // Check for '../' in $ref paths
-        if (line.match(/\$ref\s*:\s*['"].*\.\.\//)) {
-            issues.push(`Line ${lineNum}: Found relative path with '../' in $ref - Paths should be from project root, ` +
-                `not relative to the current file. Use './path/from/root/file.yaml#/Type' format.`);
-        }
-        // Check for missing './' prefix in external $ref
-        if (line.match(/\$ref\s*:\s*['"][^#'][^/]/)) {
-            const match = line.match(/\$ref\s*:\s*['"]([^'"]+)['"]/);
-            if (match && match[1] && !match[1].startsWith('#') && !match[1].startsWith('./')) {
-                warnings.push(`Line ${lineNum}: External $ref path should start with './' - ` +
-                    `Use './path/from/root/file.yaml#/Type' format.`);
-            }
-        }
-    });
-    // Try to parse YAML and check for structural issues
-    try {
-        const specData = parseYaml(specContent);
-        if (!isRecord(specData)) {
-            issues.push('Spec file root is not an object. Expected YAML object at root level.');
-        }
-        else {
-            // Check for missing info section
-            if (!isRecord(specData.info)) {
-                issues.push("Missing 'info' section - Every spec file must have an 'info' section with 'version' and 'title'.");
-            }
-            else if (!isSpecInfo(specData.info)) {
-                if (typeof specData.info.version !== 'string') {
-                    issues.push("Missing 'info.version' - Must be a string in semver format (e.g., '1.0.0').");
-                }
-                if (typeof specData.info.title !== 'string') {
-                    issues.push("Missing 'info.title' - Must be a string describing the spec.");
-                }
-            }
-            // Check if at least one of types or groupedTypes exists
-            const hasTypes = isRecord(specData.types);
-            const hasGroupedTypes = isRecord(specData.groupedTypes);
-            if (!hasTypes && !hasGroupedTypes) {
-                issues.push("Missing 'types' or 'groupedTypes' section - At least one must be defined.");
-            }
-        }
-    }
-    catch (error) {
-        if (isExecError(error)) {
-            issues.push(`YAML parsing error: ${error.message}`);
-        }
-        else {
-            issues.push('YAML parsing error: Unable to parse spec file.');
-        }
-    }
-    // Generate response
-    if (issues.length === 0 && warnings.length === 0) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: '✅ No common mistakes detected!\n\nThe spec file looks good. You can proceed with validation using validate-spec or generation using generate-types.',
-                },
-            ],
-        };
-    }
-    let response = '';
-    if (issues.length > 0) {
-        response += '❌ Issues Found:\n\n';
-        issues.forEach((issue, idx) => {
-            response += `${idx + 1}. ${issue}\n\n`;
-        });
-    }
-    if (warnings.length > 0) {
-        if (issues.length > 0)
-            response += '\n';
-        response += '⚠️  Warnings:\n\n';
-        warnings.forEach((warning, idx) => {
-            response += `${idx + 1}. ${warning}\n\n`;
-        });
-    }
-    response +=
-        '\n📖 For detailed rules and examples, use the get-spec-rules tool to see complete documentation.';
     return {
         content: [
             {
                 type: 'text',
-                text: response,
+                text: 'Supported Languages for type-crafter generate:\n\n' +
+                    '1. typescript\n' +
+                    '   - Generates TypeScript type definitions (.ts files)\n' +
+                    '   - Usage: type-crafter generate typescript <spec.yaml> <output-dir>\n\n' +
+                    '2. typescript-with-decoders\n' +
+                    '   - Generates TypeScript types WITH runtime decoders\n' +
+                    '   - Useful for runtime validation of API responses\n' +
+                    '   - Usage: type-crafter generate typescript-with-decoders <spec.yaml> <output-dir>\n\n' +
+                    'Writer Modes:\n' +
+                    '- typesWriterMode: SingleFile | Files\n' +
+                    '- groupedTypesWriterMode: FolderWithFiles | SingleFile\n\n' +
+                    'Example:\n' +
+                    'type-crafter generate typescript ./types.yaml ./src/types SingleFile FolderWithFiles',
             },
         ],
-        isError: issues.length > 0,
     };
 });
 // Start the server
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('Type Crafter MCP Server running on stdio');
+    console.error('Type Crafter MCP Server v0.2.0 running on stdio');
 }
 main().catch((error) => {
     console.error('Server error:', error);