@wundr.io/cli 1.0.11 → 1.0.12

package/dist/commands/watch.d.ts

@@ -1,76 +0,0 @@
-import type { PluginManager } from '../plugins/plugin-manager';
-import type { ConfigManager } from '../utils/config-manager';
-import type { Command } from 'commander';
-/**
- * Watch commands for real-time monitoring
- */
-export declare class WatchCommands {
-    private program;
-    private configManager;
-    private pluginManager;
-    private watchers;
-    private activeWatches;
-    constructor(program: Command, configManager: ConfigManager, pluginManager: PluginManager);
-    private registerCommands;
-    /**
-     * Start watching files or directories
-     */
-    private startWatching;
-    /**
-     * Stop watching
-     */
-    private stopWatching;
-    /**
-     * List active watches
-     */
-    private listWatches;
-    /**
-     * Show watch status
-     */
-    private showWatchStatus;
-    /**
-     * Create watch configuration
-     */
-    private createWatchConfig;
-    /**
-     * Load watch configuration from file
-     */
-    private loadWatchConfig;
-    /**
-     * Save watch configuration to file
-     */
-    private saveWatchConfig;
-    /**
-     * Watch tests
-     */
-    private watchTests;
-    /**
-     * Watch build
-     */
-    private watchBuild;
-    /**
-     * Watch lint
-     */
-    private watchLint;
-    /**
-     * Watch analysis
-     */
-    private watchAnalysis;
-    /**
-     * Helper methods
-     */
-    private setupWatchHandlers;
-    private shouldExecuteCommand;
-    private executeWatchCommand;
-    private createWatchConfigFromOptions;
-    private loadWatchConfigFile;
-    private startWatchingWithConfig;
-    private createInteractiveWatchConfig;
-    private parseWatchCommands;
-    private getTestPatterns;
-    private getTestCommand;
-    private getBuildCommand;
-    private getLintCommand;
-    private getAnalysisCommand;
-}
-//# sourceMappingURL=watch.d.ts.map

package/dist/commands/watch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/commands/watch.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;GAEG;AACH,qBAAa,aAAa;IAKtB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,aAAa;IANvB,OAAO,CAAC,QAAQ,CAAqC;IACrD,OAAO,CAAC,aAAa,CAAuC;gBAGlD,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,aAAa;IAKtC,OAAO,CAAC,gBAAgB;IAwHxB;;OAEG;YACW,aAAa;IA0C3B;;OAEG;YACW,YAAY;IAgC1B;;OAEG;YACW,WAAW;IA6BzB;;OAEG;YACW,eAAe;IAqC7B;;OAEG;YACW,iBAAiB;IAqC/B;;OAEG;YACW,eAAe;IAiB7B;;OAEG;YACW,eAAe;IAuB7B;;OAEG;YACW,UAAU;IA4BxB;;OAEG;YACW,UAAU;IA4BxB;;OAEG;YACW,SAAS;IA4BvB;;OAEG;YACW,aAAa;IA4B3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAyC1B,OAAO,CAAC,oBAAoB;YAoBd,mBAAmB;IAoCjC,OAAO,CAAC,4BAA4B;YAoBtB,mBAAmB;YAiBnB,uBAAuB;YAqBvB,4BAA4B;IA4C1C,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,kBAAkB;CAG3B"}

package/dist/commands/watch.js

@@ -1,613 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WatchCommands = void 0;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const chokidar_1 = require("chokidar");
-const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
-const yaml_1 = tslib_1.__importDefault(require("yaml"));
-const error_handler_1 = require("../utils/error-handler");
-const logger_1 = require("../utils/logger");
-/**
- * Watch commands for real-time monitoring
- */
-class WatchCommands {
-    program;
-    configManager;
-    pluginManager;
-    watchers = new Map();
-    activeWatches = new Map();
-    constructor(program, configManager, pluginManager) {
-        this.program = program;
-        this.configManager = configManager;
-        this.pluginManager = pluginManager;
-        this.registerCommands();
-    }
-    registerCommands() {
-        const watchCmd = this.program
-            .command('watch')
-            .description('real-time file and project monitoring');
-        // Start watching
-        watchCmd
-            .command('start [patterns...]')
-            .description('start watching files or directories')
-            .option('--config <config>', 'watch configuration file')
-            .option('--ignore <patterns>', 'patterns to ignore (comma-separated)')
-            .option('--command <command>', 'command to run on changes')
-            .option('--debounce <ms>', 'debounce delay in milliseconds', '300')
-            .option('--recursive', 'watch subdirectories recursively')
-            .action(async (patterns, options) => {
-            await this.startWatching(patterns, options);
-        });
-        // Stop watching
-        watchCmd
-            .command('stop [name]')
-            .description('stop specific watch or all watches')
-            .action(async (name) => {
-            await this.stopWatching(name);
-        });
-        // List active watches
-        watchCmd
-            .command('list')
-            .alias('ls')
-            .description('list active watches')
-            .action(async () => {
-            await this.listWatches();
-        });
-        // Watch status
-        watchCmd
-            .command('status [name]')
-            .description('show watch status')
-            .action(async (name) => {
-            await this.showWatchStatus(name);
-        });
-        // Create watch config
-        watchCmd
-            .command('config create <name>')
-            .description('create watch configuration')
-            .option('--patterns <patterns>', 'file patterns to watch')
-            .option('--commands <commands>', 'commands to run on changes')
-            .option('--interactive', 'create configuration interactively')
-            .action(async (name, options) => {
-            await this.createWatchConfig(name, options);
-        });
-        // Load watch config
-        watchCmd
-            .command('config load <file>')
-            .description('load watch configuration from file')
-            .action(async (file) => {
-            await this.loadWatchConfig(file);
-        });
-        // Save watch config
-        watchCmd
-            .command('config save <name> [file]')
-            .description('save watch configuration to file')
-            .action(async (name, file) => {
-            await this.saveWatchConfig(name, file);
-        });
-        // Watch tests
-        watchCmd
-            .command('test')
-            .description('watch and run tests on changes')
-            .option('--framework <framework>', 'test framework (jest, mocha, vitest)', 'jest')
-            .option('--coverage', 'run with coverage')
-            .option('--changed-only', 'run tests for changed files only')
-            .action(async (options) => {
-            await this.watchTests(options);
-        });
-        // Watch build
-        watchCmd
-            .command('build')
-            .description('watch and build on changes')
-            .option('--target <target>', 'build target')
-            .option('--incremental', 'enable incremental builds')
-            .action(async (options) => {
-            await this.watchBuild(options);
-        });
-        // Watch lint
-        watchCmd
-            .command('lint')
-            .description('watch and lint on changes')
-            .option('--fix', 'automatically fix linting issues')
-            .option('--staged-only', 'lint staged files only')
-            .action(async (options) => {
-            await this.watchLint(options);
-        });
-        // Watch analysis
-        watchCmd
-            .command('analyze')
-            .description('watch and analyze code quality')
-            .option('--type <type>', 'analysis type (quality, deps, security)', 'quality')
-            .option('--threshold <threshold>', 'quality threshold')
-            .action(async (options) => {
-            await this.watchAnalysis(options);
-        });
-    }
-    /**
-     * Start watching files or directories
-     */
-    async startWatching(patterns, options) {
-        try {
-            let watchConfig;
-            if (options.config) {
-                watchConfig = await this.loadWatchConfigFile(options.config);
-            }
-            else {
-                watchConfig = this.createWatchConfigFromOptions(patterns, options);
-            }
-            const watchName = `watch-${Date.now()}`;
-            logger_1.logger.info(`Starting watch: ${chalk_1.default.cyan(watchName)}`);
-            const watcher = (0, chokidar_1.watch)(watchConfig.patterns, {
-                ignored: watchConfig.ignore || [],
-                persistent: true,
-                ignoreInitial: true,
-                awaitWriteFinish: {
-                    stabilityThreshold: parseInt(options.debounce) || 300,
-                    pollInterval: 100,
-                },
-            });
-            // Set up event handlers
-            this.setupWatchHandlers(watcher, watchConfig, watchName);
-            // Store watcher and config
-            this.watchers.set(watchName, watcher);
-            this.activeWatches.set(watchName, watchConfig);
-            logger_1.logger.success(`Watching ${watchConfig.patterns.join(', ')}`);
-            logger_1.logger.info('Press Ctrl+C to stop watching');
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_START_FAILED', 'Failed to start watching', { patterns, options }, true);
-        }
-    }
-    /**
-     * Stop watching
-     */
-    async stopWatching(name) {
-        try {
-            if (name) {
-                const watcher = this.watchers.get(name);
-                if (watcher) {
-                    await watcher.close();
-                    this.watchers.delete(name);
-                    this.activeWatches.delete(name);
-                    logger_1.logger.success(`Stopped watch: ${name}`);
-                }
-                else {
-                    logger_1.logger.warn(`Watch not found: ${name}`);
-                }
-            }
-            else {
-                // Stop all watches
-                for (const [watchName, watcher] of this.watchers) {
-                    await watcher.close();
-                    logger_1.logger.info(`Stopped watch: ${watchName}`);
-                }
-                this.watchers.clear();
-                this.activeWatches.clear();
-                logger_1.logger.success('Stopped all watches');
-            }
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_STOP_FAILED', 'Failed to stop watching', { name }, true);
-        }
-    }
-    /**
-     * List active watches
-     */
-    async listWatches() {
-        try {
-            if (this.activeWatches.size === 0) {
-                logger_1.logger.info('No active watches');
-                return;
-            }
-            logger_1.logger.info(`Active watches (${this.activeWatches.size}):`);
-            const watchData = Array.from(this.activeWatches.entries()).map(([name, config]) => ({
-                Name: name,
-                Patterns: config.patterns.join(', '),
-                Commands: config.commands.length,
-                Debounce: `${config.debounce || 300}ms`,
-            }));
-            console.table(watchData);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_LIST_FAILED', 'Failed to list watches', {}, true);
-        }
-    }
-    /**
-     * Show watch status
-     */
-    async showWatchStatus(name) {
-        try {
-            if (name) {
-                const config = this.activeWatches.get(name);
-                const watcher = this.watchers.get(name);
-                if (!config || !watcher) {
-                    logger_1.logger.warn(`Watch not found: ${name}`);
-                    return;
-                }
-                console.log(chalk_1.default.blue(`\nWatch Status: ${name}`));
-                console.log(`Patterns: ${config.patterns.join(', ')}`);
-                console.log(`Commands: ${config.commands.length}`);
-                console.log(`Debounce: ${config.debounce || 300}ms`);
-                console.log(`Watched Paths: ${Object.keys(watcher.getWatched()).length}`);
-            }
-            else {
-                console.log(chalk_1.default.blue('\nAll Watches Status:'));
-                console.log(`Active Watches: ${this.activeWatches.size}`);
-                console.log(`Total Watchers: ${this.watchers.size}`);
-                for (const [watchName] of this.activeWatches) {
-                    await this.showWatchStatus(watchName);
-                }
-            }
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_STATUS_FAILED', 'Failed to show watch status', { name }, true);
-        }
-    }
-    /**
-     * Create watch configuration
-     */
-    async createWatchConfig(name, options) {
-        try {
-            let config;
-            if (options.interactive) {
-                config = await this.createInteractiveWatchConfig();
-            }
-            else {
-                config = {
-                    patterns: options.patterns ? options.patterns.split(',') : ['**/*'],
-                    commands: options.commands
-                        ? this.parseWatchCommands(options.commands)
-                        : [],
-                    debounce: 300,
-                    recursive: true,
-                };
-            }
-            const configPath = path_1.default.join(process.cwd(), '.wundr', 'watch', `${name}.yaml`);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(configPath));
-            await fs_extra_1.default.writeFile(configPath, yaml_1.default.stringify(config));
-            logger_1.logger.success(`Watch configuration created: ${configPath}`);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_CONFIG_CREATE_FAILED', 'Failed to create watch configuration', { name, options }, true);
-        }
-    }
-    /**
-     * Load watch configuration from file
-     */
-    async loadWatchConfig(file) {
-        try {
-            const config = await this.loadWatchConfigFile(file);
-            const name = path_1.default.basename(file, path_1.default.extname(file));
-            await this.startWatchingWithConfig(name, config);
-            logger_1.logger.success(`Loaded watch configuration: ${file}`);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_CONFIG_LOAD_FAILED', 'Failed to load watch configuration', { file }, true);
-        }
-    }
-    /**
-     * Save watch configuration to file
-     */
-    async saveWatchConfig(name, file) {
-        try {
-            const config = this.activeWatches.get(name);
-            if (!config) {
-                throw new Error(`Watch not found: ${name}`);
-            }
-            const outputPath = file || path_1.default.join(process.cwd(), '.wundr', 'watch', `${name}.yaml`);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(outputPath));
-            await fs_extra_1.default.writeFile(outputPath, yaml_1.default.stringify(config));
-            logger_1.logger.success(`Watch configuration saved: ${outputPath}`);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_CONFIG_SAVE_FAILED', 'Failed to save watch configuration', { name, file }, true);
-        }
-    }
-    /**
-     * Watch tests
-     */
-    async watchTests(options) {
-        try {
-            logger_1.logger.info('Starting test watcher...');
-            const testPatterns = this.getTestPatterns(options.framework);
-            const watchConfig = {
-                patterns: testPatterns,
-                commands: [
-                    {
-                        trigger: 'change',
-                        command: this.getTestCommand(options.framework, options),
-                        condition: 'test-files',
-                    },
-                ],
-                debounce: 1000,
-            };
-            await this.startWatchingWithConfig('test-watch', watchConfig);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_TEST_FAILED', 'Failed to start test watcher', { options }, true);
-        }
-    }
-    /**
-     * Watch build
-     */
-    async watchBuild(options) {
-        try {
-            logger_1.logger.info('Starting build watcher...');
-            const buildPatterns = ['src/**/*', 'lib/**/*', '*.config.*'];
-            const watchConfig = {
-                patterns: buildPatterns,
-                commands: [
-                    {
-                        trigger: 'change',
-                        command: this.getBuildCommand(options),
-                        condition: 'source-files',
-                    },
-                ],
-                debounce: 500,
-            };
-            await this.startWatchingWithConfig('build-watch', watchConfig);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_BUILD_FAILED', 'Failed to start build watcher', { options }, true);
-        }
-    }
-    /**
-     * Watch lint
-     */
-    async watchLint(options) {
-        try {
-            logger_1.logger.info('Starting lint watcher...');
-            const lintPatterns = ['**/*.{ts,tsx,js,jsx}', '!node_modules/**'];
-            const watchConfig = {
-                patterns: lintPatterns,
-                commands: [
-                    {
-                        trigger: 'change',
-                        command: this.getLintCommand(options),
-                        condition: 'lint-files',
-                    },
-                ],
-                debounce: 300,
-            };
-            await this.startWatchingWithConfig('lint-watch', watchConfig);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_LINT_FAILED', 'Failed to start lint watcher', { options }, true);
-        }
-    }
-    /**
-     * Watch analysis
-     */
-    async watchAnalysis(options) {
-        try {
-            logger_1.logger.info(`Starting ${options.type} analysis watcher...`);
-            const analysisPatterns = ['src/**/*', 'lib/**/*'];
-            const watchConfig = {
-                patterns: analysisPatterns,
-                commands: [
-                    {
-                        trigger: 'change',
-                        command: this.getAnalysisCommand(options),
-                        condition: 'analysis-files',
-                    },
-                ],
-                debounce: 2000,
-            };
-            await this.startWatchingWithConfig('analysis-watch', watchConfig);
-        }
-        catch (error) {
-            throw error_handler_1.errorHandler.createError('WUNDR_WATCH_ANALYSIS_FAILED', 'Failed to start analysis watcher', { options }, true);
-        }
-    }
-    /**
-     * Helper methods
-     */
-    setupWatchHandlers(watcher, config, name) {
-        const executeCommands = async (eventType, filePath) => {
-            const relevantCommands = config.commands.filter(cmd => cmd.trigger === eventType || cmd.trigger === 'change');
-            for (const cmd of relevantCommands) {
-                if (this.shouldExecuteCommand(cmd, filePath)) {
-                    await this.executeWatchCommand(cmd, filePath);
-                }
-            }
-        };
-        watcher.on('add', filePath => {
-            logger_1.logger.debug(`File added: ${filePath}`);
-            executeCommands('add', filePath);
-        });
-        watcher.on('change', filePath => {
-            logger_1.logger.debug(`File changed: ${filePath}`);
-            executeCommands('change', filePath);
-        });
-        watcher.on('unlink', filePath => {
-            logger_1.logger.debug(`File deleted: ${filePath}`);
-            executeCommands('delete', filePath);
-        });
-        watcher.on('error', error => {
-            logger_1.logger.error(`Watch error in ${name}:`, error);
-        });
-        watcher.on('ready', () => {
-            logger_1.logger.debug(`Watch ready: ${name}`);
-        });
-    }
-    shouldExecuteCommand(cmd, filePath) {
-        if (!cmd.condition) {
-            return true;
-        }
-        // Implement condition checking logic
-        switch (cmd.condition) {
-            case 'test-files':
-                return filePath.includes('.test.') || filePath.includes('.spec.');
-            case 'source-files':
-                return !filePath.includes('.test.') && !filePath.includes('.spec.');
-            case 'lint-files':
-                return /\.(ts|tsx|js|jsx)$/.test(filePath);
-            case 'analysis-files':
-                return /\.(ts|tsx|js|jsx)$/.test(filePath);
-            default:
-                return true;
-        }
-    }
-    async executeWatchCommand(cmd, filePath) {
-        try {
-            logger_1.logger.info(`Executing: ${cmd.command}`);
-            // Replace placeholders in command
-            const command = cmd.command.replace('{{file}}', filePath);
-            // Execute command
-            const { spawn } = await Promise.resolve().then(() => tslib_1.__importStar(require('child_process')));
-            const [cmdName, ...args] = command.split(' ');
-            if (!cmdName) {
-                logger_1.logger.error('Invalid command: empty command string');
-                return;
-            }
-            const child = spawn(cmdName, args, {
-                stdio: 'inherit',
-                shell: true,
-            });
-            child.on('exit', code => {
-                if (code === 0) {
-                    logger_1.logger.success(`Command completed: ${cmd.command}`);
-                }
-                else {
-                    logger_1.logger.error(`Command failed with exit code ${code}: ${cmd.command}`);
-                }
-            });
-        }
-        catch (error) {
-            logger_1.logger.error(`Failed to execute command: ${cmd.command}`, error);
-        }
-    }
-    createWatchConfigFromOptions(patterns, options) {
-        return {
-            patterns: patterns.length > 0 ? patterns : ['**/*'],
-            ignore: options.ignore ? options.ignore.split(',') : [],
-            commands: options.command
-                ? [
-                    {
-                        trigger: 'change',
-                        command: options.command,
-                    },
-                ]
-                : [],
-            debounce: parseInt(options.debounce) || 300,
-            recursive: options.recursive || true,
-        };
-    }
-    async loadWatchConfigFile(file) {
-        if (!(await fs_extra_1.default.pathExists(file))) {
-            throw new Error(`Configuration 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 configuration format: ${ext}`);
-        }
-    }
-    async startWatchingWithConfig(name, config) {
-        const watcher = (0, chokidar_1.watch)(config.patterns, {
-            ignored: config.ignore || [],
-            persistent: true,
-            ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: config.debounce || 300,
-                pollInterval: 100,
-            },
-        });
-        this.setupWatchHandlers(watcher, config, name);
-        this.watchers.set(name, watcher);
-        this.activeWatches.set(name, config);
-        logger_1.logger.success(`Started watch: ${name}`);
-    }
-    async createInteractiveWatchConfig() {
-        const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require('inquirer')));
-        const answers = await inquirer.default.prompt([
-            {
-                type: 'input',
-                name: 'patterns',
-                message: 'File patterns to watch (comma-separated):',
-                default: '**/*',
-            },
-            {
-                type: 'input',
-                name: 'ignore',
-                message: 'Patterns to ignore (comma-separated):',
-                default: 'node_modules/**,dist/**',
-            },
-            {
-                type: 'input',
-                name: 'command',
-                message: 'Command to run on changes:',
-                validate: input => input.length > 0 || 'Command is required',
-            },
-            {
-                type: 'number',
-                name: 'debounce',
-                message: 'Debounce delay (ms):',
-                default: 300,
-            },
-        ]);
-        return {
-            patterns: answers.patterns.split(',').map(p => p.trim()),
-            ignore: answers.ignore.split(',').map(p => p.trim()),
-            commands: [
-                {
-                    trigger: 'change',
-                    command: answers.command,
-                },
-            ],
-            debounce: answers.debounce,
-            recursive: true,
-        };
-    }
-    parseWatchCommands(commandsStr) {
-        return commandsStr.split(',').map(cmd => ({
-            trigger: 'change',
-            command: cmd.trim(),
-        }));
-    }
-    getTestPatterns(framework) {
-        switch (framework) {
-            case 'jest':
-                return ['**/*.{test,spec}.{js,jsx,ts,tsx}', 'src/**/*'];
-            case 'mocha':
-                return ['test/**/*.js', 'src/**/*'];
-            case 'vitest':
-                return ['**/*.{test,spec}.{js,ts}', 'src/**/*'];
-            default:
-                return ['**/*.{test,spec}.*', 'src/**/*'];
-        }
-    }
-    getTestCommand(framework, options) {
-        const baseCmd = framework === 'npm' ? 'npm test' : `npx ${framework}`;
-        const flags = [];
-        if (options.coverage) {
-            flags.push('--coverage');
-        }
-        if (options.changedOnly) {
-            flags.push('--changedSince=HEAD');
-        }
-        return `${baseCmd} ${flags.join(' ')}`;
-    }
-    getBuildCommand(options) {
-        const cmd = options.target
-            ? `npm run build:${options.target}`
-            : 'npm run build';
-        return options.incremental ? `${cmd} --incremental` : cmd;
-    }
-    getLintCommand(options) {
-        const cmd = 'npx eslint {{file}}';
-        return options.fix ? `${cmd} --fix` : cmd;
-    }
-    getAnalysisCommand(options) {
-        return `wundr analyze ${options.type}`;
-    }
-}
-exports.WatchCommands = WatchCommands;
-//# sourceMappingURL=watch.js.map