@tekton-ui/mcp-server 0.3.0

package/dist/tools/validate-environment.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Validate Environment MCP Tool
+ * SPEC-MCP-005 Phase 2: Check if user's project has required NPM packages installed
+ * SPEC-MCP-005: Tailwind CSS 설정 검증 확장
+ */
+import type { ValidateEnvironmentInput, ValidateEnvironmentOutput } from '../schemas/mcp-schemas.js';
+/**
+ * Validate user's environment for required dependencies
+ *
+ * Compares required packages against installed packages in package.json
+ * and provides installation commands for missing packages.
+ * Optionally validates Tailwind CSS configuration for @tekton-ui/ui compatibility.
+ *
+ * @param input - Project path and required packages to validate
+ * @returns Validation result with installed/missing packages and install commands
+ *
+ * @example
+ * ```typescript
+ * const result = await validateEnvironmentTool({
+ *   projectPath: '/path/to/project',
+ *   requiredPackages: ['framer-motion', 'react'],
+ *   checkTailwind: true
+ * });
+ *
+ * if (result.success && result.missing.length > 0) {
+ *   console.log(`Missing packages: ${result.missing.join(', ')}`);
+ *   console.log(`Install with: ${result.installCommands.npm}`);
+ * }
+ *
+ * if (result.tailwind?.issues.length) {
+ *   console.log('Tailwind issues:', result.tailwind.issues);
+ *   console.log('Fixes:', result.tailwind.fixes);
+ * }
+ * ```
+ */
+export declare function validateEnvironmentTool(input: ValidateEnvironmentInput): Promise<ValidateEnvironmentOutput>;
+//# sourceMappingURL=validate-environment.d.ts.map

package/dist/tools/validate-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-environment.d.ts","sourceRoot":"","sources":["../../src/tools/validate-environment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,2BAA2B,CAAC;AAKnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,yBAAyB,CAAC,CAqGpC"}

package/dist/tools/validate-environment.js

@@ -0,0 +1,153 @@
+/**
+ * Validate Environment MCP Tool
+ * SPEC-MCP-005 Phase 2: Check if user's project has required NPM packages installed
+ * SPEC-MCP-005: Tailwind CSS 설정 검증 확장
+ */
+import { readPackageJson } from '../utils/package-json-reader.js';
+import { readTailwindConfig } from '../utils/tailwind-config-reader.js';
+import { extractErrorMessage } from '../utils/error-handler.js';
+/**
+ * Validate user's environment for required dependencies
+ *
+ * Compares required packages against installed packages in package.json
+ * and provides installation commands for missing packages.
+ * Optionally validates Tailwind CSS configuration for @tekton-ui/ui compatibility.
+ *
+ * @param input - Project path and required packages to validate
+ * @returns Validation result with installed/missing packages and install commands
+ *
+ * @example
+ * ```typescript
+ * const result = await validateEnvironmentTool({
+ *   projectPath: '/path/to/project',
+ *   requiredPackages: ['framer-motion', 'react'],
+ *   checkTailwind: true
+ * });
+ *
+ * if (result.success && result.missing.length > 0) {
+ *   console.log(`Missing packages: ${result.missing.join(', ')}`);
+ *   console.log(`Install with: ${result.installCommands.npm}`);
+ * }
+ *
+ * if (result.tailwind?.issues.length) {
+ *   console.log('Tailwind issues:', result.tailwind.issues);
+ *   console.log('Fixes:', result.tailwind.fixes);
+ * }
+ * ```
+ */
+export async function validateEnvironmentTool(input) {
+    try {
+        const { projectPath, requiredPackages, checkTailwind } = input;
+        // Step 1: Read package.json from the project
+        const readResult = readPackageJson(projectPath);
+        if (!readResult.success || !readResult.installedPackages) {
+            return {
+                success: false,
+                error: readResult.error || 'Failed to read package.json',
+            };
+        }
+        const installedPackages = readResult.installedPackages;
+        // Step 2: Compare required packages with installed packages
+        const installed = {};
+        const missing = [];
+        for (const packageName of requiredPackages) {
+            const version = installedPackages[packageName];
+            if (version !== undefined) {
+                // Package is installed
+                installed[packageName] = version;
+            }
+            else {
+                // Package is missing
+                missing.push(packageName);
+            }
+        }
+        // Step 3: Generate install commands for missing packages
+        const installCommands = generateInstallCommands(missing);
+        // Step 4: Check for potential warnings (optional enhancement)
+        const warnings = [];
+        // Step 5: Tailwind CSS 설정 검증
+        let tailwind;
+        if (checkTailwind !== false) {
+            const tailwindResult = readTailwindConfig(projectPath);
+            const issues = [];
+            const fixes = [];
+            if (!tailwindResult.found) {
+                issues.push('tailwind.config.{ts,js,mjs,cjs} not found in project root');
+                fixes.push('Create a tailwind.config.ts file in your project root. ' +
+                    'See https://tailwindcss.com/docs/configuration for setup guide.');
+            }
+            else {
+                if (!tailwindResult.hasUiContentPath) {
+                    issues.push('tailwind.config content paths do not include @tekton-ui/ui — ' +
+                        'component styles (Dialog, AlertDialog, Popover, etc.) will not be compiled');
+                    fixes.push("Add '../../packages/ui/src/**/*.{ts,tsx}' (monorepo) or " +
+                        "'node_modules/@tekton-ui/ui/dist/**/*.{js,ts,jsx,tsx}' (standalone) " +
+                        'to the content array in your tailwind.config');
+                }
+                if (!tailwindResult.hasAnimatePlugin) {
+                    issues.push('tailwindcss-animate plugin is not configured — ' +
+                        'Radix UI component animations (Dialog open/close, Popover, Tooltip) will not work');
+                    fixes.push('Install tailwindcss-animate (npm install tailwindcss-animate) and add it to plugins array: ' +
+                        "import animate from 'tailwindcss-animate'; plugins: [animate]");
+                }
+            }
+            tailwind = {
+                configFound: tailwindResult.found,
+                configPath: tailwindResult.configPath,
+                hasUiContentPath: tailwindResult.hasUiContentPath,
+                hasAnimatePlugin: tailwindResult.hasAnimatePlugin,
+                issues,
+                fixes,
+            };
+        }
+        return {
+            success: true,
+            installed,
+            missing,
+            installCommands,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            tailwind,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: extractErrorMessage(error),
+        };
+    }
+}
+/**
+ * Generate installation commands for multiple package managers
+ *
+ * @param packages - Array of package names to install
+ * @returns Install commands for npm, yarn, pnpm, and bun
+ *
+ * @example
+ * ```typescript
+ * const commands = generateInstallCommands(['react', 'react-dom']);
+ * // {
+ * //   npm: 'npm install react react-dom',
+ * //   yarn: 'yarn add react react-dom',
+ * //   pnpm: 'pnpm add react react-dom',
+ * //   bun: 'bun add react react-dom'
+ * // }
+ * ```
+ */
+function generateInstallCommands(packages) {
+    if (packages.length === 0) {
+        return {
+            npm: '',
+            yarn: '',
+            pnpm: '',
+            bun: '',
+        };
+    }
+    const packageList = packages.join(' ');
+    return {
+        npm: `npm install ${packageList}`,
+        yarn: `yarn add ${packageList}`,
+        pnpm: `pnpm add ${packageList}`,
+        bun: `bun add ${packageList}`,
+    };
+}
+//# sourceMappingURL=validate-environment.js.map

package/dist/tools/validate-environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-environment.js","sourceRoot":"","sources":["../../src/tools/validate-environment.ts"],"names":[],"mappings":"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"}

package/dist/tools/validate-screen-definition.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validate Screen Definition MCP Tool
+ * SPEC-MCP-004 Phase 3.5: Validates screen definitions with helpful feedback
+ */
+import type { ValidateScreenDefinitionInput, ValidateScreenDefinitionOutput } from '../schemas/mcp-schemas.js';
+/**
+ * Validate Screen Definition tool implementation
+ */
+export declare function validateScreenDefinitionTool(input: ValidateScreenDefinitionInput): Promise<ValidateScreenDefinitionOutput>;
+//# sourceMappingURL=validate-screen-definition.d.ts.map

package/dist/tools/validate-screen-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-screen-definition.d.ts","sourceRoot":"","sources":["../../src/tools/validate-screen-definition.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,6BAA6B,EAC7B,8BAA8B,EAI/B,MAAM,2BAA2B,CAAC;AA2anC;;GAEG;AACH,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,8BAA8B,CAAC,CAkGzC"}

package/dist/tools/validate-screen-definition.js

@@ -0,0 +1,463 @@
+/**
+ * Validate Screen Definition MCP Tool
+ * SPEC-MCP-004 Phase 3.5: Validates screen definitions with helpful feedback
+ */
+import { COMPONENT_CATALOG } from '@tekton-ui/core';
+import { ScreenDefinitionSchema } from '../schemas/mcp-schemas.js';
+import { extractErrorMessage } from '../utils/error-handler.js';
+/**
+ * Valid shell tokens from SPEC-LAYOUT-001 and SPEC-LAYOUT-004
+ */
+const VALID_SHELLS = [
+    // Web shells
+    'shell.web.app',
+    'shell.web.dashboard',
+    'shell.web.auth',
+    'shell.web.marketing',
+    'shell.web.minimal',
+    // Mobile shells (SPEC-LAYOUT-004)
+    'shell.mobile.app',
+    'shell.mobile.fullscreen',
+    'shell.mobile.modal',
+    'shell.mobile.tab',
+    'shell.mobile.drawer',
+    'shell.mobile.detail',
+];
+/**
+ * Valid page tokens from SPEC-LAYOUT-001
+ */
+const VALID_PAGES = ['page.dashboard', 'page.detail', 'page.wizard', 'page.resource', 'page.empty'];
+/**
+ * Valid section patterns from SPEC-LAYOUT-001
+ */
+const VALID_SECTION_PATTERNS = [
+    'section.container',
+    'section.centered',
+    'section.grid-2',
+    'section.grid-3',
+    'section.grid-4',
+    'section.split-50-50',
+    'section.split-60-40',
+    'section.split-70-30',
+    'section.hero',
+    'section.feature',
+];
+/**
+ * Valid slot names
+ */
+const VALID_SLOTS = ['header', 'main', 'sidebar', 'footer'];
+/**
+ * Get similar values for suggestions (Levenshtein distance based)
+ */
+function getSimilarValues(value, validValues) {
+    const similar = [];
+    for (const valid of validValues) {
+        const distance = levenshteinDistance(value.toLowerCase(), valid.toLowerCase());
+        if (distance <= 3) {
+            similar.push({ value: valid, distance });
+        }
+    }
+    return similar
+        .sort((a, b) => a.distance - b.distance)
+        .slice(0, 3)
+        .map(s => s.value);
+}
+/**
+ * Simple Levenshtein distance implementation
+ */
+function levenshteinDistance(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            const cost = b.charAt(i - 1) === a.charAt(j - 1) ? 0 : 1;
+            matrix[i][j] = Math.min((matrix[i - 1]?.[j] ?? 0) + 1, (matrix[i]?.[j - 1] ?? 0) + 1, (matrix[i - 1]?.[j - 1] ?? 0) + cost);
+        }
+    }
+    return matrix[b.length]?.[a.length] ?? 0;
+}
+/**
+ * Validate shell token
+ */
+function validateShell(shell, path) {
+    const errors = [];
+    const warnings = [];
+    if (!shell.startsWith('shell.')) {
+        errors.push({
+            path,
+            code: 'INVALID_SHELL_FORMAT',
+            message: 'Shell token must start with "shell."',
+            expected: 'shell.{platform}.{name}',
+            received: shell,
+            suggestion: `Use format: shell.web.app or shell.mobile.app`,
+        });
+        return { errors, warnings };
+    }
+    if (!VALID_SHELLS.includes(shell)) {
+        const similar = getSimilarValues(shell, VALID_SHELLS);
+        errors.push({
+            path,
+            code: 'UNKNOWN_SHELL',
+            message: `Unknown shell token: "${shell}"`,
+            expected: VALID_SHELLS.slice(0, 5).join(', ') + '...',
+            received: shell,
+            suggestion: similar.length > 0
+                ? `Did you mean: ${similar.join(', ')}?`
+                : `Valid shells: ${VALID_SHELLS.join(', ')}`,
+        });
+    }
+    return { errors, warnings };
+}
+/**
+ * Validate page token
+ */
+function validatePage(page, path) {
+    const errors = [];
+    const warnings = [];
+    if (!page.startsWith('page.')) {
+        errors.push({
+            path,
+            code: 'INVALID_PAGE_FORMAT',
+            message: 'Page token must start with "page."',
+            expected: 'page.{name}',
+            received: page,
+            suggestion: 'Use format: page.dashboard, page.detail, etc.',
+        });
+        return { errors, warnings };
+    }
+    if (!VALID_PAGES.includes(page)) {
+        const similar = getSimilarValues(page, VALID_PAGES);
+        errors.push({
+            path,
+            code: 'UNKNOWN_PAGE',
+            message: `Unknown page token: "${page}"`,
+            expected: VALID_PAGES.join(', '),
+            received: page,
+            suggestion: similar.length > 0
+                ? `Did you mean: ${similar.join(', ')}?`
+                : `Valid pages: ${VALID_PAGES.join(', ')}`,
+        });
+    }
+    return { errors, warnings };
+}
+/**
+ * Validate section pattern
+ */
+function validateSectionPattern(pattern, path, strict) {
+    const errors = [];
+    const warnings = [];
+    if (!pattern.startsWith('section.')) {
+        errors.push({
+            path,
+            code: 'INVALID_SECTION_FORMAT',
+            message: 'Section pattern must start with "section."',
+            expected: 'section.{name}',
+            received: pattern,
+            suggestion: 'Use format: section.container, section.grid-4, etc.',
+        });
+        return { errors, warnings };
+    }
+    if (!VALID_SECTION_PATTERNS.includes(pattern)) {
+        if (strict) {
+            const similar = getSimilarValues(pattern, VALID_SECTION_PATTERNS);
+            errors.push({
+                path,
+                code: 'UNKNOWN_SECTION_PATTERN',
+                message: `Unknown section pattern: "${pattern}"`,
+                expected: VALID_SECTION_PATTERNS.slice(0, 5).join(', ') + '...',
+                received: pattern,
+                suggestion: similar.length > 0
+                    ? `Did you mean: ${similar.join(', ')}?`
+                    : `Valid patterns: ${VALID_SECTION_PATTERNS.join(', ')}`,
+            });
+        }
+        else {
+            warnings.push({
+                path,
+                code: 'CUSTOM_SECTION_PATTERN',
+                message: `Custom section pattern "${pattern}" - ensure it's defined in your layout system`,
+                recommendation: `Consider using standard patterns: ${VALID_SECTION_PATTERNS.slice(0, 5).join(', ')}`,
+            });
+        }
+    }
+    return { errors, warnings };
+}
+/**
+ * Validate component type
+ */
+function validateComponentType(type, path, strict) {
+    const errors = [];
+    const warnings = [];
+    // Check if component type exists in catalog (case-insensitive comparison)
+    const catalogLower = COMPONENT_CATALOG.map(c => c.toLowerCase());
+    const typeLower = type.toLowerCase();
+    if (!catalogLower.includes(typeLower)) {
+        const similar = getSimilarValues(type, COMPONENT_CATALOG);
+        if (strict) {
+            errors.push({
+                path,
+                code: 'UNKNOWN_COMPONENT',
+                message: `Unknown component type: "${type}"`,
+                expected: 'A component from @tekton-ui/ui catalog',
+                received: type,
+                suggestion: similar.length > 0
+                    ? `Did you mean: ${similar.join(', ')}?`
+                    : 'Use list-components tool to see available components',
+            });
+        }
+        else {
+            warnings.push({
+                path,
+                code: 'CUSTOM_COMPONENT',
+                message: `Component "${type}" not found in catalog - ensure it's a valid custom component`,
+                recommendation: similar.length > 0
+                    ? `Did you mean: ${similar.join(', ')}?`
+                    : 'Use list-components tool to see available components',
+            });
+        }
+    }
+    else {
+        // Check casing
+        const correctCase = COMPONENT_CATALOG.find(c => c.toLowerCase() === typeLower);
+        if (correctCase && correctCase !== type) {
+            warnings.push({
+                path,
+                code: 'COMPONENT_CASE',
+                message: `Component type "${type}" has incorrect casing`,
+                recommendation: `Use "${correctCase}" instead`,
+            });
+        }
+    }
+    return { errors, warnings };
+}
+/**
+ * Validate slot value
+ */
+function validateSlot(slot, path) {
+    const errors = [];
+    const warnings = [];
+    if (!VALID_SLOTS.includes(slot)) {
+        const similar = getSimilarValues(slot, VALID_SLOTS);
+        errors.push({
+            path,
+            code: 'INVALID_SLOT',
+            message: `Invalid slot value: "${slot}"`,
+            expected: VALID_SLOTS.join(', '),
+            received: slot,
+            suggestion: similar.length > 0
+                ? `Did you mean: ${similar.join(', ')}?`
+                : `Valid slots: ${VALID_SLOTS.join(', ')}`,
+        });
+    }
+    return { errors, warnings };
+}
+/**
+ * Generate improvement suggestions
+ */
+function generateSuggestions(definition) {
+    const suggestions = [];
+    // Handle null/undefined definition
+    if (!definition || typeof definition !== 'object') {
+        return suggestions;
+    }
+    // Check for missing name/description
+    if (!definition.name) {
+        suggestions.push({
+            category: 'maintainability',
+            message: 'Consider adding a human-readable name for better documentation',
+            affectedPath: 'name',
+            suggestedChange: 'Add a descriptive name property',
+        });
+    }
+    if (!definition.description) {
+        suggestions.push({
+            category: 'maintainability',
+            message: 'Consider adding a description for documentation purposes',
+            affectedPath: 'description',
+            suggestedChange: 'Add a brief description of the screen purpose',
+        });
+    }
+    // Check for missing themeId
+    if (!definition.themeId) {
+        suggestions.push({
+            category: 'consistency',
+            message: 'Consider specifying a themeId for consistent styling',
+            affectedPath: 'themeId',
+            suggestedChange: 'Add themeId to enable theme recipe application',
+        });
+    }
+    // Check sections
+    if (definition.sections && Array.isArray(definition.sections)) {
+        // Check for empty sections
+        for (let i = 0; i < definition.sections.length; i++) {
+            const section = definition.sections[i];
+            if (!section.components || section.components.length === 0) {
+                suggestions.push({
+                    category: 'maintainability',
+                    message: `Section "${section.id || i}" has no components`,
+                    affectedPath: `sections[${i}].components`,
+                    suggestedChange: 'Add components or remove empty section',
+                });
+            }
+            // Check for missing slot
+            if (!section.slot) {
+                suggestions.push({
+                    category: 'consistency',
+                    message: `Section "${section.id || i}" has no slot assigned`,
+                    affectedPath: `sections[${i}].slot`,
+                    suggestedChange: 'Assign to a slot (header, main, sidebar, footer) for proper layout positioning',
+                });
+            }
+            // Check components for accessibility
+            if (section.components && Array.isArray(section.components)) {
+                for (let j = 0; j < section.components.length; j++) {
+                    const component = section.components[j];
+                    // Check images for alt text
+                    if ((component.type === 'Image' || component.type === 'Avatar') &&
+                        (!component.props || !component.props.alt)) {
+                        suggestions.push({
+                            category: 'accessibility',
+                            message: `${component.type} component is missing alt text`,
+                            affectedPath: `sections[${i}].components[${j}].props.alt`,
+                            suggestedChange: 'Add descriptive alt text for screen readers',
+                        });
+                    }
+                    // Check inputs for labels
+                    if (component.type === 'Input' &&
+                        component.props &&
+                        !component.props.label &&
+                        !component.props['aria-label']) {
+                        suggestions.push({
+                            category: 'accessibility',
+                            message: 'Input component is missing a label',
+                            affectedPath: `sections[${i}].components[${j}].props.label`,
+                            suggestedChange: 'Add a label prop or aria-label for accessibility',
+                        });
+                    }
+                }
+            }
+        }
+        // Check for no main slot
+        const hasMainSlot = definition.sections.some((s) => s.slot === 'main' || !s.slot);
+        if (!hasMainSlot) {
+            suggestions.push({
+                category: 'consistency',
+                message: 'No section assigned to main slot',
+                affectedPath: 'sections',
+                suggestedChange: 'Assign at least one section to the main slot',
+            });
+        }
+    }
+    return suggestions;
+}
+/**
+ * Validate Screen Definition tool implementation
+ */
+export async function validateScreenDefinitionTool(input) {
+    try {
+        const errors = [];
+        const warnings = [];
+        const strict = input.strict !== false; // Default to strict
+        const definition = input.definition;
+        // 1. Validate with Zod schema first
+        const zodResult = ScreenDefinitionSchema.safeParse(definition);
+        if (!zodResult.success) {
+            for (const issue of zodResult.error.issues) {
+                errors.push({
+                    path: issue.path.join('.'),
+                    code: issue.code,
+                    message: issue.message,
+                    suggestion: getZodSuggestion(issue),
+                });
+            }
+        }
+        // 2. Additional semantic validation (only if basic structure is valid)
+        if (definition && typeof definition === 'object') {
+            // Validate shell
+            if (definition.shell) {
+                const shellResult = validateShell(definition.shell, 'shell');
+                errors.push(...shellResult.errors);
+                warnings.push(...shellResult.warnings);
+            }
+            // Validate page
+            if (definition.page) {
+                const pageResult = validatePage(definition.page, 'page');
+                errors.push(...pageResult.errors);
+                warnings.push(...pageResult.warnings);
+            }
+            // Validate sections
+            if (definition.sections && Array.isArray(definition.sections)) {
+                for (let i = 0; i < definition.sections.length; i++) {
+                    const section = definition.sections[i];
+                    // Validate pattern
+                    if (section.pattern) {
+                        const patternResult = validateSectionPattern(section.pattern, `sections[${i}].pattern`, strict);
+                        errors.push(...patternResult.errors);
+                        warnings.push(...patternResult.warnings);
+                    }
+                    // Validate slot
+                    if (section.slot) {
+                        const slotResult = validateSlot(section.slot, `sections[${i}].slot`);
+                        errors.push(...slotResult.errors);
+                        warnings.push(...slotResult.warnings);
+                    }
+                    // Validate components
+                    if (section.components && Array.isArray(section.components)) {
+                        for (let j = 0; j < section.components.length; j++) {
+                            const component = section.components[j];
+                            if (component.type) {
+                                const typeResult = validateComponentType(component.type, `sections[${i}].components[${j}].type`, strict);
+                                errors.push(...typeResult.errors);
+                                warnings.push(...typeResult.warnings);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // 3. Generate improvement suggestions
+        const suggestions = generateSuggestions(definition);
+        const isValid = errors.length === 0;
+        return {
+            success: true,
+            valid: isValid,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            suggestions: suggestions.length > 0 ? suggestions : undefined,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: extractErrorMessage(error),
+        };
+    }
+}
+/**
+ * Get suggestion for Zod validation issue
+ */
+function getZodSuggestion(issue) {
+    switch (issue.code) {
+        case 'invalid_type':
+            return `Expected ${issue.expected}, but received ${issue.received}`;
+        case 'invalid_string':
+            if (issue.validation === 'regex') {
+                return 'Check the format - see the pattern in error message';
+            }
+            return 'Provide a valid string value';
+        case 'too_small':
+            return `Minimum ${issue.minimum} ${issue.type} required`;
+        case 'too_big':
+            return `Maximum ${issue.maximum} ${issue.type} allowed`;
+        case 'invalid_enum_value':
+            return `Valid values: ${issue.options.join(', ')}`;
+        default:
+            return 'Check the value format and try again';
+    }
+}
+//# sourceMappingURL=validate-screen-definition.js.map