@yasserkhanorg/impact-gate 2.0.0

package/dist/esm/cli/parse_args.js

@@ -0,0 +1,251 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { logger } from '../logger.js';
+export const CONFIG_CANDIDATES = [
+    'impact-gate.config.json',
+    '.impact-gate.config.json',
+    'e2e-ai-agents.config.json',
+    '.e2e-ai-agents.config.json',
+];
+export function findConfigUpwards(startDir) {
+    if (!startDir) {
+        return undefined;
+    }
+    let current = resolve(startDir);
+    while (true) {
+        for (const candidate of CONFIG_CANDIDATES) {
+            const fullPath = join(current, candidate);
+            if (existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return undefined;
+}
+export function resolveAutoConfig(args) {
+    if (args.configPath) {
+        return args.configPath;
+    }
+    const searchRoots = [
+        process.cwd(),
+        args.testsRoot,
+        args.path,
+    ].filter(Boolean);
+    for (const root of searchRoots) {
+        const found = findConfigUpwards(root);
+        if (found) {
+            return found;
+        }
+    }
+    return undefined;
+}
+const csvSplit = (v) => v.split(',').map((s) => s.trim()).filter(Boolean);
+// prettier-ignore
+const FLAGS = {
+    // -- boolean flags --
+    '--help': { key: 'help', type: 'boolean', aliases: ['-h'] },
+    '--apply': { key: 'apply', type: 'boolean' },
+    '--allow-fallback': { key: 'allowFallback', type: 'boolean' },
+    '--pipeline': { key: 'pipeline', type: 'boolean' },
+    '--pipeline-mcp': { key: 'pipelineMcp', type: 'boolean' },
+    '--pipeline-mcp-allow-fallback': { key: 'pipelineMcpAllowFallback', type: 'boolean' },
+    '--pipeline-mcp-only': { key: 'pipelineMcpOnly', type: 'boolean' },
+    '--pipeline-headless': { key: 'pipelineHeadless', type: 'boolean' },
+    '--pipeline-headed': { key: 'pipelineHeadless', type: 'boolean-false' },
+    '--pipeline-parallel': { key: 'pipelineParallel', type: 'boolean' },
+    '--pipeline-dry-run': { key: 'pipelineDryRun', type: 'boolean' },
+    '--fail-on-must-add-tests': { key: 'failOnMustAddTests', type: 'boolean' },
+    '--crew': { key: 'crew', type: 'boolean' },
+    '--create-pr': { key: 'createPr', type: 'boolean' },
+    '--dry-run': { key: 'dryRun', type: 'boolean' },
+    '--generate': { key: 'analyzeGenerate', type: 'boolean' },
+    '--heal': { key: 'analyzeHeal', type: 'boolean' },
+    '--no-ai': { key: 'noAi', type: 'boolean' },
+    '--degraded-mode': { key: 'degradedMode', type: 'boolean' },
+    '--enrich': { key: 'trainEnrich', type: 'boolean' },
+    '--no-enrich': { key: 'trainEnrich', type: 'boolean-false' },
+    '--validate': { key: 'trainValidate', type: 'boolean' },
+    '--yes': { key: 'trainYes', type: 'boolean', aliases: ['-y'] },
+    '--verbose': { key: 'verbose', type: 'boolean', aliases: ['-v'] },
+    '--json': { key: 'jsonOutput', type: 'boolean' },
+    '--mattermost': { key: 'profile', type: 'boolean', transform: () => 'mattermost' },
+    // -- string flags --
+    '--config': { key: 'configPath', type: 'string' },
+    '--path': { key: 'path', type: 'string' },
+    '--tests-root': { key: 'testsRoot', type: 'string' },
+    '--framework': { key: 'framework', type: 'string', transform: (v) => v },
+    '--scenarios': { key: 'generateScenarios', type: 'string' },
+    '--pipeline-output': { key: 'pipelineOutput', type: 'string' },
+    '--pipeline-base-url': { key: 'pipelineBaseUrl', type: 'string' },
+    '--pipeline-project': { key: 'pipelineProject', type: 'string' },
+    '--spec': { key: 'specPDF', type: 'string' },
+    '--since': { key: 'gitSince', type: 'string' },
+    '--llm-provider': { key: 'llmProvider', type: 'string' },
+    '--ci-comment-path': { key: 'ciCommentPath', type: 'string' },
+    '--github-output': { key: 'githubOutputPath', type: 'string' },
+    '--feedback-input': { key: 'feedbackInputPath', type: 'string' },
+    '--traceability-report': { key: 'traceabilityReportPath', type: 'string' },
+    '--traceability-capture-output': { key: 'traceabilityCaptureOutputPath', type: 'string' },
+    '--traceability-coverage-map': { key: 'traceabilityCoverageMapPath', type: 'string' },
+    '--traceability-changed-files': { key: 'traceabilityChangedFilesPath', type: 'string' },
+    '--traceability-input': { key: 'traceabilityInputPath', type: 'string' },
+    '--branch': { key: 'branch', type: 'string' },
+    '--commit-message': { key: 'commitMessage', type: 'string' },
+    '--pr-title': { key: 'prTitle', type: 'string' },
+    '--pr-body': { key: 'prBody', type: 'string' },
+    '--pr-base': { key: 'prBase', type: 'string' },
+    '--generate-output': { key: 'analyzeGenerateOutputDir', type: 'string' },
+    '--heal-report': { key: 'analyzeHealReport', type: 'string' },
+    '--flow-catalog': { key: 'flowCatalogPath', type: 'string' },
+    '--output': { key: 'trainOutput', type: 'string' },
+    '--server-path': { key: 'serverPath', type: 'string' },
+    '--workflow': { key: 'crewWorkflow', type: 'string' },
+    '--crew-workflow': { key: 'crewWorkflow', type: 'string' },
+    // -- number flags (with isFinite guard) --
+    '--pipeline-scenarios': { key: 'pipelineScenarios', type: 'number' },
+    '--time': { key: 'timeLimitMinutes', type: 'number' },
+    '--budget-usd': { key: 'budgetUSD', type: 'number' },
+    '--budget-tokens': { key: 'budgetTokens', type: 'number' },
+    '--policy-min-confidence': { key: 'policyMinConfidence', type: 'number' },
+    '--policy-safe-merge-confidence': { key: 'policySafeMergeConfidence', type: 'number' },
+    '--policy-force-full-on-warnings': { key: 'policyWarningsThreshold', type: 'number' },
+    '--traceability-min-hits': { key: 'traceabilityMinHits', type: 'number' },
+    '--traceability-max-files-per-test': { key: 'traceabilityMaxFilesPerTest', type: 'number' },
+    '--traceability-max-age-days': { key: 'traceabilityMaxAgeDays', type: 'number' },
+    '--pr': { key: 'trainPr', type: 'number' },
+    // -- number-raw flags (no isFinite guard, assigned directly via Number()) --
+    '--max-attempts': { key: 'maxAttempts', type: 'number-raw', transform: (v) => parseInt(v, 10) },
+    '--pipeline-mcp-timeout-ms': { key: 'pipelineMcpTimeoutMs', type: 'number-raw' },
+    '--pipeline-mcp-retries': { key: 'pipelineMcpRetries', type: 'number-raw' },
+    // -- enum flags --
+    '--profile': { key: 'profile', type: 'enum', enumValues: ['default', 'mattermost'] },
+    '--pipeline-browser': { key: 'pipelineBrowser', type: 'enum', enumValues: ['chrome', 'chromium', 'firefox', 'webkit'] },
+    '--policy-enforcement-mode': { key: 'policyEnforcementMode', type: 'enum', enumValues: ['advisory', 'warn', 'block'] },
+    // -- csv flags --
+    '--patterns': { key: 'testPatterns', type: 'csv' },
+    '--flow-patterns': { key: 'flowPatterns', type: 'csv' },
+    '--flow-exclude': { key: 'flowExclude', type: 'csv' },
+    '--plugins': { key: 'plugins', type: 'csv' },
+    '--policy-risky-patterns': { key: 'policyRiskyPatterns', type: 'csv' },
+    '--policy-block-actions': {
+        key: 'policyBlockActions',
+        type: 'csv',
+        transform: (v) => csvSplit(v).filter((s) => s === 'run-now' || s === 'must-add-tests' || s === 'safe-to-merge'),
+    },
+    // -- gate command --
+    '--threshold': { key: 'gateThreshold', type: 'number' },
+    // -- bootstrap command --
+    '--kg-path': { key: 'bootstrapKgPath', type: 'string' },
+    '--scaffold-framework': { key: 'bootstrapScaffoldFramework', type: 'boolean' },
+    '--test-mode': { key: 'bootstrapTestMode', type: 'enum', enumValues: ['ui', 'api', 'both'] },
+    '--max-families': { key: 'bootstrapMaxFamilies', type: 'number' },
+};
+// Build a lookup from alias -> canonical flag name
+const ALIAS_MAP = {};
+for (const [flag, def] of Object.entries(FLAGS)) {
+    ALIAS_MAP[flag] = flag;
+    if (def.aliases) {
+        for (const alias of def.aliases) {
+            ALIAS_MAP[alias] = flag;
+        }
+    }
+}
+const COMMANDS = new Set([
+    'init', 'impact', 'plan', 'heal', 'suggest', 'generate',
+    'finalize-generated-tests', 'feedback',
+    'traceability-capture', 'traceability-ingest',
+    'analyze', 'llm-health', 'train', 'crew', 'cost-report', 'gate',
+    'bootstrap',
+]);
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+function setField(obj, key, value) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    obj[key] = value;
+}
+export function parseArgs(argv) {
+    const parsed = { apply: false, help: false };
+    if (argv.length === 0) {
+        return parsed;
+    }
+    const command = argv[0];
+    if (COMMANDS.has(command)) {
+        parsed.command = command;
+    }
+    const startIndex = parsed.command ? 1 : 0;
+    for (let i = startIndex; i < argv.length; i += 1) {
+        const arg = argv[i];
+        const canonical = ALIAS_MAP[arg];
+        if (!canonical) {
+            if (arg.startsWith('--')) {
+                logger.warn(`Unknown flag "${arg}" (ignored)`);
+            }
+            continue;
+        }
+        const def = FLAGS[canonical];
+        const next = argv[i + 1];
+        switch (def.type) {
+            case 'boolean':
+                setField(parsed, def.key, def.transform ? def.transform('') : true);
+                break;
+            case 'boolean-false':
+                setField(parsed, def.key, false);
+                break;
+            case 'string':
+                if (next) {
+                    setField(parsed, def.key, def.transform ? def.transform(next) : next);
+                    i += 1;
+                }
+                break;
+            case 'number':
+                if (next) {
+                    const value = Number(next);
+                    if (Number.isFinite(value)) {
+                        setField(parsed, def.key, value);
+                    }
+                    i += 1;
+                }
+                break;
+            case 'number-raw':
+                if (next) {
+                    const rawValue = def.transform ? def.transform(next) : Number(next);
+                    // Allow non-number transforms through; reject NaN/Infinity for numbers
+                    if (typeof rawValue === 'number') {
+                        if (Number.isFinite(rawValue)) {
+                            setField(parsed, def.key, rawValue);
+                        }
+                    }
+                    else {
+                        setField(parsed, def.key, rawValue);
+                    }
+                    i += 1;
+                }
+                break;
+            case 'csv':
+                if (next) {
+                    setField(parsed, def.key, def.transform ? def.transform(next) : csvSplit(next));
+                    i += 1;
+                }
+                break;
+            case 'enum':
+                if (next) {
+                    if (def.enumValues.includes(next)) {
+                        setField(parsed, def.key, next);
+                    }
+                    i += 1;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return parsed;
+}

package/dist/esm/cli/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/cli/usage.js

@@ -0,0 +1,106 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export function printUsage() {
+    console.log([
+        'Usage:',
+        '  impact-gate <command> [options]',
+        '',
+        'Core CI workflow:',
+        '  impact --path <app-root> [options]',
+        '  plan --path <app-root> [options]',
+        '  suggest --path <app-root> [options]',
+        '  gate --path <app-root> --threshold <n> [--since <ref>]',
+        '',
+        'Optional AI workflow:',
+        '  analyze --path <app-root> [--tests-root <path>] [--since <ref>] [--generate] [--generate-output <dir>] [--heal] [--heal-report <json>]',
+        '  generate [--scenarios <path|json>] [--max-attempts <n>] [--dry-run]',
+        '  heal --path <app-root> --traceability-report <json> [options]',
+        '  finalize-generated-tests --path <app-root> [options]',
+        '',
+        'Setup and calibration:',
+        '  init [--yes]',
+        '  train --path <project-root> [--no-enrich] [--validate] [--since <ref>] [--pr <num>]',
+        '  bootstrap --path <app-root> [options]',
+        '  feedback --path <app-root> --feedback-input <json>',
+        '  traceability-capture --path <app-root> --traceability-report <json>',
+        '  traceability-ingest --path <app-root> --traceability-input <json>',
+        '  cost-report [--path <app-root>]',
+        '  llm-health',
+        '',
+        'Advanced / experimental:',
+        '  crew --path <app-root> [--crew-workflow <name>] [--plugins <paths>]',
+        '',
+        'Options:',
+        '  --config <path>       Path to impact-gate.config.json (auto-discovered if present)',
+        '  --path <project-root> Path to the project root (scans both frontend and backend)',
+        '  --profile <name>     default | mattermost',
+        '  --mattermost         Shortcut for --profile mattermost',
+        '  --tests-root <path>   Path to tests root (optional)',
+        '  --framework <name>    auto | playwright | cypress | pytest | supertest | selenium',
+        '  --patterns <globs>    Comma-separated test patterns',
+        '  --flow-patterns <g>   Comma-separated flow discovery patterns',
+        '  --flow-exclude <g>    Comma-separated flow exclude patterns',
+        '  --plugins <paths>     Comma-separated plugin module paths for crew workflows',
+        '  --flow-catalog <path> Path to flow catalog JSON',
+        '  --allow-fallback      Allow impact analysis without diff',
+        '  --pipeline            Run Playwright AI pipeline for missing P0/P1 flows',
+        '  --pipeline-scenarios  Number of scenarios per flow (default 3)',
+        '  --pipeline-output     Output directory for generated tests',
+        '  --pipeline-base-url   Base URL for Playwright runs',
+        '  --pipeline-browser    Browser: chrome|chromium|firefox|webkit',
+        '  --pipeline-headless   Run in headless mode',
+        '  --pipeline-headed     Run in headed mode',
+        '  --pipeline-project    Playwright project name',
+        '  --pipeline-parallel   Enable parallel mode in generator',
+        '  --pipeline-dry-run    Do not execute pipeline (report only)',
+        '  --pipeline-mcp        Use Playwright MCP server for exploration/healing',
+        '  --pipeline-mcp-allow-fallback  Allow non-MCP fallback if official MCP setup fails',
+        '  --pipeline-mcp-only   Require MCP for UI exploration (fail if unavailable)',
+        '  --pipeline-mcp-timeout-ms <n>  Timeout per MCP CLI invocation in milliseconds',
+        '  --pipeline-mcp-retries <n>  Retry count for retryable MCP CLI failures',
+        '  --spec <path>         Optional spec PDF for context',
+        '  --since <git-ref>     Git ref for impact analysis (default HEAD~1)',
+        '  --time <minutes>      Time limit in minutes',
+        '  --budget-usd <amount> Max LLM budget in USD',
+        '  --budget-tokens <n>   Max LLM tokens',
+        '  --llm-provider <name> LLM provider: auto | anthropic | openai | ollama',
+        '  --policy-min-confidence <n>   Minimum confidence for targeted suite',
+        '  --policy-safe-merge-confidence <n> Confidence needed for safe-to-merge',
+        '  --policy-force-full-on-warnings <n> Escalate to full at warning count',
+        '  --policy-risky-patterns <globs>     Comma-separated risky file globs',
+        '  --policy-enforcement-mode <mode>    advisory | warn | block',
+        '  --policy-block-actions <actions>    Comma-separated CI actions to block/warn',
+        '  --crew                               Run Crew enrichment and attach insights to plan output',
+        '  --crew-workflow <name>               full-qa | quick-check | design-only',
+        '  --ci-comment-path <path>            Write CI markdown summary',
+        '  --github-output <path>              Write GitHub Actions outputs',
+        '  --fail-on-must-add-tests            Exit non-zero on must-add-tests decision',
+        '  --feedback-input <path>             Path to recommendation feedback JSON',
+        '  --traceability-report <path>        Path to Playwright JSON report for traceability capture',
+        '  --traceability-capture-output <path> Output path for generated traceability ingest JSON',
+        '  --traceability-coverage-map <path>  Optional coverage map (test<->files) to enrich traceability capture',
+        '  --traceability-changed-files <path> Optional changed-files list/JSON fallback for traceability capture',
+        '  --traceability-input <path>         Path to traceability ingest JSON payload',
+        '  --traceability-min-hits <n>         Minimum signal hits required per file mapping',
+        '  --traceability-max-files-per-test <n> Cap max mapped files per test',
+        '  --traceability-max-age-days <n>     Drop stale mappings older than N days',
+        '  --branch <name>      Optional handoff branch (prefixed with codex/)',
+        '  --commit-message <m> Commit message for finalize-generated-tests',
+        '  --create-pr          Open PR with gh after commit',
+        '  --pr-title <title>   PR title for finalize-generated-tests',
+        '  --pr-body <body>     PR body for finalize-generated-tests',
+        '  --pr-base <branch>   PR base branch for finalize-generated-tests',
+        '                      (auto-heal-pr defaults to base=master)',
+        '  --dry-run            Preview actions without mutating git state',
+        '  --max-attempts <n>    Max fix attempts per scenario (default: 3)',
+        '  --scenarios <path|json>  Scenarios file/JSON for generate command',
+        '  --apply               Apply data-testid patches and generate tests',
+        '                        (legacy shortcut; prefer approve-and-generate)',
+        '  --no-enrich              Disable LLM enrichment (offline mode, train command)',
+        '  --validate               Validate manifest against git history (train command)',
+        '  --pr <number>            GitHub PR number for validation (requires gh CLI)',
+        '  --yes, -y                Non-interactive mode (train command)',
+        '  --output <path>          Output path for route-families.json (train command)',
+        '  --help                Show help',
+    ].join('\n'));
+}

package/dist/esm/cli.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { resolveConfig } from './agent/config.js';
+import { parseArgs, resolveAutoConfig } from './cli/parse_args.js';
+import { resolveDefaults } from './cli/defaults.js';
+import { printUsage } from './cli/usage.js';
+import { runLlmHealth } from './cli/commands/llm_health.js';
+import { runAnalyzeCommand } from './cli/commands/analyze.js';
+import { runFeedbackCommand } from './cli/commands/feedback.js';
+import { runTraceabilityCaptureCommand, runTraceabilityIngestCommand } from './cli/commands/traceability.js';
+import { runFinalizeCommand } from './cli/commands/finalize.js';
+import { runHealCommand } from './cli/commands/heal.js';
+import { runImpactCommand } from './cli/commands/impact.js';
+import { runPlanCommand } from './cli/commands/plan.js';
+import { runGenerateCommand } from './cli/commands/generate.js';
+import { runInitCommand } from './cli/commands/init.js';
+import { runTrainCommand } from './cli/commands/train.js';
+import { runCrewCommand } from './cli/commands/crew.js';
+import { runCostReportCommand } from './cli/commands/cost_report.js';
+import { runGateCommand } from './cli/commands/gate.js';
+import { runBootstrapCommand } from './cli/commands/bootstrap.js';
+import { classifyError, EXIT_CODES } from './cli/errors.js';
+// Commands that skip default resolution (they handle their own setup)
+const SKIP_DEFAULTS_COMMANDS = new Set(['init', 'llm-health', 'cost-report', 'bootstrap']);
+// Commands that need path/testsRoot/framework/since
+const NEEDS_DEFAULTS_COMMANDS = new Set([
+    'impact', 'plan', 'suggest', 'crew', 'generate', 'heal', 'analyze', 'train',
+    'feedback', 'traceability-capture', 'traceability-ingest', 'finalize-generated-tests',
+]);
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const autoConfig = resolveAutoConfig(args);
+    // Auto-detect defaults for commands that need them (when no config file found)
+    if (args.command && NEEDS_DEFAULTS_COMMANDS.has(args.command) && !SKIP_DEFAULTS_COMMANDS.has(args.command)) {
+        const defaults = resolveDefaults({
+            path: args.path,
+            testsRoot: args.testsRoot,
+            framework: args.framework,
+            gitSince: args.gitSince,
+        });
+        args.path = args.path || defaults.path;
+        args.testsRoot = args.testsRoot || defaults.testsRoot;
+        args.framework = args.framework || defaults.framework;
+        args.gitSince = args.gitSince || defaults.since;
+    }
+    if (args.command === 'init') {
+        const hasYes = process.argv.includes('--yes') || process.argv.includes('-y');
+        await runInitCommand(hasYes);
+        return;
+    }
+    if (args.command === 'bootstrap') {
+        await runBootstrapCommand(args);
+        return;
+    }
+    if (args.command === 'train') {
+        await runTrainCommand(args, autoConfig);
+        return;
+    }
+    if (args.help) {
+        printUsage();
+        process.exit(0);
+    }
+    if (!args.command) {
+        printUsage();
+        process.exit(1);
+    }
+    if (args.command === 'llm-health') {
+        await runLlmHealth();
+        return;
+    }
+    if (args.command === 'analyze') {
+        await runAnalyzeCommand(args, autoConfig);
+        return;
+    }
+    if (args.command === 'feedback') {
+        runFeedbackCommand(args, autoConfig);
+        return;
+    }
+    if (args.command === 'traceability-capture') {
+        runTraceabilityCaptureCommand(args, autoConfig);
+        return;
+    }
+    if (args.command === 'traceability-ingest') {
+        runTraceabilityIngestCommand(args, autoConfig);
+        return;
+    }
+    if (args.command === 'finalize-generated-tests') {
+        runFinalizeCommand(args, autoConfig);
+        return;
+    }
+    if (args.command === 'heal') {
+        runHealCommand(args, autoConfig);
+        return;
+    }
+    if (args.command === 'crew') {
+        await runCrewCommand(args, autoConfig);
+        return;
+    }
+    if (args.command === 'cost-report') {
+        runCostReportCommand(args);
+        return;
+    }
+    if (args.command === 'gate') {
+        await runGateCommand(args, autoConfig);
+        return;
+    }
+    if (!args.path && !autoConfig) {
+        console.error('Error: --path is required (or provide a config file with path set)');
+        printUsage();
+        process.exit(1);
+    }
+    const { config } = resolveConfig(process.cwd(), autoConfig, {
+        path: args.path,
+        profile: args.profile,
+        testsRoot: args.testsRoot,
+        mode: 'impact',
+        framework: args.framework,
+        timeLimitMinutes: args.timeLimitMinutes,
+        budget: {
+            maxUSD: args.budgetUSD,
+            maxTokens: args.budgetTokens,
+        },
+        testPatterns: args.testPatterns,
+        flowPatterns: args.flowPatterns,
+        flowExclude: args.flowExclude,
+        flowCatalogPath: args.flowCatalogPath,
+        specPDF: args.specPDF,
+        gitSince: args.gitSince,
+        llmProvider: args.llmProvider,
+        pipeline: args.pipeline
+            ? {
+                enabled: true,
+                scenarios: args.pipelineScenarios,
+                outputDir: args.pipelineOutput,
+                baseUrl: args.pipelineBaseUrl,
+                browser: args.pipelineBrowser,
+                headless: args.pipelineHeadless,
+                project: args.pipelineProject,
+                parallel: args.pipelineParallel,
+                dryRun: args.pipelineDryRun,
+                mcp: args.pipelineMcp,
+                mcpAllowFallback: args.pipelineMcpAllowFallback,
+                mcpOnly: args.pipelineMcpOnly,
+                mcpCommandTimeoutMs: args.pipelineMcpTimeoutMs,
+                mcpRetries: args.pipelineMcpRetries,
+            }
+            : undefined,
+        policy: args.policyMinConfidence !== undefined ||
+            args.policySafeMergeConfidence !== undefined ||
+            args.policyWarningsThreshold !== undefined ||
+            (args.policyRiskyPatterns && args.policyRiskyPatterns.length > 0) ||
+            args.policyEnforcementMode !== undefined ||
+            (args.policyBlockActions && args.policyBlockActions.length > 0)
+            ? {
+                minConfidenceForTargeted: args.policyMinConfidence,
+                safeMergeMinConfidence: args.policySafeMergeConfidence,
+                forceFullOnWarningsAtOrAbove: args.policyWarningsThreshold,
+                riskyFilePatterns: args.policyRiskyPatterns,
+                enforcementMode: args.policyEnforcementMode,
+                blockOnActions: args.policyBlockActions,
+            }
+            : undefined,
+    });
+    if (args.command === 'impact') {
+        runImpactCommand(args, config);
+        return;
+    }
+    if (args.command === 'suggest' || args.command === 'plan') {
+        await runPlanCommand(args, autoConfig, config);
+        return;
+    }
+    if (args.command === 'generate') {
+        await runGenerateCommand(args, config);
+        return;
+    }
+    console.error(`Unknown command: ${args.command}`);
+    printUsage();
+    process.exit(1);
+}
+main().catch((error) => {
+    const exitCode = classifyError(error);
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    if (exitCode === EXIT_CODES.BUDGET_EXCEEDED) {
+        console.error('Hint: Increase --budget or use --degraded-mode to skip AI features.');
+    }
+    else if (exitCode === EXIT_CODES.PROVIDER_UNAVAILABLE) {
+        console.error('Hint: Check API key or use --degraded-mode for deterministic analysis only.');
+    }
+    process.exit(exitCode);
+});

package/dist/esm/crew/context.js

@@ -0,0 +1,32 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export function createEmptyUsageStats() {
+    const now = new Date();
+    return {
+        requestCount: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        averageResponseTimeMs: 0,
+        failedRequests: 0,
+        startTime: now,
+        lastUpdated: now,
+    };
+}
+export function mergeUsageStats(target, source) {
+    const prevRequestCount = target.requestCount;
+    target.requestCount += source.requestCount;
+    target.totalInputTokens += source.totalInputTokens;
+    target.totalOutputTokens += source.totalOutputTokens;
+    target.totalTokens += source.totalTokens;
+    target.totalCost += source.totalCost;
+    target.failedRequests += source.failedRequests;
+    if (source.requestCount > 0 && target.requestCount > 0) {
+        const prevWeight = prevRequestCount / target.requestCount;
+        const newWeight = source.requestCount / target.requestCount;
+        target.averageResponseTimeMs =
+            target.averageResponseTimeMs * prevWeight + source.averageResponseTimeMs * newWeight;
+    }
+    target.lastUpdated = new Date();
+}