agents-cli-automation 1.0.5 → 1.0.7

package/README.md

@@ -0,0 +1,196 @@
+# Agents CLI
+
+A simple CLI tool to bootstrap production-ready Playwright automation frameworks for UI and API testing.
+
+## Installation
+
+### Option 1: Using npx (No installation required)
+```bash
+npx agents-cli-automation init
+```
+
+### Option 2: Install globally via npm
+```bash
+npm install -g agents-cli-automation
+agents init
+```
+
+### Option 3: Install locally in a project
+```bash
+npm install agents-cli-automation
+npx agents init
+```
+
+## Quick Start
+
+Run the setup command and follow the interactive prompts:
+```bash
+npx agents-cli-automation init
+```
+
+### Step 1: Select Framework Type
+Choose your testing type:
+1. **Playwright UI Testing** - Browser automation, E2E tests, component testing
+2. **Playwright API Testing** - REST API tests, integration testing, backend validation
+
+### Step 2: Select Your Language (for UI Testing)
+Choose your preferred language:
+- **TypeScript** (Recommended) - Latest & Type Safe
+- **JavaScript** - ES Modules, modern syntax
+- **Java** - Maven + JUnit5
+- **C#** - NUnit + .NET
+
+Your scalable, production-ready framework will be generated automatically!
+
+## Available Agents
+
+### 📊 Playwright UI Testing Framework
+Creates a production-ready Playwright framework for UI automation with support for **TypeScript, JavaScript, Java, and C#**.
+
+**Core Features:**
+- ✅ **Page Object Model (POM)** - Reusable page classes with best practices
+- ✅ **Fixtures & Setup** - Built-in browser lifecycle management
+- ✅ **Parallel Execution** - Run tests simultaneously (4 workers by default)
+- ✅ **Chromium Only** - Single browser for consistency and speed
+- ✅ **Test Data Readers** - Support for JSON, CSV, and YAML files
+- ✅ **Form Helpers** - Handle dropdowns, radio buttons, checkboxes, text inputs
+- ✅ **BDD Support** - Cucumber/Gherkin feature files for scenario-based testing
+- ✅ **Latest APIs** - Uses latest Playwright versions with full type safety
+
+**Language Options:**
+- **TypeScript** - Full tsconfig with strict mode and path aliases (@pages/@utils/@fixtures/@data)
+- **JavaScript** - ES Modules with modern syntax (no build step required)
+- **Java** - Maven-based structure with JUnit 5 and all dependencies
+- **C#** - .NET 8 with NUnit and async/await patterns
+
+### 🔌 Playwright API Testing
+Creates a production-ready Playwright framework for API automation with:
+- ✅ Complete API test project structure
+- ✅ REST API request handling
+- ✅ Response validation templates
+- ✅ Authentication fixtures
+- ✅ Database integration helpers
+- ✅ Sample API tests (GET, POST, etc.)
+- ✅ CI/CD ready configuration
+
+The generated agent will include everything you need to start automating tests immediately!
+
+## What Gets Created
+
+When you run `agents init`, a `.github/agents` directory is created in your project with language-specific framework files.
+
+### For UI Testing (Choose Your Language)
+
+**TypeScript**
+- `playwright-ui-testing-typescript-agent.md`
+  - Complete TypeScript framework with strict type checking
+  - tsconfig.json with path aliases
+  - Full type definitions for all utilities
+  - ES2020 module syntax
+
+**JavaScript**
+- `playwright-ui-testing-javascript-es-modules-agent.md`
+  - Modern ES Modules syntax (Node.js 18+)
+  - No build step required
+  - Same features as TypeScript without type annotations
+
+**Java**
+- `playwright-ui-testing-java-agent.md`
+  - Maven-based project structure
+  - JUnit 5 test framework
+  - Complete pom.xml with all dependencies
+  - Maven parallel execution support
+
+**C#**
+- `playwright-ui-testing-c#-agent.md`
+  - .NET 8+ project structure
+  - NUnit test framework
+  - Complete .csproj configuration
+  - Async/await patterns throughout
+
+### For API Testing
+- `playwright-api-testing-agent.md` - Complete API framework setup
+
+## Framework Structure (All Languages)
+
+Each generated framework includes:
+
+**📂 Project Structure**
+```
+framework/
+├── pages/               # Page Object Model classes
+├── utils/              # DataReader, FormHelper, TestDataManager
+├── fixtures/           # Browser setup and fixtures
+├── tests/              # Test files
+├── features/           # Gherkin/BDD scenarios
+├── data/               # Test data (JSON, CSV, YAML)
+├── config files        # Language-specific (tsconfig.json, pom.xml, etc.)
+└── Sample tests        # Working examples ready to run
+```
+
+**✨ Included in Every Framework:**
+- Page Object Model classes with selectors
+- Form helpers for complex form interactions
+- Test data readers for JSON, CSV, YAML
+- BDD/Gherkin feature files
+- Browser fixtures with proper cleanup
+- Parallel execution configuration
+- Sample tests with SauceDemo app
+- Complete setup and run instructions
+
+## Requirements
+
+### To Run CLI
+- Node.js 18+
+- npm or yarn
+
+### To Run Generated Frameworks
+
+**TypeScript & JavaScript:**
+- Node.js 18+
+- npm or yarn
+
+**Java:**
+- Java 11+
+- Maven 3.8+
+
+**C#:**
+- .NET 8 SDK
+- Visual Studio 2022 or VS Code with C# extension
+
+## Why Choose This Framework?
+
+✅ **Multi-Language Support** - Use TypeScript, JavaScript, Java, or C#
+✅ **Minimal Setup** - Fully scaffolded projects, developers focus on tests, not setup
+✅ **Page Object Model** - Reusable, maintainable test code patterns
+✅ **Scalable Architecture** - Ready for enterprise-grade test suites
+✅ **Parallel Execution** - Run tests faster across multiple workers
+✅ **BDD Ready** - Cucumber/Gherkin support for business-readable scenarios
+✅ **Test Data Management** - JSON, CSV, YAML support out of the box
+✅ **Form Helpers** - Handle complex forms, dropdowns, checkboxes easily
+✅ **Latest Playwright** - Always using cutting-edge Playwright features
+✅ **Production Ready** - Fixtures, proper cleanup, error handling included
+
+## Framework Quick Features
+
+Each generated framework provides:
+
+**For UI Testing:**
+- SauceDemo test examples (login, shopping cart)
+- Complete page objects with all selectors
+- Form interaction helpers for any element type
+- Test data loading from multiple formats
+- BDD scenario examples with step definitions
+- Parallel execution (4 workers by default)
+- Chromium-only for reliability
+
+**For API Testing:**
+- Writing GET, POST, PUT, DELETE tests
+- Response validation patterns
+- Authentication and headers setup
+- Environment variables configuration
+- Database integration examples
+
+---
+
+**Happy automating! 🚀**

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "agents-cli-automation",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Agents CLI",
   "type": "module",
   "bin": {
-    "agents": "./bin/index.js"
+    "agents": "bin/index.js"
   },
   "files": [
     "bin",

package/src/commands/init.js

@@ -7,22 +7,87 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export default async function initCommand() {
-  console.log("\n🚀 Agents CLI setup\n");
+  console.log("\n🚀 Agents CLI - Scalable Test Framework Setup\n");
 
   const { setup } = await inquirer.prompt([
     {
       type: "list",
       name: "setup",
-      message: "Select setup",
-      choices: ["Add Playwright Agent"]
+      message: "Select framework setup",
+      choices: [
+        "Playwright UI Testing (Recommended)",
+        "Playwright API Testing"
+      ]
     }
   ]);
 
-  if (setup === "Add Playwright Agent") {
-    // Template inside your CLI package
+  if (setup === "Playwright UI Testing (Recommended)") {
+    // Ask for language preference
+    const { language } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "language",
+        message: "Select your preferred language",
+        choices: [
+          "TypeScript (Recommended - Latest & Type Safe)",
+          "JavaScript (ES Modules)",
+          "Java (Maven + JUnit)",
+          "C# (NUnit + .NET)"
+        ]
+      }
+    ]);
+
+    let templateFile;
+    let templateName;
+
+    if (language.includes("TypeScript")) {
+      templateFile = "playwright-agent-ts.md";
+      templateName = "TypeScript";
+    } else if (language.includes("JavaScript")) {
+      templateFile = "playwright-agent-js.md";
+      templateName = "JavaScript ES Modules";
+    } else if (language.includes("Java")) {
+      templateFile = "playwright-agent-java.md";
+      templateName = "Java";
+    } else if (language.includes("C#")) {
+      templateFile = "playwright-agent-csharp.md";
+      templateName = "C#";
+    }
+
+    const templatePath = path.resolve(__dirname, `../templates/${templateFile}`);
+
+    // Check if template exists
+    if (!fs.existsSync(templatePath)) {
+      console.error(
+        `\n❌ Template not found: ${templateFile}\n`
+      );
+      return;
+    }
+
+    // Target folder in user's project
+    const userProjectRoot = process.cwd();
+    const agentsDir = path.join(userProjectRoot, ".github", "agents");
+
+    // Ensure folder exists
+    await fs.ensureDir(agentsDir);
+
+    // Save file with .agent extension
+    const fileName = `playwright-ui-testing-${templateName.toLowerCase().replace(/\s/g, "-")}-agent.md`;
+    const destFile = path.join(agentsDir, fileName);
+
+    // Copy template content
+    await fs.copyFile(templatePath, destFile);
+
+    console.log(`\n✅ Playwright UI Testing Framework created!`);
+    console.log(`📝 Language: ${templateName}`);
+    console.log(`📍 Location: ${destFile}\n`);
+  }
+
+  if (setup === "Playwright API Testing") {
+    // Template for API testing
     const templatePath = path.resolve(
       __dirname,
-      "../templates/playwright-agent.md"
+      "../templates/playwright-agent-api.md"
     );
 
     // Target folder **inside the user's project**
@@ -33,13 +98,13 @@ export default async function initCommand() {
     await fs.ensureDir(agentsDir);
 
     // Save file with .agent extension
-    const destFile = path.join(agentsDir, "playwrightsetup-agent.md");
+    const destFile = path.join(agentsDir, "playwright-api-testing-agent.md");
 
     // Copy template content
     await fs.copyFile(templatePath, destFile);
 
-    console.log(`\n✅ Playwright agent created at ${destFile}\n`);
+    console.log(`\n✅ Playwright API Testing agent created at ${destFile}\n`);
   }
 
-  console.log("Setup complete 🎉\n");
+  console.log("🎉 Setup complete!\n");
 }

package/src/templates/playwright-agent-api.md

@@ -0,0 +1,190 @@
+name: Create Playwright Framework - API Testing
+description: Creates a production-ready Playwright API testing framework with all dependencies and fixtures properly configured.
+argument-hint: "framework requirements, e.g., 'REST API and webhook testing'"
+
+---
+
+# Playwright API Testing Framework Setup
+
+This agent creates a production-ready Playwright framework optimized for API automation.
+
+## Capabilities
+- Playwright API testing setup (JS / TS)
+- REST API request handling
+- Response validation
+- Database integration
+- API fixtures and helpers
+- Sample API tests
+- Scalable folder structure
+- CI/CD ready configuration
+
+## Prerequisites
+- Node.js 18+ installed
+- npm or yarn
+- API endpoint documentation
+
+## Setup Instructions
+
+### 1. Install Dependencies
+```bash
+npm install
+```
+
+### 2. Required package.json Scripts
+Ensure your `package.json` includes these scripts:
+```json
+{
+  "scripts": {
+    "test": "playwright test",
+    "test:api": "playwright test --grep @api",
+    "test:debug": "playwright test --debug",
+    "test:report": "playwright show-report"
+  }
+}
+```
+
+### 3. Playwright Configuration
+Your `playwright.config.js` should include:
+```javascript
+{
+  testDir: './tests/api',
+  fullyParallel: true,
+  workers: process.env.CI ? 1 : undefined,
+  use: {
+    baseURL: process.env.API_BASE_URL || 'https://api.example.com',
+    timeout: 10000
+  }
+}
+```
+
+### 4. Sample API Tests (Ready to Use)
+
+**Login API Test** (`tests/api/auth.spec.js`):
+```javascript
+import { test, expect } from '@playwright/test';
+
+test('@api Login endpoint', async ({ request }) => {
+  const response = await request.post('https://api.example.com/auth/login', {
+    data: {
+      username: 'testuser',
+      password: 'testpass'
+    }
+  });
+  
+  expect(response.status()).toBe(200);
+  const data = await response.json();
+  expect(data).toHaveProperty('token');
+});
+```
+
+**GET Request Test** (`tests/api/users.spec.js`):
+```javascript
+import { test, expect } from '@playwright/test';
+
+test('@api Get all users', async ({ request }) => {
+  const response = await request.get('https://api.example.com/users');
+  
+  expect(response.status()).toBe(200);
+  const data = await response.json();
+  expect(Array.isArray(data)).toBeTruthy();
+});
+
+test('@api Get specific user', async ({ request }) => {
+  const response = await request.get('https://api.example.com/users/1');
+  
+  expect(response.status()).toBe(200);
+  const data = await response.json();
+  expect(data).toHaveProperty('id');
+  expect(data.id).toBe(1);
+});
+```
+
+**POST Request Test** (`tests/api/create.spec.js`):
+```javascript
+import { test, expect } from '@playwright/test';
+
+test('@api Create new user', async ({ request }) => {
+  const response = await request.post('https://api.example.com/users', {
+    data: {
+      name: 'John Doe',
+      email: 'john@example.com'
+    }
+  });
+  
+  expect(response.status()).toBe(201);
+  const data = await response.json();
+  expect(data.name).toBe('John Doe');
+  expect(data).toHaveProperty('id');
+});
+```
+
+**API Fixture Example** (`fixtures/api.js`):
+```javascript
+import { test as base } from '@playwright/test';
+
+export const test = base.extend({
+  apiContext: async ({ playwright }, use) => {
+    const context = await playwright.request.newContext({
+      baseURL: process.env.API_BASE_URL || 'https://api.example.com',
+      extraHTTPHeaders: {
+        'Authorization': `Bearer ${process.env.API_TOKEN}`
+      }
+    });
+    
+    await use(context);
+    await context.dispose();
+  }
+});
+```
+
+### 5. Run Tests
+```bash
+# Run all API tests
+npm test
+
+# Run only tests tagged with @api
+npm run test:api
+
+# Debug mode
+npm run test:debug
+
+# View HTML report
+npm run test:report
+```
+
+## Best Practices
+- Use fixtures for authentication tokens and common setup
+- Tag tests with `@api` for easy filtering
+- Use environment variables for sensitive data (API tokens, URLs)
+- Implement proper error handling and response validation
+- Create helper functions for common API calls
+- Mock external dependencies when possible
+
+## Environment Variables
+Create a `.env` file:
+```
+API_BASE_URL=https://api.example.com
+API_TOKEN=your_token_here
+DB_HOST=localhost
+DB_USER=admin
+DB_PASS=password
+```
+
+## Verification Checklist
+✅ All dependencies installed (`npm install`)
+✅ API endpoint(s) accessible
+✅ Environment variables configured
+✅ Playwright config points to correct API base URL
+✅ Sample tests execute successfully
+✅ Response validation working
+
+## Use Cases
+- Rest API testing
+- Backend service validation
+- Integration testing
+- Microservice testing
+- Contract testing
+
+---
+
+**Ready to test your APIs! 🚀**