@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/crew/orchestrator.js

@@ -0,0 +1,325 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Crew Orchestrator — executes workflow definitions by dispatching to agents.
+ */
+import { getChangedFiles, isTestFile } from '../agent/git.js';
+import { preprocess } from '../pipeline/stage0_preprocess.js';
+import { logger } from '../logger.js';
+import { BudgetExceededError } from '../base_provider.js';
+import { BudgetLedger } from '../budget_ledger.js';
+import { createEmptyUsageStats, mergeUsageStats } from './context.js';
+import { WORKFLOWS } from './workflows.js';
+export class CrewOrchestrator {
+    constructor() {
+        this.agents = new Map();
+    }
+    registerAgent(agent) {
+        this.agents.set(agent.role, agent);
+    }
+    /**
+     * Load and register plugins from file paths.
+     * Each module must default-export an object satisfying AgentPlugin.
+     */
+    async loadPlugins(pluginPaths) {
+        const loaded = [];
+        for (const pluginPath of pluginPaths) {
+            try {
+                // Security: Only allow relative paths (starting with . or ..) to prevent loading arbitrary modules.
+                // Absolute paths, URLs, and node_modules references are rejected.
+                if (!pluginPath.startsWith('.')) {
+                    logger.warn(`Plugin path must be relative (start with ./): ${pluginPath} — skipped`);
+                    continue;
+                }
+                const resolved = new URL(pluginPath, `file://${process.cwd()}/`).href;
+                // Security: reject paths that resolve outside the workspace (e.g., ../../etc/evil.js)
+                const cwd = `file://${process.cwd()}/`;
+                if (!resolved.startsWith(cwd)) {
+                    logger.warn(`Plugin path '${pluginPath}' resolves outside workspace — skipped`);
+                    continue;
+                }
+                const mod = await import(resolved);
+                const plugin = mod.default || mod;
+                if (!plugin.role || typeof plugin.execute !== 'function') {
+                    logger.warn(`Plugin at ${pluginPath} missing required role/execute — skipped`);
+                    continue;
+                }
+                // Warn if plugin overrides a built-in agent
+                if (this.agents.has(plugin.role)) {
+                    logger.warn(`Plugin '${plugin.role}' overrides built-in agent — ensure this is intentional`);
+                }
+                this.agents.set(plugin.role, plugin);
+                loaded.push(plugin.role);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                logger.warn(`Failed to load plugin ${pluginPath}: ${msg}`);
+            }
+        }
+        return loaded;
+    }
+    async run(config) {
+        const workflow = WORKFLOWS[config.workflow || 'full-qa'];
+        const timings = {};
+        const warnings = [];
+        // Load plugins if configured, then inject them into workflow phases
+        const pluginRoles = [];
+        if (config.plugins && config.plugins.length > 0) {
+            const loaded = await this.loadPlugins(config.plugins);
+            pluginRoles.push(...loaded);
+            if (loaded.length > 0) {
+                logger.info(`Loaded ${loaded.length} plugins: ${loaded.join(', ')}`);
+            }
+        }
+        const effectivePhases = this.injectPluginsIntoPhases(workflow.phases, pluginRoles);
+        // Step 1: Get changed files
+        const gitResult = getChangedFiles(config.appPath, config.gitSince, {
+            includeUncommitted: config.gitIncludeUncommitted,
+        });
+        if (gitResult.error) {
+            warnings.push(`Git diff warning: ${gitResult.error}`);
+        }
+        const changedFiles = gitResult.files
+            .map((f) => f.replace(/\\/g, '/'))
+            .filter((f) => !isTestFile(f));
+        if (changedFiles.length === 0) {
+            warnings.push('No changed application files detected.');
+        }
+        // Create shared budget ledger for aggregate cost tracking across all agents
+        const budgetLedger = config.budgetUSD ? new BudgetLedger(config.budgetUSD) : undefined;
+        // Initialize context (will be populated during preprocess phase)
+        const ctx = {
+            changedFiles,
+            routeFamilies: [],
+            manifest: null,
+            apiSurface: { pageObjects: [], generatedAt: '' },
+            specIndex: { specs: [], indexedAt: '' },
+            context: { documents: [], warnings: [] },
+            familyGroups: [],
+            preprocessResult: null,
+            appPath: config.appPath,
+            testsRoot: config.testsRoot,
+            gitSince: config.gitSince,
+            providerOverride: config.providerOverride,
+            budgetUSD: config.budgetUSD,
+            budgetLedger,
+            impactedFlows: [],
+            strategyEntries: [],
+            testDesigns: [],
+            crossImpacts: [],
+            regressionRisks: [],
+            findings: [],
+            generatedSpecs: [],
+            usage: createEmptyUsageStats(),
+            agentUsage: [],
+            messages: [],
+            warnings,
+        };
+        // Execute each phase
+        for (const phase of effectivePhases) {
+            const timer = logger.timer(`crew:${phase.name}`);
+            if (phase.handler === 'built-in') {
+                await this.runBuiltInPhase(phase.name, ctx, config);
+                // Dry-run: after preprocess, return summary without running agents
+                if (config.dryRun && phase.name === 'preprocess') {
+                    timings[phase.name] = timer.end();
+                    ctx.warnings.push('Dry run — no LLM calls were made.');
+                    return { context: ctx, warnings, timings, dryRun: true };
+                }
+            }
+            else if (phase.parallel && phase.parallel.length > 0) {
+                await this.runParallel(phase.parallel, phase.name, ctx);
+            }
+            else if (phase.sequential && phase.sequential.length > 0) {
+                await this.runSequential(phase.sequential, phase.name, ctx);
+            }
+            else {
+                warnings.push(`Phase '${phase.name}' has no handler, parallel, or sequential agents — skipped.`);
+            }
+            timings[phase.name] = timer.end();
+            // Budget check — prefer ledger (aggregate across all providers) over ctx.usage
+            const currentCost = budgetLedger ? budgetLedger.totalCost : ctx.usage.totalCost;
+            if (config.budgetUSD && currentCost >= config.budgetUSD) {
+                warnings.push(`Budget limit reached ($${currentCost.toFixed(4)} >= $${config.budgetUSD}). Stopping workflow.`);
+                break;
+            }
+        }
+        return { context: ctx, warnings, timings };
+    }
+    async dispatch(role, action, ctx) {
+        const agent = this.agents.get(role);
+        if (!agent) {
+            return {
+                role,
+                status: 'failed',
+                output: null,
+                warnings: [`Agent '${role}' is not registered.`],
+            };
+        }
+        const task = { role, action, input: null };
+        const startMs = Date.now();
+        try {
+            const result = await agent.execute(task, ctx);
+            const durationMs = Date.now() - startMs;
+            if (result.usage) {
+                mergeUsageStats(ctx.usage, result.usage);
+                ctx.agentUsage.push({
+                    agent: role,
+                    inputTokens: result.usage.totalInputTokens,
+                    outputTokens: result.usage.totalOutputTokens,
+                    cost: result.usage.totalCost,
+                    durationMs,
+                });
+            }
+            if (result.warnings && result.warnings.length > 0) {
+                ctx.warnings.push(...result.warnings);
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof BudgetExceededError) {
+                ctx.warnings.push(`Budget exceeded ($${error.currentCost.toFixed(4)} >= $${error.budgetUSD}). Agent '${role}' skipped.`);
+                return { role, status: 'failed', output: null, warnings: [error.message] };
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            ctx.warnings.push(`Agent '${role}' failed: ${message}`);
+            return { role, status: 'failed', output: null, warnings: [message] };
+        }
+    }
+    async parallel(roles, action, ctx) {
+        const promises = roles.map((role) => this.dispatch(role, action, ctx));
+        return Promise.all(promises);
+    }
+    async broadcast(msg, ctx) {
+        ctx.messages.push(msg);
+        const promises = [];
+        for (const agent of this.agents.values()) {
+            if (agent.onMessage && agent.role !== msg.from) {
+                promises.push(agent.onMessage(msg).catch((err) => {
+                    ctx.warnings.push(`Broadcast to ${agent.role} failed: ${err instanceof Error ? err.message : String(err)}`);
+                }));
+            }
+        }
+        await Promise.all(promises);
+    }
+    async runBuiltInPhase(name, ctx, config) {
+        if (name === 'preprocess') {
+            if (ctx.changedFiles.length === 0) {
+                return;
+            }
+            const result = preprocess(ctx.changedFiles, {
+                appPath: config.appPath,
+                testsRoot: config.testsRoot,
+                routeFamilies: config.routeFamilies,
+                apiSurface: config.apiSurface,
+            });
+            ctx.preprocessResult = result;
+            ctx.manifest = result.manifest;
+            ctx.routeFamilies = result.manifest?.families || [];
+            ctx.apiSurface = result.apiSurface;
+            ctx.specIndex = result.specIndex;
+            ctx.context = result.context;
+            ctx.familyGroups = result.familyGroups;
+            ctx.warnings.push(...result.warnings);
+        }
+    }
+    async runParallel(roles, phaseName, ctx) {
+        logger.info(`Crew phase '${phaseName}': running ${roles.join(', ')} in parallel`);
+        const results = await this.parallel(roles, phaseName, ctx);
+        this.checkPhaseResults(phaseName, results, ctx);
+    }
+    async runSequential(roles, phaseName, ctx) {
+        logger.info(`Crew phase '${phaseName}': running ${roles.join(' → ')} sequentially`);
+        const results = [];
+        for (const role of roles) {
+            results.push(await this.dispatch(role, phaseName, ctx));
+        }
+        this.checkPhaseResults(phaseName, results, ctx);
+    }
+    /**
+     * Inject loaded plugins into workflow phases based on their `phase` and `runAfter` fields.
+     * Plugins with `runAfter` dependencies are appended to the sequential list of the matching phase;
+     * plugins without `runAfter` are appended to the parallel list.
+     * Returns a new array of phases (does not mutate the original workflow definition).
+     */
+    injectPluginsIntoPhases(phases, pluginRoles) {
+        if (pluginRoles.length === 0)
+            return phases;
+        // Build mutable copies keyed by phase name
+        const phaseMap = new Map();
+        const ordered = [];
+        for (const p of phases) {
+            ordered.push(p.name);
+            if (p.handler === 'built-in') {
+                phaseMap.set(p.name, { handler: 'built-in' });
+            }
+            else if (p.parallel) {
+                phaseMap.set(p.name, { parallel: [...p.parallel] });
+            }
+            else if (p.sequential) {
+                phaseMap.set(p.name, { sequential: [...p.sequential] });
+            }
+        }
+        for (const role of pluginRoles) {
+            const agent = this.agents.get(role);
+            if (!agent)
+                continue;
+            const plugin = agent;
+            if (!plugin.phase)
+                continue;
+            const target = phaseMap.get(plugin.phase);
+            if (!target) {
+                logger.warn(`Plugin '${role}' targets phase '${plugin.phase}' which does not exist in workflow — skipped`);
+                continue;
+            }
+            if (target.handler === 'built-in') {
+                logger.warn(`Plugin '${role}' targets built-in phase '${plugin.phase}' — not supported, skipped`);
+                continue;
+            }
+            const pluginRole = role;
+            if (plugin.runAfter && plugin.runAfter.length > 0) {
+                // Validate that runAfter dependencies are either in this phase or a prior phase
+                const phaseRoles = target.parallel || target.sequential || [];
+                const missingDeps = plugin.runAfter.filter((dep) => !phaseRoles.includes(dep) && !this.agents.has(dep));
+                if (missingDeps.length > 0) {
+                    logger.warn(`Plugin '${role}' has unresolved runAfter deps [${missingDeps.join(', ')}] — injecting anyway`);
+                }
+                // Plugin has dependencies — must run sequentially
+                if (target.sequential) {
+                    target.sequential.push(pluginRole);
+                }
+                else if (target.parallel) {
+                    // Convert to sequential to respect dependency ordering
+                    target.sequential = [...target.parallel, pluginRole];
+                    delete target.parallel;
+                }
+            }
+            else {
+                if (target.parallel) {
+                    target.parallel.push(pluginRole);
+                }
+                else if (target.sequential) {
+                    target.sequential.push(pluginRole);
+                }
+            }
+            logger.info(`Plugin '${role}' injected into phase '${plugin.phase}'`);
+        }
+        // Rebuild WorkflowPhase array
+        return ordered.map((name) => {
+            const entry = phaseMap.get(name);
+            if (entry.handler === 'built-in')
+                return { name, handler: 'built-in' };
+            if (entry.parallel)
+                return { name, parallel: entry.parallel };
+            if (entry.sequential)
+                return { name, sequential: entry.sequential };
+            throw new Error(`Phase '${name}' has no handler, parallel, or sequential agents after plugin injection`);
+        });
+    }
+    checkPhaseResults(phaseName, results, ctx) {
+        const allFailed = results.length > 0 && results.every((r) => r.status === 'failed');
+        if (allFailed) {
+            ctx.warnings.push(`Phase '${phaseName}': all ${results.length} agent(s) failed. Downstream phases may produce empty results.`);
+        }
+    }
+}

package/dist/esm/crew/protocol.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export {};

package/dist/esm/crew/provider.js

@@ -0,0 +1,33 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Shared provider creation for crew agents — ensures consistent provider
+ * instantiation and prevents usage stats fragmentation.
+ */
+import { LLMProviderFactory } from '../provider_factory.js';
+import { BaseProvider } from '../base_provider.js';
+import { ModelRouter } from '../model_router.js';
+export async function getCrewProvider(providerOverride, budgetUSD, opts) {
+    let effectiveOverride = providerOverride;
+    // Apply model routing if configured and agent role is provided
+    if (opts?.agentRole && opts?.modelRoutingProviderType) {
+        const router = new ModelRouter(opts.modelRoutingProviderType, opts.modelRoutingOverrides);
+        const model = router.getModel(opts.agentRole);
+        if (model) {
+            // Override uses provider:model format (e.g., "anthropic:claude-haiku-4-5-20251001")
+            effectiveOverride = `${opts.modelRoutingProviderType}:${model}`;
+        }
+    }
+    const provider = effectiveOverride
+        ? await LLMProviderFactory.createFromString(effectiveOverride)
+        : await LLMProviderFactory.createFromEnv();
+    if (provider instanceof BaseProvider) {
+        if (opts?.budgetLedger) {
+            provider.setBudgetLedger(opts.budgetLedger);
+        }
+        else if (budgetUSD !== undefined) {
+            provider.setBudget(budgetUSD);
+        }
+    }
+    return provider;
+}

package/dist/esm/crew/sanitize.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Sanitize strings before interpolating into LLM prompts.
+ * Strips common prompt injection patterns while preserving useful content.
+ */
+const INJECTION_PATTERNS = [
+    /ignore\s+(all\s+)?previous\s+instructions/gi,
+    /disregard\s+(all\s+)?(above|prior|previous)/gi,
+    /system\s*:\s*/gi,
+    /\[INST\]/gi,
+    /<<SYS>>/gi,
+    /<\|im_start\|>/gi,
+    /\bHuman\s*:\s*/gi,
+    /\bAssistant\s*:\s*/gi,
+];
+const MAX_FIELD_LENGTH = 2000;
+export function sanitizeForPrompt(value) {
+    let sanitized = value.slice(0, MAX_FIELD_LENGTH);
+    for (const pattern of INJECTION_PATTERNS) {
+        sanitized = sanitized.replace(pattern, '[filtered]');
+    }
+    return sanitized;
+}
+export function sanitizeArray(values) {
+    return values.map((v) => sanitizeForPrompt(v));
+}

package/dist/esm/crew/types.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export {};

package/dist/esm/crew/workflows.js

@@ -0,0 +1,33 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export const WORKFLOWS = {
+    'full-qa': {
+        name: 'full-qa',
+        description: 'Full multi-agent QA analysis: understand → strategize → execute → validate',
+        phases: [
+            { name: 'preprocess', handler: 'built-in' },
+            { name: 'understand', parallel: ['impact-analyst', 'cross-impact', 'regression-advisor'] },
+            { name: 'strategize', sequential: ['strategist', 'test-designer'] },
+            { name: 'execute', parallel: ['generator'] },
+            { name: 'validate', sequential: ['executor', 'healer'] },
+        ],
+    },
+    'quick-check': {
+        name: 'quick-check',
+        description: 'Quick impact analysis with strategy recommendations',
+        phases: [
+            { name: 'preprocess', handler: 'built-in' },
+            { name: 'understand', parallel: ['impact-analyst'] },
+            { name: 'strategize', sequential: ['strategist'] },
+        ],
+    },
+    'design-only': {
+        name: 'design-only',
+        description: 'Impact analysis through test design — no generation or execution',
+        phases: [
+            { name: 'preprocess', handler: 'built-in' },
+            { name: 'understand', parallel: ['impact-analyst', 'cross-impact'] },
+            { name: 'strategize', sequential: ['strategist', 'test-designer'] },
+        ],
+    },
+};