qase-javascript-commons 2.4.17 → 2.5.0

package/README.md

@@ -34,8 +34,8 @@ All configuration options are listed in the table below:
 | Description                                                                                                           | Config file                | Environment variable            | Default value                           | Required | Possible values            |
 |-----------------------------------------------------------------------------------------------------------------------|----------------------------|---------------------------------|-----------------------------------------|----------|----------------------------|
 | **Common**                                                                                                            |                            |                                 |                                         |          |                            |
-| Mode of reporter                                                                                                      | `mode`                     | `QASE_MODE`                     | `off`                                  | No       | `testops`, `report`, `off` |
-| Fallback mode of reporter                                                                                             | `fallback`                 | `QASE_FALLBACK`                 | `off`                                   | No       | `testops`, `report`, `off` |
+| Mode of reporter                                                                                                      | `mode`                     | `QASE_MODE`                     | `off`                                  | No       | `testops`, `testops_multi`, `report`, `off` |
+| Fallback mode of reporter                                                                                             | `fallback`                 | `QASE_FALLBACK`                 | `off`                                   | No       | `testops`, `testops_multi`, `report`, `off` |
 | Environment                                                                                                           | `environment`              | `QASE_ENVIRONMENT`              | undefined                              | No       | Any string                 |
 | Root suite                                                                                                            | `rootSuite`                | `QASE_ROOT_SUITE`               | undefined                               | No       | Any string                 |
 | Enable debug logs                                                                                                     | `debug`                    | `QASE_DEBUG`                    | `False`                                 | No       | `True`, `False`            |
@@ -67,6 +67,18 @@ All configuration options are listed in the table below:
 | Configuration values to create/find in groups (format: `group1=value1,group2=value2`)                                | `testops.configurations.values`     | `QASE_TESTOPS_CONFIGURATIONS_VALUES`     | undefined                               | No       | Comma-separated key=value pairs |
 | Create configuration groups if they don't exist                                                                       | `testops.configurations.createIfNotExists` | `QASE_TESTOPS_CONFIGURATIONS_CREATE_IF_NOT_EXISTS` | `false`                          | No       | `True`, `False`            |
 | Enable public report link generation and display after test run completion                                            | `testops.showPublicReportLink`      | `QASE_TESTOPS_SHOW_PUBLIC_REPORT_LINK`   | `False`                                 | No       | `True`, `False`            |
+| **Qase TestOps Multi-Project configuration**                                                                          |                                     |                                            |                                         |          |                            |
+| Default project code for tests without explicit project mapping                                                       | `testops_multi.default_project`     | N/A (use config file)                     | First project in `projects`             | No       | Any string (must match one of `projects[].code`) |
+| Array of project configurations                                                                                      | `testops_multi.projects`             | N/A (use config file)                     | `[]`                                    | Yes\*\*  | Array of objects           |
+| Project code                                                                                                         | `testops_multi.projects[].code`     | N/A                                       | undefined                               | Yes\*\*  | Any string                 |
+| Project-specific test run title                                                                                      | `testops_multi.projects[].run.title` | N/A                                       | Same as single-project default          | No       | Any string                 |
+| Project-specific test run description                                                                               | `testops_multi.projects[].run.description` | N/A                                | Same as single-project default          | No       | Any string                 |
+| Project-specific test run complete                                                                                  | `testops_multi.projects[].run.complete`    | N/A                                | `true`                                  | No       | `true`, `false`            |
+| Project-specific test run ID                                                                                        | `testops_multi.projects[].run.id`   | N/A                                       | undefined                               | No       | Any integer                |
+| Project-specific test plan ID                                                                                       | `testops_multi.projects[].plan.id`  | N/A                                       | undefined                               | No       | Any integer                |
+| Project-specific environment                                                                                        | `testops_multi.projects[].environment`     | N/A                                | Uses global `environment` if not set     | No       | Any string                 |
+
+\*\* Required when using `testops_multi` mode
 
 ### Example `qase.config.json` config
 
@@ -134,6 +146,64 @@ All configuration options are listed in the table below:
 }
 ```
 
+### Multi-Project Configuration (`testops_multi` mode)
+
+Example `qase.config.json` for multi-project reporting:
+
+```json
+{
+  "mode": "testops_multi",
+  "fallback": "report",
+  "debug": false,
+  "environment": "local",
+  "logging": {
+    "console": true,
+    "file": false
+  },
+  "report": {
+    "driver": "local",
+    "connection": {
+      "local": {
+        "path": "./build/qase-report",
+        "format": "json"
+      }
+    }
+  },
+  "testops": {
+    "api": {
+      "token": "<token>",
+      "host": "qase.io"
+    },
+    "batch": { "size": 100 },
+    "showPublicReportLink": true
+  },
+  "testops_multi": {
+    "default_project": "PROJ1",
+    "projects": [
+      {
+        "code": "PROJ1",
+        "run": {
+          "title": "PROJ1 Multi-Project Run",
+          "description": "Test run for PROJ1 project",
+          "complete": true
+        },
+        "plan": { "id": 1 },
+        "environment": "staging"
+      },
+      {
+        "code": "PROJ2",
+        "run": {
+          "title": "PROJ2 Multi-Project Run",
+          "description": "Test run for PROJ2 project",
+          "complete": true
+        },
+        "environment": "production"
+      }
+    ]
+  }
+}
+```
+
 ### Environment Variables Example
 
 ```bash
@@ -156,3 +226,193 @@ export QASE_LOGGING_FILE=true      # Enable file output
 # Enable public report link generation
 export QASE_TESTOPS_SHOW_PUBLIC_REPORT_LINK=true
 ```
+
+## Multi-Project Support
+
+The multi-project feature allows you to send test results to multiple Qase projects simultaneously, with different test case IDs for each project. This is useful when:
+
+* You need to report the same test to different projects
+* Different projects track the same functionality with different test case IDs
+* You want to maintain separate test runs for different environments or teams
+
+### How It Works
+
+1. Configure multiple projects in the `testops_multi.projects` array
+2. Each project can have its own run configuration (title, description, plan, environment)
+3. Use framework-specific helpers or markers to map test cases to projects (see table below)
+4. Tests without explicit project mapping are sent to `default_project` (or the first project). Results without any case ID are also sent to the default project without linking to a test case.
+
+### Framework-Specific Documentation
+
+For detailed framework-specific documentation on multi-project support, see:
+
+* **[Cypress Multi-Project Guide](../qase-cypress/docs/MULTI_PROJECT.md)** — `qase.projects(mapping, it(...))`, title markers
+* **[Playwright Multi-Project Guide](../qase-playwright/docs/MULTI_PROJECT.md)** — `qase.projects(mapping)`, `qase.projectsTitle()`, annotations
+* **[Jest Multi-Project Guide](../qase-jest/docs/MULTI_PROJECT.md)** — `qase.projects(mapping, name)`
+* **[Vitest Multi-Project Guide](../qase-vitest/docs/MULTI_PROJECT.md)** — `addQaseProjects(name, mapping)`
+* **[Mocha Multi-Project Guide](../qase-mocha/docs/MULTI_PROJECT.md)** — `qase.projects(mapping, name)`
+* **[WDIO Multi-Project Guide](../qase-wdio/docs/MULTI_PROJECT.md)** — `qase.projects(mapping, name)`
+* **[CucumberJS Multi-Project Guide](../qase-cucumberjs/docs/MULTI_PROJECT.md)** — tags `@qaseid.PROJ(ids)` in feature files
+* **[Newman](../examples/multiProject/newman/README.md)** — comments in test script
+* **[TestCafe](../examples/multiProject/testcafe/README.md)** — `qase.projects(mapping).create()` in `test.meta()`
+
+### Example Usage
+
+For runnable examples, see the [multi-project examples directory](../examples/multiProject/).
+
+### Configuration
+
+Set `mode` to `testops_multi` and add a `testops_multi` section with `default_project` and `projects`:
+
+```json
+{
+  "mode": "testops_multi",
+  "testops": {
+    "api": { "token": "<token>", "host": "qase.io" },
+    "batch": { "size": 100 }
+  },
+  "testops_multi": {
+    "default_project": "PROJ1",
+    "projects": [
+      {
+        "code": "PROJ1",
+        "run": { "title": "Project 1 Run", "complete": true },
+        "plan": { "id": 1 },
+        "environment": "staging"
+      },
+      {
+        "code": "PROJ2",
+        "run": { "title": "Project 2 Run", "id": 123, "complete": true },
+        "environment": "production"
+      }
+    ]
+  }
+}
+```
+
+### Test case mapping
+
+For each result you can set `testops_project_mapping` (or use the helpers on `TestResultType`):
+
+- **`testops_project_mapping`**: `Record<string, number[]>` — project code → list of test case IDs.
+- **Backward compatibility**: if `testops_project_mapping` is empty or missing, the result uses `testops_id` and is sent to `default_project` (or the first project).
+
+### How to specify projects and IDs in tests
+
+Use the syntax below **only when `mode` is `testops_multi`**. For single-project mode (`testops`), keep using the usual single-project syntax (e.g. `(Qase ID: 123)` or `qase(1, 'name')`).
+
+Use the **helper methods** below so project codes and IDs are formatted correctly (same idea as `qase(id, name)` for single-project).
+
+#### Vitest
+
+- **Single project:** `addQaseId(name, caseIds)` → `"name (Qase ID: 1,2)"`.
+- **Multi-project:** `addQaseProjects(name, mapping)` → `"name (Qase PROJ1: 1,2) (Qase PROJ2: 3)"`.
+
+```js
+import { addQaseId, addQaseProjects } from 'vitest-qase-reporter/vitest';
+
+// Single project (legacy)
+it(addQaseId('login flow', [100]), async () => { ... });
+
+// Multi-project — use helper so title is formatted correctly
+it(addQaseProjects('login flow', { PROJ1: [100], PROJ2: [200] }), async () => { ... });
+
+// Multiple IDs per project
+it(addQaseProjects('checkout', { PROJ1: [10, 11], PROJ2: [20] }), async () => { ... });
+```
+
+#### Jest
+
+- **Single project:** `qase(caseId, name)`.
+- **Multi-project:** `qase.projects(mapping, name)`.
+
+```js
+const { qase } = require('jest-qase-reporter');
+
+// Single project
+test(qase(100, 'login flow'), () => { ... });
+
+// Multi-project
+test(qase.projects({ PROJ1: [100], PROJ2: [200] }, 'login flow'), () => { ... });
+```
+
+#### Cypress
+
+- **Single project:** `qase(caseId, test)` (mutates test title) or title string `(Qase ID: 100)`.
+- **Multi-project:** `qase.projects(mapping, name)` returns the title string; use it as the first argument to `it()`.
+
+```js
+const { qase } = require('cypress-qase-reporter');
+
+// Single project
+it(qase(100, 'login flow'), () => { ... });  // if qase receives test
+it('login flow (Qase ID: 100)', () => { ... });
+
+// Multi-project — use helper
+it(qase.projects({ PROJ1: [100], PROJ2: [200] }, 'login flow'), () => { ... });
+```
+
+**Tags (Cucumber/BDD):** `@qaseid.PROJ1(100) @qaseid.PROJ2(200)`.
+
+#### Playwright
+
+- **Single project:** `qase(caseId, name)` or `qase.id([1, 2])` in test.
+- **Multi-project:** `qase.projects(mapping)` inside the test (metadata, not title).
+
+```js
+const { test } = require('@playwright/test');
+const { qase } = require('playwright-qase-reporter');
+
+// Multi-project: set mapping inside the test
+test('login and checkout', async ({ page }) => {
+  qase.projects({ PROJ1: [1, 2], PROJ2: [3] });
+  await page.goto('/login');
+  // ...
+});
+
+// Single project
+test(qase(1, 'single project test'), async ({ page }) => { ... });
+```
+
+#### Mocha
+
+- **Single project:** `qase(caseId, name)`.
+- **Multi-project:** `qase.projects(mapping, name)`.
+
+```js
+const { qase } = require('mocha-qase-reporter');
+
+it(qase(100, 'login flow'), function () { ... });
+it(qase.projects({ PROJ1: [100], PROJ2: [200] }, 'login flow'), function () { ... });
+```
+
+#### WDIO (WebdriverIO)
+
+- **Single project:** `qase(qaseId, name)`.
+- **Multi-project:** `qase.projects(mapping, name)`.
+
+```js
+const { qase } = require('wdio-qase-reporter');
+
+it(qase(1, 'should work'), async () => { ... });
+it(qase.projects({ PROJ1: [100], PROJ2: [200] }, 'Login flow'), async () => { ... });
+```
+
+You can still type markers manually in the title (e.g. `(Qase PROJ1: 100) (Qase PROJ2: 200)`); the helpers avoid typos and keep the format consistent.
+
+#### Summary
+
+| Framework   | Single project (legacy)     | Multi-project (project: IDs in title or API)     |
+|------------|-----------------------------|--------------------------------------------------|
+| **Vitest** | `(Qase ID: 123)` in title   | `(Qase PROJ1: 123) (Qase PROJ2: 456)` in title   |
+| **Jest**   | `(Qase ID: 123)` in title   | `(Qase PROJ1: 123) (Qase PROJ2: 456)` in title   |
+| **Cypress**| `(Qase ID: 123)` or `@qaseid(123)` | `(Qase PROJ1: 123) (Qase PROJ2: 456)` or `@qaseid.PROJ1(123) @qaseid.PROJ2(456)` |
+| **Playwright** | `qase(1, 'name')` or metadata | `qase.projects({ PROJ1: [1, 2], PROJ2: [3] })` in test |
+| **Mocha**  | `(Qase ID: 123)` in title   | `(Qase PROJ1: 123) (Qase PROJ2: 456)` in title   |
+| **WDIO**   | `(Qase ID: 123)` in title   | `(Qase PROJ1: 123) (Qase PROJ2: 456)` in title   |
+
+- **Title format:** `(Qase PROJECT_CODE: id1,id2,...)` — space after `Qase`, project code (letters, numbers, underscores), colon, then one or more IDs separated by commas. Several projects = several such blocks in one title.
+- **Cypress tags:** `@qaseid.PROJECT_CODE(id1,id2,...)`.
+- **Playwright:** `qase.projects({ PROJECT_CODE: [id1, id2, ...], ... })`; project codes must match `testops_multi.projects[].code`.
+
+Tests that do not specify any multi-project mapping are sent to `default_project` (or the first project) using their usual single-project ID, if any.

package/changelog.md

@@ -1,3 +1,20 @@
+# qase-javascript-commons@2.5.0
+
+## What's new
+
+Added **multi-project support** (`testops_multi` mode):
+
+- New mode `testops_multi` sends results to multiple Qase projects in one run; each project gets its own run.
+- New field `testops_project_mapping` on `TestResultType`: project code → list of test case IDs. Helpers: `setTestopsProjectMapping()`, `getTestopsProjectMapping()`, `getTestopsIdsForProject()`, `getProjects()`.
+- New config: `testops_multi.default_project` and `testops_multi.projects[]` with `code`, `run`, `plan`, `environment` per project.
+- New reporter `TestOpsMultiReporter`; selected when `mode` is `testops_multi`. Single-project behavior is unchanged.
+
+# qase-javascript-commons@2.4.18
+
+## What's new
+
+Fixed issue with incorrect link to failed test in the console output.
+
 # qase-javascript-commons@2.4.17
 
 ## What's new

package/dist/config/config-validation-schema.d.ts

@@ -184,6 +184,88 @@ export declare const configValidationSchema: {
                 };
             };
         };
+        testops_multi: {
+            type: string;
+            nullable: boolean;
+            properties: {
+                default_project: {
+                    type: string;
+                    nullable: boolean;
+                };
+                projects: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            code: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                            run: {
+                                type: string;
+                                nullable: boolean;
+                                properties: {
+                                    id: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                    title: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                    description: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                    complete: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                    tags: {
+                                        type: string;
+                                        items: {
+                                            type: string;
+                                        };
+                                        nullable: boolean;
+                                    };
+                                    externalLink: {
+                                        type: string;
+                                        nullable: boolean;
+                                        properties: {
+                                            type: {
+                                                type: string;
+                                                enum: ExternalLinkType[];
+                                            };
+                                            link: {
+                                                type: string;
+                                            };
+                                        };
+                                        required: string[];
+                                    };
+                                };
+                            };
+                            plan: {
+                                type: string;
+                                nullable: boolean;
+                                properties: {
+                                    id: {
+                                        type: string;
+                                        nullable: boolean;
+                                    };
+                                };
+                            };
+                            environment: {
+                                type: string;
+                                nullable: boolean;
+                            };
+                        };
+                        required: string[];
+                    };
+                    nullable: boolean;
+                };
+            };
+            required: string[];
+        };
         report: {
             type: string;
             nullable: boolean;

package/dist/config/config-validation-schema.js

@@ -12,12 +12,12 @@ exports.configValidationSchema = {
     properties: {
         mode: {
             type: 'string',
-            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.off],
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.testops_multi, options_1.ModeEnum.off],
             nullable: true,
         },
         fallback: {
             type: 'string',
-            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.off],
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.testops_multi, options_1.ModeEnum.off],
             nullable: true,
         },
         debug: {
@@ -187,6 +187,69 @@ exports.configValidationSchema = {
                 },
             },
         },
+        testops_multi: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                default_project: {
+                    type: 'string',
+                    nullable: true,
+                },
+                projects: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            code: {
+                                type: 'string',
+                                nullable: true,
+                            },
+                            run: {
+                                type: 'object',
+                                nullable: true,
+                                properties: {
+                                    id: { type: 'number', nullable: true },
+                                    title: { type: 'string', nullable: true },
+                                    description: { type: 'string', nullable: true },
+                                    complete: { type: 'boolean', nullable: true },
+                                    tags: {
+                                        type: 'array',
+                                        items: { type: 'string' },
+                                        nullable: true,
+                                    },
+                                    externalLink: {
+                                        type: 'object',
+                                        nullable: true,
+                                        properties: {
+                                            type: {
+                                                type: 'string',
+                                                enum: [TestOpsOptionsType_1.ExternalLinkType.JIRA_CLOUD, TestOpsOptionsType_1.ExternalLinkType.JIRA_SERVER],
+                                            },
+                                            link: { type: 'string' },
+                                        },
+                                        required: ['type', 'link'],
+                                    },
+                                },
+                            },
+                            plan: {
+                                type: 'object',
+                                nullable: true,
+                                properties: {
+                                    id: { type: 'number', nullable: true },
+                                },
+                            },
+                            environment: {
+                                type: 'string',
+                                nullable: true,
+                            },
+                        },
+                        required: ['code'],
+                    },
+                    nullable: true,
+                },
+            },
+            required: ['projects'],
+        },
         report: {
             type: 'object',
             nullable: true,

package/dist/env/env-validation-schema.js

@@ -12,12 +12,12 @@ exports.envValidationSchema = {
     properties: {
         [env_enum_1.EnvEnum.mode]: {
             type: 'string',
-            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.off],
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.testops_multi, options_1.ModeEnum.off],
             nullable: true,
         },
         [env_enum_1.EnvEnum.fallback]: {
             type: 'string',
-            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.off],
+            enum: [options_1.ModeEnum.report, options_1.ModeEnum.testops, options_1.ModeEnum.testops_multi, options_1.ModeEnum.off],
             nullable: true,
         },
         [env_enum_1.EnvEnum.debug]: {

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from './reporters';
 export * from './writer';
 export * from './utils/get-package-version';
 export * from './utils/mimeTypes';
+export * from './utils/project-mapping-utils';
 export * from './utils/signature';
 export * from './utils/test-status-utils';
 export * from './steps/step';

package/dist/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./reporters"), exports);
 __exportStar(require("./writer"), exports);
 __exportStar(require("./utils/get-package-version"), exports);
 __exportStar(require("./utils/mimeTypes"), exports);
+__exportStar(require("./utils/project-mapping-utils"), exports);
 __exportStar(require("./utils/signature"), exports);
 __exportStar(require("./utils/test-status-utils"), exports);
 __exportStar(require("./steps/step"), exports);

package/dist/models/config/TestOpsOptionsType.d.ts

@@ -1,3 +1,21 @@
+/**
+ * Per-project configuration for multi-project (testops_multi) mode.
+ */
+export interface TestOpsProjectConfigType {
+    code: string;
+    run?: TestOpsRunType;
+    plan?: TestOpsPlanType;
+    environment?: string;
+}
+/**
+ * Multi-project TestOps configuration.
+ */
+export interface TestOpsMultiConfigType {
+    /** Default project for tests without explicit mapping (and for results without any case ID). */
+    default_project?: string;
+    /** List of project configurations. */
+    projects: TestOpsProjectConfigType[];
+}
 export interface TestOpsOptionsType {
     project: string;
     uploadAttachments?: boolean | undefined;

package/dist/models/index.d.ts

@@ -1,5 +1,5 @@
 export { TestResultType } from './test-result';
-export type { Relation, Suite, SuiteData } from './test-result';
+export type { Relation, Suite, SuiteData, TestopsProjectMapping } from './test-result';
 export { TestExecution, TestStatusEnum } from './test-execution';
 export { TestStepType, StepType } from './test-step';
 export { StepStatusEnum } from './step-execution';
@@ -8,4 +8,4 @@ export type { Report } from './report';
 export { CompoundError } from './error';
 export type { ConfigurationGroup, ConfigurationItem, ConfigurationGroupResponse } from './configuration';
 export { ExternalLinkType } from './config/TestOpsOptionsType';
-export type { TestOpsOptionsType, TestOpsApiType, TestOpsRunType, TestOpsPlanType, TestOpsBatchType, TestOpsConfigurationType, TestOpsConfigurationValueType, TestOpsExternalLinkType } from './config/TestOpsOptionsType';
+export type { TestOpsOptionsType, TestOpsApiType, TestOpsRunType, TestOpsPlanType, TestOpsBatchType, TestOpsConfigurationType, TestOpsConfigurationValueType, TestOpsExternalLinkType, TestOpsProjectConfigType, TestOpsMultiConfigType } from './config/TestOpsOptionsType';

package/dist/models/test-result.d.ts

@@ -1,12 +1,23 @@
 import { TestStepType } from './test-step';
 import { Attachment } from './attachment';
 import { TestExecution } from './test-execution';
+/**
+ * Project code to test case IDs mapping for multi-project support.
+ * Key: project code (string), Value: array of test case IDs (numbers).
+ */
+export type TestopsProjectMapping = Record<string, number[]>;
 export declare class TestResultType {
     id: string;
     title: string;
     signature: string;
     run_id: number | null;
     testops_id: number | number[] | null;
+    /**
+     * Multi-project mapping: project code -> array of test case IDs.
+     * When set, overrides testops_id for multi-project mode.
+     * If empty/null, fall back to testops_id for single project.
+     */
+    testops_project_mapping: TestopsProjectMapping | null;
     execution: TestExecution;
     fields: Record<string, string>;
     attachments: Attachment[];
@@ -19,6 +30,22 @@ export declare class TestResultType {
     message: string | null;
     preparedAttachments?: string[];
     constructor(title: string);
+    /**
+     * Set test case IDs for a specific project in multi-project mapping.
+     */
+    setTestopsProjectMapping(projectCode: string, testopsIds: number[]): void;
+    /**
+     * Get the entire project-to-IDs mapping.
+     */
+    getTestopsProjectMapping(): TestopsProjectMapping | null;
+    /**
+     * Get test case IDs for a specific project.
+     */
+    getTestopsIdsForProject(projectCode: string): number[] | undefined;
+    /**
+     * Get list of all project codes in the mapping.
+     */
+    getProjects(): string[];
 }
 export interface Relation {
     suite?: Suite;

package/dist/models/test-result.js

@@ -8,6 +8,12 @@ class TestResultType {
     signature;
     run_id;
     testops_id;
+    /**
+     * Multi-project mapping: project code -> array of test case IDs.
+     * When set, overrides testops_id for multi-project mode.
+     * If empty/null, fall back to testops_id for single project.
+     */
+    testops_project_mapping;
     execution;
     fields;
     attachments;
@@ -25,6 +31,7 @@ class TestResultType {
         this.signature = '';
         this.run_id = null;
         this.testops_id = null;
+        this.testops_project_mapping = null;
         this.execution = new test_execution_1.TestExecution();
         this.fields = {};
         this.attachments = [];
@@ -37,5 +44,32 @@ class TestResultType {
         this.message = null;
         this.preparedAttachments = [];
     }
+    /**
+     * Set test case IDs for a specific project in multi-project mapping.
+     */
+    setTestopsProjectMapping(projectCode, testopsIds) {
+        if (!this.testops_project_mapping) {
+            this.testops_project_mapping = {};
+        }
+        this.testops_project_mapping[projectCode] = testopsIds;
+    }
+    /**
+     * Get the entire project-to-IDs mapping.
+     */
+    getTestopsProjectMapping() {
+        return this.testops_project_mapping;
+    }
+    /**
+     * Get test case IDs for a specific project.
+     */
+    getTestopsIdsForProject(projectCode) {
+        return this.testops_project_mapping?.[projectCode];
+    }
+    /**
+     * Get list of all project codes in the mapping.
+     */
+    getProjects() {
+        return this.testops_project_mapping ? Object.keys(this.testops_project_mapping) : [];
+    }
 }
 exports.TestResultType = TestResultType;

package/dist/options/mode-enum.d.ts

@@ -4,5 +4,7 @@
 export declare enum ModeEnum {
     report = "report",
     testops = "testops",
+    /** Multi-project mode: send results to multiple Qase projects. */
+    testops_multi = "testops_multi",
     off = "off"
 }

package/dist/options/mode-enum.js

@@ -8,5 +8,7 @@ var ModeEnum;
 (function (ModeEnum) {
     ModeEnum["report"] = "report";
     ModeEnum["testops"] = "testops";
+    /** Multi-project mode: send results to multiple Qase projects. */
+    ModeEnum["testops_multi"] = "testops_multi";
     ModeEnum["off"] = "off";
 })(ModeEnum || (exports.ModeEnum = ModeEnum = {}));

package/dist/options/options-type.d.ts

@@ -1,6 +1,6 @@
 import { ModeEnum } from './mode-enum';
 import { DriverEnum, FsWriterOptionsType } from '../writer';
-import { TestOpsOptionsType } from '../models/config/TestOpsOptionsType';
+import { TestOpsOptionsType, TestOpsMultiConfigType } from '../models/config/TestOpsOptionsType';
 type RecursivePartial<T> = {
     [K in keyof T]?: RecursivePartial<T[K]> | undefined;
 };
@@ -28,6 +28,8 @@ export type OptionsType = {
     statusMapping?: Record<string, string> | undefined;
     logging?: RecursivePartial<LoggingOptionsType> | undefined;
     testops?: RecursivePartial<TestOpsOptionsType> | undefined;
+    /** Multi-project configuration (used when mode is testops_multi). */
+    testops_multi?: TestOpsMultiConfigType | undefined;
     report?: RecursivePartial<AdditionalReportOptionsType> | undefined;
 };
 export type FrameworkOptionsType<F extends string, O> = {

package/dist/qase.js

@@ -97,7 +97,10 @@ class QaseReporter {
         this.logger.logDebug(`Config: ${JSON.stringify(this.sanitizeOptions(composedOptions))}`);
         const effectiveMode = composedOptions.mode || options_1.ModeEnum.off;
         const effectiveFallback = composedOptions.fallback || options_1.ModeEnum.off;
-        const needsHostData = effectiveMode === options_1.ModeEnum.testops || effectiveFallback === options_1.ModeEnum.testops;
+        const needsHostData = effectiveMode === options_1.ModeEnum.testops ||
+            effectiveMode === options_1.ModeEnum.testops_multi ||
+            effectiveFallback === options_1.ModeEnum.testops ||
+            effectiveFallback === options_1.ModeEnum.testops_multi;
         this.hostData = needsHostData
             ? (0, hostData_1.getHostInfo)(options.frameworkPackage, options.reporterName)
             : (0, hostData_1.getMinimalHostData)();
@@ -453,6 +456,21 @@ class QaseReporter {
                 const apiClient = new clientV2_1.ClientV2(this.logger, options.testops, options.environment, options.rootSuite, this.hostData, options.reporterName, options.frameworkPackage);
                 return new reporters_1.TestOpsReporter(this.logger, apiClient, this.withState, options.testops.project, options.testops.api.host, options.testops.batch?.size, options.testops.run?.id, options.testops.showPublicReportLink);
             }
+            case options_1.ModeEnum.testops_multi: {
+                if (!options.testops?.api?.token) {
+                    throw new Error(`Either "testops.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "testops_multi" mode`);
+                }
+                const multi = options.testops_multi;
+                if (!multi?.projects?.length) {
+                    throw new Error('"testops_multi.projects" must contain at least one project with a "code" field');
+                }
+                for (const p of multi.projects) {
+                    if (!p?.code) {
+                        throw new Error('Each project in "testops_multi.projects" must have a "code" field');
+                    }
+                }
+                return new reporters_1.TestOpsMultiReporter(this.logger, options.testops, multi, this.withState, this.hostData, options.reporterName, options.frameworkPackage, options.environment, options.testops.api?.host, options.testops.batch?.size, options.testops.showPublicReportLink);
+            }
             case options_1.ModeEnum.report: {
                 const localOptions = options.report?.connections?.[writer_1.DriverEnum.local];
                 const writer = new writer_1.FsWriter(localOptions);

package/dist/reporters/abstract-reporter.d.ts

@@ -64,5 +64,5 @@ export declare abstract class AbstractReporter implements InternalReporterInterf
      * @param {TestResultType[]} results
      */
     setTestResults(results: TestResultType[]): void;
-    private removeAnsiEscapeCodes;
+    protected removeAnsiEscapeCodes(str: string): string;
 }

package/dist/reporters/index.d.ts

@@ -1,3 +1,4 @@
 export { AbstractReporter, type InternalReporterInterface, } from './abstract-reporter';
 export { ReportReporter } from './report-reporter';
 export { TestOpsReporter } from './testops-reporter';
+export { TestOpsMultiReporter } from './testops-multi-reporter';

package/dist/reporters/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestOpsReporter = exports.ReportReporter = exports.AbstractReporter = void 0;
+exports.TestOpsMultiReporter = exports.TestOpsReporter = exports.ReportReporter = exports.AbstractReporter = void 0;
 var abstract_reporter_1 = require("./abstract-reporter");
 Object.defineProperty(exports, "AbstractReporter", { enumerable: true, get: function () { return abstract_reporter_1.AbstractReporter; } });
 var report_reporter_1 = require("./report-reporter");
 Object.defineProperty(exports, "ReportReporter", { enumerable: true, get: function () { return report_reporter_1.ReportReporter; } });
 var testops_reporter_1 = require("./testops-reporter");
 Object.defineProperty(exports, "TestOpsReporter", { enumerable: true, get: function () { return testops_reporter_1.TestOpsReporter; } });
+var testops_multi_reporter_1 = require("./testops-multi-reporter");
+Object.defineProperty(exports, "TestOpsMultiReporter", { enumerable: true, get: function () { return testops_multi_reporter_1.TestOpsMultiReporter; } });

package/dist/reporters/testops-multi-reporter.d.ts

@@ -0,0 +1,50 @@
+import { AbstractReporter } from './abstract-reporter';
+import { Attachment, TestResultType } from '../models';
+import type { TestOpsOptionsType, TestOpsMultiConfigType } from '../models/config/TestOpsOptionsType';
+import { LoggerInterface } from '../utils/logger';
+import { HostData } from '../models/host-data';
+/**
+ * Multi-project TestOps reporter. Sends test results to multiple Qase projects
+ * with different test case IDs per project. Each project gets its own run.
+ */
+export declare class TestOpsMultiReporter extends AbstractReporter {
+    private readonly baseUrl;
+    private readonly batchSize;
+    /** Project code -> run ID */
+    private readonly runIds;
+    /** Project code -> API client for that project */
+    private readonly clients;
+    /** Project code -> queue of results to send */
+    private readonly projectQueues;
+    /** Project code -> first unsent index (for batch tracking) */
+    private readonly firstIndexByProject;
+    private isTestRunReady;
+    private readonly mutex;
+    private readonly defaultProject;
+    private readonly projectCodes;
+    private readonly showPublicReportLink;
+    constructor(logger: LoggerInterface, testopsOptions: TestOpsOptionsType, multiConfig: TestOpsMultiConfigType, withState: boolean, hostData: HostData, reporterName: string | undefined, frameworkPackage: string | undefined, environment?: string, baseUrl?: string, batchSize?: number, showPublicReportLink?: boolean);
+    private buildProjectOptions;
+    startTestRun(): Promise<void>;
+    addTestResult(result: TestResultType): Promise<void>;
+    /**
+     * Get list of (projectCode, ids) for a result (multi-project mapping or legacy testops_id).
+     * Caller must hold mutex when using projectQueues.
+     */
+    private getProjectsToUseForResult;
+    /**
+     * Push a result into project queues (by project / case IDs). Used by addTestResult and by
+     * sendResults() when results were set via setTestResults() (e.g. Cypress hooks in another process).
+     * Caller must hold mutex.
+     */
+    private distributeResultToProjectQueues;
+    private copyResultForProject;
+    private checkOrCreateTestRuns;
+    private sendResultsForProject;
+    sendResults(): Promise<void>;
+    publish(): Promise<void>;
+    complete(): Promise<void>;
+    uploadAttachment(attachment: Attachment): Promise<string>;
+    private getBaseUrl;
+    private showLink;
+}

package/dist/reporters/testops-multi-reporter.js

@@ -0,0 +1,299 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestOpsMultiReporter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const uuid_1 = require("uuid");
+const abstract_reporter_1 = require("./abstract-reporter");
+const models_1 = require("../models");
+const async_mutex_1 = require("async-mutex");
+const clientV2_1 = require("../client/clientV2");
+const defaultChunkSize = 200;
+/**
+ * Multi-project TestOps reporter. Sends test results to multiple Qase projects
+ * with different test case IDs per project. Each project gets its own run.
+ */
+class TestOpsMultiReporter extends abstract_reporter_1.AbstractReporter {
+    baseUrl;
+    batchSize;
+    /** Project code -> run ID */
+    runIds = new Map();
+    /** Project code -> API client for that project */
+    clients = new Map();
+    /** Project code -> queue of results to send */
+    projectQueues = new Map();
+    /** Project code -> first unsent index (for batch tracking) */
+    firstIndexByProject = new Map();
+    isTestRunReady = false;
+    mutex = new async_mutex_1.Mutex();
+    defaultProject;
+    projectCodes;
+    showPublicReportLink;
+    constructor(logger, testopsOptions, multiConfig, withState, hostData, reporterName, frameworkPackage, environment, baseUrl, batchSize, showPublicReportLink) {
+        super(logger);
+        this.baseUrl = this.getBaseUrl(baseUrl ?? testopsOptions.api?.host);
+        this.batchSize = batchSize ?? testopsOptions.batch?.size ?? defaultChunkSize;
+        this.showPublicReportLink = showPublicReportLink ?? testopsOptions.showPublicReportLink;
+        this.defaultProject =
+            multiConfig.default_project ??
+                (multiConfig.projects.length > 0 ? multiConfig.projects[0].code : '');
+        this.projectCodes = multiConfig.projects
+            .filter((p) => Boolean(p?.code))
+            .map((p) => p.code);
+        void withState; // reserved for future StateManager integration
+        for (const proj of multiConfig.projects) {
+            if (!proj?.code)
+                continue;
+            const projectOptions = this.buildProjectOptions(testopsOptions, proj);
+            const env = proj.environment ?? environment;
+            const client = new clientV2_1.ClientV2(logger, projectOptions, env, undefined, hostData, reporterName, frameworkPackage);
+            this.clients.set(proj.code, client);
+            this.projectQueues.set(proj.code, []);
+            this.firstIndexByProject.set(proj.code, 0);
+        }
+    }
+    buildProjectOptions(global, proj) {
+        const opts = {
+            project: proj.code,
+            api: global.api,
+            run: proj.run ?? global.run ?? {},
+            plan: proj.plan ?? global.plan ?? {},
+            uploadAttachments: global.uploadAttachments,
+            defect: global.defect,
+            configurations: global.configurations,
+            statusFilter: global.statusFilter,
+            showPublicReportLink: this.showPublicReportLink,
+        };
+        if (global.batch !== undefined) {
+            opts.batch = global.batch;
+        }
+        return opts;
+    }
+    async startTestRun() {
+        await this.checkOrCreateTestRuns();
+    }
+    async addTestResult(result) {
+        if (result.execution.status === models_1.TestStatusEnum.failed) {
+            const mapping = result.getTestopsProjectMapping?.() ?? result.testops_project_mapping ?? null;
+            if (mapping) {
+                for (const [projectCode, ids] of Object.entries(mapping)) {
+                    for (const id of ids) {
+                        this.showLink(projectCode, id, result.title);
+                    }
+                }
+            }
+            else {
+                const ids = Array.isArray(result.testops_id) ? result.testops_id : [result.testops_id];
+                for (const id of ids) {
+                    if (id != null) {
+                        this.showLink(this.defaultProject, id, result.title);
+                    }
+                }
+            }
+        }
+        const release = await this.mutex.acquire();
+        try {
+            // Keep original in this.results for getTestResults / fallback
+            if (result.execution.stacktrace) {
+                result.execution.stacktrace = this.removeAnsiEscapeCodes(result.execution.stacktrace);
+            }
+            if (result.message) {
+                result.message = this.removeAnsiEscapeCodes(result.message);
+            }
+            this.results.push(result);
+            if (!this.isTestRunReady) {
+                return;
+            }
+            for (const { code, ids } of this.getProjectsToUseForResult(result)) {
+                const copy = this.copyResultForProject(result, code, ids);
+                const queue = this.projectQueues.get(code);
+                queue.push(copy);
+                const first = this.firstIndexByProject.get(code) ?? 0;
+                if (queue.length >= first + this.batchSize) {
+                    await this.sendResultsForProject(code);
+                }
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Get list of (projectCode, ids) for a result (multi-project mapping or legacy testops_id).
+     * Caller must hold mutex when using projectQueues.
+     */
+    getProjectsToUseForResult(result) {
+        const mapping = result.getTestopsProjectMapping?.() ?? result.testops_project_mapping ?? null;
+        const projectsToUse = [];
+        if (mapping && Object.keys(mapping).length > 0) {
+            for (const [code, ids] of Object.entries(mapping)) {
+                if (this.projectCodes.includes(code) && ids.length > 0) {
+                    projectsToUse.push({ code, ids });
+                }
+            }
+        }
+        else {
+            // Backward compatibility: use default project + testops_id, or send without case ID to default project
+            const ids = Array.isArray(result.testops_id)
+                ? result.testops_id
+                : result.testops_id != null
+                    ? [result.testops_id]
+                    : [];
+            if (this.defaultProject) {
+                projectsToUse.push({ code: this.defaultProject, ids });
+            }
+        }
+        return projectsToUse;
+    }
+    /**
+     * Push a result into project queues (by project / case IDs). Used by addTestResult and by
+     * sendResults() when results were set via setTestResults() (e.g. Cypress hooks in another process).
+     * Caller must hold mutex.
+     */
+    distributeResultToProjectQueues(result) {
+        for (const { code, ids } of this.getProjectsToUseForResult(result)) {
+            const copy = this.copyResultForProject(result, code, ids);
+            const queue = this.projectQueues.get(code);
+            queue.push(copy);
+        }
+    }
+    copyResultForProject(result, _projectCode, ids) {
+        const copy = { ...result };
+        copy.id = (0, uuid_1.v4)();
+        copy.testops_id = ids.length === 0 ? null : ids.length === 1 ? ids[0] : ids;
+        copy.testops_project_mapping = null;
+        return copy;
+    }
+    async checkOrCreateTestRuns() {
+        for (const code of this.projectCodes) {
+            const client = this.clients.get(code);
+            const runId = await client.createRun();
+            this.runIds.set(code, runId);
+            this.logger.logDebug(`[${code}] Run ID: ${runId}`);
+        }
+        this.isTestRunReady = true;
+    }
+    async sendResultsForProject(projectCode) {
+        const queue = this.projectQueues.get(projectCode);
+        const first = this.firstIndexByProject.get(projectCode) ?? 0;
+        const client = this.clients.get(projectCode);
+        const runId = this.runIds.get(projectCode);
+        if (!queue || !client || runId === undefined) {
+            return false;
+        }
+        const toSend = queue.slice(first, first + this.batchSize);
+        if (toSend.length === 0) {
+            return false;
+        }
+        try {
+            await client.uploadResults(runId, toSend);
+            this.firstIndexByProject.set(projectCode, first + toSend.length);
+            this.logger.logDebug(`[${projectCode}] Sent ${toSend.length} results to Qase`);
+            return true;
+        }
+        catch (error) {
+            this.logger.logError(`[${projectCode}] Error sending results:`, error);
+            return false;
+        }
+    }
+    async sendResults() {
+        const release = await this.mutex.acquire();
+        try {
+            // Only flush this.results when projectQueues are empty (e.g. Cypress: results set via
+            // setTestResults() in another process). When addTestResult() already queued results
+            // (same process, e.g. Cucumber), do not flush to avoid sending each result twice.
+            const queuesEmpty = this.projectCodes.every((code) => (this.projectQueues.get(code)?.length ?? 0) === 0);
+            if (this.results.length > 0 && this.isTestRunReady && queuesEmpty) {
+                for (const result of this.results) {
+                    this.distributeResultToProjectQueues(result);
+                }
+                this.results = [];
+            }
+            for (const code of this.projectCodes) {
+                let sent;
+                do {
+                    sent = await this.sendResultsForProject(code);
+                } while (sent);
+            }
+            for (const code of this.projectCodes) {
+                this.projectQueues.set(code, []);
+                this.firstIndexByProject.set(code, 0);
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async publish() {
+        // Do not hold mutex here: sendResults() and complete() acquire it themselves.
+        // Holding mutex would deadlock when sendResults() tries to acquire the same mutex.
+        await this.sendResults();
+        await this.complete();
+    }
+    async complete() {
+        const release = await this.mutex.acquire();
+        try {
+            // Send any remaining results per project
+            for (const code of this.projectCodes) {
+                let sent;
+                do {
+                    sent = await this.sendResultsForProject(code);
+                } while (sent);
+            }
+            for (const code of this.projectCodes) {
+                this.projectQueues.set(code, []);
+                this.firstIndexByProject.set(code, 0);
+            }
+        }
+        finally {
+            release();
+        }
+        const completePromises = this.projectCodes.map(async (code) => {
+            const client = this.clients.get(code);
+            const runId = this.runIds.get(code);
+            if (client && runId !== undefined) {
+                try {
+                    await client.completeRun(runId);
+                    if (this.showPublicReportLink) {
+                        try {
+                            await client.enablePublicReport(runId);
+                        }
+                        catch {
+                            // Error already logged in enablePublicReport
+                        }
+                    }
+                    this.logger.log((0, chalk_1.default) `{green [${code}] Run ${runId} completed}`);
+                }
+                catch (error) {
+                    this.logger.logError(`[${code}] Error completing run:`, error);
+                }
+            }
+        });
+        await Promise.all(completePromises);
+    }
+    async uploadAttachment(attachment) {
+        // Attachments are uploaded per project when results are sent; use default project's client
+        const client = this.clients.get(this.defaultProject);
+        if (client) {
+            return await client.uploadAttachment(attachment);
+        }
+        return '';
+    }
+    getBaseUrl(url) {
+        if (!url || url === 'qase.io') {
+            return 'https://app.qase.io';
+        }
+        return `https://${url.replace('api', 'app')}`;
+    }
+    showLink(projectCode, id, title) {
+        const runId = this.runIds.get(projectCode);
+        if (runId === undefined)
+            return;
+        const baseLink = `${this.baseUrl}/run/${projectCode}/dashboard/${runId}?source=logs&search=`;
+        const link = id != null ? `${baseLink}${projectCode}-${id}` : `${baseLink}${encodeURI(title)}`;
+        this.logger.log((0, chalk_1.default) `{blue See why this test failed: ${link}}`);
+    }
+}
+exports.TestOpsMultiReporter = TestOpsMultiReporter;

package/dist/reporters/testops-reporter.js

@@ -181,7 +181,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         if (!this.runId) {
             throw new Error('Run ID is not set');
         }
-        const baseLink = `${this.baseUrl}/run/${this.projectCode}/dashboard/${this.runId}?source=logs&status=%5B2%5D&search=`;
+        const baseLink = `${this.baseUrl}/run/${this.projectCode}/dashboard/${this.runId}?source=logs&search=`;
         if (id) {
             return `${baseLink}${this.projectCode}-${id}`;
         }

package/dist/utils/project-mapping-utils.d.ts

@@ -0,0 +1,46 @@
+import type { TestopsProjectMapping } from '../models';
+/**
+ * Result of parsing project/ID markers from a test title.
+ * - legacyIds: from "(Qase ID: 123)" or "(Qase ID: 123,124)" — single-project mode.
+ * - projectMapping: from "(Qase PROJ1: 123)" etc. — multi-project mode (project code -> IDs).
+ * - cleanedTitle: title with all such patterns removed.
+ */
+export interface ParsedProjectMapping {
+    legacyIds: number[];
+    projectMapping: TestopsProjectMapping;
+    cleanedTitle: string;
+}
+/**
+ * Result of parsing @qaseid / @qaseid.PROJ tags.
+ * - legacyIds: from @qaseid(123) or @qaseid(123,124).
+ * - projectMapping: from @qaseid.PROJ1(123,124).
+ */
+export interface ParsedTagsProjectMapping {
+    legacyIds: number[];
+    projectMapping: TestopsProjectMapping;
+}
+/**
+ * Parse @qaseid and @qaseid.PROJECT tags into legacy IDs and project mapping.
+ *
+ * @param tags — e.g. ["@qaseid(1,2)", "@qaseid.PROJ2(3)"]
+ * @returns legacyIds from @qaseid(...), projectMapping from @qaseid.PROJ(...)
+ */
+export declare function parseProjectMappingFromTags(tags: string[]): ParsedTagsProjectMapping;
+/**
+ * Parse multi-project and legacy Qase ID markers from a test title.
+ * - "(Qase ID: 123)" or "(Qase ID: 123,124)" → legacyIds, single-project.
+ * - "(Qase PROJ1: 123)" or "(Qase PROJ2: 456)" → projectMapping for testops_multi.
+ *
+ * @param title — test title that may contain "(Qase ID: …)" or "(Qase PROJECT_CODE: …)".
+ * @returns legacyIds, projectMapping, and cleanedTitle with all markers stripped.
+ */
+export declare function parseProjectMappingFromTitle(title: string): ParsedProjectMapping;
+/**
+ * Build a test title with multi-project markers for use in test names.
+ * Use this (or framework-specific qase.projects()) so the reporter can parse project and IDs.
+ *
+ * @param title — base test title (e.g. "Login flow").
+ * @param mapping — project code → list of test case IDs (e.g. { PROJ1: [1, 2], PROJ2: [3] }).
+ * @returns title with appended markers, e.g. "Login flow (Qase PROJ1: 1,2) (Qase PROJ2: 3)".
+ */
+export declare function formatTitleWithProjectMapping(title: string, mapping: TestopsProjectMapping): string;

package/dist/utils/project-mapping-utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProjectMappingFromTags = parseProjectMappingFromTags;
+exports.parseProjectMappingFromTitle = parseProjectMappingFromTitle;
+exports.formatTitleWithProjectMapping = formatTitleWithProjectMapping;
+/** Matches @qaseid(123) or @qaseid.PROJ1(123,124). */
+const QASEID_TAG_REGEXP = /@qaseid(?:\.([A-Za-z0-9_]+))?\(([\d,]+)\)/gi;
+/**
+ * Parse @qaseid and @qaseid.PROJECT tags into legacy IDs and project mapping.
+ *
+ * @param tags — e.g. ["@qaseid(1,2)", "@qaseid.PROJ2(3)"]
+ * @returns legacyIds from @qaseid(...), projectMapping from @qaseid.PROJ(...)
+ */
+function parseProjectMappingFromTags(tags) {
+    const legacyIds = [];
+    const projectMapping = {};
+    for (const tag of tags) {
+        let m;
+        const re = new RegExp(QASEID_TAG_REGEXP.source, 'gi');
+        while ((m = re.exec(tag)) !== null) {
+            const projectCode = m[1]; // undefined for @qaseid(1)
+            const idsStr = m[2] ?? '';
+            const ids = idsStr.split(',').map((s) => parseInt(s, 10)).filter((n) => !Number.isNaN(n));
+            if (!projectCode || projectCode.toUpperCase() === 'ID') {
+                legacyIds.push(...ids);
+            }
+            else if (ids.length > 0) {
+                const existing = projectMapping[projectCode] ?? [];
+                projectMapping[projectCode] = [...existing, ...ids];
+            }
+        }
+    }
+    return { legacyIds, projectMapping };
+}
+/** Matches "(Qase ID: 123)" or "(Qase PROJ1: 123,124)" — optional space after "Qase". */
+const QASE_MARKER_REGEXP = /\(Qase\s+([A-Za-z0-9_]+):\s*([\d,]+)\)/gi;
+/**
+ * Parse multi-project and legacy Qase ID markers from a test title.
+ * - "(Qase ID: 123)" or "(Qase ID: 123,124)" → legacyIds, single-project.
+ * - "(Qase PROJ1: 123)" or "(Qase PROJ2: 456)" → projectMapping for testops_multi.
+ *
+ * @param title — test title that may contain "(Qase ID: …)" or "(Qase PROJECT_CODE: …)".
+ * @returns legacyIds, projectMapping, and cleanedTitle with all markers stripped.
+ */
+function parseProjectMappingFromTitle(title) {
+    const legacyIds = [];
+    const projectMapping = {};
+    let cleanedTitle = title;
+    let m;
+    const re = new RegExp(QASE_MARKER_REGEXP.source, 'gi');
+    while ((m = re.exec(title)) !== null) {
+        const projectCode = m[1] ?? '';
+        const idsStr = m[2] ?? '';
+        const ids = idsStr.split(',').map((s) => parseInt(s, 10)).filter((n) => !Number.isNaN(n));
+        if (projectCode.toUpperCase() === 'ID') {
+            legacyIds.push(...ids);
+        }
+        else if (projectCode && ids.length > 0) {
+            const existing = projectMapping[projectCode] ?? [];
+            projectMapping[projectCode] = [...existing, ...ids];
+        }
+        cleanedTitle = cleanedTitle.replace(m[0], '');
+    }
+    cleanedTitle = cleanedTitle.replace(/\s+/g, ' ').trim();
+    return { legacyIds, projectMapping, cleanedTitle };
+}
+/**
+ * Build a test title with multi-project markers for use in test names.
+ * Use this (or framework-specific qase.projects()) so the reporter can parse project and IDs.
+ *
+ * @param title — base test title (e.g. "Login flow").
+ * @param mapping — project code → list of test case IDs (e.g. { PROJ1: [1, 2], PROJ2: [3] }).
+ * @returns title with appended markers, e.g. "Login flow (Qase PROJ1: 1,2) (Qase PROJ2: 3)".
+ */
+function formatTitleWithProjectMapping(title, mapping) {
+    if (!title || typeof title !== 'string') {
+        return title;
+    }
+    const parts = Object.entries(mapping)
+        .filter(([, ids]) => Array.isArray(ids) && ids.length > 0)
+        .map(([code, ids]) => `(Qase ${code}: ${ids.join(',')})`);
+    if (parts.length === 0) {
+        return title.trim();
+    }
+    return `${title.trim()} ${parts.join(' ')}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.4.17",
+  "version": "2.5.0",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",