experiment-e2e-generator 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-02-02
+
+### Added
+- Initial release of @sogody/experiment-e2e-generator
+- Interactive CLI for generating Playwright E2E test infrastructure
+- Complete template system with placeholder replacement
+- Auto-detection of experiment names from project structure
+- Safe package.json updating (preserves existing configuration)
+- Generated test structure includes:
+  - `playwright.config.js` - Multi-browser configuration
+  - `tests/config/` - Experiment and URL configuration files
+  - `tests/e2e/` - Sample test suites for control and experiment
+  - `tests/fixtures/` - Custom Playwright fixtures
+  - `tests/utils/` - Reusable helper functions
+- Pre-flight validation checks
+- Warning system for existing test directories
+- Comprehensive documentation and examples
+- Support for environment variables (CONTROL_URL, EXPERIMENT_URL, etc.)
+- Adobe Target preview token integration
+- Organized folder structure following best practices
+
+### Template Variables
+- `{{EXPERIMENT_NAME}}` - Original experiment name
+- `{{EXPERIMENT_NAME_KEBAB}}` - Kebab-case formatted name
+- `{{BASE_URL}}` - Base URL for tests
+- `{{MARKET}}` - Market code (uppercase)
+
+### Dependencies
+- chalk ^5.6.2 - Terminal styling
+- fs-extra ^11.3.3 - File system utilities
+- prompts ^2.4.2 - Interactive CLI prompts
+
+### Requirements
+- Node.js >= 16.15.1
+- Existing package.json in project root
+
+[1.0.0]: https://github.com/sogody/experiment-e2e-generator/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aldi
+
+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/README.md

@@ -0,0 +1,382 @@
+# @sogody/experiment-e2e-generator
+
+A CLI tool to scaffold Playwright E2E testing infrastructure for Experiment Framework projects. Generate a complete test setup with configuration, fixtures, utilities, and sample tests in seconds.
+
+## Features
+
+- 🎭 **Complete Playwright Setup** - Generates all necessary configuration and structure
+- 📁 **Organized Structure** - Tests, configs, fixtures, and utilities properly organized
+- 🔧 **Smart Configuration** - Auto-detects project settings and experiment names
+- ✨ **Template System** - Customizable templates with placeholder replacement
+- 📦 **Safe Updates** - Merges dependencies without overwriting existing `package.json`
+- 🎯 **Best Practices** - Follows Playwright and A/B testing best practices
+
+## Installation & Usage
+
+No installation required! Use `npx` to run directly:
+
+```bash
+npx @sogody/experiment-e2e-generator
+```
+
+### Requirements
+
+- Node.js >= 16.15.1
+- Existing `package.json` in project root
+- Project must be an Experiment Framework project
+
+## What It Generates
+
+Running the generator creates the following structure:
+
+```
+your-project/
+├── playwright.config.js          # Playwright configuration
+├── tests/
+│   ├── config/
+│   │   ├── index.js             # Central config export
+│   │   ├── experiment.config.js # Experiment-specific settings
+│   │   └── qa-links.config.js   # Test URLs (control & experiment)
+│   ├── e2e/
+│   │   └── your-experiment/
+│   │       └── your-experiment.spec.js  # Sample test suite
+│   ├── fixtures/
+│   │   └── test-fixtures.js     # Custom test fixtures
+│   └── utils/
+│       └── test-helpers.js      # Reusable helper functions
+└── package.json                 # Updated with Playwright dependencies
+```
+
+## Interactive Setup
+
+The generator will prompt you for:
+
+1. **Experiment Name** - Your experiment's name (auto-detected if possible)
+2. **Base URL** - The base URL for tests (e.g., `https://www.samsung.com`)
+3. **Market Code** - Primary market (e.g., `NL`, `BE`, `US`)
+
+### Example Session
+
+```bash
+$ npx @sogody/experiment-e2e-generator
+
+🎭 Experiment E2E Test Generator
+
+Running pre-flight checks...
+
+Please provide the following information:
+
+? What is your experiment name? › My Awesome Experiment
+? Base URL for tests › https://www.samsung.com
+? Primary market code › NL
+
+📁 Generating test files...
+
+  ✓ playwright.config.js
+  ✓ tests/config/index.js
+  ✓ tests/config/experiment.config.js
+  ✓ tests/config/qa-links.config.js
+  ✓ tests/fixtures/test-fixtures.js
+  ✓ tests/utils/test-helpers.js
+  ✓ tests/e2e/my-awesome-experiment/my-awesome-experiment.spec.js
+
+📦 Updating package.json...
+
+  ✓ Added Playwright dependencies to devDependencies
+  ✓ Added "test:e2e" script
+
+✓ Test structure generated successfully!
+```
+
+## After Generation
+
+### 1. Install Dependencies
+
+```bash
+yarn install
+```
+
+Or with npm:
+
+```bash
+npm install
+```
+
+### 2. Configure Test URLs
+
+Update the URLs in `tests/config/qa-links.config.js`:
+
+```javascript
+export const qaLinksConfig = {
+  controlUrl: process.env.CONTROL_URL || 'https://www.samsung.com/nl/control-page/',
+  experimentUrl: process.env.EXPERIMENT_URL || 'https://www.samsung.com/nl/experiment-page/',
+};
+```
+
+You can set these via environment variables or update them directly in the file.
+
+### 3. Customize Test Selectors
+
+Edit your test file at `tests/e2e/your-experiment/your-experiment.spec.js`:
+
+```javascript
+// Update selectors to match your experiment component
+const experimentComponent = page.locator('[data-experiment="your-experiment"]');
+```
+
+### 4. Run Tests
+
+```bash
+# Run all tests
+yarn test:e2e
+
+# Run in headed mode
+yarn playwright test --headed
+
+# Run specific test file
+yarn playwright test tests/e2e/your-experiment
+
+# Run with UI mode
+yarn playwright test --ui
+```
+
+## Generated Files Overview
+
+### `playwright.config.js`
+
+Main Playwright configuration with:
+- Multi-browser support (Chromium, Firefox, WebKit)
+- HTML reporter
+- Screenshot and trace on failure
+- Optimized for CI/CD
+
+### `tests/config/experiment.config.js`
+
+Experiment-specific settings:
+- Experiment name and market
+- Timeout configurations
+- Environment variables
+- Adobe Target integration (if needed)
+
+### `tests/config/qa-links.config.js`
+
+Test URL management:
+- Control and experiment URLs
+- URL validation
+- Environment variable support
+
+### `tests/e2e/your-experiment/your-experiment.spec.js`
+
+Sample test suite with:
+- **Control tests** - Verify experiment doesn't appear
+- **Experiment tests** - Verify experiment appears and functions
+- Proper test structure following best practices
+
+### `tests/fixtures/test-fixtures.js`
+
+Custom Playwright fixtures:
+- Experiment context with utilities
+- Adobe Target preview support
+- URL building helpers
+
+### `tests/utils/test-helpers.js`
+
+Reusable helper functions:
+- Network idle waiting
+- Element stability checks
+- Viewport utilities
+- Screenshot helpers
+- Retry with backoff
+
+## Testing Strategy
+
+The generated tests follow A/B testing best practices:
+
+### Control Group Tests
+Verify that the experiment component **does not appear** in the control variant:
+
+```javascript
+test.describe('Your Experiment - Control', () => {
+  test('should not display experiment component', async ({ page }) => {
+    await page.goto(qaLinksConfig.controlUrl);
+    await expect(experimentComponent).not.toBeVisible();
+  });
+});
+```
+
+### Experiment Group Tests
+Verify that the experiment component **appears and functions correctly**:
+
+```javascript
+test.describe('Your Experiment - Experiment', () => {
+  test('should display experiment component', async ({ page }) => {
+    await page.goto(qaLinksConfig.experimentUrl);
+    await expect(experimentComponent).toBeVisible();
+  });
+  
+  test('should handle user interactions correctly', async ({ page }) => {
+    await page.goto(qaLinksConfig.experimentUrl);
+    // Test interactions...
+  });
+});
+```
+
+## Environment Variables
+
+You can use environment variables for dynamic configuration:
+
+```bash
+# Set test URLs
+export CONTROL_URL=https://www.samsung.com/nl/control
+export EXPERIMENT_URL=https://www.samsung.com/nl/experiment
+
+# Set Adobe Target preview token (if applicable)
+export ADOBE_PREVIEW_TOKEN=your-token-here
+
+# Set test environment
+export TEST_ENV=qa
+
+# Run tests
+yarn test:e2e
+```
+
+## Best Practices
+
+### Locator Strategy
+
+The generated tests follow Playwright's recommended locator hierarchy:
+
+1. **getByRole** - Preferred for accessibility
+2. **getByText** - For visible text content
+3. **getByLabel** - For form fields
+4. **data attributes** - Only when necessary
+
+### Test Structure
+
+- Use `test.describe` blocks for logical grouping
+- Keep tests independent and isolated
+- Use `test.beforeEach` for common setup
+- Avoid sharing state between tests
+
+### Assertions
+
+- Use web-first assertions that auto-wait
+- Prefer `toBeVisible()` over checking element existence
+- Use `toHaveText()` instead of `textContent()`
+
+## Troubleshooting
+
+### Tests directory already exists
+
+If you see a warning about existing tests, the generator will ask for confirmation before overwriting. Make sure to back up any important test files first.
+
+### Package.json not found
+
+The generator must be run from your project root where `package.json` exists. Navigate to your project directory first:
+
+```bash
+cd your-project
+npx @sogody/experiment-e2e-generator
+```
+
+### Playwright installation fails
+
+If Playwright installation fails, try manually installing:
+
+```bash
+yarn add -D @playwright/test playwright
+yarn playwright install
+```
+
+## Advanced Usage
+
+### Custom Test URLs per Environment
+
+Use a `.env` file (add it to `.gitignore`):
+
+```env
+# .env
+TEST_ENV=staging
+CONTROL_URL=https://staging.samsung.com/nl/control
+EXPERIMENT_URL=https://staging.samsung.com/nl/experiment
+```
+
+Then use a package like `dotenv`:
+
+```bash
+yarn add -D dotenv
+```
+
+### Running Tests in CI/CD
+
+The generated `playwright.config.js` is CI-ready with:
+- Automatic retry on failure
+- Single worker for stability
+- Built-in reporters
+
+Example GitHub Actions workflow:
+
+```yaml
+name: E2E Tests
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - run: yarn install --frozen-lockfile
+      - run: yarn playwright install --with-deps
+      - run: yarn test:e2e
+        env:
+          CONTROL_URL: ${{ secrets.CONTROL_URL }}
+          EXPERIMENT_URL: ${{ secrets.EXPERIMENT_URL }}
+```
+
+## Package.json Updates
+
+The generator safely updates your `package.json`:
+
+### Added Dependencies
+
+```json
+{
+  "devDependencies": {
+    "@playwright/test": "^1.40.0",
+    "playwright": "^1.40.0"
+  }
+}
+```
+
+### Added Scripts
+
+```json
+{
+  "scripts": {
+    "test:e2e": "playwright test"
+  }
+}
+```
+
+Existing dependencies and scripts are preserved.
+
+## Documentation & Resources
+
+- [Playwright Documentation](https://playwright.dev/docs/intro)
+- [Playwright Best Practices](https://playwright.dev/docs/best-practices)
+- [Playwright API Reference](https://playwright.dev/docs/api/class-playwright)
+- [Samsung Design System](https://design.samsung.com/)
+
+## Support & Contributing
+
+For issues, questions, or contributions, please contact the Sogody team.
+
+## License
+
+MIT
+
+---
+
+**Made with ❤️ by Sogody**

package/bin/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { generator } from '../src/generator.js';
+
+// Run the generator
+generator().catch((error) => {
+	console.error('Unexpected error:', error);
+	process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "experiment-e2e-generator",
+    "version": "1.0.0",
+    "description": "CLI tool to generate Playwright e2e tests for Experiment Framework projects",
+    "type": "module",
+    "bin": {
+        "experiment-e2e-generator": "./bin/cli.js"
+    },
+    "files": [
+        "bin",
+        "templates",
+        "src"
+    ],
+    "keywords": [
+        "playwright",
+        "e2e",
+        "testing",
+        "experiment-framework",
+        "generator"
+    ],
+    "author": "Aldisogody",
+    "license": "MIT",
+    "engines": {
+        "node": ">=v16.15.1"
+    },
+    "dependencies": {
+        "chalk": "^5.6.2",
+        "fs-extra": "^11.3.3",
+        "prompts": "^2.4.2"
+    }
+}

package/src/file-operations.js

@@ -0,0 +1,91 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+import { copyTemplateFile, ensureDir, toKebabCase } from './utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMPLATES_DIR = path.join(__dirname, '..', 'templates');
+
+/**
+ * Generate all test files from templates
+ * @param {string} targetDir - Target project directory
+ * @param {Object} config - Configuration object with user inputs
+ */
+export async function generateTestFiles(targetDir, config) {
+	const { experimentName, baseUrl, market } = config;
+	const experimentNameKebab = toKebabCase(experimentName);
+	
+	// Template variables
+	const variables = {
+		EXPERIMENT_NAME: experimentName,
+		EXPERIMENT_NAME_KEBAB: experimentNameKebab,
+		BASE_URL: baseUrl,
+		MARKET: market.toUpperCase(),
+	};
+	
+	// Define file mappings: [source, destination]
+	const fileMappings = [
+		// Root level playwright config
+		['playwright.config.js', 'playwright.config.js'],
+		
+		// Config files
+		['tests/config/index.js', 'tests/config/index.js'],
+		['tests/config/experiment.config.js', 'tests/config/experiment.config.js'],
+		['tests/config/qa-links.config.js', 'tests/config/qa-links.config.js'],
+		
+		// Fixtures
+		['tests/fixtures/test-fixtures.js', 'tests/fixtures/test-fixtures.js'],
+		
+		// Utils
+		['tests/utils/test-helpers.js', 'tests/utils/test-helpers.js'],
+		
+		// Test spec (with dynamic folder name)
+		[
+			'tests/e2e/experiment-name/experiment.spec.js',
+			`tests/e2e/${experimentNameKebab}/${experimentNameKebab}.spec.js`,
+		],
+	];
+	
+	// Copy and process each template file
+	for (const [source, dest] of fileMappings) {
+		const sourcePath = path.join(TEMPLATES_DIR, source);
+		const destPath = path.join(targetDir, dest);
+		
+		await copyTemplateFile(sourcePath, destPath, variables);
+	}
+	
+	return {
+		testsDir: path.join(targetDir, 'tests'),
+		experimentDir: path.join(targetDir, 'tests', 'e2e', experimentNameKebab),
+	};
+}
+
+/**
+ * Check if tests directory already exists
+ * @param {string} targetDir - Target project directory
+ * @returns {Promise<boolean>}
+ */
+export async function testsDirectoryExists(targetDir) {
+	const testsPath = path.join(targetDir, 'tests');
+	return await fs.pathExists(testsPath);
+}
+
+/**
+ * Get list of generated files for display
+ * @param {string} experimentName - Experiment name
+ * @returns {Array<string>} - List of file paths
+ */
+export function getGeneratedFilesList(experimentName) {
+	const experimentNameKebab = toKebabCase(experimentName);
+	
+	return [
+		'playwright.config.js',
+		'tests/config/index.js',
+		'tests/config/experiment.config.js',
+		'tests/config/qa-links.config.js',
+		'tests/fixtures/test-fixtures.js',
+		'tests/utils/test-helpers.js',
+		`tests/e2e/${experimentNameKebab}/${experimentNameKebab}.spec.js`,
+	];
+}

package/src/generator.js

@@ -0,0 +1,99 @@
+import path from 'path';
+import chalk from 'chalk';
+import { validateProjectDirectory, pathExists } from './utils.js';
+import { getUserInput, confirmAction } from './prompts.js';
+import { generateTestFiles, testsDirectoryExists, getGeneratedFilesList } from './file-operations.js';
+import { updatePackageJson, isPlaywrightInstalled } from './package-updater.js';
+
+/**
+ * Main generator function
+ */
+export async function generator() {
+	const cwd = process.cwd();
+	
+	console.log(chalk.blue.bold('\n🎭 Experiment E2E Test Generator\n'));
+	
+	// Step 1: Pre-flight checks
+	console.log(chalk.gray('Running pre-flight checks...'));
+	
+	const validation = await validateProjectDirectory(cwd);
+	if (!validation.isValid) {
+		console.error(chalk.red(`\n✗ ${validation.error}\n`));
+		process.exit(1);
+	}
+	
+	// Check if tests directory already exists
+	const testsExist = await testsDirectoryExists(cwd);
+	if (testsExist) {
+		console.log(chalk.yellow('\n⚠ Warning: tests/ directory already exists'));
+		const shouldContinue = await confirmAction(
+			'Do you want to overwrite existing test files?'
+		);
+		
+		if (!shouldContinue) {
+			console.log(chalk.gray('\nOperation cancelled.\n'));
+			process.exit(0);
+		}
+	}
+	
+	// Check if Playwright is already installed
+	const playwrightInstalled = await isPlaywrightInstalled(cwd);
+	if (playwrightInstalled) {
+		console.log(chalk.gray('✓ Playwright is already installed'));
+	}
+	
+	// Step 2: Get user input
+	console.log(chalk.blue('\nPlease provide the following information:\n'));
+	const config = await getUserInput(cwd);
+	
+	// Step 3: Generate files
+	console.log(chalk.blue('\n📁 Generating test files...\n'));
+	
+	try {
+		const { testsDir, experimentDir } = await generateTestFiles(cwd, config);
+		
+		const generatedFiles = getGeneratedFilesList(config.experimentName);
+		generatedFiles.forEach(file => {
+			console.log(chalk.green(`  ✓ ${file}`));
+		});
+		
+		// Step 4: Update package.json
+		console.log(chalk.blue('\n📦 Updating package.json...\n'));
+		
+		const packageResult = await updatePackageJson(cwd);
+		if (packageResult.updated) {
+			packageResult.changes.forEach(change => {
+				console.log(chalk.green(`  ✓ ${change}`));
+			});
+		} else {
+			console.log(chalk.gray('  ℹ No package.json updates needed'));
+		}
+		
+		// Step 5: Display completion message
+		console.log(chalk.green.bold('\n✓ Test structure generated successfully!\n'));
+		
+		console.log(chalk.blue('Next steps:\n'));
+		console.log(chalk.white('  1. Install dependencies:'));
+		console.log(chalk.gray('     yarn install\n'));
+		
+		console.log(chalk.white('  2. Update test URLs in:'));
+		console.log(chalk.gray('     tests/config/qa-links.config.js\n'));
+		
+		console.log(chalk.white('  3. Customize test selectors in:'));
+		console.log(chalk.gray(`     tests/e2e/${config.experimentName.toLowerCase().replace(/\s+/g, '-')}/${config.experimentName.toLowerCase().replace(/\s+/g, '-')}.spec.js\n`));
+		
+		console.log(chalk.white('  4. Run tests:'));
+		console.log(chalk.gray('     yarn test:e2e\n'));
+		
+		console.log(chalk.blue('📖 Documentation:'));
+		console.log(chalk.gray('   https://playwright.dev/docs/intro\n'));
+		
+	} catch (error) {
+		console.error(chalk.red('\n✗ Error generating test files:\n'));
+		console.error(chalk.red(error.message));
+		if (error.stack) {
+			console.error(chalk.gray('\n' + error.stack));
+		}
+		process.exit(1);
+	}
+}

package/src/package-updater.js

@@ -0,0 +1,73 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { mergePackageJson, formatPackageJson } from './utils.js';
+
+/**
+ * Update package.json with Playwright dependencies and scripts
+ * @param {string} targetDir - Target project directory
+ * @returns {Promise<{updated: boolean, changes: Array<string>}>}
+ */
+export async function updatePackageJson(targetDir) {
+	const packageJsonPath = path.join(targetDir, 'package.json');
+	const changes = [];
+	
+	// Read existing package.json
+	const existingPackageJson = await fs.readJson(packageJsonPath);
+	
+	// Define additions
+	const additions = {
+		devDependencies: {
+			'@playwright/test': '^1.40.0',
+			'playwright': '^1.40.0',
+		},
+		scripts: {},
+	};
+	
+	// Check if devDependencies need to be added
+	const existingDevDeps = existingPackageJson.devDependencies || {};
+	const needsPlaywright = !existingDevDeps['@playwright/test'];
+	
+	if (needsPlaywright) {
+		changes.push('Added Playwright dependencies to devDependencies');
+	}
+	
+	// Check if test script needs to be added
+	const existingScripts = existingPackageJson.scripts || {};
+	if (!existingScripts['test:e2e']) {
+		additions.scripts['test:e2e'] = 'playwright test';
+		changes.push('Added "test:e2e" script');
+	}
+	
+	// Only update if there are changes
+	if (changes.length === 0) {
+		return { updated: false, changes: [] };
+	}
+	
+	// Merge and write back
+	const updatedPackageJson = mergePackageJson(existingPackageJson, additions);
+	const formattedContent = formatPackageJson(updatedPackageJson);
+	await fs.writeFile(packageJsonPath, formattedContent, 'utf-8');
+	
+	return { updated: true, changes };
+}
+
+/**
+ * Check if Playwright is already installed
+ * @param {string} targetDir - Target project directory
+ * @returns {Promise<boolean>}
+ */
+export async function isPlaywrightInstalled(targetDir) {
+	try {
+		const packageJsonPath = path.join(targetDir, 'package.json');
+		const packageJson = await fs.readJson(packageJsonPath);
+		
+		const deps = {
+			...(packageJson.dependencies || {}),
+			...(packageJson.devDependencies || {}),
+		};
+		
+		return !!deps['@playwright/test'] || !!deps['playwright'];
+	} catch {
+		return false;
+	}
+}

package/src/prompts.js

@@ -0,0 +1,88 @@
+import prompts from 'prompts';
+import { detectExperimentName } from './utils.js';
+
+/**
+ * Get user input through interactive prompts
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<Object>} - User responses
+ */
+export async function getUserInput(cwd) {
+	// Try to detect experiment name
+	const detectedName = await detectExperimentName(cwd);
+	
+	const questions = [
+		{
+			type: 'text',
+			name: 'experimentName',
+			message: 'What is your experiment name?',
+			initial: detectedName || '',
+			validate: (value) => {
+				if (!value.trim()) {
+					return 'Experiment name is required';
+				}
+				return true;
+			},
+		},
+		{
+			type: 'text',
+			name: 'baseUrl',
+			message: 'Base URL for tests (e.g., https://www.samsung.com)',
+			initial: 'https://www.samsung.com',
+			validate: (value) => {
+				if (!value.trim()) {
+					return 'Base URL is required';
+				}
+				try {
+					new URL(value);
+					return true;
+				} catch {
+					return 'Please enter a valid URL';
+				}
+			},
+		},
+		{
+			type: 'text',
+			name: 'market',
+			message: 'Primary market code (e.g., NL, BE)',
+			initial: 'NL',
+			validate: (value) => {
+				if (!value.trim()) {
+					return 'Market code is required';
+				}
+				if (value.length > 5) {
+					return 'Market code should be short (e.g., NL, BE, UK)';
+				}
+				return true;
+			},
+		},
+	];
+	
+	const response = await prompts(questions, {
+		onCancel: () => {
+			console.log('\nOperation cancelled by user');
+			process.exit(0);
+		},
+	});
+	
+	return response;
+}
+
+/**
+ * Ask user for confirmation before overwriting
+ * @param {string} message - Confirmation message
+ * @returns {Promise<boolean>}
+ */
+export async function confirmAction(message) {
+	const response = await prompts({
+		type: 'confirm',
+		name: 'value',
+		message,
+		initial: false,
+	}, {
+		onCancel: () => {
+			return false;
+		},
+	});
+	
+	return response.value;
+}

package/src/utils.js

@@ -0,0 +1,162 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Convert string to kebab-case
+ * @param {string} str - Input string
+ * @returns {string} - kebab-case string
+ */
+export function toKebabCase(str) {
+	return str
+		.trim()
+		.toLowerCase()
+		.replace(/[\s_]+/g, '-')
+		.replace(/[^\w-]+/g, '')
+		.replace(/--+/g, '-')
+		.replace(/^-+/, '')
+		.replace(/-+$/, '');
+}
+
+/**
+ * Replace template variables in content
+ * @param {string} content - Template content
+ * @param {Object} variables - Variables to replace
+ * @returns {string} - Content with replaced variables
+ */
+export function replaceTemplateVars(content, variables) {
+	let result = content;
+	
+	Object.entries(variables).forEach(([key, value]) => {
+		const placeholder = new RegExp(`{{${key}}}`, 'g');
+		result = result.replace(placeholder, value);
+	});
+	
+	return result;
+}
+
+/**
+ * Check if a path exists
+ * @param {string} targetPath - Path to check
+ * @returns {Promise<boolean>}
+ */
+export async function pathExists(targetPath) {
+	try {
+		await fs.access(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Safely merge package.json dependencies
+ * @param {Object} existing - Existing package.json content
+ * @param {Object} additions - New dependencies to add
+ * @returns {Object} - Merged package.json
+ */
+export function mergePackageJson(existing, additions) {
+	const merged = { ...existing };
+	
+	// Merge devDependencies
+	if (additions.devDependencies) {
+		merged.devDependencies = {
+			...merged.devDependencies,
+			...additions.devDependencies,
+		};
+	}
+	
+	// Merge scripts (don't overwrite existing)
+	if (additions.scripts) {
+		merged.scripts = {
+			...merged.scripts,
+			...additions.scripts,
+		};
+	}
+	
+	return merged;
+}
+
+/**
+ * Attempt to detect experiment name from project structure
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<string|null>} - Detected experiment name or null
+ */
+export async function detectExperimentName(cwd) {
+	try {
+		// Try to read package.json
+		const packageJsonPath = path.join(cwd, 'package.json');
+		if (await pathExists(packageJsonPath)) {
+			const packageJson = await fs.readJson(packageJsonPath);
+			if (packageJson.name) {
+				// Extract experiment name from package name
+				const name = packageJson.name.replace(/^@[^/]+\//, '');
+				return name;
+			}
+		}
+		
+		// Try to find experiment folder structure
+		const srcPath = path.join(cwd, 'src');
+		if (await pathExists(srcPath)) {
+			const componentsPath = path.join(srcPath, 'components');
+			if (await pathExists(componentsPath)) {
+				const components = await fs.readdir(componentsPath);
+				if (components.length > 0) {
+					// Use first component name as experiment name
+					return components[0].replace(/\.(jsx?|tsx?)$/, '');
+				}
+			}
+		}
+	} catch (error) {
+		// Ignore detection errors
+	}
+	
+	return null;
+}
+
+/**
+ * Format package.json content with proper indentation
+ * @param {Object} content - Package.json object
+ * @returns {string} - Formatted JSON string
+ */
+export function formatPackageJson(content) {
+	return JSON.stringify(content, null, 2) + '\n';
+}
+
+/**
+ * Validate that current directory is a valid project
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<{isValid: boolean, error?: string}>}
+ */
+export async function validateProjectDirectory(cwd) {
+	// Check if package.json exists
+	const packageJsonPath = path.join(cwd, 'package.json');
+	if (!await pathExists(packageJsonPath)) {
+		return {
+			isValid: false,
+			error: 'No package.json found in current directory. Please run this command from your project root.',
+		};
+	}
+	
+	return { isValid: true };
+}
+
+/**
+ * Create directory if it doesn't exist
+ * @param {string} dirPath - Directory path
+ */
+export async function ensureDir(dirPath) {
+	await fs.ensureDir(dirPath);
+}
+
+/**
+ * Copy file with template variable replacement
+ * @param {string} sourcePath - Source file path
+ * @param {string} destPath - Destination file path
+ * @param {Object} variables - Template variables
+ */
+export async function copyTemplateFile(sourcePath, destPath, variables) {
+	const content = await fs.readFile(sourcePath, 'utf-8');
+	const processedContent = replaceTemplateVars(content, variables);
+	await ensureDir(path.dirname(destPath));
+	await fs.writeFile(destPath, processedContent, 'utf-8');
+}

package/templates/playwright.config.js

@@ -0,0 +1,29 @@
+import { defineConfig, devices } from '@playwright/test';
+
+/**
+ * Playwright configuration for {{EXPERIMENT_NAME}} experiment tests
+ * @see https://playwright.dev/docs/test-configuration
+ */
+export default defineConfig({
+	testDir: './tests',
+	fullyParallel: true,
+	reporter: 'html',
+	use: {
+		trace: 'on-first-retry',
+		screenshot: 'only-on-failure',
+	},
+	projects: [
+		{
+			name: 'chromium',
+			use: { ...devices['Desktop Chrome'] },
+		},
+		{
+			name: 'firefox',
+			use: { ...devices['Desktop Firefox'] },
+		},
+		{
+			name: 'webkit',
+			use: { ...devices['Desktop Safari'] },
+		},
+	],
+});

package/templates/tests/config/experiment.config.js

@@ -0,0 +1,28 @@
+/**
+ * Experiment configuration for {{EXPERIMENT_NAME}}
+ * Contains experiment-specific settings and environment variables
+ */
+export const experimentConfig = {
+	name: '{{EXPERIMENT_NAME}}',
+	market: '{{MARKET}}',
+	baseUrl: '{{BASE_URL}}',
+	
+	// Experiment variants
+	variants: {
+		control: 'control',
+		experiment: 'experiment',
+	},
+	
+	// Timeout configurations (in milliseconds)
+	timeouts: {
+		navigation: 30000,
+		element: 5000,
+		api: 10000,
+	},
+	
+	// Test environment
+	environment: process.env.TEST_ENV || 'qa',
+	
+	// Adobe Target preview token (if applicable)
+	adobePreviewToken: process.env.ADOBE_PREVIEW_TOKEN || '',
+};

package/templates/tests/config/index.js

@@ -0,0 +1,5 @@
+/**
+ * Central configuration export for {{EXPERIMENT_NAME}} tests
+ */
+export { experimentConfig } from './experiment.config.js';
+export { qaLinksConfig, validateUrls } from './qa-links.config.js';

package/templates/tests/config/qa-links.config.js

@@ -0,0 +1,17 @@
+export const qaLinksConfig = {
+	controlUrl: process.env.CONTROL_URL || '{{BASE_URL}}/{{MARKET}}/control-page/',
+	experimentUrl: process.env.EXPERIMENT_URL || '{{BASE_URL}}/{{MARKET}}/experiment-page/',
+};
+
+/**
+ * Validates that required URLs are configured
+ * @throws {Error} if required URLs are missing
+ */
+export function validateUrls() {
+	if (!qaLinksConfig.controlUrl || !qaLinksConfig.experimentUrl) {
+		throw new Error(
+			'Missing required URLs. Please set CONTROL_URL and EXPERIMENT_URL environment variables ' +
+			'or update the URLs in tests/config/qa-links.config.js'
+		);
+	}
+}

package/templates/tests/e2e/experiment-name/experiment.spec.js

@@ -0,0 +1,53 @@
+import { test, expect } from '@playwright/test';
+import { qaLinksConfig, validateUrls } from '../../config/index.js';
+
+test.describe('{{EXPERIMENT_NAME}} - Control', () => {
+	test.beforeEach(async ({ page }) => {
+		validateUrls();
+		await page.goto(qaLinksConfig.controlUrl);
+	});
+
+	test('should not display experiment component', async ({ page }) => {
+		// TODO: Update this selector to match your experiment component
+		const experimentComponent = page.locator('[data-experiment="{{EXPERIMENT_NAME_KEBAB}}"]');
+		
+		// Verify the experiment component is not visible in control
+		await expect(experimentComponent).not.toBeVisible();
+	});
+
+	test('should display baseline content', async ({ page }) => {
+		// TODO: Add assertions to verify baseline/control content
+		// Example:
+		// await expect(page.getByRole('heading', { name: 'Control Heading' })).toBeVisible();
+	});
+});
+
+test.describe('{{EXPERIMENT_NAME}} - Experiment', () => {
+	test.beforeEach(async ({ page }) => {
+		validateUrls();
+		await page.goto(qaLinksConfig.experimentUrl);
+	});
+
+	test('should display experiment component', async ({ page }) => {
+		// TODO: Update this selector to match your experiment component
+		const experimentComponent = page.locator('[data-experiment="{{EXPERIMENT_NAME_KEBAB}}"]');
+		
+		// Verify the experiment component is visible
+		await expect(experimentComponent).toBeVisible();
+	});
+
+	test('should have correct experiment styling', async ({ page }) => {
+		// TODO: Add assertions to verify experiment-specific styling or content
+		// Example:
+		// const experimentButton = page.getByRole('button', { name: 'Experiment CTA' });
+		// await expect(experimentButton).toBeVisible();
+		// await expect(experimentButton).toHaveCSS('background-color', 'rgb(0, 119, 200)');
+	});
+
+	test('should handle user interactions correctly', async ({ page }) => {
+		// TODO: Add test for user interactions with the experiment component
+		// Example:
+		// await page.getByRole('button', { name: 'Click Me' }).click();
+		// await expect(page.getByText('Success!')).toBeVisible();
+	});
+});

package/templates/tests/fixtures/test-fixtures.js

@@ -0,0 +1,51 @@
+import { test as base } from '@playwright/test';
+import { experimentConfig } from '../config/index.js';
+
+/**
+ * Custom test fixtures for {{EXPERIMENT_NAME}} experiment
+ * Extend Playwright's base test with custom fixtures and utilities
+ */
+export const test = base.extend({
+	/**
+	 * Custom fixture for experiment context
+	 * Provides experiment-specific configuration and utilities
+	 */
+	experimentContext: async ({}, use) => {
+		const context = {
+			name: experimentConfig.name,
+			market: experimentConfig.market,
+			baseUrl: experimentConfig.baseUrl,
+			
+			/**
+			 * Helper to construct URLs with experiment parameters
+			 * @param {string} path - URL path
+			 * @param {Object} params - Additional query parameters
+			 */
+			buildUrl: (path, params = {}) => {
+				const url = new URL(path, experimentConfig.baseUrl);
+				Object.entries(params).forEach(([key, value]) => {
+					url.searchParams.append(key, value);
+				});
+				return url.toString();
+			},
+		};
+		
+		await use(context);
+	},
+	
+	/**
+	 * Custom fixture for Adobe Target preview (if applicable)
+	 */
+	adobePreview: async ({ page }, use) => {
+		if (experimentConfig.adobePreviewToken) {
+			// Add Adobe preview token to page context
+			await page.addInitScript((token) => {
+				window.adobePreviewToken = token;
+			}, experimentConfig.adobePreviewToken);
+		}
+		
+		await use(page);
+	},
+});
+
+export { expect } from '@playwright/test';

package/templates/tests/utils/test-helpers.js

@@ -0,0 +1,114 @@
+/**
+ * Test helper utilities for {{EXPERIMENT_NAME}} experiment
+ * Reusable functions for common test operations
+ */
+
+/**
+ * Wait for network idle state
+ * Useful for waiting for async operations to complete
+ * @param {Page} page - Playwright page object
+ * @param {number} timeout - Maximum wait time in milliseconds
+ */
+export async function waitForNetworkIdle(page, timeout = 5000) {
+	await page.waitForLoadState('networkidle', { timeout });
+}
+
+/**
+ * Wait for a specific element to be stable (no animations)
+ * @param {Locator} locator - Playwright locator
+ * @param {number} timeout - Maximum wait time in milliseconds
+ */
+export async function waitForStable(locator, timeout = 3000) {
+	await locator.waitFor({ state: 'visible', timeout });
+	// Wait a bit for any CSS transitions/animations to complete
+	await new Promise(resolve => setTimeout(resolve, 300));
+}
+
+/**
+ * Get computed style of an element
+ * @param {Locator} locator - Playwright locator
+ * @param {string} property - CSS property name
+ * @returns {Promise<string>} - Computed style value
+ */
+export async function getComputedStyle(locator, property) {
+	return await locator.evaluate((el, prop) => {
+		return window.getComputedStyle(el).getPropertyValue(prop);
+	}, property);
+}
+
+/**
+ * Check if element is in viewport
+ * @param {Locator} locator - Playwright locator
+ * @returns {Promise<boolean>}
+ */
+export async function isInViewport(locator) {
+	return await locator.evaluate((el) => {
+		const rect = el.getBoundingClientRect();
+		return (
+			rect.top >= 0 &&
+			rect.left >= 0 &&
+			rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
+			rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+		);
+	});
+}
+
+/**
+ * Scroll element into view smoothly
+ * @param {Locator} locator - Playwright locator
+ */
+export async function scrollIntoView(locator) {
+	await locator.evaluate((el) => {
+		el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+	});
+	// Wait for scroll to complete
+	await new Promise(resolve => setTimeout(resolve, 500));
+}
+
+/**
+ * Take a screenshot with a descriptive name
+ * @param {Page} page - Playwright page object
+ * @param {string} name - Screenshot name
+ * @returns {Promise<Buffer>}
+ */
+export async function takeScreenshot(page, name) {
+	const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+	return await page.screenshot({
+		path: `screenshots/${name}-${timestamp}.png`,
+		fullPage: true,
+	});
+}
+
+/**
+ * Wait for specific text to appear on page
+ * @param {Page} page - Playwright page object
+ * @param {string} text - Text to wait for
+ * @param {number} timeout - Maximum wait time in milliseconds
+ */
+export async function waitForText(page, text, timeout = 5000) {
+	await page.waitForSelector(`text=${text}`, { timeout });
+}
+
+/**
+ * Retry an action with exponential backoff
+ * @param {Function} action - Async function to retry
+ * @param {number} maxRetries - Maximum number of retry attempts
+ * @param {number} initialDelay - Initial delay in milliseconds
+ */
+export async function retryWithBackoff(action, maxRetries = 3, initialDelay = 1000) {
+	let lastError;
+	
+	for (let i = 0; i < maxRetries; i++) {
+		try {
+			return await action();
+		} catch (error) {
+			lastError = error;
+			if (i < maxRetries - 1) {
+				const delay = initialDelay * Math.pow(2, i);
+				await new Promise(resolve => setTimeout(resolve, delay));
+			}
+		}
+	}
+	
+	throw lastError;
+}