@hypercli/core 0.1.1

package/dist/parsers/template-parser.js

@@ -0,0 +1,896 @@
+/**
+ * Template.yml Parser
+ *
+ * Parses and validates template.yml files to extract action definitions
+ * and variable configurations for code generation
+ */
+import fs from "node:fs";
+import path from "node:path";
+import yaml from "js-yaml";
+export class TemplateParser {
+    static SUPPORTED_VERSIONS = ["1.0.0"];
+    static VALID_VARIABLE_TYPES = [
+        "string",
+        "number",
+        "boolean",
+        "enum",
+        "array",
+        "object",
+        "file",
+        "directory",
+    ];
+    static VALID_TOOL_TYPES = [
+        "template",
+        "action",
+        "codemod",
+        "recipe",
+        "shell",
+    ];
+    /**
+     * Parse a template.yml file and return validated configuration
+     */
+    static async parseTemplateFile(filePath) {
+        const result = {
+            config: {},
+            filePath,
+            isValid: false,
+            errors: [],
+            warnings: [],
+        };
+        try {
+            // Check if file exists
+            if (!fs.existsSync(filePath)) {
+                result.errors.push(`Template file not found: ${filePath}`);
+                return result;
+            }
+            // Read and parse YAML
+            const content = fs.readFileSync(filePath, "utf-8");
+            const parsed = yaml.load(content);
+            if (!parsed || typeof parsed !== "object") {
+                result.errors.push("Invalid YAML format or empty file");
+                return result;
+            }
+            // Validate and build config
+            result.config = TemplateParser.validateAndBuildConfig(parsed, result.errors, result.warnings);
+            result.isValid = result.errors.length === 0;
+            return result;
+        }
+        catch (error) {
+            result.errors.push(`Failed to parse template file: ${error.message}`);
+            return result;
+        }
+    }
+    /**
+     * Parse all template.yml files in a directory
+     */
+    static async parseTemplateDirectory(dirPath) {
+        const results = [];
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const templatePath = path.join(dirPath, entry.name, "template.yml");
+                    if (fs.existsSync(templatePath)) {
+                        const parsed = await TemplateParser.parseTemplateFile(templatePath);
+                        results.push(parsed);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Return empty array if directory doesn't exist or can't be read
+            console.warn(`Warning: Could not read template directory: ${dirPath}`);
+        }
+        return results;
+    }
+    /**
+     * Validate template configuration and build normalized config object
+     */
+    static validateAndBuildConfig(parsed, errors, warnings) {
+        const config = {
+            name: "",
+            variables: {},
+        };
+        // Validate required fields
+        if (!parsed.name || typeof parsed.name !== "string") {
+            errors.push("Template name is required and must be a string");
+        }
+        else {
+            config.name = parsed.name;
+        }
+        if (!parsed.variables || typeof parsed.variables !== "object") {
+            errors.push("Template variables section is required and must be an object");
+        }
+        else {
+            TemplateParser.validateVariables(parsed.variables, config, errors, warnings);
+        }
+        // Validate optional fields
+        if (parsed.description && typeof parsed.description === "string") {
+            config.description = parsed.description;
+        }
+        if (parsed.version) {
+            if (typeof parsed.version !== "string") {
+                warnings.push("Template version should be a string");
+            }
+            else {
+                config.version = parsed.version;
+                if (!TemplateParser.SUPPORTED_VERSIONS.includes(parsed.version)) {
+                    warnings.push(`Unsupported template version: ${parsed.version}`);
+                }
+            }
+        }
+        if (parsed.author && typeof parsed.author === "string") {
+            config.author = parsed.author;
+        }
+        if (parsed.category && typeof parsed.category === "string") {
+            config.category = parsed.category;
+        }
+        if (parsed.tags) {
+            if (Array.isArray(parsed.tags)) {
+                config.tags = parsed.tags.filter((tag) => typeof tag === "string");
+                if (config.tags && config.tags.length !== parsed.tags.length) {
+                    warnings.push("Some tags were ignored (must be strings)");
+                }
+            }
+            else {
+                warnings.push("Tags should be an array of strings");
+            }
+        }
+        if (parsed.examples) {
+            if (Array.isArray(parsed.examples)) {
+                config.examples = TemplateParser.validateExamples(parsed.examples, config.variables, warnings);
+            }
+            else {
+                warnings.push("Examples should be an array");
+            }
+        }
+        if (parsed.outputs) {
+            if (Array.isArray(parsed.outputs)) {
+                config.outputs = parsed.outputs.filter((output) => typeof output === "string");
+            }
+            else {
+                warnings.push("Outputs should be an array of strings");
+            }
+        }
+        // Recipe Step System validation
+        if (parsed.steps) {
+            if (Array.isArray(parsed.steps)) {
+                config.steps = TemplateParser.validateSteps(parsed.steps, config.variables, errors, warnings);
+            }
+            else {
+                warnings.push("Steps should be an array");
+            }
+        }
+        // Recipe settings validation
+        if (parsed.settings) {
+            config.settings = TemplateParser.validateSettings(parsed.settings, warnings);
+        }
+        return config;
+    }
+    /**
+     * Validate variables section of template configuration
+     */
+    static validateVariables(variables, config, errors, warnings) {
+        for (const [varName, varConfig] of Object.entries(variables)) {
+            if (!varConfig || typeof varConfig !== "object") {
+                errors.push(`Variable '${varName}' must be an object`);
+                continue;
+            }
+            const variable = TemplateParser.validateVariable(varName, varConfig, errors, warnings);
+            if (variable) {
+                config.variables[varName] = variable;
+            }
+        }
+    }
+    /**
+     * Validate individual variable configuration
+     */
+    static validateVariable(varName, varConfig, errors, warnings) {
+        const variable = {
+            type: "string",
+        };
+        // Validate type
+        if (!varConfig.type) {
+            errors.push(`Variable '${varName}' must have a type`);
+            return null;
+        }
+        if (!TemplateParser.VALID_VARIABLE_TYPES.includes(varConfig.type)) {
+            errors.push(`Variable '${varName}' has invalid type: ${varConfig.type}`);
+            return null;
+        }
+        variable.type = varConfig.type;
+        // Validate required field
+        if (varConfig.required !== undefined) {
+            if (typeof varConfig.required !== "boolean") {
+                warnings.push(`Variable '${varName}' required field should be boolean`);
+            }
+            else {
+                variable.required = varConfig.required;
+            }
+        }
+        // Validate default value
+        if (varConfig.default !== undefined) {
+            if (variable.required) {
+                errors.push(`Variable '${varName}': 'default' and 'required' are mutually exclusive`);
+                return null;
+            }
+            if (varConfig.suggestion !== undefined) {
+                errors.push(`Variable '${varName}': 'default' and 'suggestion' are mutually exclusive`);
+                return null;
+            }
+            variable.default = varConfig.default;
+        }
+        // Validate suggestion value
+        if (varConfig.suggestion !== undefined) {
+            variable.suggestion = varConfig.suggestion;
+        }
+        // Validate description
+        if (varConfig.description) {
+            if (typeof varConfig.description !== "string") {
+                warnings.push(`Variable '${varName}' description should be a string`);
+            }
+            else {
+                variable.description = varConfig.description;
+            }
+        }
+        // Validate pattern (for string types)
+        if (varConfig.pattern) {
+            if (variable.type !== "string") {
+                warnings.push(`Variable '${varName}' pattern only applies to string types`);
+            }
+            else if (typeof varConfig.pattern !== "string") {
+                warnings.push(`Variable '${varName}' pattern should be a string`);
+            }
+            else {
+                try {
+                    new RegExp(varConfig.pattern);
+                    variable.pattern = varConfig.pattern;
+                }
+                catch (error) {
+                    errors.push(`Variable '${varName}' has invalid regex pattern: ${varConfig.pattern}`);
+                }
+            }
+        }
+        // Validate enum values
+        if (varConfig.values) {
+            if (variable.type !== "enum") {
+                warnings.push(`Variable '${varName}' values only apply to enum types`);
+            }
+            else if (!Array.isArray(varConfig.values)) {
+                errors.push(`Variable '${varName}' values must be an array`);
+            }
+            else {
+                variable.values = varConfig.values.filter((val) => typeof val === "string");
+                if (variable.values && variable.values.length === 0) {
+                    errors.push(`Variable '${varName}' enum must have at least one value`);
+                }
+            }
+        }
+        // Validate position (for positional CLI args)
+        if (varConfig.position !== undefined) {
+            if (typeof varConfig.position !== "number" ||
+                varConfig.position < 0 ||
+                !Number.isInteger(varConfig.position)) {
+                warnings.push(`Variable '${varName}' position should be a non-negative integer`);
+            }
+            else {
+                variable.position = varConfig.position;
+            }
+        }
+        // Validate min/max (for number types)
+        if (varConfig.min !== undefined) {
+            if (variable.type !== "number") {
+                warnings.push(`Variable '${varName}' min only applies to number types`);
+            }
+            else if (typeof varConfig.min !== "number") {
+                warnings.push(`Variable '${varName}' min should be a number`);
+            }
+            else {
+                variable.min = varConfig.min;
+            }
+        }
+        if (varConfig.max !== undefined) {
+            if (variable.type !== "number") {
+                warnings.push(`Variable '${varName}' max only applies to number types`);
+            }
+            else if (typeof varConfig.max !== "number") {
+                warnings.push(`Variable '${varName}' max should be a number`);
+            }
+            else {
+                variable.max = varConfig.max;
+            }
+        }
+        return variable;
+    }
+    /**
+     * Validate examples section
+     */
+    static validateExamples(examples, variables, warnings) {
+        const validExamples = [];
+        for (const [index, example] of examples.entries()) {
+            if (!example || typeof example !== "object") {
+                warnings.push(`Example ${index + 1} must be an object`);
+                continue;
+            }
+            if (!example.title || typeof example.title !== "string") {
+                warnings.push(`Example ${index + 1} must have a title`);
+                continue;
+            }
+            if (!example.variables || typeof example.variables !== "object") {
+                warnings.push(`Example ${index + 1} must have variables`);
+                continue;
+            }
+            const validExample = {
+                title: example.title,
+                variables: example.variables,
+            };
+            if (example.description && typeof example.description === "string") {
+                validExample.description = example.description;
+            }
+            // Validate example variables against template variables
+            for (const [varName, _varValue] of Object.entries(example.variables)) {
+                if (!variables[varName]) {
+                    warnings.push(`Example ${index + 1} references undefined variable: ${varName}`);
+                }
+            }
+            validExamples.push(validExample);
+        }
+        return validExamples;
+    }
+    /**
+     * Validate variable value against template variable definition
+     */
+    static validateVariableValue(varName, value, variable) {
+        // Check required
+        if (variable.required && (value === undefined || value === null || value === "")) {
+            return { isValid: false, error: `Variable '${varName}' is required` };
+        }
+        // If value is undefined and not required, use default
+        if (value === undefined && variable.default !== undefined) {
+            return { isValid: true };
+        }
+        // If value is undefined and no default, skip validation
+        if (value === undefined) {
+            return { isValid: true };
+        }
+        // Type validation
+        switch (variable.type) {
+            case "string":
+                if (typeof value !== "string") {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be a string`,
+                    };
+                }
+                if (variable.pattern) {
+                    const regex = new RegExp(variable.pattern);
+                    if (!regex.test(value)) {
+                        return {
+                            isValid: false,
+                            error: `Variable '${varName}' does not match pattern: ${variable.pattern}`,
+                        };
+                    }
+                }
+                break;
+            case "number":
+                if (typeof value !== "number") {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be a number`,
+                    };
+                }
+                if (variable.min !== undefined && value < variable.min) {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be >= ${variable.min}`,
+                    };
+                }
+                if (variable.max !== undefined && value > variable.max) {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be <= ${variable.max}`,
+                    };
+                }
+                break;
+            case "boolean":
+                if (typeof value !== "boolean") {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be a boolean`,
+                    };
+                }
+                break;
+            case "enum":
+                if (variable.multiple && Array.isArray(value)) {
+                    // Validate each value in array
+                    const invalid = value.find((v) => !variable.values?.includes(v));
+                    if (invalid) {
+                        return {
+                            isValid: false,
+                            error: `Value '${invalid}' for variable '${varName}' must be one of: ${variable.values?.join(", ")}`,
+                        };
+                    }
+                }
+                else if (!variable.values || !variable.values.includes(value)) {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be one of: ${variable.values?.join(", ")}`,
+                    };
+                }
+                break;
+            case "array":
+                if (!Array.isArray(value)) {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be an array`,
+                    };
+                }
+                break;
+            case "object":
+                if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                    return {
+                        isValid: false,
+                        error: `Variable '${varName}' must be an object`,
+                    };
+                }
+                break;
+        }
+        return { isValid: true };
+    }
+    /**
+     * Get resolved variable value (with default if not provided)
+     */
+    static getResolvedValue(value, variable) {
+        if (value !== undefined) {
+            return value;
+        }
+        return variable.default;
+    }
+    /**
+     * Validate recipe steps array (Recipe Step System)
+     */
+    static validateSteps(steps, variables, errors, warnings) {
+        const validSteps = [];
+        const stepNames = new Set();
+        const stepDependencies = new Map();
+        for (const [index, step] of steps.entries()) {
+            if (!step || typeof step !== "object") {
+                errors.push(`Step ${index + 1} must be an object`);
+                continue;
+            }
+            const validStep = TemplateParser.validateStep(step, index + 1, variables, errors, warnings);
+            if (validStep) {
+                // Check for duplicate step names
+                if (stepNames.has(validStep.name)) {
+                    errors.push(`Duplicate step name: '${validStep.name}'`);
+                }
+                else {
+                    stepNames.add(validStep.name);
+                }
+                validSteps.push(validStep);
+                // Track dependencies for circular dependency check
+                if (validStep.dependsOn) {
+                    stepDependencies.set(validStep.name, validStep.dependsOn);
+                }
+            }
+        }
+        // Check for circular dependencies
+        TemplateParser.validateStepDependencies(stepDependencies, errors);
+        // Validate step dependencies reference existing steps
+        TemplateParser.validateStepDependencyReferences(stepDependencies, stepNames, warnings);
+        return validSteps;
+    }
+    /**
+     * Validate individual recipe step
+     */
+    static validateStep(step, index, _variables, errors, warnings) {
+        // Validate required fields
+        if (!step.name || typeof step.name !== "string") {
+            errors.push(`Step ${index} must have a name (string)`);
+            return null;
+        }
+        // Tool inference / Shorthand support
+        if (!step.tool) {
+            if (step.command) {
+                step.tool = "shell";
+            }
+            else if (step.recipe) {
+                step.tool = "recipe";
+            }
+            else if (step.template) {
+                step.tool = "template";
+            }
+            else if (step.action) {
+                step.tool = "action";
+            }
+            else if (step.codemod) {
+                step.tool = "codemod";
+            }
+        }
+        if (!step.tool || !TemplateParser.VALID_TOOL_TYPES.includes(step.tool)) {
+            errors.push(`Step '${step.name}' must have a valid tool type (${TemplateParser.VALID_TOOL_TYPES.join(", ")})`);
+            return null;
+        }
+        // Base step configuration
+        const baseStep = {
+            name: step.name,
+            tool: step.tool,
+        };
+        // Validate optional base fields
+        if (step.description && typeof step.description === "string") {
+            baseStep.description = step.description;
+        }
+        if (step.when && typeof step.when === "string") {
+            // Basic condition validation - check if it looks like a valid expression
+            if (TemplateParser.validateConditionExpression(step.when)) {
+                baseStep.when = step.when;
+            }
+            else {
+                baseStep.when = step.when;
+                warnings.push(`Step '${step.name}' has potentially invalid condition expression`);
+            }
+        }
+        if (step.dependsOn) {
+            if (Array.isArray(step.dependsOn)) {
+                const validDeps = step.dependsOn.filter((dep) => typeof dep === "string");
+                if (validDeps.length !== step.dependsOn.length) {
+                    warnings.push(`Step '${step.name}' has some invalid dependencies (must be strings)`);
+                }
+                if (validDeps.length > 0) {
+                    baseStep.dependsOn = validDeps;
+                }
+            }
+            else {
+                warnings.push(`Step '${step.name}' dependsOn should be an array of strings`);
+            }
+        }
+        if (step.parallel !== undefined && typeof step.parallel === "boolean") {
+            baseStep.parallel = step.parallel;
+        }
+        if (step.continueOnError !== undefined && typeof step.continueOnError === "boolean") {
+            baseStep.continueOnError = step.continueOnError;
+        }
+        if (step.timeout !== undefined && typeof step.timeout === "number" && step.timeout > 0) {
+            baseStep.timeout = step.timeout;
+        }
+        if (step.retries !== undefined && typeof step.retries === "number" && step.retries >= 0) {
+            baseStep.retries = step.retries;
+        }
+        if (step.tags && Array.isArray(step.tags)) {
+            const validTags = step.tags.filter((tag) => typeof tag === "string");
+            if (validTags.length > 0) {
+                baseStep.tags = validTags;
+            }
+        }
+        if (step.variables && typeof step.variables === "object" && step.variables !== null) {
+            baseStep.variables = step.variables;
+        }
+        if (step.environment && typeof step.environment === "object" && step.environment !== null) {
+            baseStep.environment = step.environment;
+        }
+        // Tool-specific validation
+        switch (step.tool) {
+            case "template":
+                return TemplateParser.validateTemplateStep(baseStep, step, errors, warnings);
+            case "action":
+                return TemplateParser.validateActionStep(baseStep, step, errors, warnings);
+            case "codemod":
+                return TemplateParser.validateCodeModStep(baseStep, step, errors, warnings);
+            case "recipe":
+                return TemplateParser.validateRecipeStep(baseStep, step, errors, warnings);
+            default:
+                errors.push(`Step '${step.name}' has unsupported tool type: ${step.tool}`);
+                return null;
+        }
+    }
+    /**
+     * Validate template step configuration
+     */
+    static validateTemplateStep(baseStep, step, errors, warnings) {
+        if (!step.template || typeof step.template !== "string") {
+            errors.push(`Template step '${step.name}' must have a template (string)`);
+            return null;
+        }
+        const templateStep = {
+            ...baseStep,
+            template: step.template,
+        };
+        if (step.outputDir && typeof step.outputDir === "string") {
+            templateStep.outputDir = step.outputDir;
+        }
+        if (step.overwrite !== undefined && typeof step.overwrite === "boolean") {
+            templateStep.overwrite = step.overwrite;
+        }
+        if (step.exclude && Array.isArray(step.exclude)) {
+            const validExcludes = step.exclude.filter((pattern) => typeof pattern === "string");
+            if (validExcludes.length > 0) {
+                templateStep.exclude = validExcludes;
+            }
+        }
+        if (step.templateConfig && typeof step.templateConfig === "object") {
+            templateStep.templateConfig = step.templateConfig;
+        }
+        return templateStep;
+    }
+    /**
+     * Validate action step configuration
+     */
+    static validateActionStep(baseStep, step, errors, warnings) {
+        if (!step.action || typeof step.action !== "string") {
+            errors.push(`Action step '${step.name}' must have an action (string)`);
+            return null;
+        }
+        const actionStep = {
+            ...baseStep,
+            action: step.action,
+        };
+        if (step.parameters && typeof step.parameters === "object" && step.parameters !== null) {
+            actionStep.parameters = step.parameters;
+        }
+        if (step.dryRun !== undefined && typeof step.dryRun === "boolean") {
+            actionStep.dryRun = step.dryRun;
+        }
+        if (step.force !== undefined && typeof step.force === "boolean") {
+            actionStep.force = step.force;
+        }
+        if (step.actionConfig && typeof step.actionConfig === "object") {
+            actionStep.actionConfig = step.actionConfig;
+        }
+        return actionStep;
+    }
+    /**
+     * Validate codemod step configuration
+     */
+    static validateCodeModStep(baseStep, step, errors, warnings) {
+        if (!step.codemod || typeof step.codemod !== "string") {
+            errors.push(`CodeMod step '${step.name}' must have a codemod (string)`);
+            return null;
+        }
+        if (!step.files || !Array.isArray(step.files) || step.files.length === 0) {
+            errors.push(`CodeMod step '${step.name}' must have a files array with at least one pattern`);
+            return null;
+        }
+        const validFiles = step.files.filter((file) => typeof file === "string");
+        if (validFiles.length !== step.files.length) {
+            warnings.push(`CodeMod step '${step.name}' has some invalid file patterns (must be strings)`);
+        }
+        if (validFiles.length === 0) {
+            errors.push(`CodeMod step '${step.name}' must have at least one valid file pattern`);
+            return null;
+        }
+        const codemodStep = {
+            ...baseStep,
+            codemod: step.codemod,
+            files: validFiles,
+        };
+        if (step.backup !== undefined && typeof step.backup === "boolean") {
+            codemodStep.backup = step.backup;
+        }
+        if (step.parser && ["typescript", "javascript", "json", "auto"].includes(step.parser)) {
+            codemodStep.parser = step.parser;
+        }
+        if (step.parameters && typeof step.parameters === "object" && step.parameters !== null) {
+            codemodStep.parameters = step.parameters;
+        }
+        if (step.force !== undefined && typeof step.force === "boolean") {
+            codemodStep.force = step.force;
+        }
+        if (step.codemodConfig && typeof step.codemodConfig === "object") {
+            codemodStep.codemodConfig = step.codemodConfig;
+        }
+        return codemodStep;
+    }
+    /**
+     * Validate recipe step configuration
+     */
+    static validateRecipeStep(baseStep, step, errors, warnings) {
+        if (!step.recipe || typeof step.recipe !== "string") {
+            errors.push(`Recipe step '${step.name}' must have a recipe (string)`);
+            return null;
+        }
+        const recipeStep = {
+            ...baseStep,
+            recipe: step.recipe,
+        };
+        if (step.version && typeof step.version === "string") {
+            recipeStep.version = step.version;
+        }
+        if (step.inheritVariables !== undefined && typeof step.inheritVariables === "boolean") {
+            recipeStep.inheritVariables = step.inheritVariables;
+        }
+        if (step.variableOverrides &&
+            typeof step.variableOverrides === "object" &&
+            step.variableOverrides !== null) {
+            recipeStep.variableOverrides = step.variableOverrides;
+        }
+        if (step.recipeConfig && typeof step.recipeConfig === "object") {
+            recipeStep.recipeConfig = step.recipeConfig;
+        }
+        return recipeStep;
+    }
+    /**
+     * Validate step dependencies for circular references
+     */
+    static validateStepDependencies(dependencies, errors) {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const detectCycle = (stepName, path) => {
+            if (recursionStack.has(stepName)) {
+                // Found a cycle - return the cycle path
+                const cycleStart = path.indexOf(stepName);
+                return path.slice(cycleStart).concat(stepName);
+            }
+            if (visited.has(stepName)) {
+                return null; // Already processed
+            }
+            visited.add(stepName);
+            recursionStack.add(stepName);
+            const currentPath = [...path, stepName];
+            const stepDeps = dependencies.get(stepName) || [];
+            for (const dep of stepDeps) {
+                const cycle = detectCycle(dep, currentPath);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+            recursionStack.delete(stepName);
+            return null;
+        };
+        for (const stepName of dependencies.keys()) {
+            if (!visited.has(stepName)) {
+                const cycle = detectCycle(stepName, []);
+                if (cycle) {
+                    errors.push(`Circular dependency detected: ${cycle.join(" -> ")}`);
+                    break; // Report only the first cycle found
+                }
+            }
+        }
+    }
+    /**
+     * Validate that step dependencies reference existing steps
+     */
+    static validateStepDependencyReferences(dependencies, stepNames, warnings) {
+        for (const [stepName, deps] of dependencies) {
+            for (const dep of deps) {
+                if (!stepNames.has(dep)) {
+                    warnings.push(`Step '${stepName}' depends on undefined step: '${dep}'`);
+                }
+            }
+        }
+    }
+    /**
+     * Basic validation of condition expressions
+     */
+    static validateConditionExpression(condition) {
+        // Basic validation - just check if it looks like a reasonable expression
+        // More sophisticated validation could be added later
+        if (!condition.trim()) {
+            return false;
+        }
+        // Check for obviously invalid patterns
+        const invalidPatterns = [
+            /^[{}()\[\].,;]*$/, // Only punctuation
+            /^\d+$/, // Only numbers
+            /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*$/, // Only a single identifier
+        ];
+        return !invalidPatterns.some((pattern) => pattern.test(condition.trim()));
+    }
+    /**
+     * Validate recipe execution settings
+     */
+    static validateSettings(settings, warnings) {
+        const result = {};
+        if (typeof settings !== "object" || settings === null) {
+            warnings.push("Settings should be an object");
+            return result;
+        }
+        if (settings.timeout !== undefined) {
+            if (typeof settings.timeout === "number" && settings.timeout > 0) {
+                result.timeout = settings.timeout;
+            }
+            else {
+                warnings.push("Settings timeout should be a positive number");
+            }
+        }
+        if (settings.retries !== undefined) {
+            if (typeof settings.retries === "number" && settings.retries >= 0) {
+                result.retries = settings.retries;
+            }
+            else {
+                warnings.push("Settings retries should be a non-negative number");
+            }
+        }
+        if (settings.continueOnError !== undefined) {
+            if (typeof settings.continueOnError === "boolean") {
+                result.continueOnError = settings.continueOnError;
+            }
+            else {
+                warnings.push("Settings continueOnError should be a boolean");
+            }
+        }
+        if (settings.maxParallelSteps !== undefined) {
+            if (typeof settings.maxParallelSteps === "number" && settings.maxParallelSteps > 0) {
+                result.maxParallelSteps = settings.maxParallelSteps;
+            }
+            else {
+                warnings.push("Settings maxParallelSteps should be a positive number");
+            }
+        }
+        if (settings.workingDir !== undefined) {
+            if (typeof settings.workingDir === "string") {
+                result.workingDir = settings.workingDir;
+            }
+            else {
+                warnings.push("Settings workingDir should be a string");
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if this configuration uses the Recipe Step System
+     */
+    static isRecipeConfig(config) {
+        return Array.isArray(config.steps) && config.steps.length > 0;
+    }
+    /**
+     * Convert a TemplateConfig to RecipeConfig (Recipe Step System)
+     */
+    static toRecipeConfig(templateConfig) {
+        if (!TemplateParser.isRecipeConfig(templateConfig)) {
+            return null; // Not a recipe configuration
+        }
+        const recipeConfig = {
+            name: templateConfig.name,
+            variables: templateConfig.variables,
+            steps: templateConfig.steps,
+        };
+        // Copy optional fields
+        if (templateConfig.description)
+            recipeConfig.description = templateConfig.description;
+        if (templateConfig.version)
+            recipeConfig.version = templateConfig.version;
+        if (templateConfig.author)
+            recipeConfig.author = templateConfig.author;
+        if (templateConfig.category)
+            recipeConfig.category = templateConfig.category;
+        if (templateConfig.tags)
+            recipeConfig.tags = templateConfig.tags;
+        if (templateConfig.outputs)
+            recipeConfig.outputs = templateConfig.outputs;
+        // Convert examples if present
+        if (templateConfig.examples) {
+            recipeConfig.examples = templateConfig.examples.map((example) => ({
+                title: example.title,
+                description: example.description,
+                variables: example.variables,
+            }));
+        }
+        // Convert settings if present
+        if (templateConfig.settings) {
+            recipeConfig.settings = templateConfig.settings;
+        }
+        return recipeConfig;
+    }
+    /**
+     * Validate that step configuration matches expected tool schema
+     */
+    static validateStepToolConfiguration(step, errors, warnings) {
+        switch (step.tool) {
+            case "template":
+                // Additional template-specific validation can be added here
+                break;
+            case "action":
+                // Additional action-specific validation can be added here
+                break;
+            case "codemod":
+                // Additional codemod-specific validation can be added here
+                break;
+            case "recipe":
+                // Additional recipe-specific validation can be added here
+                break;
+            default:
+                errors.push(`Unknown tool type: ${step.tool}`);
+        }
+    }
+}
+//# sourceMappingURL=template-parser.js.map