@every-env/cli/dist/patterns/registry/pattern-loader.js

Multi-agent orchestrator for AI-powered development workflows

import { existsSync } from 'fs';
import { join } from 'path';
import { PatternRegistry } from './pattern-registry.js';
import { PatternResolver } from './pattern-resolver.js';
export class PatternLoader {
    registry;
    resolver;
    constructor() {
        this.registry = new PatternRegistry();
        this.resolver = new PatternResolver(this.registry);
    }
    async load(options = {}) {
        const { configPath = '.docs-config.json', loadBuiltIn = true, command, } = options;
        this.registry.clear();
        if (loadBuiltIn) {
            await this.registry.loadBuiltInPatterns(command);
        }
        const altConfigPath = '.every-env/config.json';
        const actualConfigPath = existsSync(configPath) ? configPath :
            existsSync(altConfigPath) ? altConfigPath : null;
        if (actualConfigPath) {
            await this.registry.loadProjectPatterns(actualConfigPath);
        }
        return this.resolver;
    }
    async loadForCommand(command, config) {
        await this.load({ command, loadBuiltIn: true });
        if (config?.patterns) {
            // Convert Config patterns to CommandPatterns
            const commandPatterns = config.patterns.map(p => ({
                ...p,
                overridable: true,
            }));
            await this.registry.loadUserPatterns(commandPatterns);
        }
        return this.resolver.resolveAll({ command });
    }
    getRegistry() {
        return this.registry;
    }
    getResolver() {
        return this.resolver;
    }
    static createPatternPath(command, patternName) {
        return join('resources', 'patterns', command, `${patternName}.json`);
    }
    static async mergePatterns(builtIn, user) {
        const merged = new Map();
        for (const pattern of builtIn) {
            merged.set(pattern.name, pattern);
        }
        for (const pattern of user) {
            const existing = merged.get(pattern.name);
            if (existing && existing.overridable !== false) {
                merged.set(pattern.name, {
                    ...existing,
                    ...pattern,
                    builtIn: false,
                });
            }
            else if (!existing) {
                merged.set(pattern.name, pattern);
            }
        }
        return Array.from(merged.values());
    }
}
//# sourceMappingURL=pattern-loader.js.map