playwright-smart-test 0.0.0-stage → 1.0.2

package/dist/cli/index.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { loadConfig } from '../config/index.js';
+import { GitDiffAnalyzer } from '../diff/git-diff-analyzer.js';
+import { TestCatalogIndexer } from '../catalog/test-catalog.js';
+import { TestSelector } from '../selector/test-selector.js';
+import { TerminalReporter } from '../reporters/terminal-reporter.js';
+import { GitHubReporter } from '../reporters/github-reporter.js';
+import { PlaywrightRunner } from '../runner/playwright-runner.js';
+const program = new Command();
+program
+    .name('playwright-smart-test')
+    .description('AI-Powered Smart Regression Test Selection Agent for Playwright')
+    .version('1.0.2');
+async function executeAnalysis(options) {
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const config = loadConfig(cwd, options.config);
+    console.log(pc.cyan(`\n🔍 Scanning repository at ${cwd}...`));
+    const diffAnalyzer = new GitDiffAnalyzer(cwd);
+    const changedFiles = await diffAnalyzer.getChangedFiles({
+        base: options.base,
+        head: options.head,
+        staged: options.staged,
+    });
+    console.log(`Detected ${pc.yellow(changedFiles.length.toString())} modified files.`);
+    const catalogIndexer = new TestCatalogIndexer(cwd);
+    const catalog = await catalogIndexer.scanTestFiles(config.testDir, config.testMatch);
+    console.log(`Indexed ${pc.yellow(catalog.length.toString())} Playwright spec files in '${config.testDir}'.`);
+    const selector = new TestSelector(config, cwd);
+    const result = await selector.selectTests(changedFiles, catalog);
+    return { result, cwd, config };
+}
+program
+    .command('analyze')
+    .description('Analyze PR diff and identify impacted Playwright regression tests')
+    .option('-b, --base <ref>', 'Base git commit/branch (e.g. origin/main or HEAD~1)')
+    .option('-h, --head <ref>', 'Head git commit/branch (e.g. HEAD)')
+    .option('--staged', 'Analyze only staged changes')
+    .option('-c, --config <path>', 'Path to custom config file')
+    .option('-o, --output <path>', 'Save analysis result to file (.json or .md)')
+    .option('--cwd <dir>', 'Working directory', process.cwd())
+    .action(async (options) => {
+    try {
+        const { result } = await executeAnalysis(options);
+        TerminalReporter.report(result);
+        if (options.output) {
+            const outPath = path.resolve(options.cwd || process.cwd(), options.output);
+            if (outPath.endsWith('.json')) {
+                fs.writeFileSync(outPath, JSON.stringify(result, null, 2), 'utf8');
+                console.log(pc.green(`✓ Analysis saved to JSON: ${outPath}`));
+            }
+            else {
+                const md = GitHubReporter.generateMarkdown(result);
+                fs.writeFileSync(outPath, md, 'utf8');
+                console.log(pc.green(`✓ Markdown PR report saved to: ${outPath}`));
+            }
+        }
+    }
+    catch (err) {
+        console.error(pc.red(`Error during analysis: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('run')
+    .description('Analyze PR diff and run the selected Playwright tests')
+    .option('-b, --base <ref>', 'Base git commit/branch')
+    .option('-h, --head <ref>', 'Head git commit/branch')
+    .option('--staged', 'Analyze only staged changes')
+    .option('-c, --config <path>', 'Path to custom config file')
+    .option('--cwd <dir>', 'Working directory', process.cwd())
+    .option('--dry-run', 'Print the command without executing')
+    .action(async (options) => {
+    try {
+        const { result, cwd } = await executeAnalysis(options);
+        TerminalReporter.report(result);
+        if (options.dryRun) {
+            console.log(pc.yellow(`[Dry-run] Would execute: ${result.playwrightCommand}`));
+            return;
+        }
+        if (result.selectedSpecs.length === 0 && !result.isFullRegression) {
+            console.log(pc.green('No regression tests required for this change. Exiting.'));
+            return;
+        }
+        const exitCode = await PlaywrightRunner.execute(result.playwrightCommand, cwd);
+        process.exit(exitCode);
+    }
+    catch (err) {
+        console.error(pc.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('comment')
+    .description('Generate GitHub PR comment markdown')
+    .option('-b, --base <ref>', 'Base git commit/branch')
+    .option('-h, --head <ref>', 'Head git commit/branch')
+    .option('--staged', 'Analyze only staged changes')
+    .option('-c, --config <path>', 'Path to custom config file')
+    .option('--cwd <dir>', 'Working directory', process.cwd())
+    .action(async (options) => {
+    try {
+        const { result } = await executeAnalysis(options);
+        const markdown = GitHubReporter.generateMarkdown(result);
+        console.log(markdown);
+    }
+    catch (err) {
+        console.error(pc.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+});
+program
+    .command('init')
+    .description('Create a sample playwright-smart-test.config.json file')
+    .option('--cwd <dir>', 'Target directory', process.cwd())
+    .action((options) => {
+    const targetDir = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const filePath = path.join(targetDir, 'playwright-smart-test.config.json');
+    const sample = {
+        testDir: 'tests',
+        testMatch: ['**/*.spec.ts'],
+        pageObjectsDir: 'src/pages',
+        components: [
+            { name: 'checkout', patterns: ['src/**/checkout*'] },
+            { name: 'payment', patterns: ['src/**/payment*'] },
+            { name: 'basket', patterns: ['src/**/basket*', 'src/**/cart*'] }
+        ],
+        safetyRules: {
+            maxChangedDomainsForFullRun: 8,
+            maxImpactRatioForFullRun: 0.7,
+            smokeTag: '@smoke',
+            smokeSpecPattern: '**/*smoke*.spec.ts',
+            fullRunPatterns: []
+        },
+        ai: {
+            provider: 'gemini',
+            model: 'gemini-3.8-flash',
+            temperature: 0.2
+        }
+    };
+    fs.writeFileSync(filePath, JSON.stringify(sample, null, 2), 'utf8');
+    console.log(pc.green(`✓ Initialized configuration file at: ${filePath}`));
+});
+program.parse(process.argv);

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+import { SmartRegressionConfig } from './schema.js';
+export * from './schema.js';
+export declare function loadConfig(cwd?: string, customConfigPath?: string): SmartRegressionConfig;

package/dist/config/index.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import dotenv from 'dotenv';
+import { SmartRegressionConfigSchema } from './schema.js';
+dotenv.config();
+export * from './schema.js';
+export function loadConfig(cwd = process.cwd(), customConfigPath) {
+    let loadedConfig = {};
+    const possiblePaths = customConfigPath
+        ? [path.resolve(cwd, customConfigPath)]
+        : [
+            path.resolve(cwd, 'playwright-smart-test.config.json'),
+            path.resolve(cwd, '.playwright-smart-testrc.json'),
+            path.resolve(cwd, 'smart-regression.config.json'),
+            path.resolve(cwd, '.smart-regressionrc.json'),
+            path.resolve(cwd, 'smart-regression.json'),
+        ];
+    for (const configPath of possiblePaths) {
+        if (fs.existsSync(configPath)) {
+            try {
+                const raw = fs.readFileSync(configPath, 'utf8');
+                loadedConfig = JSON.parse(raw);
+                break;
+            }
+            catch (err) {
+                console.warn(`[smart-test] Warning: Failed to parse config file at ${configPath}:`, err);
+            }
+        }
+    }
+    const parsed = SmartRegressionConfigSchema.parse(loadedConfig);
+    const envApiKey = process.env.GEMINI_API_KEY;
+    if (envApiKey && !parsed.ai.apiKey) {
+        parsed.ai.apiKey = envApiKey;
+    }
+    if (process.env.GEMINI_MODEL) {
+        parsed.ai.model = process.env.GEMINI_MODEL;
+    }
+    return parsed;
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+export declare const AIConfigSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodLiteral<"gemini">>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    model: z.ZodDefault<z.ZodString>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ComponentRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    patterns: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SmartRegressionConfigSchema: z.ZodObject<{
+    testDir: z.ZodDefault<z.ZodString>;
+    testMatch: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    pageObjectsDir: z.ZodDefault<z.ZodString>;
+    components: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        patterns: z.ZodArray<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    safetyRules: z.ZodDefault<z.ZodObject<{
+        fullRunPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        maxImpactRatioForFullRun: z.ZodDefault<z.ZodNumber>;
+        maxChangedDomainsForFullRun: z.ZodDefault<z.ZodNumber>;
+        smokeTag: z.ZodDefault<z.ZodString>;
+        smokeSpecPattern: z.ZodDefault<z.ZodString>;
+        docsOnlyPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    ai: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodLiteral<"gemini">>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        model: z.ZodDefault<z.ZodString>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SmartRegressionConfig = z.infer<typeof SmartRegressionConfigSchema>;
+export declare const AISelectedTestSchema: z.ZodObject<{
+    specFile: z.ZodString;
+    testTitles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    reason: z.ZodString;
+    isIndirectImpact: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const AIImpactAnalysisSchema: z.ZodObject<{
+    changedComponents: z.ZodArray<z.ZodString>;
+    impactedComponents: z.ZodArray<z.ZodString>;
+    directReason: z.ZodString;
+    rippleEffectReason: z.ZodString;
+    riskScore: z.ZodEnum<{
+        LOW: "LOW";
+        MEDIUM: "MEDIUM";
+        HIGH: "HIGH";
+        CRITICAL: "CRITICAL";
+    }>;
+    requiresFullRegression: z.ZodDefault<z.ZodBoolean>;
+    confidenceScore: z.ZodDefault<z.ZodEnum<{
+        LOW: "LOW";
+        MEDIUM: "MEDIUM";
+        HIGH: "HIGH";
+    }>>;
+    recommendedTests: z.ZodArray<z.ZodObject<{
+        specFile: z.ZodString;
+        testTitles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        reason: z.ZodString;
+        isIndirectImpact: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AIImpactAnalysis = z.infer<typeof AIImpactAnalysisSchema>;
+export interface DiffFile {
+    path: string;
+    status: 'added' | 'modified' | 'deleted' | 'renamed';
+    additions: number;
+    deletions: number;
+    patch?: string;
+}
+export interface SpecCatalogEntry {
+    filePath: string;
+    testTitles: string[];
+    tags: string[];
+    importedModules: string[];
+}
+export interface FinalSelectionResult {
+    isFullRegression: boolean;
+    fullRegressionReason?: string;
+    isSmokeFallback?: boolean;
+    smokeFallbackReason?: string;
+    changedFiles: DiffFile[];
+    changedComponents: string[];
+    impactedComponents: string[];
+    aiAnalysis: AIImpactAnalysis;
+    selectedSpecs: string[];
+    directlyModifiedSpecs: string[];
+    componentRuleSpecs: string[];
+    aiRecommendedSpecs: string[];
+    grepFilter?: string;
+    playwrightCommand: string;
+}

package/dist/config/schema.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export const AIConfigSchema = z.object({
+    provider: z.literal('gemini').default('gemini'),
+    apiKey: z.string().optional(),
+    model: z.string().default('gemini-3.8-flash'),
+    temperature: z.number().min(0).max(1).default(0.2),
+});
+export const ComponentRuleSchema = z.object({
+    name: z.string(),
+    patterns: z.array(z.string()),
+    description: z.string().optional(),
+});
+export const SmartRegressionConfigSchema = z.object({
+    testDir: z.string().default('tests'),
+    testMatch: z.array(z.string()).default(['**/*.spec.ts', '**/*.test.ts']),
+    pageObjectsDir: z.string().default('src/pages'),
+    components: z.array(ComponentRuleSchema).default([]),
+    safetyRules: z.object({
+        fullRunPatterns: z.array(z.string()).default([]),
+        maxImpactRatioForFullRun: z.number().min(0).max(1).default(0.7),
+        maxChangedDomainsForFullRun: z.number().default(8),
+        smokeTag: z.string().default('@smoke'),
+        smokeSpecPattern: z.string().default('**/*smoke*.spec.ts'),
+        docsOnlyPatterns: z.array(z.string()).default([
+            '**/*.md',
+            'docs/**',
+            'LICENSE',
+            '**/.gitignore',
+            '**/assets/**',
+            '**/*.png',
+            '**/*.jpg',
+            '**/*.svg',
+        ]),
+    }).default({
+        fullRunPatterns: [],
+        maxImpactRatioForFullRun: 0.7,
+        maxChangedDomainsForFullRun: 8,
+        smokeTag: '@smoke',
+        smokeSpecPattern: '**/*smoke*.spec.ts',
+        docsOnlyPatterns: [
+            '**/*.md',
+            'docs/**',
+            'LICENSE',
+            '**/.gitignore',
+            '**/assets/**',
+            '**/*.png',
+            '**/*.jpg',
+            '**/*.svg',
+        ],
+    }),
+    ai: AIConfigSchema.default({
+        provider: 'gemini',
+        model: 'gemini-3.8-flash',
+        temperature: 0.2,
+    }),
+});
+export const AISelectedTestSchema = z.object({
+    specFile: z.string().describe('Relative path to the Playwright spec file'),
+    testTitles: z.array(z.string()).optional().describe('Specific test titles or describe blocks to target'),
+    reason: z.string().describe('Detailed rationale for why this test is affected'),
+    isIndirectImpact: z.boolean().describe('True if impacted due to workflow/transitive side effect rather than direct import'),
+});
+export const AIImpactAnalysisSchema = z.object({
+    changedComponents: z.array(z.string()).describe('Identified components directly modified in the diff (e.g. checkout, payment)'),
+    impactedComponents: z.array(z.string()).describe('Upstream or downstream components impacted by this change (e.g. basket, order-summary)'),
+    directReason: z.string().describe('Summary of the direct code changes and their purpose'),
+    rippleEffectReason: z.string().describe('Explanation of the ripple effects across related business flows'),
+    riskScore: z.enum(['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']).describe('Risk level of the change'),
+    requiresFullRegression: z.boolean().default(false).describe('True if changes affect global infrastructure or blast radius cannot be isolated'),
+    confidenceScore: z.enum(['HIGH', 'MEDIUM', 'LOW']).default('HIGH').describe('Confidence in isolating impact'),
+    recommendedTests: z.array(AISelectedTestSchema).describe('List of recommended Playwright tests to execute'),
+});

package/dist/diff/git-diff-analyzer.d.ts

@@ -0,0 +1,24 @@
+import { DiffFile } from '../config/schema.js';
+export interface DiffOptions {
+    base?: string;
+    head?: string;
+    staged?: boolean;
+}
+export declare class GitDiffAnalyzer {
+    private cwd;
+    constructor(cwd?: string);
+    private runGit;
+    getChangedFiles(options?: DiffOptions): Promise<DiffFile[]>;
+    /**
+     * Parse git diff --numstat output:
+     * <additions>\t<deletions>\t<file>
+     */
+    parseNumstat(output: string): Map<string, {
+        additions: number;
+        deletions: number;
+    }>;
+    /**
+     * Split unified diff output into per-file patches
+     */
+    splitPatches(rawDiff: string): Map<string, string>;
+}

package/dist/diff/git-diff-analyzer.js

@@ -0,0 +1,105 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export class GitDiffAnalyzer {
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    async runGit(args) {
+        try {
+            const { stdout } = await execFileAsync('git', args, {
+                cwd: this.cwd,
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+            });
+            return stdout;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`Git command failed [git ${args.join(' ')}]: ${message}`);
+        }
+    }
+    async getChangedFiles(options = {}) {
+        await this.runGit(['rev-parse', '--is-inside-work-tree']);
+        let diffRangeArgs;
+        if (options.base && options.head) {
+            diffRangeArgs = [`${options.base}...${options.head}`];
+        }
+        else if (options.base) {
+            diffRangeArgs = [options.base];
+        }
+        else if (options.staged) {
+            diffRangeArgs = ['--cached'];
+        }
+        else {
+            diffRangeArgs = ['HEAD'];
+        }
+        const numstatOutput = await this.runGit(['diff', '--numstat', ...diffRangeArgs]);
+        const numstatMap = this.parseNumstat(numstatOutput);
+        const rawDiff = await this.runGit(['diff', ...diffRangeArgs]);
+        const patchesByFile = this.splitPatches(rawDiff);
+        const allPaths = Array.from(new Set([...numstatMap.keys(), ...patchesByFile.keys()]));
+        const files = allPaths.map((filePath) => {
+            const numstat = numstatMap.get(filePath) || { additions: 0, deletions: 0 };
+            const patch = patchesByFile.get(filePath) || '';
+            let status = 'modified';
+            if (patch.includes('new file mode')) {
+                status = 'added';
+            }
+            else if (patch.includes('deleted file mode')) {
+                status = 'deleted';
+            }
+            else if (patch.includes('rename from ') || patch.includes('similarity index')) {
+                status = 'renamed';
+            }
+            return {
+                path: filePath.replace(/\\/g, '/'),
+                status,
+                additions: numstat.additions,
+                deletions: numstat.deletions,
+                patch,
+            };
+        });
+        return files;
+    }
+    /**
+     * Parse git diff --numstat output:
+     * <additions>\t<deletions>\t<file>
+     */
+    parseNumstat(output) {
+        const map = new Map();
+        const lines = output.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const parts = trimmed.split(/\s+/);
+            if (parts.length >= 3) {
+                const additions = parts[0] === '-' ? 0 : parseInt(parts[0], 10) || 0;
+                const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10) || 0;
+                const filePath = parts.slice(2).join(' ').replace(/\\/g, '/');
+                map.set(filePath, { additions, deletions });
+            }
+        }
+        return map;
+    }
+    /**
+     * Split unified diff output into per-file patches
+     */
+    splitPatches(rawDiff) {
+        const filePatches = new Map();
+        if (!rawDiff.trim())
+            return filePatches;
+        const diffSections = rawDiff.split(/(?=^diff --git )/m);
+        for (const section of diffSections) {
+            if (!section.trim())
+                continue;
+            const match = section.match(/^diff --git a\/(.+?) b\/(.+?)$/m);
+            if (match) {
+                const filePath = match[2] || match[1];
+                filePatches.set(filePath.replace(/\\/g, '/'), section.trim());
+            }
+        }
+        return filePatches;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './config/index.js';
+export * from './diff/git-diff-analyzer.js';
+export * from './catalog/test-catalog.js';
+export * from './ai/ai-analyzer.js';
+export * from './selector/test-selector.js';
+export * from './reporters/terminal-reporter.js';
+export * from './reporters/github-reporter.js';
+export * from './runner/playwright-runner.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './config/index.js';
+export * from './diff/git-diff-analyzer.js';
+export * from './catalog/test-catalog.js';
+export * from './ai/ai-analyzer.js';
+export * from './selector/test-selector.js';
+export * from './reporters/terminal-reporter.js';
+export * from './reporters/github-reporter.js';
+export * from './runner/playwright-runner.js';

package/dist/reporters/github-reporter.d.ts

@@ -0,0 +1,5 @@
+import { FinalSelectionResult } from '../config/schema.js';
+export declare class GitHubReporter {
+    static generateMarkdown(result: FinalSelectionResult): string;
+    private static getRiskBadge;
+}

package/dist/reporters/github-reporter.js

@@ -0,0 +1,72 @@
+export class GitHubReporter {
+    static generateMarkdown(result) {
+        const riskBadge = this.getRiskBadge(result.aiAnalysis.riskScore);
+        const changedBadges = result.changedComponents.length > 0
+            ? result.changedComponents.map((c) => `\`${c}\``).join(', ')
+            : '_None identified_';
+        const impactedBadges = result.impactedComponents.length > 0
+            ? result.impactedComponents.map((c) => `\`${c}\``).join(', ')
+            : '_None_';
+        let markdown = `## 🤖 Playwright Smart Regression Selection Report\n\n`;
+        markdown += `**Risk Level:** ${riskBadge}\n\n`;
+        if (result.isFullRegression) {
+            markdown += `> [!WARNING]\n`;
+            markdown += `> **Full Regression Suite Triggered**: ${result.fullRegressionReason || 'Critical configuration or high impact threshold reached.'}\n\n`;
+        }
+        else if (result.isSmokeFallback) {
+            markdown += `> [!NOTE]\n`;
+            markdown += `> **Smoke Safety Net Activated**: ${result.smokeFallbackReason}\n\n`;
+        }
+        markdown += `| Scope | Identified Areas |\n`;
+        markdown += `| :--- | :--- |\n`;
+        markdown += `| **Changed Components** | ${changedBadges} |\n`;
+        markdown += `| **Potentially Impacted Areas** | ${impactedBadges} |\n\n`;
+        markdown += `### 🧠 AI Semantic Rationale\n`;
+        markdown += `- **Direct Impact:** ${result.aiAnalysis.directReason}\n`;
+        if (result.aiAnalysis.rippleEffectReason) {
+            markdown += `- **Ripple Effects:** ${result.aiAnalysis.rippleEffectReason}\n`;
+        }
+        markdown += `\n`;
+        markdown += `### 🧪 Selected Regression Tests (${result.selectedSpecs.length})\n\n`;
+        if (result.selectedSpecs.length === 0) {
+            markdown += `_No tests selected. Changes do not impact any existing test suites._\n\n`;
+        }
+        else {
+            markdown += `| Spec File | Selection Type | Rationale |\n`;
+            markdown += `| :--- | :---: | :--- |\n`;
+            for (const spec of result.selectedSpecs) {
+                const aiRec = result.aiAnalysis.recommendedTests.find((t) => t.specFile.endsWith(spec) || spec.endsWith(t.specFile));
+                const isIndirect = aiRec ? aiRec.isIndirectImpact : false;
+                const typeBadge = isIndirect ? '🟡 Ripple' : '🟢 Direct';
+                const reason = aiRec
+                    ? aiRec.reason
+                    : result.directlyModifiedSpecs?.includes(spec)
+                        ? 'Directly modified spec'
+                        : result.componentRuleSpecs?.includes(spec)
+                            ? 'Component mapping rule'
+                            : result.isSmokeFallback
+                                ? 'Smoke safety net fallback'
+                                : 'Impacted area';
+                markdown += `| \`${spec}\` | ${typeBadge} | ${reason} |\n`;
+            }
+            markdown += `\n`;
+        }
+        markdown += `### ⚡ Playwright Execution Command\n`;
+        markdown += `\`\`\`bash\n${result.playwrightCommand}\n\`\`\`\n\n`;
+        markdown += `---\n*Generated automatically by Smart Regression Selection Agent*`;
+        return markdown;
+    }
+    static getRiskBadge(score) {
+        switch (score) {
+            case 'CRITICAL':
+                return '🔴 **CRITICAL**';
+            case 'HIGH':
+                return '🟠 **HIGH**';
+            case 'MEDIUM':
+                return '🟡 **MEDIUM**';
+            case 'LOW':
+            default:
+                return '🟢 **LOW**';
+        }
+    }
+}

package/dist/reporters/terminal-reporter.d.ts

@@ -0,0 +1,5 @@
+import { FinalSelectionResult } from '../config/schema.js';
+export declare class TerminalReporter {
+    static report(result: FinalSelectionResult): void;
+    private static formatRisk;
+}

package/dist/reporters/terminal-reporter.js

@@ -0,0 +1,69 @@
+import pc from 'picocolors';
+import Table from 'cli-table3';
+export class TerminalReporter {
+    static report(result) {
+        console.log('\n' + pc.bold(pc.cyan('🤖 Smart Regression Selection Agent — Impact Analysis')));
+        console.log(pc.gray('═'.repeat(65)));
+        const riskBadge = this.formatRisk(result.aiAnalysis.riskScore);
+        console.log(`${pc.bold('Risk Score:')} ${riskBadge}`);
+        if (result.isFullRegression) {
+            console.log(pc.yellow(`\n⚠️  FULL REGRESSION TRIGGERED: ${result.fullRegressionReason || 'Safety threshold reached.'}`));
+        }
+        else if (result.isSmokeFallback) {
+            console.log(pc.yellow(`\n⚠️  SMOKE SAFETY NET TRIGGERED: ${result.smokeFallbackReason}`));
+        }
+        console.log(`\n${pc.bold('Changed Components:')} ${result.changedComponents.length > 0
+            ? result.changedComponents.map((c) => pc.magenta(c)).join(', ')
+            : pc.gray('None identified')}`);
+        console.log(`${pc.bold('Potentially Impacted Areas:')} ${result.impactedComponents.length > 0
+            ? result.impactedComponents.map((c) => pc.yellow(c)).join(', ')
+            : pc.gray('None')}`);
+        console.log(`\n${pc.bold('🧠 AI Impact Rationale:')}`);
+        console.log(`  ${pc.white(result.aiAnalysis.directReason)}`);
+        if (result.aiAnalysis.rippleEffectReason) {
+            console.log(`  ${pc.italic(pc.gray(result.aiAnalysis.rippleEffectReason))}`);
+        }
+        console.log(`\n${pc.bold('🧪 Selected Playwright Regression Tests:')}`);
+        const table = new Table({
+            head: [pc.cyan('Spec File'), pc.cyan('Type'), pc.cyan('Reason')],
+            colWidths: [35, 12, 35],
+            wordWrap: true,
+        });
+        if (result.selectedSpecs.length === 0) {
+            table.push([pc.gray('No tests selected'), pc.gray('-'), pc.gray('PR changes do not impact any existing tests')]);
+        }
+        else {
+            for (const spec of result.selectedSpecs) {
+                const aiRec = result.aiAnalysis.recommendedTests.find((t) => t.specFile.endsWith(spec) || spec.endsWith(t.specFile));
+                const isIndirect = aiRec ? aiRec.isIndirectImpact : false;
+                const typeLabel = isIndirect ? pc.yellow('Ripple') : pc.green('Direct');
+                const reason = aiRec
+                    ? aiRec.reason
+                    : result.directlyModifiedSpecs?.includes(spec)
+                        ? 'Directly modified spec'
+                        : result.componentRuleSpecs?.includes(spec)
+                            ? 'Component mapping rule'
+                            : result.isSmokeFallback
+                                ? 'Smoke safety net fallback'
+                                : 'Impacted area';
+                table.push([spec, typeLabel, reason]);
+            }
+        }
+        console.log(table.toString());
+        console.log(`\n${pc.bold('⚡ Playwright Execution Command:')}`);
+        console.log(`  ${pc.green(result.playwrightCommand)}\n`);
+    }
+    static formatRisk(score) {
+        switch (score) {
+            case 'CRITICAL':
+                return pc.bgRed(pc.white(` ${score} `));
+            case 'HIGH':
+                return pc.red(pc.bold(score));
+            case 'MEDIUM':
+                return pc.yellow(pc.bold(score));
+            case 'LOW':
+            default:
+                return pc.green(pc.bold(score));
+        }
+    }
+}