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

Multi-agent orchestrator for AI-powered development workflows

export class PatternResolver {
    registry;
    constructor(registry) {
        this.registry = registry;
    }
    resolve(name, options = {}) {
        const { allowOverrides = true, namespace, command, } = options;
        const possibleNames = this.generatePossibleNames(name, namespace, command);
        for (const possibleName of possibleNames) {
            const pattern = this.registry.get(possibleName);
            if (pattern) {
                if (!allowOverrides && pattern.builtIn === false && pattern.overridable === false) {
                    continue;
                }
                return pattern;
            }
        }
        return undefined;
    }
    resolveAll(options = {}) {
        const { namespace, command } = options;
        let patterns = [];
        if (command) {
            patterns = this.registry.getByCommand(command);
        }
        else if (namespace) {
            patterns = this.registry.getByNamespace(namespace);
        }
        else {
            patterns = this.registry.getAll();
        }
        return this.applyOverrides(patterns, options);
    }
    generatePossibleNames(name, namespace, command) {
        const names = [];
        if (name.includes('.')) {
            names.push(name);
        }
        if (namespace) {
            names.push(`${namespace}.${name}`);
        }
        if (command) {
            names.push(`${command}.${name}`);
        }
        names.push(name);
        return [...new Set(names)];
    }
    applyOverrides(patterns, options) {
        const { preferUserPatterns = true, allowOverrides = true } = options;
        const patternMap = new Map();
        for (const pattern of patterns) {
            const source = this.registry.getSource(pattern.name) || 'user';
            const existing = patternMap.get(pattern.name);
            if (!existing) {
                patternMap.set(pattern.name, { pattern, source });
                continue;
            }
            if (!allowOverrides && !pattern.overridable) {
                continue;
            }
            const shouldReplace = this.shouldReplacePattern(existing.source, source, preferUserPatterns);
            if (shouldReplace) {
                patternMap.set(pattern.name, { pattern, source });
            }
        }
        return Array.from(patternMap.values()).map(({ pattern }) => pattern);
    }
    shouldReplacePattern(existingSource, newSource, preferUserPatterns) {
        const sourcePriority = preferUserPatterns
            ? { 'user': 3, 'project': 2, 'built-in': 1 }
            : { 'built-in': 3, 'project': 2, 'user': 1 };
        return sourcePriority[newSource] > sourcePriority[existingSource];
    }
    getConflicts() {
        const conflicts = new Map();
        for (const pattern of this.registry.getAll()) {
            const source = this.registry.getSource(pattern.name);
            if (!source)
                continue;
            if (!conflicts.has(pattern.name)) {
                conflicts.set(pattern.name, new Set());
            }
            conflicts.get(pattern.name).add(source);
        }
        return Array.from(conflicts.entries())
            .filter(([_, sources]) => sources.size > 1)
            .map(([name, sources]) => ({
            name,
            sources: Array.from(sources),
        }));
    }
    validatePattern(pattern) {
        const errors = [];
        if (!pattern.name) {
            errors.push('Pattern must have a name');
        }
        if (!pattern.agents || pattern.agents.length === 0) {
            errors.push('Pattern must have at least one agent');
        }
        for (let i = 0; i < pattern.agents.length; i++) {
            const agent = pattern.agents[i];
            if (!agent.id) {
                errors.push(`Agent at index ${i} must have an id`);
            }
            if (!agent.promptFile) {
                errors.push(`Agent ${agent.id || i} must have promptFile`);
            }
        }
        return errors;
    }
}
//# sourceMappingURL=pattern-resolver.js.map