allure 3.14.3 → 3.16.0

package/dist/commands/run.js

@@ -7,12 +7,14 @@ import { serve } from "@allurereport/static-server";
 import { Command, Option, UsageError } from "clipanion";
 import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
 import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
+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");
 export class RunCommand extends Command {
     constructor() {
         super(...arguments);
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -49,6 +51,12 @@ export class RunCommand extends Command {
         this.hideLabels = Option.Array("--hide-labels", {
             description: "Hide labels by exact name in generated reports. Repeat the option for multiple labels",
         });
+        this.knownIssues = Option.String("--known-issues", {
+            description: "Path to known issues file",
+        });
+        this.resultsDir = Option.Array("--results-dir", {
+            description: "Glob pattern or path for Allure results directories (repeatable). Overrides config.resultsDir. Quote globs in the shell",
+        });
         this.commandToRun = Option.Rest();
     }
     get logs() {
@@ -58,17 +66,15 @@ export class RunCommand extends Command {
         return this.ignoreLogs ? "inherit" : "pipe";
     }
     async execute() {
-        const args = this.commandToRun.filter((arg) => arg !== "--");
-        if (!args || !args.length) {
-            throw new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
+        const { command, commandArgs } = parseRunCommand(this.commandToRun);
+        if (!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 command = args[0];
-        const commandArgs = args.slice(1);
         const cwd = await realpath(this.cwd ?? process.cwd());
         const hideLabels = this.hideLabels?.length ? this.hideLabels : undefined;
         console.log(`${command} ${commandArgs.join(" ")}`);
@@ -94,8 +100,10 @@ export class RunCommand extends Command {
             open: this.open,
             port: this.port,
             hideLabels,
-            historyLimit: this.historyLimit ? parseInt(this.historyLimit, 10) : undefined,
+            historyLimit: this.historyLimit !== undefined ? parseInt(this.historyLimit, 10) : undefined,
+            knownIssuesPath: this.knownIssues,
         });
+        const resultsPatterns = resolveResultsPatterns(this.resultsDir ?? [], config.resultsDir);
         const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
         const withRerun = maxRerun > 0;
         const withQualityGate = !!config.qualityGate && !withRerun;
@@ -145,6 +153,7 @@ export class RunCommand extends Command {
             silent: this.silent,
             ignoreLogs: this.ignoreLogs,
             maxRerun,
+            resultsPatterns,
         });
         if (config.open) {
             await serve({
@@ -161,7 +170,10 @@ export class RunCommand extends Command {
 RunCommand.paths = [["run"]];
 RunCommand.usage = Command.Usage({
     description: "Run specified command",
-    details: "This command runs the specified command and collects Allure results.",
+    details: "This command runs the specified command and collects Allure results. " +
+        "Override results discovery with repeated `--results-dir` (CLI overrides `config.resultsDir`). " +
+        "When neither is set, directories named `allure-results` are discovered dynamically. " +
+        "Quote globs in the shell so they are not expanded early.",
     examples: [
         ["run -- npm run test", "Run npm run test and collect Allure results"],
         ["run --rerun 3 -- npm run test", "Run npm run test and rerun failed tests up to 3 times"],
@@ -169,5 +181,9 @@ RunCommand.usage = Command.Usage({
             "run --dump=my-dump -- npm run test",
             "Run npm run test and pack inner report state into my-dump.zip archive to restore the state in the next run",
         ],
+        [
+            "run --results-dir './artifacts/**/allure-results' -- npm test",
+            "Override results discovery with a quoted glob",
+        ],
     ],
 });

package/dist/commands/slack.js

@@ -5,15 +5,15 @@ import { AllureReport, readConfig } from "@allurereport/core";
 import SlackPlugin from "@allurereport/plugin-slack";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class SlackCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -29,18 +29,18 @@ export class SlackCommand extends Command {
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         const defaultSlackOptions = {
             token: this.token,
             channel: this.channel,
         };
         const config = await readConfig(cwd, this.config);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, config.resultsDir);
+        if (!resultDirectories.length) {
+            console.error(red(`No test results directories found matching pattern: ${patterns}`));
+            exit(1);
+            return;
+        }
         config.plugins = [
             {
                 id: "slack",

package/dist/commands/testplan.js

@@ -1,22 +1,24 @@
 import * as console from "node:console";
 import { basename, dirname, resolve } from "node:path";
-import { exit } from "node:process";
-import { AllureReport, resolveConfig } from "@allurereport/core";
+import { cwd as processCwd, exit } from "node:process";
+import { AllureReport, readRawConfig, resolveConfig } from "@allurereport/core";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveAndFindResultsDirs } from "../utils/resultsPatterns.js";
 export class TestPlanCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Defaults to ./**/allure-results when neither is set.",
         });
         this.output = Option.String("--output,-o", {
             description: "The output file name. Absolute paths are accepted as well",
         });
     }
     async execute() {
-        const { resultDirectories, patterns } = await findAllureResultDirectories(process.cwd(), this.resultsDir);
+        const cwd = processCwd();
+        const rawConfig = await readRawConfig(cwd);
+        const { resultDirectories, patterns } = await resolveAndFindResultsDirs(cwd, this.resultsDir, rawConfig.resultsDir);
         if (!resultDirectories.length) {
             console.error(red(`No test results directories found matching pattern: ${patterns}`));
             exit(1);

package/dist/commands/watch.d.ts

@@ -9,5 +9,7 @@ export declare class WatchCommand extends Command {
     reportName: string | undefined;
     open: boolean | undefined;
     port: string | undefined;
+    preserve: boolean | undefined;
+    newOnly: boolean;
     execute(): Promise<void>;
 }

package/dist/commands/watch.js

@@ -2,25 +2,26 @@ import * as console from "node:console";
 import { realpath } from "node:fs/promises";
 import { rm } from "node:fs/promises";
 import { join } from "node:path";
-import process, { exit } from "node:process";
+import process from "node:process";
 import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
-import { newFilesInDirectoryWatcher } from "@allurereport/directory-watcher";
+import { allureResultsDirectoriesWatcher, newFilesInDirectoryWatcher } from "@allurereport/directory-watcher";
 import Awesome from "@allurereport/plugin-awesome";
 import ProgressPlugin from "@allurereport/plugin-progress";
 import ServerReloadPlugin from "@allurereport/plugin-server-reload";
 import { PathResultFile } from "@allurereport/reader-api";
 import { serve } from "@allurereport/static-server";
 import { Command, Option } from "clipanion";
-import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
+import { resolveResultsPatterns } from "../utils/resultsPatterns.js";
+import { boundedTerminationSignal, notifySignals, waitForAbort } from "../utils/signals.js";
+import { allureResultsDirectoriesGlobWatcher } from "./commons/resultsDiscovery.js";
 export class WatchCommand extends Command {
     constructor() {
         super(...arguments);
         this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+            name: "Patterns to match test results directories. Overrides config.resultsDir. Empty patterns use name-based discovery.",
         });
         this.config = Option.String("--config,-c", {
-            description: "The path Allure config file",
+            description: "The path to Allure config file",
         });
         this.cwd = Option.String("--cwd", {
             description: "The working directory for the command to run (default: current working directory)",
@@ -37,15 +38,15 @@ export class WatchCommand extends Command {
         this.port = Option.String("--port", {
             description: "The port to serve the reports on (default: random port)",
         });
+        this.preserve = Option.Boolean("--preserve", {
+            description: "Don't clear terminal output on the data refresh",
+        });
+        this.newOnly = Option.Boolean("--new-only", true, {
+            description: "Skip whatever test results already exist on disk at startup and only react to results written after the watch has started, instead of ingesting the existing backlog first (default: true). Pass --no-new-only to ingest the existing backlog too",
+        });
     }
     async execute() {
         const cwd = await realpath(this.cwd ?? process.cwd());
-        const { resultDirectories, patterns } = await findAllureResultDirectories(cwd, this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
         const before = new Date().getTime();
         process.on("exit", (code) => {
             const after = new Date().getTime();
@@ -57,6 +58,8 @@ export class WatchCommand extends Command {
             open: this.open,
             port: this.port,
         });
+        const resultsPatterns = resolveResultsPatterns(this.resultsDir ?? [], config.resultsDir);
+        const useDynamicNameDiscovery = resultsPatterns.length === 0;
         try {
             await rm(config.output, { recursive: true });
         }
@@ -93,7 +96,7 @@ export class WatchCommand extends Command {
                     id: "watch log",
                     enabled: true,
                     options: {},
-                    plugin: new ProgressPlugin(),
+                    plugin: new ProgressPlugin({ preserve: this.preserve }),
                 },
                 {
                     id: "server reload",
@@ -107,39 +110,85 @@ export class WatchCommand extends Command {
         });
         await allureReport.start();
         const abortFunctions = [];
-        for (const directory of resultDirectories) {
-            const { abort } = newFilesInDirectoryWatcher(directory, async (path) => {
-                await allureReport.readResult(new PathResultFile(path));
-            });
-            abortFunctions.push(abort);
-        }
+        const perDirectoryWatchers = new Map();
+        let isInitialDiscovery = true;
+        const onDiscoveryUpdate = async (newDirectories, deletedDirectories) => {
+            for (const deletedDir of deletedDirectories) {
+                const watcher = perDirectoryWatchers.get(deletedDir);
+                if (watcher) {
+                    await watcher.abort();
+                }
+                perDirectoryWatchers.delete(deletedDir);
+            }
+            for (const newDir of newDirectories) {
+                if (perDirectoryWatchers.has(newDir)) {
+                    continue;
+                }
+                const watcher = newFilesInDirectoryWatcher(newDir, async (path) => {
+                    await allureReport.readResult(new PathResultFile(path));
+                }, { ignoreInitial: this.newOnly && isInitialDiscovery });
+                perDirectoryWatchers.set(newDir, watcher);
+                await watcher.initialScan();
+            }
+            isInitialDiscovery = false;
+        };
+        const discoveryWatcher = useDynamicNameDiscovery
+            ? allureResultsDirectoriesWatcher(cwd, onDiscoveryUpdate)
+            : allureResultsDirectoriesGlobWatcher(cwd, resultsPatterns, onDiscoveryUpdate, { indexDelay: 600 });
+        await discoveryWatcher.initialScan();
+        abortFunctions.push(discoveryWatcher.abort);
+        abortFunctions.push(async (immediately) => {
+            for (const watcher of perDirectoryWatchers.values()) {
+                await watcher.abort(immediately);
+            }
+            perDirectoryWatchers.clear();
+        });
         const pluginIdToOpen = config.plugins?.find((plugin) => !!plugin.options.open)?.id;
         if (pluginIdToOpen) {
             await server.open(join(server.url, pluginIdToOpen));
         }
         console.info("Press Ctrl+C to exit");
-        process.on("SIGINT", async () => {
-            console.log("");
+        const notifier = notifySignals(["SIGINT", "SIGTERM"], (signal) => {
+            console.log(`\nreceived another ${signal}, force exiting...`);
+            process.exit(130);
+        });
+        await waitForAbort(notifier.signal);
+        const signalInfo = notifier.info();
+        console.log(`\nreceived ${signalInfo?.signal}, stopping (press again to force exit)...`);
+        const terminationSignal = boundedTerminationSignal(signalInfo, 5000);
+        const cleanup = (async () => {
             for (const abort of abortFunctions) {
-                await abort();
+                await abort(true);
             }
             await server.stop();
             await allureReport.done();
-            process.exit(0);
-        });
+        })();
+        const timedOut = await Promise.race([cleanup.then(() => false), waitForAbort(terminationSignal).then(() => true)]);
+        if (timedOut) {
+            console.log("shutdown is taking too long, force exiting...");
+            process.exit(130);
+        }
+        notifier.dispose();
+        process.exit(signalInfo?.code ?? 0);
     }
 }
 WatchCommand.paths = [["watch"]];
 WatchCommand.usage = Command.Usage({
     description: "Watches Allure Results changes in Real-time",
-    details: "This command watches for changes in the Allure Results directory and updates the report in real-time.",
+    details: "This command watches for changes in Allure Results directories and updates the report in real-time. " +
+        "CLI patterns and config.resultsDir use live re-glob discovery. " +
+        "When both are empty, directories named `allure-results` are discovered dynamically (unlike generate, which defaults to `./**/allure-results`). " +
+        "Quote globs in the shell so they are not expanded early.",
     examples: [
         ["watch ./allure-results", "Watch for changes in the ./allure-results directory"],
         [
             "watch ./allure-results --port 8080",
             "Watch for changes in the ./allure-results directory and serve the report on port 8080",
         ],
-        ["watch ./packages/*/allure-results", "Watch for changes in all Allure result directories matching the pattern"],
+        [
+            "watch './packages/*/allure-results'",
+            "Watch for changes in all Allure result directories matching the pattern",
+        ],
         [
             "watch ./packages/foo/allure-results ./packages/bar/allure-results",
             "Watch for changes in two Allure result directories",

package/dist/index.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import process, { argv } from "node:process";
 import { Builtins, Cli } from "clipanion";
-import { AgentCommand, AGENT_TASK_MAP_HELP, AgentCapabilitiesCommand, AgentInspectCommand, AgentLatestCommand, AgentQueryCommand, AgentSelectCommand, AgentStateDirCommand, Allure2Command, AwesomeCommand, CheckCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, JiraClearCommand, KnownIssueCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, isAgentTaskMapHelpRequest, } from "./commands/index.js";
+import { AgentCommand, AGENT_TASK_MAP_HELP, AgentCapabilitiesCommand, AgentInspectCommand, AgentLatestCommand, AgentQueryCommand, AgentSelectCommand, AgentStateDirCommand, Allure2Command, AwesomeCommand, CheckCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, JiraClearCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, isAgentTaskMapHelpRequest, } from "./commands/index.js";
 const [node, app, ...args] = argv;
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const cli = new Cli({
@@ -25,7 +25,6 @@ cli.register(DashboardCommand);
 cli.register(GenerateCommand);
 cli.register(HistoryCommand);
 cli.register(JiraClearCommand);
-cli.register(KnownIssueCommand);
 cli.register(LogCommand);
 cli.register(OpenCommand);
 cli.register(QualityGateCommand);

package/dist/utils/index.d.ts

@@ -3,3 +3,5 @@ export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
 export * from "./fileSystem.js";
+export * from "./resultsPatterns.js";
+export * from "./signals.js";

package/dist/utils/index.js

@@ -3,3 +3,5 @@ export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
 export * from "./fileSystem.js";
+export * from "./resultsPatterns.js";
+export * from "./signals.js";

package/dist/utils/process.js

@@ -74,6 +74,7 @@ export const runProcess = (params) => {
 };
 export const terminationOf = (testProcess) => new Promise((resolve) => {
     testProcess.on("exit", (code) => resolve(code));
+    testProcess.on("error", () => resolve(null));
 });
 export const stopProcessTree = async (pid, { signal = "SIGTERM" } = {}) => {
     const tree = new Map();

package/dist/utils/resultsPatterns.d.ts

@@ -0,0 +1,12 @@
+export declare const normalizeResultsDir: (value?: string | readonly string[]) => string[];
+export declare const resolveResultsPatterns: (cliPatterns?: string | readonly string[] | null, configResultsDir?: string | readonly string[]) => string[];
+export declare const normalizeResultsDirectoryPath: (path: string) => string;
+export type ParsedRunCommand = {
+    command: string | undefined;
+    commandArgs: string[];
+};
+export declare const parseRunCommand: (args: string[]) => ParsedRunCommand;
+export declare const resolveAndFindResultsDirs: (cwd: string, cliPatterns: readonly string[], configResultsDir?: string | string[]) => Promise<{
+    patterns: readonly string[];
+    resultDirectories: string[];
+}>;

package/dist/utils/resultsPatterns.js

@@ -0,0 +1,37 @@
+import { resolve } from "node:path";
+import { findAllureResultDirectories } from "./fileSystem.js";
+export const normalizeResultsDir = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    const values = typeof value === "string" ? [value] : [...value];
+    return values.filter((entry) => entry.length > 0);
+};
+export const resolveResultsPatterns = (cliPatterns, configResultsDir) => {
+    const fromCli = normalizeResultsDir(cliPatterns ?? undefined);
+    if (fromCli.length) {
+        return fromCli;
+    }
+    return normalizeResultsDir(configResultsDir);
+};
+export const normalizeResultsDirectoryPath = (path) => {
+    return resolve(path.replace(/[/\\]+$/, ""));
+};
+export const parseRunCommand = (args) => {
+    let start = 0;
+    while (start < args.length && args[start] === "--") {
+        start += 1;
+    }
+    const commandParts = args.slice(start);
+    if (!commandParts.length) {
+        return { command: undefined, commandArgs: [] };
+    }
+    return {
+        command: commandParts[0],
+        commandArgs: commandParts.slice(1),
+    };
+};
+export const resolveAndFindResultsDirs = async (cwd, cliPatterns, configResultsDir) => {
+    const patterns = resolveResultsPatterns(cliPatterns, configResultsDir);
+    return findAllureResultDirectories(cwd, patterns);
+};

package/dist/utils/signals.d.ts

@@ -0,0 +1,18 @@
+export declare const SIGNAL_EXIT_CODES: Partial<Record<NodeJS.Signals, number>>;
+export declare const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 60000;
+export declare const COMMAND_TERMINATION_GRACE_MS = 5000;
+export type SignalInfo = {
+    signal: NodeJS.Signals;
+    code: number;
+    receivedAt: number;
+    deadline: number;
+};
+export type SignalNotifier = {
+    signal: AbortSignal;
+    info: () => SignalInfo | undefined;
+    dispose: () => void;
+};
+export declare const notifySignals: (signals?: NodeJS.Signals[], onRepeat?: (signal: NodeJS.Signals) => void) => SignalNotifier;
+export declare const gracefulShutdownRemaining: (info: SignalInfo | undefined) => number | undefined;
+export declare const boundedTerminationSignal: (info: SignalInfo | undefined, graceMs?: number) => AbortSignal;
+export declare const waitForAbort: (signal: AbortSignal) => Promise<void>;

package/dist/utils/signals.js

@@ -0,0 +1,52 @@
+import process from "node:process";
+export const SIGNAL_EXIT_CODES = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+export const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 60000;
+export const COMMAND_TERMINATION_GRACE_MS = 5000;
+const exitCodeForSignal = (signal) => SIGNAL_EXIT_CODES[signal] ?? 1;
+export const notifySignals = (signals = ["SIGINT", "SIGTERM"], onRepeat) => {
+    const controller = new AbortController();
+    let info;
+    const handler = (signal) => {
+        if (info) {
+            onRepeat?.(signal);
+            return;
+        }
+        const receivedAt = Date.now();
+        info = {
+            signal,
+            code: exitCodeForSignal(signal),
+            receivedAt,
+            deadline: receivedAt + GRACEFUL_SHUTDOWN_TIMEOUT_MS,
+        };
+        controller.abort();
+    };
+    for (const signal of signals) {
+        process.on(signal, handler);
+    }
+    return {
+        signal: controller.signal,
+        info: () => info,
+        dispose: () => {
+            for (const signal of signals) {
+                process.off(signal, handler);
+            }
+        },
+    };
+};
+export const gracefulShutdownRemaining = (info) => {
+    if (!info) {
+        return undefined;
+    }
+    return Math.max(0, info.deadline - Date.now());
+};
+export const boundedTerminationSignal = (info, graceMs = COMMAND_TERMINATION_GRACE_MS) => {
+    const remaining = gracefulShutdownRemaining(info);
+    const timeoutMs = remaining === undefined ? graceMs : Math.min(remaining, graceMs);
+    return AbortSignal.timeout(timeoutMs);
+};
+export const waitForAbort = (signal) => signal.aborted
+    ? Promise.resolve()
+    : new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));

package/package.json

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

package/dist/commands/knownIssue.d.ts

@@ -1,8 +0,0 @@
-import { Command } from "clipanion";
-export declare class KnownIssueCommand extends Command {
-    static paths: string[][];
-    static usage: import("clipanion").Usage;
-    resultsDir: string[];
-    output: string | undefined;
-    execute(): Promise<void>;
-}

package/dist/commands/knownIssue.js

@@ -1,59 +0,0 @@
-import * as console from "node:console";
-import { resolve } from "node:path";
-import process, { exit } from "node:process";
-import { AllureReport, resolveConfig, writeKnownIssues } from "@allurereport/core";
-import { Command, Option } from "clipanion";
-import { red } from "yoctocolors";
-import { findAllureResultDirectories } from "../utils/fileSystem.js";
-export class KnownIssueCommand extends Command {
-    constructor() {
-        super(...arguments);
-        this.resultsDir = Option.Rest({
-            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
-        });
-        this.output = Option.String("--output,-o", {
-            description: "The output file name. Absolute paths are accepted as well",
-        });
-    }
-    async execute() {
-        const { resultDirectories, patterns } = await findAllureResultDirectories(process.cwd(), this.resultsDir);
-        if (!resultDirectories.length) {
-            console.error(red(`No test results directories found matching pattern: ${patterns}`));
-            exit(1);
-            return;
-        }
-        const outputPath = this.output ?? "known-issues.json";
-        const config = await resolveConfig({
-            plugins: {},
-        });
-        const allureReport = new AllureReport(config);
-        await allureReport.start();
-        for (const directory of resultDirectories) {
-            await allureReport.readDirectory(directory);
-        }
-        await allureReport.done();
-        const targetPath = resolve(outputPath);
-        await writeKnownIssues(allureReport.store, outputPath);
-        console.log(`writing known-issues.json to ${targetPath}`);
-    }
-}
-KnownIssueCommand.paths = [["known-issue"]];
-KnownIssueCommand.usage = Command.Usage({
-    description: "Generates a known issue list",
-    details: "This command generates a known issue list from the provided Allure Results directory.",
-    examples: [
-        ["known-issue ./allure-results", "Generate a known issue list from the ./allure-results directory"],
-        [
-            "known-issue ./allure-results --output custom-issues.json",
-            "Generate a known issue list from the ./allure-results directory to the custom-issues.json file",
-        ],
-        [
-            "known-issue ./packages/*/allure-results",
-            "Generate a known issue list from all Allure result directories matching the pattern",
-        ],
-        [
-            "known-issue ./packages/foo/allure-results ./packages/bar/allure-results",
-            "Generate a known issue list from two Allure result directories",
-        ],
-    ],
-});