@syrin/cli 1.3.0

package/dist/config/env-checker.js

@@ -0,0 +1,136 @@
+/**
+ * Environment variable checker.
+ * Validates that required environment variables are set.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { Messages, Paths } from '../constants/index.js';
+/**
+ * Parse .env file and return key-value pairs.
+ * @param envFilePath - Path to .env file
+ * @returns Map of environment variables
+ */
+function parseEnvFile(envFilePath) {
+    const envMap = new Map();
+    if (!fs.existsSync(envFilePath)) {
+        return envMap;
+    }
+    try {
+        const content = fs.readFileSync(envFilePath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            // Skip comments and empty lines
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            // Parse KEY=VALUE format
+            const match = trimmed.match(/^([^=:#]+)=(.*)$/);
+            if (match) {
+                const key = match[1]?.trim();
+                const value = match[2]?.trim() || '';
+                // Remove quotes if present
+                const unquotedValue = value.replace(/^["']|["']$/g, '');
+                if (key) {
+                    envMap.set(key, unquotedValue);
+                }
+            }
+        }
+    }
+    catch {
+        // If we can't parse the file, return empty map
+        // The error will be handled elsewhere
+    }
+    return envMap;
+}
+/**
+ * Check if an environment variable is set.
+ * Checks both process.env and .env file, providing detailed error messages.
+ * @param varName - Name of the environment variable
+ * @param projectRoot - Root directory of the project
+ * @returns Check result with detailed error information
+ */
+export function checkEnvVar(varName, projectRoot = process.cwd()) {
+    const envFilePath = path.join(projectRoot, Paths.ENV_FILE);
+    const envFileExists = fs.existsSync(envFilePath);
+    // First check process.env (takes precedence)
+    const processEnvValue = process.env[varName];
+    if (processEnvValue !== undefined && processEnvValue !== '') {
+        return {
+            isSet: true,
+            value: processEnvValue,
+            envFileExists,
+            keyExistsInEnvFile: undefined, // Not checked since process.env has it
+        };
+    }
+    // If not in process.env, check .env file
+    if (!envFileExists) {
+        return {
+            isSet: false,
+            envFileExists: false,
+            keyExistsInEnvFile: false,
+            errorMessage: Messages.ENV_FILE_NOT_PRESENT(varName),
+        };
+    }
+    // Parse .env file
+    const envMap = parseEnvFile(envFilePath);
+    const keyExistsInEnvFile = envMap.has(varName);
+    const envFileValue = envMap.get(varName);
+    if (!keyExistsInEnvFile) {
+        return {
+            isSet: false,
+            envFileExists: true,
+            keyExistsInEnvFile: false,
+            errorMessage: Messages.ENV_KEY_NOT_FOUND(varName),
+        };
+    }
+    if (envFileValue === '' || envFileValue === undefined) {
+        return {
+            isSet: false,
+            value: envFileValue,
+            envFileExists: true,
+            keyExistsInEnvFile: true,
+            errorMessage: Messages.ENV_KEY_EMPTY(varName),
+        };
+    }
+    // Key exists and has a value
+    return {
+        isSet: true,
+        value: envFileValue,
+        envFileExists: true,
+        keyExistsInEnvFile: true,
+    };
+}
+/**
+ * Check if a command exists and is executable.
+ * @param command - Command to check (e.g., "python3", "node")
+ * @returns true if command exists
+ */
+export function checkCommandExists(command) {
+    try {
+        // Try to find the command using 'which' or 'where' depending on platform
+        if (process.platform === 'win32') {
+            execSync(`where ${command}`, { stdio: 'ignore' });
+        }
+        else {
+            execSync(`which ${command}`, { stdio: 'ignore' });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract command name from a script string.
+ * @param script - Script command (e.g., "python3 server.py")
+ * @returns Command name (e.g., "python3")
+ */
+export function extractCommandName(script) {
+    // Remove quotes and split by space
+    const cleaned = script.replace(/['"]/g, '').trim();
+    const parts = cleaned.split(/\s+/);
+    return parts[0] || '';
+}
+//# sourceMappingURL=env-checker.js.map

package/dist/config/generator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Configuration file generator.
+ * Creates well-documented, production-ready syrin.yaml files from template.
+ */
+import type { InitOptions } from '../config/types.js';
+/**
+ * Generate a production-ready syrin.yaml file with comprehensive documentation.
+ * @param options - Initialization options
+ * @param projectRoot - Root directory where syrin.yaml will be created
+ * @returns Path to the created config file
+ */
+export declare function generateConfigFile(options: InitOptions, projectRoot: string): string;
+/**
+ * Check if a Syrin project is already initialized in the current directory.
+ * @param projectRoot - Root directory of the project
+ * @returns true if project is already initialized
+ */
+export declare function isProjectInitialized(projectRoot: string): boolean;
+//# sourceMappingURL=generator.d.ts.map

package/dist/config/generator.js

@@ -0,0 +1,196 @@
+/**
+ * Configuration file generator.
+ * Creates well-documented, production-ready syrin.yaml files from template.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { makeSyrinVersion } from '../types/factories.js';
+import { Paths } from '../constants/index.js';
+/**
+ * Get the path to the template file.
+ * The template is located in the same directory as this file.
+ */
+function getTemplatePath() {
+    // Get the directory of the current file using import.meta.url
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return path.join(__dirname, 'syrin.template.yaml');
+}
+/**
+ * Read the template file.
+ */
+function readTemplate() {
+    const templatePath = getTemplatePath();
+    if (!fs.existsSync(templatePath)) {
+        throw new Error(`Template file not found: ${templatePath}. This is a build error.`);
+    }
+    return fs.readFileSync(templatePath, 'utf-8');
+}
+/**
+ * Generate a production-ready syrin.yaml file with comprehensive documentation.
+ * @param options - Initialization options
+ * @param projectRoot - Root directory where syrin.yaml will be created
+ * @returns Path to the created config file
+ */
+export function generateConfigFile(options, projectRoot) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    const configContent = buildConfigContent(options);
+    fs.writeFileSync(configPath, configContent, 'utf-8');
+    return configPath;
+}
+/**
+ * Build the YAML content for the config file from template.
+ */
+function buildConfigContent(options) {
+    const config = {
+        version: makeSyrinVersion('1.0.0'),
+        project_name: options.projectName,
+        agent_name: options.agentName,
+        transport: options.transport,
+        script: options.script,
+        llm: buildLLMConfig(options.llmProviders),
+    };
+    // Add transport-specific fields
+    if (options.transport === 'http' && options.mcpUrl) {
+        config.mcp_url = options.mcpUrl;
+    }
+    // Read template
+    let template = readTemplate();
+    // Replace simple placeholders
+    template = template.replace(/\{\{VERSION\}\}/g, String(config.version));
+    template = template.replace(/\{\{PROJECT_NAME\}\}/g, String(config.project_name));
+    template = template.replace(/\{\{AGENT_NAME\}\}/g, String(config.agent_name));
+    template = template.replace(/\{\{TRANSPORT\}\}/g, config.transport);
+    // Handle transport-specific blocks
+    if (config.transport === 'http' && config.mcp_url) {
+        template = template.replace(/\{\{#IF_HTTP\}\}([\s\S]*?)\{\{\/IF_HTTP\}\}/g, (match, content) => {
+            return content.replace(/\{\{MCP_URL\}\}/g, String(config.mcp_url));
+        });
+        template = template.replace(/\{\{#IF_STDIO\}\}([\s\S]*?)\{\{\/IF_STDIO\}\}/g, '');
+    }
+    else {
+        template = template.replace(/\{\{#IF_HTTP\}\}([\s\S]*?)\{\{\/IF_HTTP\}\}/g, '');
+        template = template.replace(/\{\{#IF_STDIO\}\}([\s\S]*?)\{\{\/IF_STDIO\}\}/g, (match, content) => content);
+    }
+    // Handle script blocks
+    if (config.script) {
+        template = template.replace(/\{\{#IF_SCRIPT\}\}([\s\S]*?)\{\{\/IF_SCRIPT\}\}/g, (match, content) => {
+            return content.replace(/\{\{SCRIPT\}\}/g, String(config.script));
+        });
+        template = template.replace(/\{\{#IF_NO_SCRIPT\}\}([\s\S]*?)\{\{\/IF_NO_SCRIPT\}\}/g, '');
+    }
+    else {
+        template = template.replace(/\{\{#IF_SCRIPT\}\}([\s\S]*?)\{\{\/IF_SCRIPT\}\}/g, '');
+        template = template.replace(/\{\{#IF_NO_SCRIPT\}\}([\s\S]*?)\{\{\/IF_NO_SCRIPT\}\}/g, (match, content) => content);
+    }
+    // Handle LLM providers loop
+    const llmEntries = Object.entries(config.llm);
+    const hasOpenAI = llmEntries.some(([name]) => name === 'openai');
+    const hasClaude = llmEntries.some(([name]) => name === 'claude');
+    const hasOllama = llmEntries.some(([name]) => name === 'ollama');
+    // Extract the LLM provider template block
+    const llmTemplateMatch = template.match(/\{\{#LLM_PROVIDERS\}\}([\s\S]*?)\{\{\/LLM_PROVIDERS\}\}/);
+    if (!llmTemplateMatch) {
+        throw new Error('LLM_PROVIDERS template block not found');
+    }
+    const providerTemplate = llmTemplateMatch[1];
+    let llmSection = '';
+    for (const [providerName, providerConfig] of llmEntries) {
+        const isOllama = providerName === 'ollama';
+        const isDefault = providerConfig.default === true;
+        const providerNameUpper = providerName.toUpperCase();
+        // Start with a fresh copy of the template for each provider
+        let providerBlock = providerTemplate;
+        // Replace provider-specific placeholders
+        providerBlock = providerBlock.replace(/\{\{PROVIDER_NAME\}\}/g, providerName);
+        providerBlock = providerBlock.replace(/\{\{PROVIDER_NAME_UPPER\}\}/g, providerNameUpper);
+        // Handle Ollama vs Cloud provider blocks
+        if (isOllama) {
+            providerBlock = providerBlock.replace(/\{\{#IF_OLLAMA\}\}([\s\S]*?)\{\{\/IF_OLLAMA\}\}/g, (match, content) => {
+                return content.replace(/\{\{MODEL_NAME\}\}/g, String(providerConfig.MODEL_NAME || ''));
+            });
+            providerBlock = providerBlock.replace(/\{\{#IF_CLOUD_PROVIDER\}\}([\s\S]*?)\{\{\/IF_CLOUD_PROVIDER\}\}/g, '');
+        }
+        else {
+            providerBlock = providerBlock.replace(/\{\{#IF_OLLAMA\}\}([\s\S]*?)\{\{\/IF_OLLAMA\}\}/g, '');
+            providerBlock = providerBlock.replace(/\{\{#IF_CLOUD_PROVIDER\}\}([\s\S]*?)\{\{\/IF_CLOUD_PROVIDER\}\}/g, (match, content) => {
+                return content
+                    .replace(/\{\{API_KEY\}\}/g, String(providerConfig.API_KEY || ''))
+                    .replace(/\{\{MODEL_NAME\}\}/g, String(providerConfig.MODEL_NAME || ''));
+            });
+        }
+        // Handle default flag
+        if (isDefault) {
+            providerBlock = providerBlock.replace(/\{\{#IF_DEFAULT\}\}([\s\S]*?)\{\{\/IF_DEFAULT\}\}/g, (match, content) => content);
+            providerBlock = providerBlock.replace(/\{\{#IF_NOT_DEFAULT\}\}([\s\S]*?)\{\{\/IF_NOT_DEFAULT\}\}/g, '');
+        }
+        else {
+            providerBlock = providerBlock.replace(/\{\{#IF_DEFAULT\}\}([\s\S]*?)\{\{\/IF_DEFAULT\}\}/g, '');
+            providerBlock = providerBlock.replace(/\{\{#IF_NOT_DEFAULT\}\}([\s\S]*?)\{\{\/IF_NOT_DEFAULT\}\}/g, (match, content) => content);
+        }
+        // Handle alternative provider suggestions (only show once per provider type)
+        if (providerName === 'openai' && !hasClaude) {
+            providerBlock = providerBlock.replace(/\{\{#IF_OPENAI_AND_NO_CLAUDE\}\}([\s\S]*?)\{\{\/IF_OPENAI_AND_NO_CLAUDE\}\}/g, (match, content) => content);
+        }
+        else {
+            providerBlock = providerBlock.replace(/\{\{#IF_OPENAI_AND_NO_CLAUDE\}\}([\s\S]*?)\{\{\/IF_OPENAI_AND_NO_CLAUDE\}\}/g, '');
+        }
+        if (providerName === 'claude' && !hasOpenAI) {
+            providerBlock = providerBlock.replace(/\{\{#IF_CLAUDE_AND_NO_OPENAI\}\}([\s\S]*?)\{\{\/IF_CLAUDE_AND_NO_OPENAI\}\}/g, (match, content) => content);
+        }
+        else {
+            providerBlock = providerBlock.replace(/\{\{#IF_CLAUDE_AND_NO_OPENAI\}\}([\s\S]*?)\{\{\/IF_CLAUDE_AND_NO_OPENAI\}\}/g, '');
+        }
+        // Only show Ollama suggestion if no Ollama provider exists
+        // But only add it once (on the last provider)
+        const isLastProvider = llmEntries[llmEntries.length - 1][0] === providerName;
+        if (isLastProvider && !hasOllama) {
+            providerBlock = providerBlock.replace(/\{\{#IF_NO_OLLAMA\}\}([\s\S]*?)\{\{\/IF_NO_OLLAMA\}\}/g, (match, content) => content);
+        }
+        else {
+            providerBlock = providerBlock.replace(/\{\{#IF_NO_OLLAMA\}\}([\s\S]*?)\{\{\/IF_NO_OLLAMA\}\}/g, '');
+        }
+        llmSection += providerBlock;
+    }
+    // Replace LLM providers section
+    template = template.replace(/\{\{#LLM_PROVIDERS\}\}([\s\S]*?)\{\{\/LLM_PROVIDERS\}\}/, llmSection);
+    return template;
+}
+/**
+ * Build LLM configuration object from init options.
+ */
+function buildLLMConfig(providers) {
+    const llmConfig = {};
+    if (providers.openai) {
+        llmConfig.openai = {
+            API_KEY: providers.openai.apiKey,
+            MODEL_NAME: providers.openai.modelName,
+            default: providers.openai.default ?? false,
+        };
+    }
+    if (providers.claude) {
+        llmConfig.claude = {
+            API_KEY: providers.claude.apiKey,
+            MODEL_NAME: providers.claude.modelName,
+            default: providers.claude.default ?? false,
+        };
+    }
+    if (providers.ollama) {
+        llmConfig.ollama = {
+            MODEL_NAME: providers.ollama.modelName,
+            default: providers.ollama.default ?? false,
+        };
+    }
+    return llmConfig;
+}
+/**
+ * Check if a Syrin project is already initialized in the current directory.
+ * @param projectRoot - Root directory of the project
+ * @returns true if project is already initialized
+ */
+export function isProjectInitialized(projectRoot) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    return fs.existsSync(configPath);
+}
+//# sourceMappingURL=generator.js.map

package/dist/config/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Configuration module exports.
+ */
+export * from './types.js';
+export * from './schema.js';
+export * from './generator.js';
+export * from './loader.js';
+export * from './env-checker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -0,0 +1,9 @@
+/**
+ * Configuration module exports.
+ */
+export * from './types.js';
+export * from './schema.js';
+export * from './generator.js';
+export * from './loader.js';
+export * from './env-checker.js';
+//# sourceMappingURL=index.js.map

package/dist/config/loader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Configuration file loader.
+ * Loads and parses the syrin.yaml file.
+ */
+import type { SyrinConfig } from './types.js';
+/**
+ * Load configuration from syrin.yaml file.
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @returns Loaded and validated configuration
+ * @throws {ConfigurationError} If config file is missing or invalid
+ */
+export declare function loadConfig(projectRoot?: string): SyrinConfig;
+/**
+ * Check if a configuration file exists.
+ * @param projectRoot - Root directory of the project
+ * @returns true if config file exists
+ */
+export declare function configExists(projectRoot?: string): boolean;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.js

@@ -0,0 +1,57 @@
+/**
+ * Configuration file loader.
+ * Loads and parses the syrin.yaml file.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { load } from 'js-yaml';
+import { validateConfig } from './schema.js';
+import { ConfigurationError } from '../utils/errors.js';
+import { Paths, Messages, ToolCommands } from '../constants/index.js';
+/**
+ * Load configuration from syrin.yaml file.
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @returns Loaded and validated configuration
+ * @throws {ConfigurationError} If config file is missing or invalid
+ */
+export function loadConfig(projectRoot = process.cwd()) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    // Check if config file exists
+    if (!fs.existsSync(configPath)) {
+        throw new ConfigurationError(Messages.ERROR_CONFIG_NOT_FOUND(ToolCommands.INIT), {
+            context: { projectRoot, configPath },
+        });
+    }
+    try {
+        // Read and parse YAML file
+        const configContent = fs.readFileSync(configPath, 'utf-8');
+        const configData = load(configContent);
+        if (!configData || typeof configData !== 'object') {
+            throw new ConfigurationError(Messages.ERROR_CONFIG_EMPTY_OR_INVALID, {
+                context: { configPath },
+            });
+        }
+        // Validate and transform to opaque types
+        const validatedConfig = validateConfig(configData);
+        return validatedConfig;
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError) {
+            throw error;
+        }
+        throw new ConfigurationError(`${Messages.ERROR_LOADING_CONFIG}: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error instanceof Error ? error : new Error(String(error)),
+            context: { configPath },
+        });
+    }
+}
+/**
+ * Check if a configuration file exists.
+ * @param projectRoot - Root directory of the project
+ * @returns true if config file exists
+ */
+export function configExists(projectRoot = process.cwd()) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    return fs.existsSync(configPath);
+}
+//# sourceMappingURL=loader.js.map

package/dist/config/schema.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Configuration schema validation using Zod.
+ * Provides runtime validation for the Syrin configuration file.
+ */
+import { z } from 'zod';
+import type { SyrinConfig } from '../config/types.js';
+/**
+ * Main configuration schema.
+ */
+export declare const ConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    project_name: z.ZodString;
+    agent_name: z.ZodString;
+    transport: z.ZodEnum<{
+        stdio: "stdio";
+        http: "http";
+    }>;
+    mcp_url: z.ZodOptional<z.ZodString>;
+    script: z.ZodOptional<z.ZodString>;
+    llm: z.ZodRecord<z.ZodString, z.ZodObject<{
+        API_KEY: z.ZodOptional<z.ZodString>;
+        MODEL_NAME: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    check: z.ZodOptional<z.ZodObject<{
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+        memory_limit_mb: z.ZodOptional<z.ZodNumber>;
+        tools_dir: z.ZodOptional<z.ZodString>;
+        max_output_size_kb: z.ZodOptional<z.ZodNumber>;
+        determinism_runs: z.ZodOptional<z.ZodNumber>;
+        test_retries: z.ZodOptional<z.ZodBoolean>;
+        max_retries: z.ZodOptional<z.ZodNumber>;
+        retry_delay_ms: z.ZodOptional<z.ZodNumber>;
+        strict_mode: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Type inference from schema.
+ */
+export type ConfigSchemaType = z.infer<typeof ConfigSchema>;
+export declare function validateConfig(config: unknown): SyrinConfig;
+//# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.js

@@ -0,0 +1,181 @@
+/**
+ * Configuration schema validation using Zod.
+ * Provides runtime validation for the Syrin configuration file.
+ */
+import { z } from 'zod';
+import { ConfigurationError } from '../utils/errors.js';
+import { makeProjectName, makeAgentName, makeMCPURL, makeAPIKey, makeModelName, makeScriptCommand, makeSyrinVersion, } from '../types/factories.js';
+/**
+ * Schema for LLM provider configuration.
+ */
+const LLMProviderSchema = z
+    .object({
+    API_KEY: z.string().optional(),
+    MODEL_NAME: z.string().optional(),
+    default: z.boolean().optional(),
+})
+    .refine(data => {
+    // For cloud providers (have API_KEY), both API_KEY and MODEL_NAME are required
+    if (data.API_KEY) {
+        if (!data.MODEL_NAME) {
+            return false;
+        }
+        return true;
+    }
+    // For Ollama (no API_KEY), MODEL_NAME is required
+    if (!data.API_KEY && !data.MODEL_NAME) {
+        return false;
+    }
+    return true;
+}, {
+    message: 'For cloud providers (OpenAI, Claude), API_KEY and MODEL_NAME are required. For Ollama, MODEL_NAME is required.',
+});
+/**
+ * Schema for check configuration (v1.3.0).
+ */
+const CheckConfigSchema = z
+    .object({
+    timeout_ms: z.number().int().positive().optional(),
+    memory_limit_mb: z.number().int().positive().optional(),
+    tools_dir: z.string().min(1).optional(),
+    max_output_size_kb: z.number().int().positive().optional(),
+    determinism_runs: z.number().int().positive().min(2).optional(),
+    test_retries: z.boolean().optional(),
+    max_retries: z.number().int().min(1).max(10).optional(),
+    retry_delay_ms: z.number().int().nonnegative().optional(),
+    strict_mode: z.boolean().optional(),
+})
+    .optional();
+/**
+ * Main configuration schema.
+ */
+export const ConfigSchema = z
+    .object({
+    version: z.string().min(1, 'Version is required'),
+    project_name: z.string().min(1, 'Project name is required'),
+    agent_name: z.string().min(1, 'Agent name is required'),
+    transport: z.enum(['stdio', 'http']),
+    mcp_url: z.string().url().optional(),
+    script: z.string().optional(),
+    llm: z
+        .record(z.string(), LLMProviderSchema)
+        .refine(obj => Object.keys(obj).length > 0, {
+        message: 'At least one LLM provider is required',
+    }),
+    check: CheckConfigSchema,
+})
+    .refine(data => {
+    // If transport is http, mcp_url must be provided
+    if (data.transport === 'http' && !data.mcp_url) {
+        return false;
+    }
+    return true;
+}, {
+    message: 'mcp_url is required when transport is "http"',
+    path: ['mcp_url'],
+})
+    .refine(data => {
+    // If transport is stdio, script must be provided
+    if (data.transport === 'stdio') {
+        if (!data.script) {
+            return false;
+        }
+    }
+    return true;
+}, {
+    message: 'script is required when transport is "stdio"',
+    path: ['script'],
+})
+    .refine(data => {
+    // At least one LLM provider should be set as default
+    const providers = Object.values(data.llm);
+    const hasDefault = providers.some(provider => {
+        return (provider && typeof provider === 'object' && provider.default === true);
+    });
+    return hasDefault;
+}, {
+    message: 'At least one LLM provider must be set as default',
+    path: ['llm'],
+});
+/**
+ * Validate a configuration object against the schema.
+ * @param config - Configuration object to validate
+ * @returns Validated configuration with opaque types
+ * @throws {ConfigurationError} If validation fails
+ */
+/**
+ * Format Zod validation errors into user-friendly messages.
+ */
+function formatValidationError(error) {
+    const issues = error.issues;
+    if (issues.length === 0) {
+        return 'Configuration validation failed';
+    }
+    const messages = [];
+    for (const issue of issues) {
+        const path = issue.path.length > 0 ? issue.path.join('.') : 'configuration';
+        let message = `\n  • ${path}: ${issue.message}`;
+        // Add helpful hints for common errors
+        if (issue.code === 'invalid_type') {
+            // Type guard for invalid_type issues
+            const invalidTypeIssue = issue;
+            if (invalidTypeIssue.received === 'undefined') {
+                message += `\n    → Fix: Add "${path}" to your config.yaml file`;
+            }
+            else {
+                message += `\n    → Expected: ${invalidTypeIssue.expected}, but received: ${invalidTypeIssue.received}`;
+            }
+        }
+        else if (issue.code === 'too_small') {
+            // Type guard for too_small issues
+            const tooSmallIssue = issue;
+            if (tooSmallIssue.type === 'string') {
+                message += `\n    → Fix: "${path}" cannot be empty`;
+            }
+        }
+        // Check for URL validation errors in the message
+        if (issue.message.toLowerCase().includes('url') ||
+            issue.message.toLowerCase().includes('invalid url')) {
+            message += `\n    → Fix: Provide a valid URL for "${path}"`;
+        }
+        messages.push(message);
+    }
+    return `Configuration validation failed:${messages.join('')}\n\n💡 Tip: Run \`syrin doctor\` after fixing your config.yaml to verify the setup.`;
+}
+export function validateConfig(config) {
+    try {
+        const parsed = ConfigSchema.parse(config);
+        // Transform to opaque types
+        const validated = {
+            version: makeSyrinVersion(parsed.version),
+            project_name: makeProjectName(parsed.project_name),
+            agent_name: makeAgentName(parsed.agent_name),
+            transport: parsed.transport,
+            mcp_url: parsed.mcp_url ? makeMCPURL(parsed.mcp_url) : undefined,
+            script: parsed.script ? makeScriptCommand(parsed.script) : undefined,
+            llm: Object.fromEntries(Object.entries(parsed.llm).map(([key, provider]) => [
+                key,
+                {
+                    API_KEY: provider.API_KEY
+                        ? makeAPIKey(provider.API_KEY)
+                        : undefined,
+                    MODEL_NAME: provider.MODEL_NAME
+                        ? makeModelName(provider.MODEL_NAME)
+                        : undefined,
+                    default: provider.default,
+                },
+            ])),
+            check: parsed.check,
+        };
+        return validated;
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new ConfigurationError(formatValidationError(error), {
+                context: { errors: error.issues },
+            });
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=schema.js.map