@every-env/cli/dist/patterns/pattern-executor.js

Multi-agent orchestrator for AI-powered development workflows

import { PatternManager } from "./pattern-manager-stub.js";
import { execCommand } from "../utils/exec.js";
import chalk from "chalk";
// Simplified pattern executor for docs command
export class PatternExecutor {
    config;
    patternManager = new PatternManager();
    constructor(config) {
        this.config = config;
    }
    async executePatterns(patternNames, options = {}) {
        const patterns = patternNames
            ? this.patternManager.findPatterns(this.config, patternNames)
            : this.config.patterns || this.config.docs.patterns;
        if (patterns.length === 0) {
            throw new Error(`No patterns found${patternNames ? ` matching: ${patternNames.join(", ")}` : ""}`);
        }
        console.log(chalk.cyan(`\nExecuting ${patterns.length} pattern(s)...\n`));
        const results = [];
        // Execute patterns serially using direct exec
        for (const pattern of patterns) {
            for (const agent of pattern.agents) {
                const defaultCommand = this.config.docs?.defaultCommand ?? this.config.defaultCommand ?? "claude";
                const defaultFlags = this.config.docs?.defaultFlags ?? this.config.defaultFlags ?? [];
                const command = agent.command || defaultCommand;
                const args = [...defaultFlags, ...(agent.flags || [])];
                console.log(chalk.gray(`Running: ${command} ${args.join(" ")}`));
                if (options.dryRun) {
                    // In dry run, return a simple descriptor and do not execute anything
                    results.push({ pattern: pattern.name, agent: agent.id, command, args });
                    continue;
                }
                try {
                    await execCommand(command, args, {
                        interactive: true,
                        cwd: agent.workingDir || process.cwd(),
                    });
                    results.push({ pattern: pattern.name, agent: agent.id, command, args, executed: true });
                }
                catch (error) {
                    const msg = error instanceof Error ? error.message : String(error);
                    console.error(chalk.red(`✖ Pattern ${pattern.name} failed: ${msg}`));
                    throw error;
                }
            }
        }
        console.log(chalk.green("\n✨ All patterns executed successfully!"));
        return results;
    }
    async executePattern(patternName, options = {}) {
        return this.executePatterns([patternName], options);
    }
}
//# sourceMappingURL=pattern-executor.js.map