playwright-smart-test 0.0.0-stage → 1.0.1

package/dist/runner/playwright-runner.js

@@ -0,0 +1,25 @@
+import { spawn } from 'node:child_process';
+import pc from 'picocolors';
+export class PlaywrightRunner {
+    static async execute(command, cwd = process.cwd()) {
+        console.log(pc.bold(pc.cyan(`\n🚀 Executing Playwright Regression Suite...`)));
+        console.log(pc.gray(`$ ${command}\n`));
+        return new Promise((resolve) => {
+            const parts = command.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+            const executable = parts[0] || 'npx';
+            const args = parts.slice(1).map((a) => a.replace(/^"|"$/g, ''));
+            const child = spawn(executable, args, {
+                cwd,
+                stdio: 'inherit',
+                shell: true,
+            });
+            child.on('close', (code) => {
+                resolve(code ?? 0);
+            });
+            child.on('error', (err) => {
+                console.error(pc.red(`Failed to start Playwright runner: ${err.message}`));
+                resolve(1);
+            });
+        });
+    }
+}

package/dist/selector/test-selector.d.ts

@@ -0,0 +1,18 @@
+import { DiffFile, FinalSelectionResult, SmartRegressionConfig, SpecCatalogEntry } from '../config/schema.js';
+export declare class TestSelector {
+    private config;
+    private cwd;
+    private aiAnalyzer;
+    constructor(config: SmartRegressionConfig, cwd?: string);
+    selectTests(changedFiles: DiffFile[], catalog: SpecCatalogEntry[]): Promise<FinalSelectionResult>;
+    private isDocsAndAssetsOnly;
+    private checkCustomFullRunPatterns;
+    private hasApplicationCodeChanged;
+    private checkDomainScatter;
+    private findDirectlyModifiedSpecs;
+    private findComponentRuleSpecs;
+    private findSmokeTests;
+    private normalizeAndFilterSpecs;
+    private simpleGlobMatch;
+    private buildPlaywrightCommand;
+}

package/dist/selector/test-selector.js

@@ -0,0 +1,303 @@
+import path from 'node:path';
+import { AISemanticAnalyzer } from '../ai/ai-analyzer.js';
+export class TestSelector {
+    config;
+    cwd;
+    aiAnalyzer;
+    constructor(config, cwd = process.cwd()) {
+        this.config = config;
+        this.cwd = cwd;
+        this.aiAnalyzer = new AISemanticAnalyzer(config);
+    }
+    async selectTests(changedFiles, catalog) {
+        const allKnownSpecs = catalog.map((c) => c.filePath.replace(/\\/g, '/'));
+        const deletedPaths = new Set(changedFiles.filter((f) => f.status === 'deleted').map((f) => f.path.replace(/\\/g, '/')));
+        // Guardrail 1: Docs & Asset Fast-Path
+        if (this.isDocsAndAssetsOnly(changedFiles)) {
+            return {
+                isFullRegression: false,
+                fullRegressionReason: undefined,
+                changedFiles,
+                changedComponents: [],
+                impactedComponents: [],
+                aiAnalysis: {
+                    changedComponents: [],
+                    impactedComponents: [],
+                    directReason: 'Only documentation, assets, or markdown files modified.',
+                    rippleEffectReason: 'No regression test execution required.',
+                    riskScore: 'LOW',
+                    requiresFullRegression: false,
+                    confidenceScore: 'HIGH',
+                    recommendedTests: [],
+                },
+                selectedSpecs: [],
+                directlyModifiedSpecs: [],
+                componentRuleSpecs: [],
+                aiRecommendedSpecs: [],
+                playwrightCommand: 'npx playwright test',
+            };
+        }
+        // Guardrail: Configured Full Run Patterns (if user explicitly provided any)
+        const customPatternTrigger = this.checkCustomFullRunPatterns(changedFiles);
+        if (customPatternTrigger) {
+            const aiAnalysis = await this.aiAnalyzer.analyzeImpact(changedFiles, catalog);
+            return {
+                isFullRegression: true,
+                fullRegressionReason: customPatternTrigger,
+                changedFiles,
+                changedComponents: aiAnalysis.changedComponents,
+                impactedComponents: aiAnalysis.impactedComponents,
+                aiAnalysis,
+                selectedSpecs: allKnownSpecs,
+                directlyModifiedSpecs: [],
+                componentRuleSpecs: [],
+                aiRecommendedSpecs: allKnownSpecs,
+                playwrightCommand: 'npx playwright test',
+            };
+        }
+        // Guardrail 2: Domain Scatter Guard (Arch blast radius)
+        const scatterCheck = this.checkDomainScatter(changedFiles);
+        if (scatterCheck) {
+            const aiAnalysis = await this.aiAnalyzer.analyzeImpact(changedFiles, catalog);
+            return {
+                isFullRegression: true,
+                fullRegressionReason: scatterCheck,
+                changedFiles,
+                changedComponents: aiAnalysis.changedComponents,
+                impactedComponents: aiAnalysis.impactedComponents,
+                aiAnalysis,
+                selectedSpecs: allKnownSpecs,
+                directlyModifiedSpecs: [],
+                componentRuleSpecs: [],
+                aiRecommendedSpecs: allKnownSpecs,
+                playwrightCommand: 'npx playwright test',
+            };
+        }
+        // Guardrail 3: Directly Modified Test Specs Invariant
+        const directlyModifiedSpecs = this.findDirectlyModifiedSpecs(changedFiles, allKnownSpecs);
+        // Guardrail 4: Component Configuration Rules Match
+        const componentRuleSpecs = this.findComponentRuleSpecs(changedFiles, catalog);
+        // The AI Brain: Semantic Ripple & Impact Analysis
+        let aiAnalysis = await this.aiAnalyzer.analyzeImpact(changedFiles, catalog);
+        // Guardrail 5: AI Safe Fallback on Uncertainty or Global Infrastructure Flag
+        let isFullRegression = false;
+        let fullRegressionReason;
+        if (aiAnalysis.requiresFullRegression || aiAnalysis.confidenceScore === 'LOW') {
+            isFullRegression = true;
+            fullRegressionReason = `AI indicated global impact or uncertain blast radius: ${aiAnalysis.directReason}`;
+        }
+        // Guardrail 6: Catalog Whitelist & Deleted File Purge
+        const rawAiSpecs = aiAnalysis.recommendedTests.map((t) => t.specFile.replace(/\\/g, '/'));
+        const validatedAiSpecs = this.normalizeAndFilterSpecs(rawAiSpecs, allKnownSpecs, deletedPaths);
+        // Combine candidate specs
+        const combinedSpecs = Array.from(new Set([
+            ...directlyModifiedSpecs.filter((s) => !deletedPaths.has(s)),
+            ...componentRuleSpecs.filter((s) => !deletedPaths.has(s)),
+            ...validatedAiSpecs,
+        ]));
+        // Guardrail 7: Impact Threshold Ratio
+        const totalSpecsCount = allKnownSpecs.length;
+        const impactRatio = totalSpecsCount > 0 ? combinedSpecs.length / totalSpecsCount : 0;
+        const maxRatio = this.config.safetyRules?.maxImpactRatioForFullRun ?? 0.7;
+        if (!isFullRegression && totalSpecsCount >= 4 && impactRatio >= maxRatio) {
+            isFullRegression = true;
+            fullRegressionReason = `Impacted specs (${combinedSpecs.length}/${totalSpecsCount}, ${(impactRatio * 100).toFixed(0)}%) exceed threshold of ${(maxRatio * 100).toFixed(0)}%. Full regression triggered for safety.`;
+        }
+        // Guardrail 8: Zero-Test Smoke Safety Net
+        let isSmokeFallback = false;
+        let smokeFallbackReason;
+        let finalSelectedSpecs = isFullRegression ? allKnownSpecs : combinedSpecs;
+        if (!isFullRegression && finalSelectedSpecs.length === 0 && this.hasApplicationCodeChanged(changedFiles)) {
+            const smokeSpecs = this.findSmokeTests(catalog);
+            if (smokeSpecs.length > 0) {
+                finalSelectedSpecs = smokeSpecs;
+                isSmokeFallback = true;
+                smokeFallbackReason = 'Application code was modified but no specific test was selected. Executing smoke test suite as safety baseline.';
+            }
+        }
+        const playwrightCommand = this.buildPlaywrightCommand(finalSelectedSpecs, isFullRegression);
+        return {
+            isFullRegression,
+            fullRegressionReason,
+            isSmokeFallback,
+            smokeFallbackReason,
+            changedFiles,
+            changedComponents: aiAnalysis.changedComponents,
+            impactedComponents: aiAnalysis.impactedComponents,
+            aiAnalysis,
+            selectedSpecs: finalSelectedSpecs,
+            directlyModifiedSpecs,
+            componentRuleSpecs,
+            aiRecommendedSpecs: validatedAiSpecs,
+            playwrightCommand,
+        };
+    }
+    isDocsAndAssetsOnly(changedFiles) {
+        if (changedFiles.length === 0)
+            return true;
+        const docsPatterns = this.config.safetyRules?.docsOnlyPatterns || [
+            '**/*.md',
+            'docs/**',
+            'LICENSE',
+            '**/.gitignore',
+            '**/assets/**',
+            '**/*.png',
+            '**/*.jpg',
+            '**/*.svg',
+        ];
+        return changedFiles.every((file) => {
+            const p = file.path.replace(/\\/g, '/');
+            const base = path.basename(p);
+            return docsPatterns.some((pattern) => this.simpleGlobMatch(p, pattern) || this.simpleGlobMatch(base, pattern));
+        });
+    }
+    checkCustomFullRunPatterns(changedFiles) {
+        const patterns = this.config.safetyRules?.fullRunPatterns || [];
+        if (patterns.length === 0)
+            return null;
+        for (const file of changedFiles) {
+            const p = file.path.replace(/\\/g, '/');
+            const fileName = path.basename(p);
+            for (const pattern of patterns) {
+                if (this.simpleGlobMatch(p, pattern) || this.simpleGlobMatch(fileName, pattern)) {
+                    return `Critical configuration file modified: '${file.path}'. Full test suite required.`;
+                }
+            }
+        }
+        return null;
+    }
+    hasApplicationCodeChanged(changedFiles) {
+        return changedFiles.some((f) => {
+            const p = f.path.replace(/\\/g, '/');
+            if (p.startsWith('tests/') || p.startsWith('docs/'))
+                return false;
+            return (p.endsWith('.ts') ||
+                p.endsWith('.tsx') ||
+                p.endsWith('.js') ||
+                p.endsWith('.jsx') ||
+                p.endsWith('.vue') ||
+                p.endsWith('.html') ||
+                p.endsWith('.json'));
+        });
+    }
+    checkDomainScatter(changedFiles) {
+        const maxDomains = this.config.safetyRules?.maxChangedDomainsForFullRun ?? 8;
+        const domains = new Set();
+        for (const file of changedFiles) {
+            const normalized = file.path.replace(/\\/g, '/');
+            const parts = normalized.split('/').filter(Boolean);
+            if (parts.length >= 2) {
+                domains.add(`${parts[0]}/${parts[1]}`);
+            }
+            else if (parts.length === 1) {
+                domains.add(parts[0]);
+            }
+        }
+        if (domains.size > maxDomains) {
+            return `Changes scattered across ${domains.size} architectural domains (exceeds threshold of ${maxDomains}). Full regression triggered for safety.`;
+        }
+        return null;
+    }
+    findDirectlyModifiedSpecs(changedFiles, allKnownSpecs) {
+        const knownSet = new Set(allKnownSpecs);
+        const result = [];
+        for (const file of changedFiles) {
+            if (file.status === 'deleted')
+                continue;
+            const normalized = file.path.replace(/\\/g, '/');
+            if ((normalized.endsWith('.spec.ts') || normalized.endsWith('.test.ts')) &&
+                (knownSet.has(normalized) || allKnownSpecs.some((k) => k.endsWith(path.basename(normalized))))) {
+                const match = knownSet.has(normalized)
+                    ? normalized
+                    : allKnownSpecs.find((k) => k.endsWith(path.basename(normalized)));
+                if (!result.includes(match)) {
+                    result.push(match);
+                }
+            }
+        }
+        return result;
+    }
+    findComponentRuleSpecs(changedFiles, catalog) {
+        const components = this.config.components || [];
+        if (components.length === 0)
+            return [];
+        const matchedComponents = new Set();
+        for (const file of changedFiles) {
+            const p = file.path.replace(/\\/g, '/');
+            for (const comp of components) {
+                for (const pattern of comp.patterns) {
+                    if (this.simpleGlobMatch(p, pattern)) {
+                        matchedComponents.add(comp.name);
+                    }
+                }
+            }
+        }
+        const matchedSpecs = [];
+        for (const compName of Array.from(matchedComponents)) {
+            for (const spec of catalog) {
+                const p = spec.filePath.replace(/\\/g, '/').toLowerCase();
+                if (p.includes(compName.toLowerCase()) || spec.tags.some((t) => t.toLowerCase().includes(compName.toLowerCase()))) {
+                    if (!matchedSpecs.includes(spec.filePath)) {
+                        matchedSpecs.push(spec.filePath);
+                    }
+                }
+            }
+        }
+        return matchedSpecs;
+    }
+    findSmokeTests(catalog) {
+        const smokeTag = (this.config.safetyRules?.smokeTag || '@smoke').toLowerCase();
+        const smokePattern = this.config.safetyRules?.smokeSpecPattern || '**/*smoke*.spec.ts';
+        const smokeSpecs = [];
+        for (const spec of catalog) {
+            const p = spec.filePath.replace(/\\/g, '/');
+            const hasSmokeTag = spec.tags.some((t) => t.toLowerCase() === smokeTag);
+            const matchesPattern = this.simpleGlobMatch(p, smokePattern);
+            if (hasSmokeTag || matchesPattern) {
+                smokeSpecs.push(p);
+            }
+        }
+        return smokeSpecs;
+    }
+    normalizeAndFilterSpecs(candidateSpecs, knownSpecs, deletedPaths) {
+        const knownSet = new Set(knownSpecs.map((s) => s.replace(/\\/g, '/')));
+        const selected = [];
+        for (const spec of candidateSpecs) {
+            const norm = spec.replace(/\\/g, '/');
+            if (deletedPaths.has(norm))
+                continue;
+            if (knownSet.has(norm)) {
+                selected.push(norm);
+                continue;
+            }
+            const base = path.basename(norm);
+            const match = knownSpecs.find((k) => k.endsWith(base));
+            if (match && !deletedPaths.has(match) && !selected.includes(match)) {
+                selected.push(match);
+            }
+        }
+        return selected;
+    }
+    simpleGlobMatch(str, pattern) {
+        let p = pattern;
+        if (p.startsWith('**/')) {
+            p = '(?:.+/)?' + p.slice(3);
+        }
+        if (p.endsWith('/**')) {
+            p = p.slice(0, -3) + '(?:/.*)?';
+        }
+        const regexStr = p
+            .replace(/\./g, '\\.')
+            .replace(/\*\*/g, '§§')
+            .replace(/\*/g, '[^/]*')
+            .replace(/§§/g, '.*');
+        return new RegExp(`^${regexStr}$`, 'i').test(str);
+    }
+    buildPlaywrightCommand(selectedSpecs, isFull) {
+        if (isFull || selectedSpecs.length === 0) {
+            return 'npx playwright test';
+        }
+        const filesArgs = selectedSpecs.map((s) => `"${s}"`).join(' ');
+        return `npx playwright test ${filesArgs}`;
+    }
+}

package/node_modules/@colors/colors/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Original Library
+  - Copyright (c) Marak Squires
+
+Additional Functionality
+ - Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+ - Copyright (c) DABH (https://github.com/DABH)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/@colors/colors/README.md

@@ -0,0 +1,219 @@
+# @colors/colors ("colors.js")
+[![Build Status](https://github.com/DABH/colors.js/actions/workflows/ci.yml/badge.svg)](https://github.com/DABH/colors.js/actions/workflows/ci.yml)
+[![version](https://img.shields.io/npm/v/@colors/colors.svg)](https://www.npmjs.org/package/@colors/colors)
+
+Please check out the [roadmap](ROADMAP.md) for upcoming features and releases.  Please open Issues to provide feedback.
+
+## get color and style in your node.js console
+
+![Demo](https://raw.githubusercontent.com/DABH/colors.js/master/screenshots/colors.png)
+
+## Installation
+
+    npm install @colors/colors
+
+## colors and styles!
+
+### text colors
+
+  - black
+  - red
+  - green
+  - yellow
+  - blue
+  - magenta
+  - cyan
+  - white
+  - gray
+  - grey
+
+### bright text colors
+
+  - brightRed
+  - brightGreen
+  - brightYellow
+  - brightBlue
+  - brightMagenta
+  - brightCyan
+  - brightWhite
+
+### background colors
+
+  - bgBlack
+  - bgRed
+  - bgGreen
+  - bgYellow
+  - bgBlue
+  - bgMagenta
+  - bgCyan
+  - bgWhite
+  - bgGray
+  - bgGrey
+
+### bright background colors
+
+  - bgBrightRed
+  - bgBrightGreen
+  - bgBrightYellow
+  - bgBrightBlue
+  - bgBrightMagenta
+  - bgBrightCyan
+  - bgBrightWhite
+
+### styles
+
+  - reset
+  - bold
+  - dim
+  - italic
+  - underline
+  - inverse
+  - hidden
+  - strikethrough
+
+### extras
+
+  - rainbow
+  - zebra
+  - america
+  - trap
+  - random
+
+
+## Usage
+
+By popular demand, `@colors/colors` now ships with two types of usages!
+
+The super nifty way
+
+```js
+var colors = require('@colors/colors');
+
+console.log('hello'.green); // outputs green text
+console.log('i like cake and pies'.underline.red); // outputs red underlined text
+console.log('inverse the color'.inverse); // inverses the color
+console.log('OMG Rainbows!'.rainbow); // rainbow
+console.log('Run the trap'.trap); // Drops the bass
+
+```
+
+or a slightly less nifty way which doesn't extend `String.prototype`
+
+```js
+var colors = require('@colors/colors/safe');
+
+console.log(colors.green('hello')); // outputs green text
+console.log(colors.red.underline('i like cake and pies')); // outputs red underlined text
+console.log(colors.inverse('inverse the color')); // inverses the color
+console.log(colors.rainbow('OMG Rainbows!')); // rainbow
+console.log(colors.trap('Run the trap')); // Drops the bass
+
+```
+
+I prefer the first way. Some people seem to be afraid of extending `String.prototype` and prefer the second way. 
+
+If you are writing good code you will never have an issue with the first approach. If you really don't want to touch `String.prototype`, the second usage will not touch `String` native object.
+
+## Enabling/Disabling Colors
+
+The package will auto-detect whether your terminal can use colors and enable/disable accordingly. When colors are disabled, the color functions do nothing. You can override this with a command-line flag:
+
+```bash
+node myapp.js --no-color
+node myapp.js --color=false
+
+node myapp.js --color
+node myapp.js --color=true
+node myapp.js --color=always
+
+FORCE_COLOR=1 node myapp.js
+```
+
+Or in code:
+
+```javascript
+var colors = require('@colors/colors');
+colors.enable();
+colors.disable();
+```
+
+## Console.log [string substitution](http://nodejs.org/docs/latest/api/console.html#console_console_log_data)
+
+```js
+var name = 'Beowulf';
+console.log(colors.green('Hello %s'), name);
+// outputs -> 'Hello Beowulf'
+```
+
+## Custom themes
+
+### Using standard API
+
+```js
+
+var colors = require('@colors/colors');
+
+colors.setTheme({
+  silly: 'rainbow',
+  input: 'grey',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red'
+});
+
+// outputs red text
+console.log("this is an error".error);
+
+// outputs yellow text
+console.log("this is a warning".warn);
+```
+
+### Using string safe API
+
+```js
+var colors = require('@colors/colors/safe');
+
+// set single property
+var error = colors.red;
+error('this is red');
+
+// set theme
+colors.setTheme({
+  silly: 'rainbow',
+  input: 'grey',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red'
+});
+
+// outputs red text
+console.log(colors.error("this is an error"));
+
+// outputs yellow text
+console.log(colors.warn("this is a warning"));
+
+```
+
+### Combining Colors
+
+```javascript
+var colors = require('@colors/colors');
+
+colors.setTheme({
+  custom: ['red', 'underline']
+});
+
+console.log('test'.custom);
+```
+
+*Protip: There is a secret undocumented style in `colors`. If you find the style you can summon him.*

package/node_modules/@colors/colors/examples/normal-usage.js

@@ -0,0 +1,83 @@
+var colors = require('../lib/index');
+
+console.log('First some yellow text'.yellow);
+
+console.log('Underline that text'.yellow.underline);
+
+console.log('Make it bold and red'.red.bold);
+
+console.log(('Double Raindows All Day Long').rainbow);
+
+console.log('Drop the bass'.trap);
+
+console.log('DROP THE RAINBOW BASS'.trap.rainbow);
+
+// styles not widely supported
+console.log('Chains are also cool.'.bold.italic.underline.red);
+
+// styles not widely supported
+console.log('So '.green + 'are'.underline + ' ' + 'inverse'.inverse
+  + ' styles! '.yellow.bold);
+console.log('Zebras are so fun!'.zebra);
+
+//
+// Remark: .strikethrough may not work with Mac OS Terminal App
+//
+console.log('This is ' + 'not'.strikethrough + ' fun.');
+
+console.log('Background color attack!'.black.bgWhite);
+console.log('Use random styles on everything!'.random);
+console.log('America, Heck Yeah!'.america);
+
+// eslint-disable-next-line max-len
+console.log('Blindingly '.brightCyan + 'bright? '.brightRed + 'Why '.brightYellow + 'not?!'.brightGreen);
+
+console.log('Setting themes is useful');
+
+//
+// Custom themes
+//
+console.log('Generic logging theme as JSON'.green.bold.underline);
+// Load theme with JSON literal
+colors.setTheme({
+  silly: 'rainbow',
+  input: 'grey',
+  verbose: 'cyan',
+  prompt: 'grey',
+  info: 'green',
+  data: 'grey',
+  help: 'cyan',
+  warn: 'yellow',
+  debug: 'blue',
+  error: 'red',
+});
+
+// outputs red text
+console.log('this is an error'.error);
+
+// outputs yellow text
+console.log('this is a warning'.warn);
+
+// outputs grey text
+console.log('this is an input'.input);
+
+console.log('Generic logging theme as file'.green.bold.underline);
+
+// Load a theme from file
+try {
+  colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));
+} catch (err) {
+  console.log(err);
+}
+
+// outputs red text
+console.log('this is an error'.error);
+
+// outputs yellow text
+console.log('this is a warning'.warn);
+
+// outputs grey text
+console.log('this is an input'.input);
+
+// console.log("Don't summon".zalgo)
+