docs: add npm downloads badges to all reporter READMEs

.gitignore

@@ -77,4 +77,7 @@ jspm_packages/
 
 # Temporary files and playground
 tmp
-*.tmp
+*.tmp
+
+CLAUDE.md
+.planning/

examples/multiProject/README.md

@@ -184,12 +184,38 @@ Project codes (e.g. `PROJ1`, `PROJ2`) must match `testops_multi.projects[].code`
 
 When you run the examples:
 
-1. **Test runs are created** in each configured project (e.g. DEVX and DEMO).
+1. **Test runs are created** in each configured project (e.g. PROJ1 and PROJ2).
 2. **Test results are sent** to the appropriate projects based on the mapping you specify.
 3. **Each project has its own test run** with the title and description from config.
-4. **Results appear** in both projects’ dashboards.
+4. **Results appear** in both projects' dashboards.
 5. **Tests without any Qase ID** are sent to the `default_project` without linking to a test case.
 
+## Expected Behavior by Framework
+
+### CucumberJS
+* Uses Gherkin tag syntax: `@qaseid.PROJ1(1)` and `@qaseid.PROJ2(2)` in feature files
+* Each scenario can be reported to multiple projects using separate tags
+* Native Gherkin Given/When/Then steps are automatically captured
+* Attachments via `this.attach()` in step definitions
+
+### Newman
+* Uses comment-based markers: `// qase PROJ1: 1` and `// qase PROJ2: 2` in test scripts
+* Multiple comments before `pm.test()` map the same test to multiple projects
+* No programmatic steps or attachments API (Postman limitation)
+* Collection structure determines test organization
+
+### TestCafe
+* Uses builder pattern: `test.meta(qase.projects({ PROJ1: [1], PROJ2: [2] }).create())`
+* Chaining supported: `qase.projects({...}).title('...').fields({...}).create()`
+* Nested steps use callback parameter (s, s1, s2) for hierarchy
+* Attachments use `type` parameter (not `contentType`)
+
+### WDIO
+* **Mocha/Jasmine mode:** `it(qase.projects({ PROJ1: [1], PROJ2: [2] }, 'Test name'), () => {...})`
+* **Cucumber mode:** Uses Gherkin tags like CucumberJS
+* Supports both programmatic steps and Gherkin steps depending on framework
+* Reporter options: `disableWebdriverStepsReporting`, `useCucumber`
+
 ## Mapping Tests to Projects (Summary)
 
 | Reporter   | Helper / usage |

examples/single/cucumberjs/README.md

@@ -0,0 +1,81 @@
+# CucumberJS Example
+
+This is a sample project demonstrating how to write and execute tests using the CucumberJS framework with integration to Qase Test Management.
+
+## Prerequisites
+
+Ensure that the following tools are installed on your machine:
+
+1. [Node.js](https://nodejs.org/) (version 18 or higher is recommended)
+2. [npm](https://www.npmjs.com/) or [yarn](https://yarnpkg.com/)
+
+## Setup Instructions
+
+1. Clone this repository by running the following commands:
+   ```bash
+   git clone https://github.com/qase-tms/qase-javascript.git
+   cd qase-javascript/examples/single/cucumberjs
+   ```
+
+2. Install the project dependencies:
+   ```bash
+   npm install
+   ```
+
+3. Create a `qase.config.json` file in the root of the project. Follow the instructions on [how to configure the file](https://github.com/qase-tms/qase-javascript/tree/main/qase-javascript-commons#configuration).
+
+## Example Files
+
+This example includes:
+
+* **features/** — Gherkin feature files with test scenarios
+  * `simple.feature` — Basic scenarios with Qase tags (@QaseID, @QaseTitle, @QaseFields)
+  * `table.feature` — Examples using data tables
+* **step_definitions/** — Step implementation files
+  * `simple_steps.js` — Step definitions using native Cucumber Given/When/Then
+  * `table_steps.js` — Step definitions for table-based scenarios
+* **qase.config.json** — Qase reporter configuration
+
+## Running Tests
+
+To run tests locally without reporting to Qase:
+
+```bash
+QASE_MODE=off npm test
+```
+
+To run tests and upload the results to Qase Test Management:
+
+```bash
+npm test
+```
+
+Or with explicit mode:
+
+```bash
+QASE_MODE=testops npx cucumber-js -f cucumberjs-qase-reporter
+```
+
+## Expected Behavior
+
+When tests execute with Qase reporting enabled:
+
+* **Gherkin scenarios** are reported as individual test cases in Qase
+* **Given/When/Then/And steps** from feature files are automatically reported as Qase test steps
+* **@QaseID tags** link scenarios to existing test cases in your Qase project
+* **@QaseTitle tags** override the default scenario name in Qase
+* **@QaseFields tags** add metadata (severity, priority, etc.) to test results
+* **Attachments** added via `this.attach()` in step definitions are included in Qase results
+
+## Framework-Specific Features
+
+CucumberJS with Qase has unique patterns:
+
+* **No programmatic qase.step() API** — Steps come from Gherkin syntax (Given/When/Then)
+* **Native Cucumber attachments** — Use `this.attach(content, mimeType)` in step definitions (not `qase.attach()`)
+* **Tag-based metadata** — Test configuration uses Gherkin tags instead of programmatic calls
+* **Feature-based organization** — Test suite hierarchy comes from Feature/Scenario structure
+
+## Additional Resources
+
+For more details on how to use this integration with Qase Test Management, visit the [Qase CucumberJS documentation](https://github.com/qase-tms/qase-javascript/tree/main/qase-cucumberjs).

examples/single/cypress/README.md

@@ -15,7 +15,7 @@ Ensure that the following tools are installed on your machine:
 1. Clone this repository by running the following commands:
    ```bash
    git clone https://github.com/qase-tms/qase-javascript.git
-   cd qase-js/examples/cypress
+   cd qase-javascript/examples/single/cypress
    ```
 
 2. Install the project dependencies:
@@ -26,18 +26,131 @@ Ensure that the following tools are installed on your machine:
 3. Create a `qase.config.json` file in the root of the project. Follow the instructions
    on [how to configure the file](https://github.com/qase-tms/qase-javascript/tree/main/qase-javascript-commons#configuration).
 
-4. Run the Cypress tests locally:
+4. To run tests locally without Qase reporting (interactive mode):
    ```bash
-   npx cypress open
+   QASE_MODE=off npx cypress open
    ```
-   This will open the Cypress Test Runner, where you can manually execute tests.
 
-5. To run tests and upload the results to Qase Test Management, use the following command:
+5. To run tests locally without Qase reporting (headless mode):
    ```bash
-   npx cypress run --env qaseApiToken=YOUR_QASE_API_TOKEN,qaseProjectCode=YOUR_PROJECT_CODE
+   QASE_MODE=off npx cypress run
    ```
 
-   Replace `YOUR_QASE_API_TOKEN` and `YOUR_PROJECT_CODE` with your Qase API token and project code.
+6. To run tests and upload the results to Qase Test Management:
+   ```bash
+   QASE_MODE=testops npx cypress run
+   ```
+
+## Example Files
+
+This project contains several test files demonstrating different Qase features:
+
+| File | Feature | Description |
+|------|---------|-------------|
+| `simpleTests.cy.js` | Basic tests | Simple Cypress tests with and without Qase integration |
+| `methodTests.cy.js` | Qase methods | Demonstrates `qase.comment()` and `qase.attach()` methods |
+| `stepTests.cy.js` | Test steps | Defines execution steps with `qase.step()` (synchronous callbacks) |
+| `parametrizedTests.cy.js` | Parameters | Reports parameterized test data with `qase.parameters()` |
+
+## Expected Behavior
+
+### Running with QASE_MODE=off (Local Development)
+
+When running tests with `QASE_MODE=off`, tests execute normally without Qase reporting:
+
+- Tests run and pass/fail as usual
+- No data is sent to Qase TestOps
+- No Qase API token required
+- Output shows standard Cypress test results
+- Cypress screenshots and videos work normally
+
+This mode is useful for local development and debugging.
+
+### Running with QASE_MODE=testops (CI/CD and Reporting)
+
+When running tests with `QASE_MODE=testops`, test results are reported to Qase:
+
+- Tests execute and results are sent to Qase TestOps
+- A new test run is created in your Qase project
+- Test results include all metadata (steps, attachments, comments, etc.)
+- Console output includes Qase test run link
+- Requires valid `QASE_TESTOPS_API_TOKEN` and `QASE_TESTOPS_PROJECT` configuration
+- Cypress screenshots on failure can be attached automatically
+
+**Steps Example (`stepTests.cy.js`):**
+- Creates test result with multiple named steps using `qase.step()`
+- Each step shows execution status, duration, and any errors
+- **Important:** Cypress steps use synchronous callbacks (no async/await)
+- Nested steps can be created by calling `qase.step()` within another step
+- Steps are visible in Qase test run details
+
+**Attachments Example (`methodTests.cy.js`):**
+- Content attached via `qase.attach()` appears in test results
+- Supports attaching text, JSON, and other content types
+- Cypress screenshots and videos can be attached automatically on failure
+- Attachments are visible in the test run details
+
+**Parameters Example (`parametrizedTests.cy.js`):**
+- Parameterized tests report their parameter values to Qase
+- Parameters help identify which test variant produced which result
+- Useful for data-driven testing scenarios
+
+**Multi-Project Support:**
+- When configured for multi-project reporting, same test results are sent to multiple Qase projects
+- Each project can have different test case IDs for the same test
+
+## Configuration
+
+Example `qase.config.json`:
+
+```json
+{
+  "mode": "testops",
+  "debug": false,
+  "testops": {
+    "api": {
+      "token": "your_api_token_here"
+    },
+    "project": "YOUR_PROJECT_CODE",
+    "run": {
+      "title": "Cypress Automated Test Run",
+      "complete": true
+    }
+  }
+}
+```
+
+Or configure via `cypress.config.js`:
+
+```javascript
+const { defineConfig } = require('cypress');
+
+module.exports = defineConfig({
+  reporter: 'cypress-qase-reporter',
+  reporterOptions: {
+    mode: 'testops',
+    testops: {
+      api: {
+        token: process.env.QASE_TESTOPS_API_TOKEN,
+      },
+      project: 'YOUR_PROJECT_CODE',
+      run: {
+        complete: true,
+      },
+    },
+  },
+  e2e: {
+    setupNodeEvents(on, config) {
+      // implement node event listeners here
+    },
+  },
+});
+```
+
+## Important Notes
+
+- **Synchronous Steps:** Unlike Jest or Playwright, Cypress steps use synchronous callbacks. Do NOT use `async/await` with `qase.step()` in Cypress tests.
+- **Import Pattern:** Use `import { qase } from 'cypress-qase-reporter/mocha';` (note the `/mocha` suffix, as Cypress uses Mocha under the hood)
 
 ## Additional Resources