allure 3.19.1 → 3.20.1

package/README.md

@@ -68,6 +68,11 @@ Repeat `--results-dir` for multiple patterns. CLI overrides `config.resultsDir`.
 
 After the tests complete, the report is generated automatically. Existing results from previous runs are ignored, as Allure 3 focuses solely on new data to ensure accurate and up-to-date reporting.
 
+Allure operational messages use scoped prefixes such as `[AllureRun]:`, `[QualityGate]:`, and `[AllureRerun]:`.
+Set `ALLURE_LOG_LEVEL=debug` to include details such as selected tests and temporary test plan paths. Allure ignores
+the generic `LOG_LEVEL` environment variable. Use `--silent` to hide the nested test process output while keeping
+Allure lifecycle messages visible.
+
 ### Running Tests In Agent Mode
 
 When you need agent-friendly markdown output for review, debugging, or scope validation, use the `agent` command:

package/dist/commands/commons/generate.d.ts

@@ -2,6 +2,7 @@ import { type ReportContext } from "@allurereport/ci";
 import type { FullConfig } from "@allurereport/core";
 export type GenerateResult = {
     summary?: ReportContext;
+    exitCode: 0 | 1;
 };
 export declare const generate: (params: {
     cwd: string;

package/dist/commands/commons/generate.js

@@ -1,6 +1,6 @@
 import { exit } from "node:process";
 import { createReportContext } from "@allurereport/ci";
-import { AllureReport } from "@allurereport/core";
+import { AllureReport, filterFailedQualityGateResults, stringifyQualityGateResults } from "@allurereport/core";
 import { KnownError } from "@allurereport/service";
 import { red } from "yoctocolors";
 import { findFilesByGlobs } from "../../utils/fileSystem.js";
@@ -26,11 +26,25 @@ export const generate = async (params) => {
         for (const dir of resultDirectories) {
             await allureReport.readDirectory(dir);
         }
+        let exitCode = 0;
+        if (allureReport.hasQualityGate) {
+            const trs = await allureReport.store.allTestResults({ includeRetries: false });
+            const { results } = await allureReport.validate({
+                trs,
+                environment: params.config.environment,
+            });
+            const qualityGateMessage = stringifyQualityGateResults(results);
+            if (qualityGateMessage) {
+                console.error(qualityGateMessage);
+            }
+            allureReport.realtimeDispatcher.sendQualityGateResults(results);
+            exitCode = filterFailedQualityGateResults(results).length > 0 ? 1 : 0;
+        }
         await allureReport.done();
         if (!params.collectSummary) {
-            return;
+            return { exitCode };
         }
-        const result = {};
+        const result = { exitCode };
         try {
             const summary = await createReportContext(params.config.output, {
                 onError: (message) => console.warn(message),

package/dist/commands/commons/run.d.ts

@@ -8,6 +8,10 @@ export type TestProcessResult = {
     fastFailed: boolean;
 };
 export type RunLogsMode = "pipe" | "inherit" | "ignore";
+type RunAttempt = {
+    current: number;
+    total: number;
+};
 export declare const executeNestedAllureCommand: (params: {
     command: string;
     commandArgs: string[];
@@ -26,6 +30,7 @@ export declare const runTests: (params: {
     silent?: boolean;
     logs?: RunLogsMode;
     logProcessExit?: boolean;
+    attempt?: RunAttempt;
     resultsPatterns?: readonly string[];
 }) => Promise<TestProcessResult | null>;
 export declare const executeAllureRun: (params: {
@@ -46,3 +51,4 @@ export declare const executeAllureRun: (params: {
     globalExitCode: ExitCode;
     testProcessResult: TestProcessResult | null;
 }>;
+export {};

package/dist/commands/commons/run.js

@@ -1,20 +1,22 @@
-import * as console from "node:console";
 import { randomUUID } from "node:crypto";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import process from "node:process";
+import { Logger } from "@allurereport/cli-commons";
 import { QualityGateState, filterFailedQualityGateResults, stringifyQualityGateResults, } from "@allurereport/core";
-import { createTestPlan } from "@allurereport/core-api";
+import { createTestPlan, formatDuration } from "@allurereport/core-api";
 import { allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, newFilesInDirectoryWatcher, } from "@allurereport/directory-watcher";
 import { formatProcessLogAttachmentName } from "@allurereport/plugin-agent";
 import { BufferResultFile, PathResultFile } from "@allurereport/reader-api";
 import { KnownError } from "@allurereport/service";
-import { red } from "yoctocolors";
-import { logTests, runProcess, terminationOf } from "../../utils/index.js";
+import { runProcess, terminationOf } from "../../utils/index.js";
 import { logError } from "../../utils/logs.js";
 import { stopProcessTree } from "../../utils/process.js";
 import { allureResultsDirectoriesGlobWatcher } from "./resultsDiscovery.js";
+const runLogger = new Logger("AllureRun");
+const qualityGateLogger = new Logger("QualityGate");
+const rerunLogger = new Logger("AllureRerun");
 export const executeNestedAllureCommand = async (params) => {
     const nestedProcess = runProcess({
         command: params.command,
@@ -34,7 +36,7 @@ const attachResultsDirectoryWatchers = (params) => {
     return allureResultsDirectoriesWatcher(params.cwd, params.onUpdate, { indexDelay: 600 });
 };
 export const runTests = async (params) => {
-    const { allureReport, cwd, command, commandArgs, logs, environmentVariables, environment, withQualityGate, silent, logProcessExit = true, resultsPatterns = [], } = params;
+    const { allureReport, cwd, command, commandArgs, logs, environmentVariables, environment, withQualityGate, silent, logProcessExit = true, attempt = { current: 1, total: 1 }, resultsPatterns = [], } = params;
     let testProcessStarted = false;
     const allureResultsWatchers = new Map();
     const processWatcher = delayedFileProcessingWatcher(async (path) => {
@@ -72,6 +74,16 @@ export const runTests = async (params) => {
     await allureResultsWatch.initialScan();
     testProcessStarted = true;
     const beforeProcess = Date.now();
+    const commandLine = [command, ...commandArgs].join(" ");
+    const rerunsEnabled = attempt.total > 1;
+    if (logProcessExit) {
+        if (rerunsEnabled) {
+            runLogger.info(`Attempt ${attempt.current}/${attempt.total} started: ${commandLine}`);
+        }
+        else {
+            runLogger.info(`Running: ${commandLine}`);
+        }
+    }
     const testProcess = runProcess({
         command,
         commandArgs,
@@ -107,6 +119,10 @@ export const runTests = async (params) => {
             fastFailTriggered = true;
             qualityGateResults = results;
             qualityGateUnsub = undefined;
+            const failedRules = filterFailedQualityGateResults(results).map(({ rule }) => rule);
+            const failedRulesMessage = failedRules.length > 0 ? `: ${failedRules.join(", ")}` : "";
+            const stopTarget = rerunsEnabled ? `attempt ${attempt.current}/${attempt.total}` : "test process";
+            qualityGateLogger.info(`Fast-fail triggered${failedRulesMessage}; stopping ${stopTarget}`);
             try {
                 await stopProcessTree(testProcess.pid);
             }
@@ -136,12 +152,16 @@ export const runTests = async (params) => {
     }
     const code = await terminationOf(testProcess);
     const afterProcess = Date.now();
-    if (logProcessExit) {
-        if (code !== null) {
-            console.log(`process finished with code ${code} (${afterProcess - beforeProcess}ms)`);
+    if (logProcessExit && rerunsEnabled) {
+        const duration = formatDuration(afterProcess - beforeProcess);
+        if (fastFailTriggered) {
+            runLogger.info(`Attempt ${attempt.current}/${attempt.total} stopped by Quality Gate after ${duration}`);
+        }
+        else if (code !== null) {
+            runLogger.info(`Attempt ${attempt.current}/${attempt.total} finished with code ${code} after ${duration}`);
         }
         else {
-            console.log(`process terminated (${afterProcess - beforeProcess}ms)`);
+            runLogger.warn(`Attempt ${attempt.current}/${attempt.total} terminated after ${duration}`);
         }
     }
     await allureResultsWatch.abort();
@@ -159,6 +179,11 @@ export const runTests = async (params) => {
         fastFailed: fastFailTriggered,
     };
 };
+const relatedQualityGateTestResults = async (allureReport, qualityGateResults) => {
+    const testResultIds = new Set(filterFailedQualityGateResults(qualityGateResults).flatMap(({ testResults }) => testResults));
+    const testResults = await Promise.all([...testResultIds].map((id) => allureReport.store.testResultById(id)));
+    return testResults.filter((testResult) => testResult !== undefined);
+};
 const publishProcessGlobals = (params) => {
     const { allureReport, command, commandArgs, ignoreLogs, processFailed, testProcessResult } = params;
     if (!ignoreLogs && testProcessResult?.stdout) {
@@ -182,6 +207,7 @@ const publishProcessGlobals = (params) => {
 };
 export const executeAllureRun = async (params) => {
     const { allureReport, cwd, command, commandArgs, environmentVariables = {}, environment, withQualityGate, silent, logs, ignoreLogs, maxRerun = 0, logProcessExit = true, resultsPatterns = [], } = params;
+    const totalAttempts = maxRerun + 1;
     await allureReport.start();
     const globalExitCode = {
         original: 0,
@@ -201,6 +227,10 @@ export const executeAllureRun = async (params) => {
             environmentVariables,
             withQualityGate,
             logProcessExit,
+            attempt: {
+                current: 1,
+                total: totalAttempts,
+            },
             resultsPatterns,
         });
         const allFailuresAfterInitialRun = await allureReport.store.failedTestResults();
@@ -218,37 +248,75 @@ export const executeAllureRun = async (params) => {
                 testProcessResult,
             });
         }
-        for (let rerun = 0; rerun < maxRerun && testProcessResult && !testProcessResult.fastFailed; rerun++) {
-            const failed = await allureReport.store.blockingFailedTestResults();
-            if (failed.length === 0) {
-                console.log("no failed tests is detected.");
-                break;
+        for (let rerun = 0; rerun < maxRerun && testProcessResult; rerun++) {
+            const nextAttempt = {
+                current: rerun + 2,
+                total: totalAttempts,
+            };
+            const fullRerun = testProcessResult.fastFailed;
+            let testResultsToRerun = [];
+            if (!fullRerun) {
+                const blockingFailures = await allureReport.store.blockingFailedTestResults();
+                let relatedTestResults = [];
+                if (withQualityGate) {
+                    const currentTestResults = await allureReport.store.allTestResults({ includeRetries: false });
+                    const { results } = await allureReport.validate({
+                        trs: currentTestResults,
+                        environment,
+                    });
+                    relatedTestResults = await relatedQualityGateTestResults(allureReport, results);
+                }
+                testResultsToRerun = [
+                    ...new Map([...blockingFailures, ...relatedTestResults].map((testResult) => [testResult.id, testResult])).values(),
+                ];
+                if (testResultsToRerun.length === 0) {
+                    rerunLogger.info("No blocking failures or failed Quality Gate-related tests remain; no further reruns are needed");
+                    break;
+                }
+            }
+            const testPlan = createTestPlan(testResultsToRerun);
+            if (fullRerun) {
+                rerunLogger.warn(`Attempt ${nextAttempt.current}/${nextAttempt.total}: Quality Gate fast-fail interrupted the previous attempt; restarting full test process`);
+            }
+            else {
+                const testWord = testPlan.tests.length === 1 ? "test" : "tests";
+                rerunLogger.info(`Attempt ${nextAttempt.current}/${nextAttempt.total}: rerunning ${testPlan.tests.length} failed, broken, or Quality Gate-related ${testWord}`);
+                testResultsToRerun.forEach(({ fullName, status }) => {
+                    rerunLogger.debug(`${fullName} (${status})`);
+                });
+            }
+            const tmpDir = fullRerun ? undefined : await mkdtemp(join(tmpdir(), "allure-run-"));
+            const testPlanPath = tmpDir ? resolve(tmpDir, `${rerun}-testplan.json`) : undefined;
+            try {
+                if (testPlanPath) {
+                    await writeFile(testPlanPath, JSON.stringify(testPlan));
+                    rerunLogger.debug(`Test plan: ${testPlanPath}`);
+                }
+                allureReport.realtimeDispatcher.sendProcessGlobalsReset();
+                testProcessResult = await runTests({
+                    silent,
+                    logs,
+                    allureReport,
+                    cwd,
+                    command,
+                    commandArgs,
+                    environment,
+                    environmentVariables: {
+                        ...environmentVariables,
+                        ...(testPlanPath ? { ALLURE_TESTPLAN_PATH: testPlanPath } : {}),
+                        ALLURE_RERUN: `${rerun}`,
+                    },
+                    withQualityGate,
+                    logProcessExit,
+                    attempt: nextAttempt,
+                    resultsPatterns,
+                });
+            }
+            finally {
+                if (tmpDir) {
+                    await rm(tmpDir, { recursive: true, force: true });
+                }
             }
-            const testPlan = createTestPlan(failed);
-            console.log(`rerun number ${rerun} of ${testPlan.tests.length} tests:`);
-            logTests(failed);
-            const tmpDir = await mkdtemp(join(tmpdir(), "allure-run-"));
-            const testPlanPath = resolve(tmpDir, `${rerun}-testplan.json`);
-            await writeFile(testPlanPath, JSON.stringify(testPlan));
-            allureReport.realtimeDispatcher.sendProcessGlobalsReset();
-            testProcessResult = await runTests({
-                silent,
-                logs,
-                allureReport,
-                cwd,
-                command,
-                commandArgs,
-                environment,
-                environmentVariables: {
-                    ...environmentVariables,
-                    ALLURE_TESTPLAN_PATH: testPlanPath,
-                    ALLURE_RERUN: `${rerun}`,
-                },
-                withQualityGate,
-                logProcessExit,
-                resultsPatterns,
-            });
-            await rm(tmpDir, { recursive: true });
             const allFailuresAfterRerun = await allureReport.store.failedTestResults();
             const blockingFailuresAfterRerun = await allureReport.store.blockingFailedTestResults();
             publishProcessGlobals({
@@ -261,7 +329,6 @@ export const executeAllureRun = async (params) => {
                     : (testProcessResult?.code ?? -1)) !== 0,
                 testProcessResult,
             });
-            logTests(await allureReport.store.allTestResults());
         }
         const allFailuresAfterReruns = await allureReport.store.failedTestResults();
         const blockingFailuresAfterReruns = await allureReport.store.blockingFailedTestResults();
@@ -280,7 +347,7 @@ export const executeAllureRun = async (params) => {
         if (qualityGateResults.length) {
             const qualityGateMessage = stringifyQualityGateResults(qualityGateResults);
             if (qualityGateMessage) {
-                console.error(qualityGateMessage);
+                qualityGateLogger.error(qualityGateMessage);
             }
             allureReport.realtimeDispatcher.sendQualityGateResults(qualityGateResults);
         }
@@ -292,13 +359,13 @@ export const executeAllureRun = async (params) => {
     catch (error) {
         globalExitCode.actual = 1;
         if (error instanceof KnownError) {
-            console.error(red(error.message));
+            runLogger.error(error.message);
             allureReport.realtimeDispatcher.sendGlobalError({
                 message: error.message,
             });
         }
         else {
-            await logError("Failed to run tests using Allure due to unexpected error", error);
+            await logError("Failed to run tests using Allure due to unexpected error", error, (message) => runLogger.error(message));
             allureReport.realtimeDispatcher.sendGlobalError({
                 message: error.message,
                 trace: error.stack,

package/dist/commands/generate.d.ts

@@ -14,5 +14,5 @@ export declare class GenerateCommand extends Command {
     historyBaseUrl: string | undefined;
     hideLabels: string[] | undefined;
     knownIssues: string | undefined;
-    execute(): Promise<void>;
+    execute(): Promise<0 | 1 | undefined>;
 }

package/dist/commands/generate.js

@@ -59,12 +59,15 @@ export class GenerateCommand extends Command {
             ...(this.historyBaseUrl !== undefined ? { historyBaseUrl: this.historyBaseUrl } : {}),
             resolutions: { knownIssuesPath: this.knownIssues },
         });
-        await generate({
+        const result = await generate({
             dump: this.dump,
             resultsDir: this.resultsDir,
             cwd,
             config,
         });
+        if (!result) {
+            return;
+        }
         if (config.open) {
             await serve({
                 port: config.port ? parseInt(config.port, 10) : undefined,
@@ -72,12 +75,14 @@ export class GenerateCommand extends Command {
                 open: true,
             });
         }
+        return result.exitCode;
     }
 }
 GenerateCommand.paths = [["generate"]];
 GenerateCommand.usage = Command.Usage({
     description: "Generates the report in the specified directory.",
-    details: "This command generates a report from the provided Allure Results directories.",
+    details: "This command generates a report from the provided Allure Results directories. " +
+        "When a quality gate is configured, the command validates the loaded results and finishes writing the report or dump before returning its status.",
     examples: [
         ["generate ./allure-results", "Generate a report from the ./allure-results directory"],
         [

package/dist/commands/gitlab/generate.d.ts

@@ -10,6 +10,7 @@ export declare class GitlabGenerateCommand extends Command {
     historyPath: string | undefined;
     historyLimit: string | undefined;
     historyBaseUrl: string | undefined;
+    summaryComment: boolean;
     gitlabToken: string | undefined;
-    execute(): Promise<void>;
+    execute(): Promise<0 | 1 | undefined>;
 }

package/dist/commands/gitlab/generate.js

@@ -66,6 +66,9 @@ export class GitlabGenerateCommand extends Command {
         this.historyBaseUrl = Option.String("--history-base-url", {
             description: "The public base URL of the generated report directory",
         });
+        this.summaryComment = Option.Boolean("--summary-comment", true, {
+            description: "Post a report summary comment in the merge request (default: true). Disable with --no-summary-comment",
+        });
         this.gitlabToken = Option.String("--gitlab-token", {
             description: "GitLab api token with api write permissions",
         });
@@ -111,11 +114,11 @@ export class GitlabGenerateCommand extends Command {
         }
         const reportUrl = `${config.historyBaseUrl}/index.html`;
         console.log(`GitLab report URL: ${reportUrl}`);
-        if (result.summary && existsSync(join(config.output, "index.html"))) {
+        if (this.summaryComment && result.summary && existsSync(join(config.output, "index.html"))) {
             console.log("Posting report summary comment");
             if (!token) {
                 console.log("  no API token provided, skipping");
-                return;
+                return result.exitCode;
             }
             const { summary } = result;
             await runGitlabOperation("  failed to add summary comment", () => upsertGitlabJobNote({
@@ -124,12 +127,13 @@ export class GitlabGenerateCommand extends Command {
                 reportUrl,
             }));
         }
+        return result.exitCode;
     }
 }
 GitlabGenerateCommand.paths = [["gitlab"]];
 GitlabGenerateCommand.usage = Command.Usage({
     category: "Integrations",
-    description: "Generate test report and post report summary in merge request comments",
+    description: "Generate test report and optionally post report summary in merge request comments",
     details: "This command generates a report from the provided Allure Results directories. When api access token is configured, " +
         "integration will post summary as comment for merge request pipelines and attempt to lookup history file from previously executed job ." +
         "This integration is designed to be executed from within GitLab CI job.",

package/dist/commands/run.js

@@ -1,7 +1,8 @@
-import * as console from "node:console";
 import { realpath, rm } from "node:fs/promises";
 import process, { exit } from "node:process";
+import { Logger } from "@allurereport/cli-commons";
 import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
+import { formatDuration } from "@allurereport/core-api";
 import Awesome from "@allurereport/plugin-awesome";
 import { serve } from "@allurereport/static-server";
 import { Command, Option, UsageError } from "clipanion";
@@ -10,6 +11,7 @@ import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../u
 import { parseRunCommand, resolveResultsPatterns } from "../utils/resultsPatterns.js";
 import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
 const missingRunCommandUsageError = () => new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
+const runLogger = new Logger("AllureRun");
 export class RunCommand extends Command {
     constructor() {
         super(...arguments);
@@ -32,7 +34,7 @@ export class RunCommand extends Command {
             description: "The report name (default: Allure Report)",
         });
         this.rerun = Option.String("--rerun", {
-            description: "The number of reruns for failed tests. Quality gate validation is skipped when rerun is greater than 0 (default: 0)",
+            description: "The maximum number of reruns for failed tests and Quality Gate fast-fails (default: 0)",
         });
         this.silent = Option.Boolean("--silent", {
             description: "Don't pipe the process output logs to console (default: 0)",
@@ -74,14 +76,10 @@ export class RunCommand extends Command {
             throw missingRunCommandUsageError();
         }
         const before = new Date().getTime();
-        process.on("exit", (exitCode) => {
-            const after = new Date().getTime();
-            console.log(`exit code ${exitCode} (${after - before}ms)`);
-        });
         const cwd = await realpath(this.cwd ?? process.cwd());
         const hideLabels = this.hideLabels?.length ? this.hideLabels : undefined;
-        console.log(`${command} ${commandArgs.join(" ")}`);
         if (getActiveAllureCliCommand()) {
+            runLogger.info(`Running nested command: ${[command, ...commandArgs].join(" ")}`);
             const exitCode = await executeNestedAllureCommand({
                 command,
                 commandArgs,
@@ -109,17 +107,13 @@ export class RunCommand extends Command {
         });
         const resultsPatterns = resolveResultsPatterns(this.resultsDir ?? [], config.resultsDir);
         const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
-        const withRerun = maxRerun > 0;
-        const withQualityGate = !!config.qualityGate && !withRerun;
-        if (config.qualityGate && withRerun) {
-            console.warn("Quality gate doesn't work with rerun; skipping quality gate validation.");
-        }
+        const withQualityGate = !!config.qualityGate;
         try {
             await rm(config.output, { recursive: true });
         }
         catch (e) {
             if (!isFileNotFoundError(e)) {
-                console.error("could not clean output directory", e);
+                runLogger.error(`Could not clean output directory: ${e instanceof Error ? e.message : String(e)}`);
             }
         }
         const allureReport = new AllureReport({
@@ -157,6 +151,8 @@ export class RunCommand extends Command {
             maxRerun,
             resultsPatterns,
         });
+        const finalExitCode = globalExitCode.actual ?? globalExitCode.original;
+        runLogger.info(`Completed with exit code ${finalExitCode} after ${formatDuration(Date.now() - before)}`);
         if (config.open) {
             await serve({
                 port: config.port ? parseInt(config.port, 10) : undefined,
@@ -165,7 +161,7 @@ export class RunCommand extends Command {
             });
         }
         else {
-            exit(globalExitCode.actual ?? globalExitCode.original);
+            exit(finalExitCode);
         }
     }
 }

package/dist/utils/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./process.js";
-export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
 export * from "./fileSystem.js";

package/dist/utils/index.js

@@ -1,5 +1,4 @@
 export * from "./process.js";
-export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
 export * from "./fileSystem.js";

package/dist/utils/logs.d.ts

@@ -1,3 +1,3 @@
 export declare const getLogFileName: () => string;
 export declare const readLogs: () => Promise<string>;
-export declare const logError: (message: string, error: Error) => Promise<void>;
+export declare const logError: (message: string, error: Error, log?: (formattedMessage: string) => void) => Promise<void>;

package/dist/utils/logs.js

@@ -11,11 +11,13 @@ export const readLogs = async () => {
         const logs = await readFile(logFilePath, "utf-8");
         return logs;
     }
-    catch (err) {
+    catch {
         return "";
     }
 };
-export const logError = async (message, error) => {
+export const logError = async (message, error, log = (formattedMessage) => {
+    console.error(red(formattedMessage));
+}) => {
     let logs = await readLogs();
     if (!logs) {
         logs += `${new Date().toISOString()}[ERROR] ${error.message}\n`;
@@ -28,5 +30,5 @@ export const logError = async (message, error) => {
     }
     const logFilePath = join(LOGS_DIRECTORY, getLogFileName());
     await writeFile(logFilePath, logs, "utf-8");
-    console.error(red(`${message}. Check logs for more details: ${logFilePath}`));
+    log(`${message}. Check logs for more details: ${logFilePath}`);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allure",
-  "version": "3.19.1",
+  "version": "3.20.1",
   "description": "Allure Commandline Tool",
   "keywords": [
     "allure",
@@ -32,26 +32,27 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/charts-api": "3.19.1",
-    "@allurereport/ci": "3.19.1",
-    "@allurereport/core": "3.19.1",
-    "@allurereport/core-api": "3.19.1",
-    "@allurereport/directory-watcher": "3.19.1",
-    "@allurereport/plugin-agent": "3.19.1",
-    "@allurereport/plugin-allure2": "3.19.1",
-    "@allurereport/plugin-api": "3.19.1",
-    "@allurereport/plugin-awesome": "3.19.1",
-    "@allurereport/plugin-classic": "3.19.1",
-    "@allurereport/plugin-csv": "3.19.1",
-    "@allurereport/plugin-dashboard": "3.19.1",
-    "@allurereport/plugin-jira": "3.19.1",
-    "@allurereport/plugin-log": "3.19.1",
-    "@allurereport/plugin-progress": "3.19.1",
-    "@allurereport/plugin-server-reload": "3.19.1",
-    "@allurereport/plugin-slack": "3.19.1",
-    "@allurereport/reader-api": "3.19.1",
-    "@allurereport/service": "3.19.1",
-    "@allurereport/static-server": "3.19.1",
+    "@allurereport/charts-api": "3.20.1",
+    "@allurereport/ci": "3.20.1",
+    "@allurereport/cli-commons": "3.20.1",
+    "@allurereport/core": "3.20.1",
+    "@allurereport/core-api": "3.20.1",
+    "@allurereport/directory-watcher": "3.20.1",
+    "@allurereport/plugin-agent": "3.20.1",
+    "@allurereport/plugin-allure2": "3.20.1",
+    "@allurereport/plugin-api": "3.20.1",
+    "@allurereport/plugin-awesome": "3.20.1",
+    "@allurereport/plugin-classic": "3.20.1",
+    "@allurereport/plugin-csv": "3.20.1",
+    "@allurereport/plugin-dashboard": "3.20.1",
+    "@allurereport/plugin-jira": "3.20.1",
+    "@allurereport/plugin-log": "3.20.1",
+    "@allurereport/plugin-progress": "3.20.1",
+    "@allurereport/plugin-server-reload": "3.20.1",
+    "@allurereport/plugin-slack": "3.20.1",
+    "@allurereport/reader-api": "3.20.1",
+    "@allurereport/service": "3.20.1",
+    "@allurereport/static-server": "3.20.1",
     "adm-zip": "^0.6.0",
     "clipanion": "^4.0.0-rc.4",
     "glob": "^13.0.6",

package/dist/utils/terminal.d.ts

@@ -1,3 +0,0 @@
-import type { TestResult, TestStatus } from "@allurereport/core-api";
-export declare const status2color: (status: TestStatus) => import("yoctocolors").Format;
-export declare const logTests: (testResults: TestResult[]) => void;

package/dist/utils/terminal.js

@@ -1,20 +0,0 @@
-import console from "node:console";
-import { formatDuration } from "@allurereport/core-api";
-import { blue, gray, green, red, yellow } from "yoctocolors";
-export const status2color = (status) => {
-    switch (status) {
-        case "failed":
-            return red;
-        case "broken":
-            return yellow;
-        case "passed":
-            return green;
-        case "skipped":
-            return gray;
-        default:
-            return blue;
-    }
-};
-export const logTests = (testResults) => {
-    testResults.forEach((tr) => console.log(`${tr.fullName} ${status2color(tr.status)(tr.status)} ${tr.duration !== undefined ? gray(`(${formatDuration(tr.duration)})`) : ""}`));
-};