@qodo/sdk 0.1.0

package/dist/parser/index.js

@@ -0,0 +1,967 @@
+import * as toml from 'toml';
+import * as yaml from 'yaml';
+import jmespath from "jmespath";
+import { MCPManager } from "../mcp/index.js";
+import path from "path";
+import { transformOutputSchema } from "./utils.js";
+import { LATEST_CONFIG_VERSION } from "../constants/versions.js";
+import { isUrl, loadConfigContent } from '../config/index.js';
+/**
+ * Detects the configuration file format based on file extension
+ * @param filePath Path to the configuration file
+ * @returns 'toml' or 'yaml'
+ */
+function detectConfigFormat(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.yaml' || ext === '.yml') {
+        return 'yaml';
+    }
+    return 'toml'; // Default to TOML for backward compatibility
+}
+/**
+ * Parses a configuration string based on format
+ * @returns Parsed configuration object
+ * @param value
+ */
+function normalizeMcpServersValue(value) {
+    if (value == null)
+        return undefined;
+    const unwrap = (obj) => {
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+            return undefined;
+        // Backward compatibility: allow embedding under { "mcpServers": { ... } }
+        if (Object.prototype.hasOwnProperty.call(obj, 'mcpServers')) {
+            const inner = obj.mcpServers;
+            if (inner && typeof inner === 'object' && !Array.isArray(inner)) {
+                return inner;
+            }
+        }
+        return obj;
+    };
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return unwrap(parsed);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse mcpServers JSON: ${e?.message || String(e)}`);
+        }
+    }
+    return unwrap(value);
+}
+/**
+ * Normalize a config object the same way as file/string parsing.
+ *
+ * Important:
+ * - Does not mutate the user-provided object (clones first).
+ * - Supports aliases and legacy formats for smooth SDK embedding.
+ */
+export function normalizeConfigObject(rawConfig) {
+    // SDK runtime metadata (Zod schemas, etc.) is stored under `command.__sdk`.
+    // That metadata is not necessarily cloneable/serializable.
+    //
+    // We intentionally preserve it *by reference* while still cloning the user config
+    // object, so we don't mutate the input but also don't lose SDK-only metadata.
+    const sdkCommandMeta = {};
+    try {
+        const cmds = rawConfig?.commands;
+        if (cmds && typeof cmds === 'object') {
+            for (const [name, cmd] of Object.entries(cmds)) {
+                const meta = cmd?.__sdk;
+                if (meta)
+                    sdkCommandMeta[name] = meta;
+            }
+        }
+    }
+    catch { }
+    const clone = (obj) => {
+        if (obj == null)
+            return obj;
+        try {
+            // Node 18+ supports structuredClone; use it when available.
+            // eslint-disable-next-line no-undef
+            if (typeof structuredClone === 'function') {
+                // eslint-disable-next-line no-undef
+                return structuredClone(obj);
+            }
+        }
+        catch { }
+        // Fallback: JSON clone (configs are expected to be plain data objects).
+        return JSON.parse(JSON.stringify(obj));
+    };
+    const config = clone(rawConfig || {});
+    // Restore preserved SDK-only metadata on the cloned config.
+    try {
+        if (config?.commands && typeof config.commands === 'object') {
+            for (const [name, meta] of Object.entries(sdkCommandMeta)) {
+                if (config.commands[name]) {
+                    config.commands[name].__sdk = meta;
+                }
+            }
+        }
+    }
+    catch { }
+    // Normalize top-level mcpServers if provided (stringified JSON or record)
+    if (Object.prototype.hasOwnProperty.call(config, 'mcpServers')) {
+        config.mcpServers = normalizeMcpServersValue(config.mcpServers);
+    }
+    // Normalize command-level mcpServers if provided
+    if (config.commands) {
+        Object.keys(config.commands).forEach((commandName) => {
+            const command = config.commands[commandName];
+            if (command && Object.prototype.hasOwnProperty.call(command, 'mcpServers')) {
+                command.mcpServers = normalizeMcpServersValue(command.mcpServers);
+            }
+        });
+    }
+    // Normalize mode-level mcpServers if provided
+    if (config.modes) {
+        Object.keys(config.modes).forEach((modeName) => {
+            const mode = config.modes[modeName];
+            if (mode && Object.prototype.hasOwnProperty.call(mode, 'mcpServers')) {
+                mode.mcpServers = normalizeMcpServersValue(mode.mcpServers);
+            }
+        });
+    }
+    // Handle "tools" as synonym for "available_tools" at top level
+    if (Object.prototype.hasOwnProperty.call(config, 'tools') && !config.available_tools) {
+        config.available_tools = config.tools;
+        // If tools is explicitly an empty array, disable MCP entirely for this config
+        if (Array.isArray(config.tools) && config.tools.length === 0) {
+            config.disable_mcp = true;
+        }
+        delete config.tools;
+    }
+    // Handle "tools" as synonym for "available_tools" in commands
+    if (config.commands) {
+        Object.keys(config.commands).forEach((commandName) => {
+            const command = config.commands[commandName];
+            if (command && Object.prototype.hasOwnProperty.call(command, 'tools') && !command.available_tools) {
+                command.available_tools = command.tools;
+                // If tools is explicitly an empty array at command level, disable MCP for that command
+                if (Array.isArray(command.tools) && command.tools.length === 0) {
+                    command.disable_mcp = true;
+                }
+                delete command.tools;
+            }
+        });
+    }
+    // Handle "tools" as synonym for "available_tools" in modes
+    if (config.modes) {
+        Object.keys(config.modes).forEach((modeName) => {
+            const mode = config.modes[modeName];
+            if (mode && Object.prototype.hasOwnProperty.call(mode, 'tools') && !mode.available_tools) {
+                mode.available_tools = mode.tools;
+                // If tools is explicitly an empty array at mode level, disable MCP for that mode
+                if (Array.isArray(mode.tools) && mode.tools.length === 0) {
+                    mode.disable_mcp = true;
+                }
+                delete mode.tools;
+            }
+        });
+    }
+    // Handle "no_tools" as synonym for "ignore_tools" at top level
+    if (config.no_tools && !config.ignore_tools) {
+        config.ignore_tools = config.no_tools;
+        delete config.no_tools;
+    }
+    // Handle "no_tools" as synonym for "ignore_tools" in commands
+    if (config.commands) {
+        Object.keys(config.commands).forEach((commandName) => {
+            const command = config.commands[commandName];
+            if (command?.no_tools && !command.ignore_tools) {
+                command.ignore_tools = command.no_tools;
+                delete command.no_tools;
+            }
+        });
+    }
+    // Handle "no_tools" as synonym for "ignore_tools" in modes
+    if (config.modes) {
+        Object.keys(config.modes).forEach((modeName) => {
+            const mode = config.modes[modeName];
+            if (mode?.no_tools && !mode.ignore_tools) {
+                mode.ignore_tools = mode.no_tools;
+                delete mode.no_tools;
+            }
+        });
+    }
+    // Default missing version for SDK-friendly usage.
+    // The validator will still warn when version is missing (checkConfigVersion).
+    if (!config.version) {
+        config.version = LATEST_CONFIG_VERSION;
+    }
+    return config;
+}
+function parseConfigByFormat(configString, format) {
+    try {
+        let parsed;
+        if (format === 'yaml') {
+            parsed = yaml.parse(configString);
+        }
+        else {
+            parsed = toml.parse(configString);
+        }
+        return normalizeConfigObject(parsed);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${format.toUpperCase()} configuration: ${error.message}`);
+    }
+}
+/**
+ * Loads and parses a configuration file (TOML or YAML) with support for imports
+ *
+ * @param pathOrUrl Path to the TOML configuration file
+ * @returns Parsed configuration object
+ */
+export async function loadConfigFromFile(pathOrUrl) {
+    try {
+        const fileContent = await loadConfigContent(pathOrUrl);
+        const configDir = isUrl(pathOrUrl) ? process.cwd() : path.dirname(pathOrUrl);
+        return await parseConfigStringWithImports(fileContent, configDir, pathOrUrl);
+    }
+    catch (error) {
+        throw new Error(`Failed to load configuration: ${error.message}`);
+    }
+}
+/**
+ * Loads and parses a configuration file (TOML or YAML) with support for imports
+ *
+ * @param fileContent Content of the TOML configuration file as a string
+ * @returns Parsed configuration object
+ */
+export async function loadConfigFromString(fileContent) {
+    try {
+        const configDir = process.cwd();
+        return await parseConfigStringWithImports(fileContent, configDir);
+    }
+    catch (error) {
+        throw new Error(`Failed to load configuration: ${error.message}`);
+    }
+}
+/**
+ * Parses a version string in x.y format
+ */
+function parseVersion(version) {
+    const versionStr = typeof version === 'number'
+        ? (Number.isInteger(version) ? `${version}.0` : version.toString())
+        : version;
+    const versionRegex = /^(\d+)\.(\d+)$/;
+    const match = RegExp(versionRegex).exec(versionStr);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: parseInt(match[1], 10),
+        minor: parseInt(match[2], 10)
+    };
+}
+/**
+ * Compares two version objects
+ * Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+function compareVersions(v1, v2) {
+    if (v1.major !== v2.major) {
+        return v1.major < v2.major ? -1 : 1;
+    }
+    if (v1.minor !== v2.minor) {
+        return v1.minor < v2.minor ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * Resolves imports in a configuration string (TOML or YAML)
+ *
+ * @param configString Configuration string (TOML or YAML)
+ * @param baseDir Base directory for resolving relative import paths
+ * @param sourceFile Optional source file path for tracking
+ * @returns Parsed configuration object with resolved imports
+ */
+export async function parseConfigStringWithImports(configString, baseDir = process.cwd(), sourceFile) {
+    try {
+        // Detect format and parse the base configuration
+        const format = sourceFile ? detectConfigFormat(sourceFile) : 'toml';
+        const baseConfig = parseConfigByFormat(configString, format);
+        // Track source file for this config
+        if (sourceFile) {
+            baseConfig._sourceFile = sourceFile;
+        }
+        // Check for import directive
+        if (baseConfig.imports && Array.isArray(baseConfig.imports)) {
+            const importPromises = baseConfig.imports.map(async (importPath) => {
+                try {
+                    let fullPath;
+                    let importBaseDir;
+                    if (isUrl(importPath)) {
+                        // For URL imports, use current directory as base for nested imports
+                        fullPath = importPath;
+                        importBaseDir = process.cwd();
+                    }
+                    else {
+                        // For local imports, resolve relative to the current config's directory
+                        fullPath = path.resolve(baseDir, importPath);
+                        importBaseDir = path.dirname(fullPath);
+                    }
+                    // Load the content
+                    const importContent = await loadConfigContent(fullPath);
+                    // Recursively resolve nested imports
+                    return await parseConfigStringWithImports(importContent, importBaseDir, fullPath);
+                }
+                catch (importError) {
+                    console.warn(`⚠️ Warning: Failed to import ${importPath}: ${importError.message}`);
+                    // Return null to indicate this import failed but should not crash the process
+                    return null;
+                }
+            });
+            // Wait for all imports to be resolved
+            const importResults = await Promise.all(importPromises);
+            // Filter out failed imports (null values)
+            const importedConfigs = importResults.filter((config) => config !== null);
+            // Deep merge all successfully imported configurations with the base config
+            const mergedConfig = deepMergeConfigs([...importedConfigs, baseConfig]);
+            // Remove the imports property from the final config
+            if ('imports' in mergedConfig) {
+                delete mergedConfig.imports;
+            }
+            return mergedConfig;
+        }
+        return baseConfig;
+    }
+    catch (error) {
+        throw new Error(`Failed to parse configuration: ${error.message}`);
+    }
+}
+/**
+ * Parses a TOML configuration string (without imports)
+ *
+ * @param configString TOML configuration string
+ * @returns Parsed configuration object
+ */
+export function parseConfigString(configString) {
+    try {
+        return toml.parse(configString);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse TOML configuration: ${error.message}`);
+    }
+}
+/**
+ * Deep merges multiple configuration objects
+ * Later configs in the array take precedence over earlier ones
+ *
+ * @param configs Array of configuration objects to merge
+ * @returns Merged configuration
+ */
+function deepMergeConfigs(configs) {
+    if (configs.length === 0) {
+        throw new Error('No configurations to merge');
+    }
+    const merged = {
+        version: configs[configs.length - 1].version || LATEST_CONFIG_VERSION,
+        commands: {},
+        modes: {},
+        mcpServers: {},
+        available_tools: [],
+        ignore_tools: [],
+        instructions: undefined,
+        disable_mcp: undefined,
+    };
+    // Track command names and their source files for duplicate detection
+    const commandSources = new Map();
+    // Track mode names and their source files for duplicate detection
+    const modeSources = new Map();
+    // Process commands from all configurations
+    configs.forEach(config => {
+        // load mcpServers (supports stringified JSON, object, and legacy wrapper { mcpServers: { ... } })
+        let configMCPServers = {};
+        if (config.mcpServers) {
+            if (typeof config.mcpServers === 'string') {
+                // parseConfigByFormat should already normalize this, but keep for backward-compatibility
+                try {
+                    const parsed = JSON.parse(config.mcpServers);
+                    configMCPServers = (parsed?.mcpServers ?? parsed);
+                }
+                catch {
+                    configMCPServers = {};
+                }
+            }
+            else if (typeof config.mcpServers === 'object') {
+                const obj = config.mcpServers;
+                configMCPServers = (obj?.mcpServers ?? obj);
+            }
+        }
+        if (config.system_prompt) {
+            merged.system_prompt = config.system_prompt;
+        }
+        if (config.instructions) {
+            merged.instructions = config.instructions;
+        }
+        if (config.model) {
+            merged.model = config.model;
+        }
+        if (config.available_tools) {
+            merged.available_tools = config.available_tools;
+        }
+        if (config.ignore_tools) {
+            merged.ignore_tools = config.ignore_tools;
+        }
+        // If any imported config explicitly disabled MCP, preserve that on the merged config
+        if (config.disable_mcp === true) {
+            merged.disable_mcp = true;
+        }
+        if (config.output_schema) {
+            merged.output_schema = typeof config.output_schema === 'string' ? transformOutputSchema(config.output_schema, "QodoAgent") : config.output_schema;
+        }
+        if (config.execution_strategy) {
+            merged.execution_strategy = config.execution_strategy;
+        }
+        merged.mcpServers = { ...merged.mcpServers, ...configMCPServers };
+        merged.commands = { ...(merged.commands || {}), ...(config.commands || {}) };
+        // Track command names and detect duplicates
+        Object.entries(config.commands || {}).forEach(([commandName, command]) => {
+            const sourceFile = config._sourceFile || 'main config';
+            if (commandSources.has(commandName)) {
+                const sources = commandSources.get(commandName);
+                sources.push(sourceFile);
+                // Get unique file names for the warning (remove duplicates)
+                const uniqueFiles = [...new Set(sources)];
+                const fileNames = uniqueFiles.map(file => file === 'main config' ? 'main config' : path.basename(file));
+                console.warn(`⚠️ Warning: Duplicate command name '${commandName}' found in multiple files: ${fileNames.join(', ')}. Using command from ${path.basename(sourceFile)}.`);
+            }
+            else {
+                commandSources.set(commandName, [sourceFile]);
+            }
+            // mcpServers are normalized in parseConfigByFormat (stringified JSON and legacy wrappers).
+            // Preserve them here without overwriting.
+            if (!merged.commands)
+                merged.commands = {};
+            merged.commands[commandName] = command;
+        });
+        // Merge modes
+        if (config.modes) {
+            Object.entries(config.modes).forEach(([modeName, mode]) => {
+                const sourceFile = config._sourceFile || 'main config';
+                if (modeSources.has(modeName)) {
+                    const sources = modeSources.get(modeName);
+                    sources.push(sourceFile);
+                    const uniqueFiles = [...new Set(sources)];
+                    const fileNames = uniqueFiles.map(file => file === 'main config' ? 'main config' : path.basename(file));
+                    console.warn(`⚠️ Warning: Duplicate mode name '${modeName}' found in multiple files: ${fileNames.join(', ')}. Using mode from ${path.basename(sourceFile)}.`);
+                }
+                else {
+                    modeSources.set(modeName, [sourceFile]);
+                }
+                // Don't parse/transform here; keep raw and handle later in ConfigManager like commands
+                merged.modes[modeName] = mode;
+            });
+        }
+    });
+    return merged;
+}
+/**
+ * Validates a configuration object against the expected schema
+ *
+ * @param config Configuration object to validate
+ * @param userCommand
+ * @returns Validation result
+ */
+export function validateConfig(config, userCommand) {
+    const errors = [];
+    // Check version
+    const versionCheck = checkConfigVersion(config.version);
+    if (!versionCheck.isLatest && versionCheck.message) {
+        console.warn(versionCheck.message);
+    }
+    if (config.version) {
+        const parsedVersion = parseVersion(config.version);
+        if (!parsedVersion) {
+            errors.push({
+                path: 'version',
+                message: `Invalid version format "${config.version}". Expected format is x.y (e.g., "1.0", "2.1").`
+            });
+        }
+        else {
+            const parsedLatest = parseVersion(LATEST_CONFIG_VERSION);
+            if (parsedLatest && compareVersions(parsedVersion, parsedLatest) > 0) {
+                errors.push({
+                    path: 'version',
+                    message: `Config version ${config.version} is newer than the latest supported version ${LATEST_CONFIG_VERSION}. Please update your CLI or downgrade your configuration.`
+                });
+            }
+        }
+    }
+    // Validate top-level exit_expression if present
+    if (config.exit_expression) {
+        if (!config.output_schema) {
+            errors.push({
+                path: 'exit_expression',
+                message: 'Exit expression requires an output schema to be defined'
+            });
+        }
+        else {
+            try {
+                //@ts-ignore
+                jmespath.compile(config.exit_expression);
+            }
+            catch (e) {
+                errors.push({
+                    path: 'exit_expression',
+                    message: `Invalid JMESPath expression: ${e.message}`
+                });
+            }
+        }
+    }
+    if (config.execution_strategy && !['plan', 'act'].includes(config.execution_strategy)) {
+        errors.push({
+            path: 'execution_strategy',
+            message: 'Execution strategy must be either "plan" or "act"'
+        });
+    }
+    // Check commands
+    if (config.commands) {
+        if (typeof config.commands !== 'object') {
+            errors.push({ path: 'commands', message: 'Commands must be an object' });
+        }
+        else {
+            Object.entries(config.commands).forEach(([commandName, command]) => {
+                if (commandName !== userCommand) {
+                    return;
+                }
+                const commandPath = `commands.${commandName}`;
+                // Validate command properties
+                if (!command.instructions) {
+                    errors.push({ path: `${commandPath}.instructions`, message: 'Instructions are required' });
+                }
+                if (config.execution_strategy && !['plan', 'act'].includes(config.execution_strategy)) {
+                    errors.push({
+                        path: `${commandPath}.execution_strategy`,
+                        message: 'Execution strategy must be either "plan" or "act"'
+                    });
+                }
+                if (command.available_tools) {
+                    validateAvailableTools(command.available_tools, `${commandPath}.available_tools`, errors);
+                }
+                if (command.ignore_tools) {
+                    validateAvailableTools(command.ignore_tools, `${commandPath}.ignore_tools`, errors);
+                }
+                // Validate command-level tools_config if present
+                if (command.mcpServers) {
+                    const commandMCPServers = command?.mcpServers && typeof command.mcpServers === 'string' ? JSON.parse(command.mcpServers) : {};
+                    Object.entries(commandMCPServers).forEach(([serverId, serverConfig]) => {
+                        validateMCPServerConfig(serverConfig, `${commandPath}.mcpServers.${serverId}`, errors);
+                    });
+                }
+                // Validate output_schema if present
+                if (command.output_schema) {
+                    validateOutputSchema(command.output_schema, `${commandPath}.output_schema`, errors);
+                }
+                // Validate command-level exit_expression if present
+                if (command.exit_expression) {
+                    if (!command.output_schema) {
+                        errors.push({
+                            path: `${commandPath}.exit_expression`,
+                            message: 'Exit expression requires an output schema to be defined'
+                        });
+                    }
+                    else {
+                        try {
+                            //@ts-ignore
+                            jmespath.compile(command.exit_expression);
+                        }
+                        catch (e) {
+                            errors.push({
+                                path: `${commandPath}.exit_expression`,
+                                message: `Invalid JMESPath expression: ${e.message}`
+                            });
+                        }
+                    }
+                }
+                // Validate arguments
+                if (command.arguments) {
+                    if (!Array.isArray(command.arguments)) {
+                        errors.push({ path: `${commandPath}.arguments`, message: 'Arguments must be an array' });
+                    }
+                    else {
+                        command.arguments.forEach((arg, index) => {
+                            const argPath = `${commandPath}.arguments[${index}]`;
+                            if (!arg.name) {
+                                errors.push({ path: `${argPath}.name`, message: 'Argument name is required' });
+                            }
+                            const validTypes = ['string', 'number', 'boolean', 'array', 'object'];
+                            if (!arg.type || !validTypes.includes(arg.type)) {
+                                errors.push({
+                                    path: `${argPath}.type`,
+                                    message: `Argument type must be one of: ${validTypes.join(', ')}`
+                                });
+                            }
+                            if (arg.required === undefined) {
+                                errors.push({ path: `${argPath}.required`, message: 'Argument required flag must be specified' });
+                            }
+                            if (!arg.description) {
+                                errors.push({ path: `${argPath}.description`, message: 'Argument description is required' });
+                            }
+                        });
+                    }
+                }
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Checks if the config version is valid and up to date
+ */
+export function checkConfigVersion(configVersion) {
+    const latestVersion = LATEST_CONFIG_VERSION;
+    const parsedLatest = parseVersion(latestVersion);
+    if (!parsedLatest) {
+        throw new Error(`Invalid LATEST_CONFIG_VERSION format: ${latestVersion}. Expected x.y format.`);
+    }
+    if (!configVersion) {
+        return {
+            isLatest: false,
+            latestVersion,
+            message: `⚠️ No version specified in agent.toml. Using latest version ${latestVersion}. Consider adding 'version = "${latestVersion}"' to your agent.toml file.`
+        };
+    }
+    const parsedCurrent = parseVersion(configVersion);
+    if (!parsedCurrent) {
+        return {
+            isLatest: false,
+            currentVersion: configVersion,
+            latestVersion,
+            message: `❌ Invalid version format "${configVersion}". Expected format is x.y (e.g., "1.0", "2.1").`
+        };
+    }
+    const comparison = compareVersions(parsedCurrent, parsedLatest);
+    if (comparison > 0) {
+        return {
+            isLatest: false,
+            currentVersion: configVersion,
+            latestVersion,
+            message: `❌ Config version ${configVersion} is newer than the latest supported version ${latestVersion}. Please update your CLI or downgrade your config.`
+        };
+    }
+    if (comparison < 0) {
+        return {
+            isLatest: false,
+            currentVersion: configVersion,
+            latestVersion,
+            message: `⚠️ Your agent.toml version (${configVersion}) is outdated. Latest version is ${latestVersion}. Consider updating your configuration.`
+        };
+    }
+    // Version is current - no message needed
+    return {
+        isLatest: true,
+        currentVersion: configVersion,
+        latestVersion
+    };
+}
+/**
+ * Validates a tool configuration
+ *
+ * @param serverConfig Tool configuration to validate
+ * @param basePath Base path for error reporting
+ * @param errors Array to collect validation errors
+ */
+function validateMCPServerConfig(serverConfig, basePath, errors) {
+    // Either command or url must be provided
+    if (!serverConfig.command && !serverConfig.url) {
+        errors.push({
+            path: basePath,
+            message: 'Either command or url must be provided for a tool configuration'
+        });
+    }
+    // Validate args if present
+    if (serverConfig.args && !Array.isArray(serverConfig.args)) {
+        errors.push({
+            path: `${basePath}.args`,
+            message: 'Tool args must be an array of strings'
+        });
+    }
+    // Validate env if present
+    if (serverConfig.env && typeof serverConfig.env !== 'object') {
+        errors.push({
+            path: `${basePath}.env`,
+            message: 'Tool env must be an object mapping environment variables to values'
+        });
+    }
+}
+// Add this function to validate the output schema
+/**
+ * Validates an output schema string
+ *
+ * @param schema Output schema string to validate
+ * @param basePath Base path for error reporting
+ * @param errors Array to collect validation errors
+ */
+export function validateOutputSchema(schema, basePath, errors) {
+    try {
+        // Parse the schema to make sure it's valid JSON
+        const parsedSchema = schema.json_schema.schema;
+        // Verify the schema has the expected structure
+        if (!parsedSchema.properties) {
+            errors.push({
+                path: basePath,
+                message: 'Output schema must have a properties object'
+            });
+        }
+        // Validate each property in the schema
+        if (parsedSchema.properties && typeof parsedSchema.properties === 'object') {
+            Object.entries(parsedSchema.properties).forEach(([propName, propDef]) => {
+                if (!propDef.description) {
+                    errors.push({
+                        path: `${basePath}.properties.${propName}`,
+                        message: `Property '${propName}' must have a description`
+                    });
+                }
+                if (!propDef.type) {
+                    errors.push({
+                        path: `${basePath}.properties.${propName}`,
+                        message: `Property '${propName}' must have a type`
+                    });
+                }
+            });
+        }
+    }
+    catch (error) {
+        errors.push({
+            path: basePath,
+            message: `Invalid JSON schema: ${error.message}`
+        });
+    }
+}
+/**
+ * Validates command arguments against the command configuration
+ * @param commandConfig The command configuration from agent.toml
+ * @param customArgs The custom arguments provided by the user
+ * @returns ValidationResult with valid flag and any errors
+ */
+export function validateCommandArgs(commandConfig, customArgs) {
+    const validationErrors = [];
+    // If no arguments defined in config, any args are valid
+    if (!commandConfig.arguments || !Array.isArray(commandConfig.arguments)) {
+        return { valid: true, errors: [] };
+    }
+    // Check for required arguments
+    const requiredArgs = commandConfig.arguments.filter(arg => arg.required);
+    for (const arg of requiredArgs) {
+        if (!(arg.name in customArgs)) {
+            validationErrors.push({
+                path: `arguments.${arg.name}`,
+                message: `Required argument '${arg.name}' is missing`
+            });
+        }
+    }
+    // Check types of provided arguments
+    for (const [key, value] of Object.entries(customArgs)) {
+        const argConfig = commandConfig.arguments.find(arg => arg.name === key);
+        // Check if argument is defined in the config
+        if (!argConfig) {
+            continue;
+        }
+        // Check type
+        switch (argConfig.type) {
+            case 'number':
+                if (typeof value !== 'number' && !/^-?\d+(\.\d+)?$/.test(String(value))) {
+                    validationErrors.push({
+                        path: `arguments.${key}`,
+                        message: `Argument '${key}' should be a number, got ${typeof value}`
+                    });
+                }
+                break;
+            case 'string':
+                if (typeof value !== 'string') {
+                    validationErrors.push({
+                        path: `arguments.${key}`,
+                        message: `Argument '${key}' should be a string, got ${typeof value}`
+                    });
+                }
+                break;
+            case 'boolean':
+                // Handle string representation of booleans from CLI
+                if (typeof value !== 'boolean' &&
+                    !(typeof value === 'string' && ['true', 'false'].includes(value.toLowerCase()))) {
+                    validationErrors.push({
+                        path: `arguments.${key}`,
+                        message: `Argument '${key}' should be a boolean, got ${typeof value}`
+                    });
+                }
+                break;
+            case 'array': {
+                // Accept either an actual array, or a stringified JSON array
+                if (Array.isArray(value)) {
+                    break;
+                }
+                if (typeof value === 'string') {
+                    try {
+                        const parsed = JSON.parse(value);
+                        if (!Array.isArray(parsed)) {
+                            validationErrors.push({
+                                path: `arguments.${key}`,
+                                message: `Argument '${key}' should be a JSON array (e.g., "[1, 2, 3]"), got valid JSON but not an array`
+                            });
+                        }
+                    }
+                    catch {
+                        validationErrors.push({
+                            path: `arguments.${key}`,
+                            message: `Argument '${key}' should be a JSON array (e.g., "[1, 2, 3]"), got invalid JSON string`
+                        });
+                    }
+                    break;
+                }
+                // Any other type is invalid
+                validationErrors.push({
+                    path: `arguments.${key}`,
+                    message: `Argument '${key}' should be a JSON array, got ${typeof value}`
+                });
+                break;
+            }
+            case 'object': {
+                // Accept either a plain object (not null/array), or a stringified JSON object
+                if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                    break;
+                }
+                if (typeof value === 'string') {
+                    try {
+                        const parsed = JSON.parse(value);
+                        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                            validationErrors.push({
+                                path: `arguments.${key}`,
+                                message: `Argument '${key}' should be a JSON object (e.g., "{\"foo\": 1}"), got valid JSON but not an object`
+                            });
+                        }
+                    }
+                    catch {
+                        validationErrors.push({
+                            path: `arguments.${key}`,
+                            message: `Argument '${key}' should be a JSON object (e.g., "{\"foo\": 1}"), got invalid JSON string`
+                        });
+                    }
+                    break;
+                }
+                // Any other type is invalid
+                validationErrors.push({
+                    path: `arguments.${key}`,
+                    message: `Argument '${key}' should be a JSON object, got ${typeof value}`
+                });
+                break;
+            }
+            default:
+                validationErrors.push({
+                    path: `arguments.${key}.type`,
+                    message: `Unknown type '${argConfig.type}' for argument '${key}'`
+                });
+        }
+    }
+    return {
+        valid: validationErrors.length === 0,
+        errors: validationErrors
+    };
+}
+/**
+ * Shared validator for available_tools entries
+ */
+function validateAvailableTools(available, basePath, errors) {
+    if (!Array.isArray(available)) {
+        errors.push({ path: basePath, message: 'Available tools must be an array' });
+        return;
+    }
+    // MCPManager may not be initialized yet during early validation (e.g., before mcpInitialization)
+    let manager = null;
+    try {
+        manager = MCPManager.getInstance();
+    }
+    catch {
+        // MCP may be disabled (tools = []), or not initialized yet.
+        // In that case, skip server/tool existence validation entirely.
+        return;
+    }
+    available.forEach((tool) => {
+        const [serverName, toolName] = String(tool).split('.');
+        const tools = manager.getTools(serverName);
+        if (tools.length === 0) {
+            errors.push({
+                path: `${basePath}[${serverName}]`,
+                message: `Could not initialize the server ${serverName}. Make sure the MCP server is configured correctly.`
+            });
+        }
+        else if (toolName && !tools.find((t) => t.name === toolName)) {
+            errors.push({
+                path: `${basePath}[${tool}]`,
+                message: `Tool ${toolName} not found in server ${serverName}`
+            });
+        }
+    });
+}
+/**
+ * Validate a mode by name
+ */
+export function validateMode(config, modeName) {
+    const errors = [];
+    if (!config.modes || typeof config.modes !== 'object') {
+        errors.push({ path: 'modes', message: 'No modes defined in configuration' });
+        return { valid: false, errors };
+    }
+    const mode = config.modes[modeName];
+    const basePath = `modes.${modeName}`;
+    if (!mode) {
+        errors.push({ path: basePath, message: `Mode '${modeName}' not found` });
+        return { valid: false, errors };
+    }
+    // instructions required
+    if (!mode.instructions || typeof mode.instructions !== 'string' || mode.instructions.trim().length === 0) {
+        errors.push({ path: `${basePath}.instructions`, message: 'Instructions are required' });
+    }
+    // execution_strategy (optional) must be plan|act
+    if (mode.execution_strategy && !['plan', 'act'].includes(mode.execution_strategy)) {
+        errors.push({ path: `${basePath}.execution_strategy`, message: 'Execution strategy must be either "plan" or "act"' });
+    }
+    // available_tools validation (optional)
+    if (mode.available_tools) {
+        validateAvailableTools(mode.available_tools, `${basePath}.available_tools`, errors);
+    }
+    if (mode.ignore_tools) {
+        validateAvailableTools(mode.ignore_tools, `${basePath}.ignore_tools`, errors);
+    }
+    // mcpServers validation (optional)
+    if (mode.mcpServers) {
+        const modeMCPServers = typeof mode.mcpServers === 'string' ? (() => { try {
+            return JSON.parse(mode.mcpServers);
+        }
+        catch {
+            return {};
+        } })() : mode.mcpServers;
+        Object.entries(modeMCPServers || {}).forEach(([serverId, serverConfig]) => {
+            validateMCPServerConfig(serverConfig, `${basePath}.mcpServers.${serverId}`, errors);
+        });
+    }
+    // output_schema validation (optional)
+    if (mode.output_schema && typeof mode.output_schema !== 'string') {
+        validateOutputSchema(mode.output_schema, `${basePath}.output_schema`, errors);
+    }
+    // exit_expression validation (optional)
+    if (mode.exit_expression) {
+        if (!mode.output_schema) {
+            errors.push({ path: `${basePath}.exit_expression`, message: 'Exit expression requires an output schema to be defined' });
+        }
+        else {
+            try {
+                // @ts-ignore
+                jmespath.compile(mode.exit_expression);
+            }
+            catch (e) {
+                errors.push({ path: `${basePath}.exit_expression`, message: `Invalid JMESPath expression: ${e.message}` });
+            }
+        }
+    }
+    // permissions (optional) basic validation
+    if (mode.permissions && !/^(r?w?x?|-|rw|rx|wx|rwx)$/.test(mode.permissions)) {
+        errors.push({ path: `${basePath}.permissions`, message: 'Invalid permissions format. Use one of: r, rw, rx, wx, rwx, -' });
+    }
+    return { valid: errors.length === 0, errors };
+}
+//# sourceMappingURL=index.js.map