Create the infrastructure for an AI-powered end-to-end test generation system with TypeScript, Playwright, and MCP Playwright Server. Set up the following:

1. Create a package.json file with:
   - TypeScript 4.x+
   - Playwright dependencies
   - Jest for unit testing
   - ESLint with TypeScript support
   - Prettier for code formatting
   - Appropriate scripts for building, testing, and linting

2. Create a basic project structure with:
   - src/ directory for source code
   - tests/ directory for tests
   - Configuration files (.eslintrc.js, jest.config.js, tsconfig.json)
   - Sample .env file for environment variables

3. Set up directory structure for the four main modules:
   - src/scenario-parser/
   - src/marathon-engine/
   - src/test-converter/
   - src/playwright-runner/
   - src/common/ (for shared types and utilities)

4. Implement shared interfaces in src/common/types.ts as defined in the PRD:
   - CommonOptions (with timeoutMs and retryCount)
   - ErrorInfo
   - OperationResult
   - TestStep interface with:
     * id (unique identifier)
     * description (human-readable description)
     * action (framework-agnostic operation type)
     * selector (element targeting)
     * value (action input value)
     * timeout (step-specific timeout)
     * waitFor (wait conditions)
     * isLastStep (control flow flag)
     * context (for debugging and self-healing)
     * maxRetries (retry strategy)
   - Other shared interfaces

5. Create a simple logging mechanism in src/common/logger.ts

Ensure code follows these practices:
- Clean architecture with separation of concerns
- KISS principle (Keep It Simple, Stupid)
- Functions should be small and focused
- TypeScript interfaces should be well-defined with JSDoc comments
- Add README.md files to each module directory explaining purpose
- Max function length of 25 lines
- Meaningful variable and function names

Include a README.md in the root directory with:
- Project overview
- Setup instructions
- How to run tests
- How to use the system

Add a simple script to validate the infrastructure setup that can be run with 'npm run validate-setup'

Create comprehensive tests for the infrastructure setup of our AI-powered end-to-end test generation system. Implement the following:

1. Unit tests for shared interfaces and types in src/common/types.ts:
   - Test type validation
   - Test interface extensions work as expected
   - Test default values where applicable

2. Unit tests for the logging mechanism in src/common/logger.ts:
   - Test different log levels
   - Test log formatting
   - Test error logging

3. Integration test to validate the entire infrastructure:
   - Verify directory structure
   - Validate configuration files
   - Ensure imports work correctly between modules
   - Verify build process completes successfully

4. Create a setup validation script:
   - Check all required dependencies are installed
   - Verify environment variables are set correctly
   - Confirm TypeScript compilation works
   - Ensure tests can run successfully

Make tests simple and focused following these practices:
- Each test should test one thing only
- Use descriptive test names
- Use arrange-act-assert pattern
- Keep test code simple and readable
- Use mocks and stubs where appropriate

Add a 'test:infra' script to package.json that runs just the infrastructure tests.
Ensure the tests can be run with a single command: npm run test:infra

Document any manual steps needed to verify the infrastructure in a TESTING.md file.

Implement the Scenario Parser module for the AI-powered E2E test generation system according to the PRD. This module transforms human-readable test scenarios into structured TestStep objects using MCP Playwright Server.

Create the following files:
1. src/scenario-parser/index.ts - Main entry point exporting the ScenarioParser class
2. src/scenario-parser/types.ts - Module-specific types
3. src/scenario-parser/mcp-client.ts - Client for interacting with MCP Playwright Server
4. src/scenario-parser/test-step-generator.ts - Logic to convert MCP actions to TestStep objects
5. src/scenario-parser/README.md - Documentation for the module

Implement the ScenarioParser class with these methods:
- parse(scenario: TestScenario): Promise<ParserResult>
- validateScenario(scenario: TestScenario): boolean
- getLastExecutionSnapshot(): any | null

The mcp-client.ts should implement these core functions:
- navigateToUrl(url: string): Promise<any>
- executeAction(action: string): Promise<any>
- getSnapshot(): Promise<any>

The TestStepGenerator should:
- Convert MCP Playwright server operations to framework-agnostic TestStep objects
- Assign unique IDs to each step (e.g., "step-1", "step-2", etc.)
- Extract appropriate selectors with resilient strategies
- Handle different action types (navigate, input, click, assert, wait, select, hover, keypress)
- Apply appropriate timeout values for each step
- Set proper waitFor conditions based on the action context
- Populate context data for debugging and self-healing

Error handling:
- Implement retry mechanism (max 3 attempts)
- Capture detailed error information
- Handle network errors, timeouts, and invalid selectors

Follow these code practices:
- Functions should be small (max 25 lines)
- Use meaningful variable and function names
- Add JSDoc comments for public methods
- Follow SOLID principles
- Separate concerns (MCP communication vs TestStep generation)
- Implement proper error handling
- Add logging at appropriate levels

Manual testing:
Create a simple CLI script (src/scenario-parser/cli.ts) that:
- Takes a JSON file with a test scenario as input
- Runs the parser
- Outputs the generated TestSteps
- Can be run with: npm run parse-scenario -- path/to/scenario.json

Add a sample scenario JSON file in examples/scenarios/login-scenario.json that can be used for testing.

Include README.md with:
- Purpose of the module
- API documentation
- Example usage
- How to run manual tests

Create comprehensive tests for the Scenario Parser module of the AI-powered E2E test generation system. Implement both unit and integration tests.

Create the following test files:
1. tests/scenario-parser/scenario-parser.test.ts - Main test file for ScenarioParser class
2. tests/scenario-parser/mcp-client.test.ts - Tests for MCP Playwright client
3. tests/scenario-parser/test-step-generator.test.ts - Tests for TestStep generation
4. tests/scenario-parser/integration.test.ts - Integration tests

Unit tests for ScenarioParser:
- Test scenario validation (valid/invalid inputs)
- Test parsing logic with mocked MCP client
- Test error handling and retry mechanism
- Test getLastExecutionSnapshot()

Unit tests for MCP client:
- Test URL navigation
- Test action execution with different action types
- Test snapshot retrieval
- Test error handling for API failures

Unit tests for TestStep generator:
- Test conversion from MCP operations to TestSteps
- Test selector extraction
- Test handling of different action types
- Test context information is properly captured

Integration tests:
- Test the complete flow with mock MCP server
- Test with various scenario types (login, form submission, navigation)
- Test error cases and recovery
- Test performance (parsing should complete within reasonable time)

Create mocks:
- Mock MCP Playwright Server responses
- Mock DOM snapshots
- Mock error conditions

Follow these testing practices:
- Use descriptive test names (should/when/then pattern)
- One assertion per test where possible
- Use beforeEach for test setup
- Properly clean up after tests
- Use test fixtures for common scenarios

Add test script to package.json:
- npm run test:parser - Runs all parser tests
- npm run test:parser:unit - Runs just unit tests
- npm run test:parser:integration - Runs just integration tests

Create a manual test script that:
- Accepts a sample scenario
- Runs the parser against it
- Displays the output in a readable format
- Can be run with: npm run test:parser:manual

Include test documentation in tests/scenario-parser/README.md with:
- Overview of testing approach
- How to run the tests
- How to add new tests
- Common test scenarios

Implement the Marathon Execution Engine module for the AI-powered E2E test generation system according to the PRD. This module executes TestStep objects using Playwright in a secure environment.

Create the following files:
1. src/marathon-engine/index.ts - Main entry point exporting the MarathonEngine class
2. src/marathon-engine/types.ts - Module-specific types
3. src/marathon-engine/test-step-executor.ts - Logic to execute TestStep objects
4. src/marathon-engine/security.ts - Security-related functionality
5. src/marathon-engine/README.md - Documentation for the module

Implement the MarathonEngine class with these methods:
- execute(request: ExecutionRequest): Promise<ExecutionResult>
- validateTestStep(step: TestStep): boolean
- getLastExecutionState(): any | null

The TestStepExecutor should:
- Map TestStep actions to Playwright API calls
- Execute steps sequentially
- Capture detailed execution information
- Handle errors and timeout conditions

Security implementation:
- URL navigation restriction (only allow the specified URL)
- Implement action allowlisting functionality (only permit actions defined in the allowedActions list)
- Leave placeholders for future security measures (with comments)

Core functionality:
- Support basic actions: navigate, input, click, assert, wait, select, hover, keypress
- Handle TestStep context information
- Respect step-specific timeouts
- Create new Playwright browser contexts for isolation
- Capture screenshots on errors
- Implement retry mechanism based on maxRetries value

Follow these code practices:
- Keep functions focused and small (max 25 lines)
- Use dependency injection for easier testing
- Add clear error messages
- Implement proper try/catch blocks
- Use async/await consistently
- Add logging at appropriate levels
- Use TypeScript types effectively

Manual testing:
Create a CLI script (src/marathon-engine/cli.ts) that:
- Takes a JSON file with TestStep objects as input
- Runs the marathon engine
- Reports execution results
- Can be run with: npm run execute-steps -- path/to/teststeps.json

Add sample TestSteps in examples/teststeps/login-steps.json for testing:

[
  {
    "id": "step-1",
    "action": "navigate",
    "value": "https://example.com/login",
    "description": "Navigate to login page",
    "waitFor": "networkidle",
    "isLastStep": false
  },
  {
    "id": "step-2",
    "action": "input",
    "selector": "#username",
    "value": "testuser",
    "description": "Enter username",
    "waitFor": "visible",
    "isLastStep": false
  },
  {
    "id": "step-3",
    "action": "input",
    "selector": "#password",
    "value": "password123",
    "description": "Enter password",
    "waitFor": "visible",
    "isLastStep": false
  },
  {
    "id": "step-4",
    "action": "click",
    "selector": "#login-button",
    "description": "Click login button",
    "waitFor": "visible",
    "isLastStep": false
  },
  {
    "id": "step-5",
    "action": "assert",
    "selector": "#welcome-message",
    "value": "Welcome!",
    "description": "Verify welcome message",
    "isLastStep": true
  }
]


Include README.md with:
- Purpose of the module
- API documentation
- Security considerations
- Example usage
- How to run manual tests

Create comprehensive tests for the Marathon Execution Engine module of the AI-powered E2E test generation system. Implement both unit and integration tests.

Create the following test files:
1. tests/marathon-engine/marathon-engine.test.ts - Main test file for MarathonEngine class
2. tests/marathon-engine/test-step-executor.test.ts - Tests for TestStep execution
3. tests/marathon-engine/security.test.ts - Tests for security features
4. tests/marathon-engine/integration.test.ts - Integration tests

Unit tests for MarathonEngine:
- Test request validation
- Test execution flow with mocked executor
- Test error handling and reporting
- Test getLastExecutionState()

Unit tests for TestStepExecutor:
- Test mapping of TestSteps to Playwright actions
- Test execution of different action types
- Test browser context creation and isolation
- Test error handling during execution
- Test handling of step-specific timeouts
- Test retry mechanism using maxRetries

Unit tests for security features:
- Test URL navigation restrictions
- Test action allowlisting (ensure only allowed actions are executed)
- Test validation logic

Integration tests:
- Test executing real TestSteps against a test website
- Test handling of various TestStep sequences
- Test error recovery
- Test execution results match expected outputs

Create mocks:
- Mock Playwright Page object
- Mock Browser context
- Mock TestSteps with different actions
- Mock error conditions

Follow these testing practices:
- Use descriptive test names
- Isolate tests from external dependencies where possible
- Clean up browser contexts after tests
- Test both success and failure paths
- Test boundary conditions

Add test script to package.json:
- npm run test:engine - Runs all engine tests
- npm run test:engine:unit - Runs just unit tests
- npm run test:engine:integration - Runs just integration tests

Create a manual test script that:
- Accepts a sample TestStep JSON file
- Executes the steps using the engine
- Displays detailed results
- Can be run with: npm run test:engine:manual

Include test documentation in tests/marathon-engine/README.md with:
- Overview of testing approach
- Description of test fixtures
- How to run the tests
- How to debug failed tests

Implement the TestStep to Playwright Code Converter module for the AI-powered E2E test generation system according to the PRD. This module converts validated TestStep objects into Playwright test code in TypeScript.

Create the following files:
1. src/test-converter/index.ts - Main entry point exporting the TestStepConverter class
2. src/test-converter/types.ts - Module-specific types
3. src/test-converter/code-generator.ts - Core logic for generating Playwright code
4. src/test-converter/templates.ts - Code templates for different test components
5. src/test-converter/README.md - Documentation for the module

Implement the TestStepConverter class with these methods:
- convert(request: ConverterRequest): ConverterResult
- supportedFrameworks(): string[]
- validateTestSteps(steps: TestStep[]): boolean

The CodeGenerator should:
- Generate Playwright test code from framework-agnostic TestStep objects
- Translate abstract actions to specific Playwright API calls
- Create proper test structure with imports
- Add comments based on step descriptions
- Generate appropriate assertions
- Format the code properly
- Handle step-specific timeouts in the generated code

Templates should include:
- Test file header with imports
- Test block structure
- Action-to-implementation mapping (e.g., each abstract action maps to specific Playwright calls):
  * 'navigate' -> page.goto()
  * 'input' -> page.fill()
  * 'click' -> page.click()
  * 'assert' -> expect() with appropriate matchers
  * 'wait' -> page.waitForSelector() or other waiting methods
  * 'select' -> page.selectOption()
  * 'hover' -> page.hover()
  * 'keypress' -> page.press()
- Comment templates

Core functionality:
- Support all TestStep action types
- Generate readable and well-formatted code
- Include appropriate error handling in generated code
- Support parameterized test names

Follow these code practices:
- Use template literals wisely
- Keep functions small and focused
- Use descriptive variable names
- Follow the single responsibility principle
- Add JSDoc comments to public methods
- Use TypeScript types effectively
- Ensure generated code is properly indented

Manual testing:
Create a CLI script (src/test-converter/cli.ts) that:
- Takes a JSON file with TestStep objects as input
- Runs the converter
- Outputs the generated Playwright code to a file
- Can be run with: npm run convert-steps -- path/to/teststeps.json output.spec.ts

Add sample TestSteps in examples/teststeps/login-steps.json for testing:

```json
[
  {
    "id": "step-1",
    "action": "navigate",
    "value": "https://example.com/login",
    "description": "Navigate to login page",
    "waitFor": "networkidle",
    "isLastStep": false
  },
  {
    "id": "step-2",
    "action": "input",
    "selector": "#username",
    "value": "testuser",
    "description": "Enter username",
    "waitFor": "visible",
    "isLastStep": false
  },
  {
    "id": "step-3",
    "action": "input",
    "selector": "#password",
    "value": "password123",
    "description": "Enter password",
    "waitFor": "visible",
    "isLastStep": false
  },
  {
    "id": "step-4",
    "action": "click",
    "selector": "#login-button",
    "description": "Click login button",
    "waitFor": "visible",
    "isLastStep": false
  },
  {
    "id": "step-5",
    "action": "assert",
    "selector": "#welcome-message",
    "value": "Welcome!",
    "description": "Verify welcome message",
    "isLastStep": true
  }
]

### TestStep Converter Tests Prompt

## Playwright Runner Module

### Playwright Runner Implementation Prompt

### Playwright Runner Tests Prompt

## End-to-End Integration

### Integration Prompt

### End-to-End Tests Prompt

## Conclusion

These prompts provide comprehensive guidance for implementing the complete AI-powered E2E test generation system as specified in the PRD. Each module has dedicated prompts for both implementation and testing, ensuring complete coverage of requirements.

Use these prompts in sequence, starting with infrastructure setup, then implementing each module, and finally integrating everything together. The testing prompts should be used alongside implementation to ensure code quality and compliance with requirements.