@zhanghongping/json-sage-workflow-cli/src/index.js

An intelligent JSON processing workflow system with improved error handling and configuration

const fs = require('fs');
const path = require('path');
const chokidar = require('chokidar');
const { JsonCompressor } = require('./core/compression');
const { JsonValidator } = require('./core/validator');
const { SmartCache } = require('./core/cache');
const { Logger } = require('./utils/logger');
const { HealthChecker } = require('./utils/healthCheck');
const { MetricsCollector } = require('./utils/metrics');

class JsonSage {
    constructor(options = {}) {
        this.options = this.validateOptions(options);
        this.logger = new Logger();
        this.healthChecker = new HealthChecker();
        this.metricsCollector = new MetricsCollector();
        this.cache = new SmartCache();
        this.watcher = null;
        this.isActive = false;

        if (this.options.watch) {
            this.start();
        }
    }

    validateOptions(options) {
        return {
            watch: Boolean(options.watch),
            autoProcess: Boolean(options.autoProcess),
            generateTypes: Boolean(options.generateTypes),
            autoOptimize: Boolean(options.autoOptimize),
            compression: Boolean(options.compression),
            validation: Boolean(options.validation),
            caching: Boolean(options.caching),
            watchPath: options.watchPath || process.cwd(),
            filePattern: options.filePattern || '**/*.json',
            schema: options.schema || null,
            memoryLimit: options.memoryLimit || 1024 * 1024 // 1MB default
        };
    }

    async start() {
        if (this.isActive) return;

        try {
            this.watcher = chokidar.watch(this.options.filePattern, {
                cwd: this.options.watchPath,
                persistent: true
            });

            this.watcher
                .on('add', this.handleFileChange.bind(this))
                .on('change', this.handleFileChange.bind(this))
                .on('unlink', this.handleFileRemove.bind(this))
                .on('error', this.handleError.bind(this));

            this.isActive = true;
            this.logger.info('JSON Agent workflow started');
            
            // 注册健康检查组件
            this.healthChecker.registerComponent('fileWatcher', () => this.isActive);
            this.healthChecker.registerComponent('cache', () => this.cache.getStats().healthy);
        } catch (error) {
            this.logger.error('Failed to start workflow', error);
            throw error;
        }
    }

    async stop() {
        if (!this.isActive) return;

        try {
            if (this.watcher) {
                await this.watcher.close();
            }
            this.isActive = false;
            this.logger.info('Workflow stopped');
        } catch (error) {
            this.logger.error('Failed to stop workflow', error);
            throw error;
        }
    }

    async handleFileChange(filePath) {
        this.logger.info(`Processing file: ${filePath}`);
        this.metricsCollector.recordProcessing();

        try {
            const fullPath = path.join(this.options.watchPath, filePath);
            const content = fs.readFileSync(fullPath, 'utf8');

            // 验证JSON
            let data = JSON.parse(content);

            if (this.options.validation && this.options.schema) {
                const validator = new JsonValidator();
                const result = validator.validate(data, this.options.schema);
                if (!result.valid) {
                    throw new Error('JSON validation failed: ' + JSON.stringify(result.errors));
                }
                data = result.data;
            }

            // 压缩处理
            if (this.options.compression) {
                const compressor = new JsonCompressor();
                data = compressor.compress(data);
            }

            // 缓存处理
            if (this.options.caching) {
                this.cache.set(filePath, data);
            }

            this.logger.info(`File processing completed: ${filePath}`);
        } catch (error) {
            this.metricsCollector.recordError();
            this.logger.error('Processing error', error);
            throw new Error(`Invalid JSON: ${error.message}`);
        }
    }

    handleFileRemove(filePath) {
        this.logger.info(`File removed: ${filePath}`);
        if (this.options.caching) {
            this.cache.delete(filePath);
        }
    }

    handleError(error) {
        this.logger.error('Watcher error', error);
        this.metricsCollector.recordError();
    }

    isWatching() {
        return this.isActive;
    }

    updateConfig(newOptions) {
        const oldOptions = this.options;
        this.options = this.validateOptions({ ...oldOptions, ...newOptions });

        if (this.isActive && !this.options.watch) {
            this.stop();
        } else if (!this.isActive && this.options.watch) {
            this.start();
        }
    }

    getStats() {
        return {
            isActive: this.isActive,
            health: this.healthChecker.check(),
            metrics: this.metricsCollector.getMetrics(),
            cache: this.cache.getStats()
        };
    }
}

module.exports = { JsonSage };