allure 3.8.2 → 3.9.0

package/dist/commands/allure2.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class Allure2Command extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string[];
     config: string | undefined;
     cwd: string | undefined;
     output: string | undefined;

package/dist/commands/allure2.js

@@ -1,15 +1,17 @@
 import * as console from "node:console";
-import { existsSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import process, { exit } from "node:process";
 import { AllureReport, readConfig } from "@allurereport/core";
 import Allure2Plugin from "@allurereport/plugin-allure2";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
+import { findAllureResultDirectories } from "../utils/fileSystem.js";
 export class Allure2Command extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.resultsDir = Option.Rest({
+            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
         this.config = Option.String("--config,-c", {
             description: "The path Allure config file",
         });
@@ -36,12 +38,13 @@ export class Allure2Command extends Command {
         });
     }
     async execute() {
-        if (!existsSync(this.resultsDir)) {
-            console.error(red(`The given test results directory doesn't exist: ${this.resultsDir}`));
+        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 cwd = await realpath(this.cwd ?? process.cwd());
         const before = new Date().getTime();
         const defaultAllure2Options = {
             singleFile: this.singleFile ?? false,
@@ -63,7 +66,9 @@ export class Allure2Command extends Command {
         ];
         const allureReport = new AllureReport(config);
         await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
+        for (const directory of resultDirectories) {
+            await allureReport.readDirectory(directory);
+        }
         await allureReport.done();
         const after = new Date().getTime();
         console.log(`the report successfully generated (${after - before}ms)`);
@@ -80,5 +85,13 @@ Allure2Command.usage = Command.Usage({
             "allure2 ./allure-results --output custom-report",
             "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
+        [
+            "allure2 ./packages/*/allure-results",
+            "Generate a report from all Allure result directories matching the pattern",
+        ],
+        [
+            "allure2 ./packages/foo/allure-results ./packages/bar/allure-results",
+            "Generate a report from two Allure result directories",
+        ],
     ],
 });

package/dist/commands/awesome.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class AwesomeCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string[];
     config: string | undefined;
     cwd: string | undefined;
     output: string | undefined;

package/dist/commands/awesome.js

@@ -1,15 +1,17 @@
 import * as console from "node:console";
-import { existsSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import process, { exit } from "node:process";
 import { AllureReport, readConfig } from "@allurereport/core";
 import { default as AwesomePlugin } from "@allurereport/plugin-awesome";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
+import { findAllureResultDirectories } from "../utils/fileSystem.js";
 export class AwesomeCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.resultsDir = Option.Rest({
+            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
         this.config = Option.String("--config,-c", {
             description: "The path Allure config file",
         });
@@ -48,12 +50,13 @@ export class AwesomeCommand extends Command {
         });
     }
     async execute() {
-        if (!existsSync(this.resultsDir)) {
-            console.error(red(`The given test results directory doesn't exist: ${this.resultsDir}`));
+        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 cwd = await realpath(this.cwd ?? process.cwd());
         const before = new Date().getTime();
         const hideLabels = this.hideLabels?.length ? this.hideLabels : undefined;
         const config = await readConfig(cwd, this.config, {
@@ -80,7 +83,9 @@ export class AwesomeCommand extends Command {
         ];
         const allureReport = new AllureReport(config);
         await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
+        for (const directory of resultDirectories) {
+            await allureReport.readDirectory(directory);
+        }
         await allureReport.done();
         const after = new Date().getTime();
         console.log(`the report successfully generated (${after - before}ms)`);
@@ -97,5 +102,13 @@ AwesomeCommand.usage = Command.Usage({
             "awesome ./allure-results --output custom-report",
             "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
+        [
+            "awesome ./packages/*/allure-results",
+            "Generate a report from all Allure result directories matching the pattern",
+        ],
+        [
+            "awesome ./packages/foo/allure-results ./packages/bar/allure-results",
+            "Generate a report from two Allure result directories",
+        ],
     ],
 });

package/dist/commands/classic.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class ClassicCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string[];
     config: string | undefined;
     cwd: string | undefined;
     output: string | undefined;

package/dist/commands/classic.js

@@ -1,15 +1,17 @@
 import * as console from "node:console";
-import { existsSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import process, { exit } from "node:process";
 import { AllureReport, readConfig } from "@allurereport/core";
 import ClassicPlugin from "@allurereport/plugin-classic";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
+import { findAllureResultDirectories } from "../utils/fileSystem.js";
 export class ClassicCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.resultsDir = Option.Rest({
+            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
         this.config = Option.String("--config,-c", {
             description: "The path Allure config file",
         });
@@ -36,12 +38,13 @@ export class ClassicCommand extends Command {
         });
     }
     async execute() {
-        if (!existsSync(this.resultsDir)) {
-            console.error(red(`The given test results directory doesn't exist: ${this.resultsDir}`));
+        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 cwd = await realpath(this.cwd ?? process.cwd());
         const before = new Date().getTime();
         const defaultClassicOptions = {
             singleFile: this.singleFile ?? false,
@@ -63,7 +66,9 @@ export class ClassicCommand extends Command {
         ];
         const allureReport = new AllureReport(config);
         await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
+        for (const directory of resultDirectories) {
+            await allureReport.readDirectory(directory);
+        }
         await allureReport.done();
         const after = new Date().getTime();
         console.log(`the report successfully generated (${after - before}ms)`);
@@ -80,5 +85,13 @@ ClassicCommand.usage = Command.Usage({
             "classic ./allure-results --output custom-report",
             "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
+        [
+            "classic ./packages/*/allure-results",
+            "Generate a report from all Allure result directories matching the pattern",
+        ],
+        [
+            "classic ./packages/foo/allure-results ./packages/bar/allure-results",
+            "Generate a report from two Allure result directories",
+        ],
     ],
 });

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

@@ -2,6 +2,6 @@ import type { FullConfig } from "@allurereport/core";
 export declare const generate: (params: {
     cwd: string;
     config: FullConfig;
-    resultsDir: string;
+    resultsDir: string[];
     dump?: string[];
 }) => Promise<void>;

package/dist/commands/commons/generate.js

@@ -1,37 +1,16 @@
 import { exit } from "node:process";
 import { AllureReport } from "@allurereport/core";
 import { KnownError } from "@allurereport/service";
-import { glob } from "glob";
 import { red } from "yoctocolors";
+import { findAllureResultDirectories, findFilesByGlobs } from "../../utils/fileSystem.js";
 import { logError } from "../../utils/logs.js";
 export const generate = async (params) => {
-    const dumpFiles = [];
-    const resultsDirectories = [];
-    if (params?.dump?.length) {
-        for (const dump of params.dump) {
-            const matchedFiles = await glob(dump, {
-                nodir: true,
-                dot: true,
-                absolute: true,
-                windowsPathsNoEscape: true,
-                cwd: params.cwd,
-            });
-            dumpFiles.push(...matchedFiles);
-        }
-    }
-    if (!!params?.resultsDir || dumpFiles.length === 0) {
-        const matchedDirs = (await glob(params.resultsDir, {
-            mark: true,
-            nodir: false,
-            absolute: true,
-            dot: true,
-            windowsPathsNoEscape: true,
-            cwd: params.cwd,
-        })).filter((p) => /(\/|\\)$/.test(p));
-        resultsDirectories.push(...matchedDirs);
-    }
-    if (resultsDirectories.length === 0 && dumpFiles.length === 0) {
-        console.error(red(`No test results directories found matching pattern: ${params.resultsDir}`));
+    const dumpFiles = params?.dump?.length ? await findFilesByGlobs(params.cwd, params.dump) : [];
+    const { resultDirectories = [], patterns = params.resultsDir } = !!params?.resultsDir || dumpFiles.length === 0
+        ? await findAllureResultDirectories(params.cwd, params.resultsDir)
+        : {};
+    if (resultDirectories.length === 0 && dumpFiles.length === 0) {
+        console.error(red(`No test results directories found matching pattern: ${patterns}`));
         exit(1);
         return;
     }
@@ -39,7 +18,7 @@ export const generate = async (params) => {
         const allureReport = new AllureReport(params.config);
         await allureReport.restoreState(Array.from(dumpFiles));
         await allureReport.start();
-        for (const dir of resultsDirectories) {
+        for (const dir of resultDirectories) {
             await allureReport.readDirectory(dir);
         }
         await allureReport.done();

package/dist/commands/commons/run.js

@@ -194,7 +194,7 @@ export const executeAllureRun = async (params) => {
             await rm(tmpDir, { recursive: true });
             logTests(await allureReport.store.allTestResults());
         }
-        const trs = await allureReport.store.allTestResults({ includeHidden: false });
+        const trs = await allureReport.store.allTestResults({ includeRetries: false });
         qualityGateResults = testProcessResult?.qualityGateResults ?? [];
         if (withQualityGate && !qualityGateResults.length) {
             const { results } = await allureReport.validate({

package/dist/commands/csv.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class CsvCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string[];
     config: string | undefined;
     cwd: string | undefined;
     output: string | undefined;

package/dist/commands/csv.js

@@ -1,5 +1,4 @@
 import * as console from "node:console";
-import { existsSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
 import process, { exit } from "node:process";
@@ -7,10 +6,13 @@ import { AllureReport, readConfig } from "@allurereport/core";
 import CsvPlugin from "@allurereport/plugin-csv";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
+import { findAllureResultDirectories } from "../utils/fileSystem.js";
 export class CsvCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.resultsDir = Option.Rest({
+            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
         this.config = Option.String("--config,-c", {
             description: "The path Allure config file",
         });
@@ -31,12 +33,13 @@ export class CsvCommand extends Command {
         });
     }
     async execute() {
-        if (!existsSync(this.resultsDir)) {
-            console.error(red(`The given test results directory doesn't exist: ${this.resultsDir}`));
+        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 cwd = await realpath(this.cwd ?? process.cwd());
         const before = new Date().getTime();
         const defaultCsvOptions = {
             separator: this.separator ?? ",",
@@ -56,7 +59,9 @@ export class CsvCommand extends Command {
         ];
         const allureReport = new AllureReport(config);
         await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
+        for (const directory of resultDirectories) {
+            await allureReport.readDirectory(directory);
+        }
         await allureReport.done();
         const after = new Date().getTime();
         console.log(`the report successfully generated (${after - before}ms)`);
@@ -73,5 +78,10 @@ CsvCommand.usage = Command.Usage({
             "csv ./allure-results --output custom-report.csv",
             "Generate a report from the ./allure-results directory to the custom-report.csv file",
         ],
+        ["csv ./packages/*/allure-results", "Generate a report from all Allure result directories matching the pattern"],
+        [
+            "csv ./packages/foo/allure-results ./packages/bar/allure-results",
+            "Generate a report from two Allure result directories",
+        ],
     ],
 });

package/dist/commands/dashboard.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class DashboardCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string[];
     config: string | undefined;
     cwd: string | undefined;
     output: string | undefined;

package/dist/commands/dashboard.js

@@ -1,15 +1,17 @@
 import * as console from "node:console";
-import { existsSync } from "node:fs";
 import { realpath } from "node:fs/promises";
 import process, { exit } from "node:process";
 import { AllureReport, readConfig } from "@allurereport/core";
 import DashboardPlugin from "@allurereport/plugin-dashboard";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
+import { findAllureResultDirectories } from "../utils/fileSystem.js";
 export class DashboardCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.resultsDir = Option.Rest({
+            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
         this.config = Option.String("--config,-c", {
             description: "The path Allure config file",
         });
@@ -36,12 +38,13 @@ export class DashboardCommand extends Command {
         });
     }
     async execute() {
-        if (!existsSync(this.resultsDir)) {
-            console.error(red(`The given test results directory doesn't exist: ${this.resultsDir}`));
+        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 cwd = await realpath(this.cwd ?? process.cwd());
         const before = new Date().getTime();
         const defaultDashboardOptions = {
             singleFile: this.singleFile ?? false,
@@ -63,7 +66,9 @@ export class DashboardCommand extends Command {
         ];
         const allureReport = new AllureReport(config);
         await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
+        for (const directory of resultDirectories) {
+            await allureReport.readDirectory(directory);
+        }
         await allureReport.done();
         const after = new Date().getTime();
         console.log(`the report successfully generated (${after - before}ms)`);
@@ -80,5 +85,13 @@ DashboardCommand.usage = Command.Usage({
             "dashboard ./allure-results --output custom-report",
             "Generate a report from the ./allure-results directory to the custom-report directory",
         ],
+        [
+            "dashboard ./packages/*/allure-results",
+            "Generate a report from all Allure result directories matching the pattern",
+        ],
+        [
+            "dashboard ./packages/foo/allure-results ./packages/bar/allure-results",
+            "Generate a report from two Allure result directories",
+        ],
     ],
 });

package/dist/commands/generate.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class GenerateCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string | undefined;
+    resultsDir: string[];
     config: string | undefined;
     output: string | undefined;
     cwd: string | undefined;

package/dist/commands/generate.js

@@ -6,9 +6,8 @@ import { generate } from "./commons/generate.js";
 export class GenerateCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({
-            required: false,
-            name: "Pattern to match test results directories in the current working directory (default: ./**/allure-results)",
+        this.resultsDir = Option.Rest({
+            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
         });
         this.config = Option.String("--config,-c", {
             description: "The path Allure config file",
@@ -23,7 +22,9 @@ export class GenerateCommand extends Command {
             description: "The report name (default: Allure Report)",
         });
         this.dump = Option.Array("--dump", {
-            description: "Dump archives to restore state from (default: empty string)",
+            description: "Path or pattern that matches one or more archives created by `allure run --dump ...`. " +
+                "Allure loads the matched archives before generating the report. " +
+                "This option can be specified multiple times.",
         });
         this.open = Option.Boolean("--open", {
             description: "Open the report in the default browser after generation (default: false)",
@@ -51,7 +52,7 @@ export class GenerateCommand extends Command {
         });
         await generate({
             dump: this.dump,
-            resultsDir: this.resultsDir ?? "./**/allure-results",
+            resultsDir: this.resultsDir,
             cwd,
             config,
         });
@@ -66,8 +67,8 @@ export class GenerateCommand extends Command {
 }
 GenerateCommand.paths = [["generate"]];
 GenerateCommand.usage = Command.Usage({
-    description: "Generates the report to specified directory",
-    details: "This command generates a report from the provided Allure Results directory.",
+    description: "Generates the report in the specified directory.",
+    details: "This command generates a report from the provided Allure Results directories.",
     examples: [
         ["generate ./allure-results", "Generate a report from the ./allure-results directory"],
         [
@@ -82,5 +83,9 @@ GenerateCommand.usage = Command.Usage({
             "generate --dump=allure-*.zip",
             "Generate a report using data from any dump archive that matches the given pattern and results directory if it exists",
         ],
+        [
+            "generate ./packages/foo/out/allure-results ./packages/bar/out/allure-results",
+            "Generate a report from two Allure results directories",
+        ],
     ],
 });

package/dist/commands/history.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class HistoryCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string[];
     historyPath: string | undefined;
     historyLimit: string | undefined;
     reportName: string | undefined;

package/dist/commands/history.js

@@ -1,13 +1,15 @@
 import * as console from "node:console";
-import { existsSync } from "node:fs";
-import { exit } from "node:process";
+import process, { exit } from "node:process";
 import { AllureReport, resolveConfig } from "@allurereport/core";
 import { Command, Option } from "clipanion";
 import { red } from "yoctocolors";
+import { findAllureResultDirectories } from "../utils/fileSystem.js";
 export class HistoryCommand extends Command {
     constructor() {
         super(...arguments);
-        this.resultsDir = Option.String({ required: true, name: "The directory with Allure results" });
+        this.resultsDir = Option.Rest({
+            name: "Patterns to match test results directories in the current working directory (default: ./**/allure-results)",
+        });
         this.historyPath = Option.String("--history-path,-h", {
             description: "The path to history file",
         });
@@ -19,9 +21,11 @@ export class HistoryCommand extends Command {
         });
     }
     async execute() {
-        if (!existsSync(this.resultsDir)) {
-            console.error(red(`The given test results directory doesn't exist: ${this.resultsDir}`));
+        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 config = await resolveConfig({
             historyPath: this.historyPath ?? "history.jsonl",
@@ -31,7 +35,9 @@ export class HistoryCommand extends Command {
         });
         const allureReport = new AllureReport(config);
         await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
+        for (const directory of resultDirectories) {
+            await allureReport.readDirectory(directory);
+        }
         await allureReport.done();
     }
 }
@@ -45,5 +51,13 @@ HistoryCommand.usage = Command.Usage({
             "history ./allure-results --history-path custom-history.jsonl",
             "Generate history from the ./allure-results directory to the custom-history.jsonl file",
         ],
+        [
+            "history ./packages/*/allure-results",
+            "Generate history from all Allure result directories matching the pattern",
+        ],
+        [
+            "history ./packages/foo/allure-results ./packages/bar/allure-results",
+            "Generate history from two Allure result directories",
+        ],
     ],
 });

package/dist/commands/knownIssue.d.ts

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

package/dist/commands/knownIssue.js

@@ -1,21 +1,24 @@
 import * as console from "node:console";
-import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import { exit } from "node:process";
+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.String({ required: true, name: "The directory with Allure results" });
+        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() {
-        if (!existsSync(this.resultsDir)) {
-            console.error(red(`The given test results directory doesn't exist: ${this.resultsDir}`));
+        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;
         }
@@ -25,7 +28,9 @@ export class KnownIssueCommand extends Command {
         });
         const allureReport = new AllureReport(config);
         await allureReport.start();
-        await allureReport.readDirectory(this.resultsDir);
+        for (const directory of resultDirectories) {
+            await allureReport.readDirectory(directory);
+        }
         await allureReport.done();
         const targetPath = resolve(outputPath);
         await writeKnownIssues(allureReport.store, outputPath);
@@ -42,5 +47,13 @@ KnownIssueCommand.usage = Command.Usage({
             "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",
+        ],
     ],
 });

package/dist/commands/log.d.ts

@@ -2,7 +2,7 @@ import { Command } from "clipanion";
 export declare class LogCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
-    resultsDir: string;
+    resultsDir: string[];
     config: string | undefined;
     cwd: string | undefined;
     groupBy: string | undefined;