@wundr.io/cli 1.0.0 → 1.0.2-dev.20260530174250.ef0ec927

package/dist/commands/batch.js

@@ -1,738 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchCommands = void 0;
-const tslib_1 = require("tslib");
-const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const yaml_1 = tslib_1.__importDefault(require("yaml"));
-const listr2_1 = require("listr2");
-const logger_1 = require("../utils/logger");
-const error_handler_1 = require("../utils/error-handler");
-/**
- * Batch commands for YAML automation and batch processing
- */
-class BatchCommands {
-    program;
-    configManager;
-    pluginManager;
-    runningJobs = new Map();
-    constructor(program, configManager, pluginManager) {
-        this.program = program;
-        this.configManager = configManager;
-        this.pluginManager = pluginManager;
-        this.registerCommands();
-    }
-    registerCommands() {
-        const batchCmd = this.program
-            .command('batch')
-            .description('batch processing and automation with YAML');
-        // Run batch job
-        batchCmd
-            .command('run <file>')
-            .description('run batch job from YAML file')
-            .option('--dry-run', 'show what would be executed without running')
-            .option('--parallel', 'run commands in parallel where possible')
-            .option('--continue-on-error', 'continue execution on command failures')
-            .option('--vars <vars>', 'variables to pass to batch job (JSON or key=value)')
-            .option('--timeout <ms>', 'global timeout for batch job')
-            .action(async (file, options) => {
-            await this.runBatchJob(file, options);
-        });
-        // Create batch job
-        batchCmd
-            .command('create <name>')
-            .description('create a new batch job')
-            .option('--template <template>', 'batch job template')
-            .option('--commands <commands>', 'commands to include (comma-separated)')
-            .option('--interactive', 'create job interactively')
-            .action(async (name, options) => {
-            await this.createBatchJob(name, options);
-        });
-        // List batch jobs
-        batchCmd
-            .command('list')
-            .alias('ls')
-            .description('list available batch jobs')
-            .option('--path <path>', 'custom batch jobs directory')
-            .action(async (options) => {
-            await this.listBatchJobs(options);
-        });
-        // Validate batch job
-        batchCmd
-            .command('validate <file>')
-            .description('validate batch job YAML file')
-            .action(async (file) => {
-            await this.validateBatchJob(file);
-        });
-        // Stop running job
-        batchCmd
-            .command('stop <jobId>')
-            .description('stop a running batch job')
-            .action(async (jobId) => {
-            await this.stopBatchJob(jobId);
-        });
-        // Show job status
-        batchCmd
-            .command('status [jobId]')
-            .description('show batch job status')
-            .action(async (jobId) => {
-            await this.showJobStatus(jobId);
-        });
-        // Schedule batch job
-        batchCmd
-            .command('schedule <file>')
-            .description('schedule batch job execution')
-            .option('--cron <expression>', 'cron expression for scheduling')
-            .option('--interval <ms>', 'interval in milliseconds')
-            .option('--once', 'run once after delay')
-            .action(async (file, options) => {
-            await this.scheduleBatchJob(file, options);
-        });
-        // Export batch job
-        batchCmd
-            .command('export <file>')
-            .description('export batch job to different formats')
-            .option('--format <format>', 'export format (json, shell, dockerfile)', 'json')
-            .option('--output <path>', 'output file path')
-            .action(async (file, options) => {
-            await this.exportBatchJob(file, options);
-        });
-        // Import batch job
-        batchCmd
-            .command('import <file>')
-            .description('import batch job from different formats')
-            .option('--format <format>', 'source format (json, shell, package-scripts)')
-            .option('--name <name>', 'batch job name')
-            .action(async (file, options) => {
-            await this.importBatchJob(file, options);
-        });
-        // Template management
-        batchCmd.command('template').description('manage batch job templates');
-        batchCmd
-            .command('template list')
-            .description('list available templates')
-            .action(async () => {
-            await this.listTemplates();
-        });
-        batchCmd
-            .command('template create <name>')
-            .description('create a new template')
-            .option('--from <file>', 'create template from existing batch job')
-            .action(async (name, options) => {
-            await this.createTemplate(name, options);
-        });
-    }
-    /**
-     * Run batch job from YAML file
-     */
-    async runBatchJob(file, options) {
-        try {
-            logger_1.logger.info(`Running batch job: ${chalk_1.default.cyan(file)}`);
-            // Load and validate batch job
-            const job = await this.loadBatchJob(file);
-            await this.validateJobStructure(job);
-            // Process variables
-            const processedJob = await this.processJobVariables(job, options.vars);
-            if (options.dryRun) {
-                await this.showDryRun(processedJob);
-                return;
-            }
-            // Create job ID and track execution
-            const jobId = `job-${Date.now()}`;
-            this.runningJobs.set(jobId, {
-                file,
-                job: processedJob,
-                startTime: Date.now(),
-                status: 'running',
-            });
-            try {
-                await this.executeBatchJob(processedJob, jobId, options);
-                logger_1.logger.success(`Batch job completed: ${file}`);
-            }
-            finally {
-                this.runningJobs.delete(jobId);
-            }
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_RUN_FAILED', 'Failed to run batch job', { file, options }, true);
-        }
-    }
-    /**
-     * Create a new batch job
-     */
-    async createBatchJob(name, options) {
-        try {
-            logger_1.logger.info(`Creating batch job: ${chalk_1.default.cyan(name)}`);
-            let job;
-            if (options.interactive) {
-                job = await this.createInteractiveBatchJob(name);
-            }
-            else if (options.template) {
-                job = await this.createJobFromTemplate(name, options.template);
-            }
-            else {
-                job = this.createBasicBatchJob(name, options);
-            }
-            const jobPath = path_1.default.join(process.cwd(), '.wundr', 'batch', `${name}.yaml`);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(jobPath));
-            await fs_extra_1.default.writeFile(jobPath, yaml_1.default.stringify(job));
-            logger_1.logger.success(`Batch job created: ${jobPath}`);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_CREATE_FAILED', 'Failed to create batch job', { name, options }, true);
-        }
-    }
-    /**
-     * List available batch jobs
-     */
-    async listBatchJobs(options) {
-        try {
-            const batchDir = options.path || path_1.default.join(process.cwd(), '.wundr', 'batch');
-            if (!(await fs_extra_1.default.pathExists(batchDir))) {
-                logger_1.logger.info('No batch jobs directory found');
-                return;
-            }
-            const files = await fs_extra_1.default.readdir(batchDir);
-            const yamlFiles = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
-            if (yamlFiles.length === 0) {
-                logger_1.logger.info('No batch jobs found');
-                return;
-            }
-            logger_1.logger.info(`Batch jobs (${yamlFiles.length}):`);
-            const jobs = [];
-            for (const file of yamlFiles) {
-                const filePath = path_1.default.join(batchDir, file);
-                try {
-                    const job = await this.loadBatchJob(filePath);
-                    jobs.push({
-                        Name: path_1.default.basename(file, path_1.default.extname(file)),
-                        Description: job.description || 'No description',
-                        Commands: job.commands.length,
-                        Parallel: job.parallel ? '✓' : '✗',
-                    });
-                }
-                catch (error) {
-                    jobs.push({
-                        Name: path_1.default.basename(file, path_1.default.extname(file)),
-                        Description: 'Invalid YAML',
-                        Commands: 'N/A',
-                        Parallel: 'N/A',
-                    });
-                }
-            }
-            console.table(jobs);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_LIST_FAILED', 'Failed to list batch jobs', { options }, true);
-        }
-    }
-    /**
-     * Validate batch job YAML file
-     */
-    async validateBatchJob(file) {
-        try {
-            logger_1.logger.info(`Validating batch job: ${chalk_1.default.cyan(file)}`);
-            const job = await this.loadBatchJob(file);
-            const validation = await this.validateJobStructure(job);
-            if (validation.valid) {
-                logger_1.logger.success('Batch job is valid ✓');
-                // Show job summary
-                console.log(chalk_1.default.blue('\nJob Summary:'));
-                console.log(`Name: ${job.name}`);
-                console.log(`Description: ${job.description || 'None'}`);
-                console.log(`Commands: ${job.commands.length}`);
-                console.log(`Parallel execution: ${job.parallel ? 'Yes' : 'No'}`);
-                console.log(`Continue on error: ${job.continueOnError ? 'Yes' : 'No'}`);
-            }
-            else {
-                logger_1.logger.error('Batch job validation failed:');
-                validation.errors.forEach(error => {
-                    logger_1.logger.error(`  - ${error}`);
-                });
-                process.exit(1);
-            }
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_VALIDATE_FAILED', 'Failed to validate batch job', { file }, true);
-        }
-    }
-    /**
-     * Stop a running batch job
-     */
-    async stopBatchJob(jobId) {
-        try {
-            const job = this.runningJobs.get(jobId);
-            if (!job) {
-                logger_1.logger.warn(`Job not found: ${jobId}`);
-                return;
-            }
-            // Stop the job (implementation would depend on how jobs are executed)
-            job.status = 'stopped';
-            this.runningJobs.delete(jobId);
-            logger_1.logger.success(`Batch job stopped: ${jobId}`);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_STOP_FAILED', 'Failed to stop batch job', { jobId }, true);
-        }
-    }
-    /**
-     * Show job status
-     */
-    async showJobStatus(jobId) {
-        try {
-            if (jobId) {
-                const job = this.runningJobs.get(jobId);
-                if (!job) {
-                    logger_1.logger.warn(`Job not found: ${jobId}`);
-                    return;
-                }
-                console.log(chalk_1.default.blue(`\nJob Status: ${jobId}`));
-                console.log(`File: ${job.file}`);
-                console.log(`Status: ${job.status}`);
-                console.log(`Started: ${new Date(job.startTime).toLocaleString()}`);
-                console.log(`Duration: ${Date.now() - job.startTime}ms`);
-            }
-            else {
-                if (this.runningJobs.size === 0) {
-                    logger_1.logger.info('No running batch jobs');
-                    return;
-                }
-                console.log(chalk_1.default.blue(`\nRunning Jobs (${this.runningJobs.size}):`));
-                const jobData = Array.from(this.runningJobs.entries()).map(([id, job]) => ({
-                    ID: id,
-                    File: path_1.default.basename(job.file),
-                    Status: job.status,
-                    Duration: `${Date.now() - job.startTime}ms`,
-                }));
-                console.table(jobData);
-            }
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_STATUS_FAILED', 'Failed to show job status', { jobId }, true);
-        }
-    }
-    /**
-     * Schedule batch job execution
-     */
-    async scheduleBatchJob(file, options) {
-        try {
-            logger_1.logger.info(`Scheduling batch job: ${chalk_1.default.cyan(file)}`);
-            // Validate the job first
-            await this.loadBatchJob(file);
-            if (options.cron) {
-                logger_1.logger.info(`Scheduled with cron: ${options.cron}`);
-                // Implementation would use a cron library
-            }
-            else if (options.interval) {
-                logger_1.logger.info(`Scheduled with interval: ${options.interval}ms`);
-                // Implementation would use setInterval
-            }
-            else if (options.once) {
-                logger_1.logger.info('Scheduled to run once');
-                // Implementation would use setTimeout
-            }
-            else {
-                throw new Error('No scheduling option provided');
-            }
-            logger_1.logger.success('Batch job scheduled successfully');
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_SCHEDULE_FAILED', 'Failed to schedule batch job', { file, options }, true);
-        }
-    }
-    /**
-     * Export batch job to different formats
-     */
-    async exportBatchJob(file, options) {
-        try {
-            logger_1.logger.info(`Exporting batch job: ${chalk_1.default.cyan(file)}`);
-            const job = await this.loadBatchJob(file);
-            let exportedContent;
-            switch (options.format) {
-                case 'json':
-                    exportedContent = JSON.stringify(job, null, 2);
-                    break;
-                case 'shell':
-                    exportedContent = this.convertToShellScript(job);
-                    break;
-                case 'dockerfile':
-                    exportedContent = this.convertToDockerfile(job);
-                    break;
-                default:
-                    throw new Error(`Unsupported export format: ${options.format}`);
-            }
-            const outputPath = options.output ||
-                `${path_1.default.basename(file, path_1.default.extname(file))}.${options.format}`;
-            await fs_extra_1.default.writeFile(outputPath, exportedContent);
-            logger_1.logger.success(`Batch job exported: ${outputPath}`);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_EXPORT_FAILED', 'Failed to export batch job', { file, options }, true);
-        }
-    }
-    /**
-     * Import batch job from different formats
-     */
-    async importBatchJob(file, options) {
-        try {
-            logger_1.logger.info(`Importing batch job: ${chalk_1.default.cyan(file)}`);
-            let job;
-            switch (options.format) {
-                case 'json':
-                    job = await this.importFromJSON(file, options.name);
-                    break;
-                case 'shell':
-                    job = await this.importFromShell(file, options.name);
-                    break;
-                case 'package-scripts':
-                    job = await this.importFromPackageScripts(file, options.name);
-                    break;
-                default:
-                    throw new Error(`Unsupported import format: ${options.format}`);
-            }
-            const jobName = options.name || path_1.default.basename(file, path_1.default.extname(file));
-            const jobPath = path_1.default.join(process.cwd(), '.wundr', 'batch', `${jobName}.yaml`);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(jobPath));
-            await fs_extra_1.default.writeFile(jobPath, yaml_1.default.stringify(job));
-            logger_1.logger.success(`Batch job imported: ${jobPath}`);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_IMPORT_FAILED', 'Failed to import batch job', { file, options }, true);
-        }
-    }
-    /**
-     * Helper methods for batch job operations
-     */
-    async loadBatchJob(file) {
-        if (!(await fs_extra_1.default.pathExists(file))) {
-            throw new Error(`Batch job file not found: ${file}`);
-        }
-        const content = await fs_extra_1.default.readFile(file, 'utf8');
-        const ext = path_1.default.extname(file).toLowerCase();
-        if (ext === '.yaml' || ext === '.yml') {
-            return yaml_1.default.parse(content);
-        }
-        else if (ext === '.json') {
-            return JSON.parse(content);
-        }
-        else {
-            throw new Error(`Unsupported file format: ${ext}`);
-        }
-    }
-    async validateJobStructure(job) {
-        const errors = [];
-        if (!job.name) {
-            errors.push('Job name is required');
-        }
-        if (!job.commands || job.commands.length === 0) {
-            errors.push('At least one command is required');
-        }
-        else {
-            job.commands.forEach((cmd, index) => {
-                if (!cmd.command) {
-                    errors.push(`Command ${index + 1} is missing command property`);
-                }
-            });
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    async processJobVariables(job, vars) {
-        let variables = {};
-        if (vars) {
-            try {
-                // Try parsing as JSON first
-                variables = JSON.parse(vars);
-            }
-            catch {
-                // Parse as key=value pairs
-                vars.split(',').forEach(pair => {
-                    const [key, value] = pair.split('=');
-                    if (key && value) {
-                        variables[key.trim()] = value.trim();
-                    }
-                });
-            }
-        }
-        // Replace variables in job
-        const processedJob = JSON.parse(JSON.stringify(job));
-        const jobString = JSON.stringify(processedJob);
-        let processedString = jobString;
-        Object.entries(variables).forEach(([key, value]) => {
-            const placeholder = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
-            processedString = processedString.replace(placeholder, String(value));
-        });
-        return JSON.parse(processedString);
-    }
-    async showDryRun(job) {
-        console.log(chalk_1.default.blue('\nDry Run - Commands to be executed:'));
-        console.log(chalk_1.default.gray('='.repeat(50)));
-        job.commands.forEach((cmd, index) => {
-            console.log(`${index + 1}. ${chalk_1.default.cyan(cmd.command)}`);
-            if (cmd.args) {
-                console.log(`   Args: ${cmd.args.join(' ')}`);
-            }
-            if (cmd.condition) {
-                console.log(`   Condition: ${cmd.condition}`);
-            }
-            if (cmd.retry) {
-                console.log(`   Retry: ${cmd.retry} times`);
-            }
-            if (cmd.timeout) {
-                console.log(`   Timeout: ${cmd.timeout}ms`);
-            }
-            console.log();
-        });
-        console.log(chalk_1.default.gray('='.repeat(50)));
-        console.log(`Total commands: ${job.commands.length}`);
-        console.log(`Parallel execution: ${job.parallel ? 'Yes' : 'No'}`);
-        console.log(`Continue on error: ${job.continueOnError ? 'Yes' : 'No'}`);
-    }
-    async executeBatchJob(job, _jobId, _options) {
-        const tasks = job.commands.map((cmd, _index) => ({
-            title: cmd.command,
-            task: async () => {
-                await this.executeCommand(cmd, _options);
-            },
-            retry: cmd.retry || 0,
-            timeout: cmd.timeout,
-        }));
-        const listr = new listr2_1.Listr(tasks, {
-            concurrent: job.parallel || _options.parallel,
-            exitOnError: !(job.continueOnError || _options.continueOnError),
-            rendererOptions: {
-                showSubtasks: true,
-            },
-        });
-        await listr.run();
-    }
-    async executeCommand(cmd, _options) {
-        // Check condition if specified
-        if (cmd.condition && !(await this.evaluateCondition(cmd.condition))) {
-            logger_1.logger.debug(`Skipping command due to condition: ${cmd.condition}`);
-            return;
-        }
-        const { spawn } = await Promise.resolve().then(() => tslib_1.__importStar(require('child_process')));
-        const [command, ...args] = cmd.command.split(' ');
-        const finalArgs = cmd.args ? [...args, ...cmd.args] : args;
-        return new Promise((resolve, reject) => {
-            const child = spawn(command ?? 'echo', finalArgs, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-                shell: true,
-            });
-            let output = '';
-            let error = '';
-            child.stdout?.on('data', (data) => {
-                output += data.toString();
-            });
-            child.stderr?.on('data', (data) => {
-                error += data.toString();
-            });
-            child.on('exit', (code) => {
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Command failed with exit code ${code}: ${error}`));
-                }
-            });
-            // Handle timeout
-            if (cmd.timeout) {
-                setTimeout(() => {
-                    child.kill();
-                    reject(new Error(`Command timed out after ${cmd.timeout}ms`));
-                }, cmd.timeout);
-            }
-        });
-    }
-    async evaluateCondition(condition) {
-        // Simple condition evaluation
-        // In a real implementation, this would be more sophisticated
-        switch (condition) {
-            case 'always':
-                return true;
-            case 'never':
-                return false;
-            default:
-                // Could evaluate file existence, environment variables, etc.
-                return true;
-        }
-    }
-    async createInteractiveBatchJob(name) {
-        const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require('inquirer')));
-        const answers = await inquirer.default.prompt([
-            {
-                type: 'input',
-                name: 'description',
-                message: 'Job description:',
-            },
-            {
-                type: 'confirm',
-                name: 'parallel',
-                message: 'Run commands in parallel?',
-                default: false,
-            },
-            {
-                type: 'confirm',
-                name: 'continueOnError',
-                message: 'Continue on command failure?',
-                default: false,
-            },
-        ]);
-        const commands = [];
-        let addMore = true;
-        while (addMore) {
-            const cmdAnswers = await inquirer.default.prompt([
-                {
-                    type: 'input',
-                    name: 'command',
-                    message: 'Command:',
-                    validate: input => input.length > 0 || 'Command is required',
-                },
-                {
-                    type: 'input',
-                    name: 'condition',
-                    message: 'Condition (optional):',
-                },
-                {
-                    type: 'number',
-                    name: 'retry',
-                    message: 'Retry count:',
-                    default: 0,
-                },
-                {
-                    type: 'confirm',
-                    name: 'addMore',
-                    message: 'Add another command?',
-                    default: true,
-                },
-            ]);
-            commands.push({
-                command: cmdAnswers.command,
-                condition: cmdAnswers.condition || undefined,
-                retry: cmdAnswers.retry || undefined,
-            });
-            addMore = cmdAnswers.addMore;
-        }
-        return {
-            name,
-            description: answers.description,
-            commands,
-            parallel: answers.parallel,
-            continueOnError: answers.continueOnError,
-        };
-    }
-    createBasicBatchJob(name, options) {
-        const commands = options.commands
-            ? options.commands
-                .split(',')
-                .map((cmd) => ({ command: cmd.trim() }))
-            : [];
-        return {
-            name,
-            description: `Batch job: ${name}`,
-            commands,
-            parallel: false,
-            continueOnError: false,
-        };
-    }
-    async createJobFromTemplate(name, template) {
-        // Load template and create job
-        const templatePath = path_1.default.join(__dirname, '../../templates/batch', `${template}.yaml`);
-        if (await fs_extra_1.default.pathExists(templatePath)) {
-            const templateJob = await this.loadBatchJob(templatePath);
-            return { ...templateJob, name };
-        }
-        throw new Error(`Template not found: ${template}`);
-    }
-    // Format conversion methods
-    convertToShellScript(job) {
-        let script = `#!/bin/bash\n# Generated from batch job: ${job.name}\n\n`;
-        if (job.description) {
-            script += `# ${job.description}\n\n`;
-        }
-        script += 'set -e\n\n'; // Exit on error unless continueOnError is true
-        job.commands.forEach(cmd => {
-            script += `echo "Executing: ${cmd.command}"\n`;
-            script += `${cmd.command}\n\n`;
-        });
-        return script;
-    }
-    convertToDockerfile(job) {
-        let dockerfile = `# Generated from batch job: ${job.name}\n`;
-        dockerfile += `FROM node:18-alpine\n\n`;
-        if (job.description) {
-            dockerfile += `# ${job.description}\n`;
-        }
-        dockerfile += `WORKDIR /app\n`;
-        dockerfile += `COPY . .\n\n`;
-        job.commands.forEach(cmd => {
-            dockerfile += `RUN ${cmd.command}\n`;
-        });
-        return dockerfile;
-    }
-    async importFromJSON(file, name) {
-        const content = await fs_extra_1.default.readJson(file);
-        return { ...content, name: name || content.name };
-    }
-    async importFromShell(file, name) {
-        const content = await fs_extra_1.default.readFile(file, 'utf8');
-        const commands = content
-            .split('\n')
-            .filter(line => line.trim() && !line.startsWith('#'))
-            .map(line => ({ command: line.trim() }));
-        return {
-            name: name || path_1.default.basename(file, path_1.default.extname(file)),
-            description: `Imported from shell script: ${file}`,
-            commands,
-        };
-    }
-    async importFromPackageScripts(file, name) {
-        const packageJson = await fs_extra_1.default.readJson(file);
-        const scripts = packageJson.scripts || {};
-        const commands = Object.entries(scripts).map(([script, command]) => ({
-            command: `npm run ${script}`,
-            args: [],
-            condition: undefined,
-        }));
-        return {
-            name: name || 'package-scripts',
-            description: `Imported from package.json scripts`,
-            commands,
-        };
-    }
-    async listTemplates() {
-        const templatesDir = path_1.default.join(__dirname, '../../templates/batch');
-        if (await fs_extra_1.default.pathExists(templatesDir)) {
-            const templates = await fs_extra_1.default.readdir(templatesDir);
-            const yamlTemplates = templates.filter(t => t.endsWith('.yaml') || t.endsWith('.yml'));
-            if (yamlTemplates.length > 0) {
-                logger_1.logger.info('Available templates:');
-                yamlTemplates.forEach(template => {
-                    console.log(`  - ${path_1.default.basename(template, path_1.default.extname(template))}`);
-                });
-            }
-            else {
-                logger_1.logger.info('No templates available');
-            }
-        }
-        else {
-            logger_1.logger.info('No templates directory found');
-        }
-    }
-    async createTemplate(name, options) {
-        logger_1.logger.info(`Creating template: ${name}`);
-        if (options.from) {
-            const job = await this.loadBatchJob(options.from);
-            const templatePath = path_1.default.join(__dirname, '../../templates/batch', `${name}.yaml`);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(templatePath));
-            await fs_extra_1.default.writeFile(templatePath, yaml_1.default.stringify(job));
-            logger_1.logger.success(`Template created: ${templatePath}`);
-        }
-        else {
-            logger_1.logger.info('Template creation from scratch not yet implemented');
-        }
-    }
-}
-exports.BatchCommands = BatchCommands;
-//# sourceMappingURL=batch.js.map