allure 3.9.0 → 3.11.0

package/README.md

@@ -74,7 +74,21 @@ For example:
 npx allure agent -- npm test
 ```
 
-`allure agent` runs with an agent-only profile by default. It creates a fresh output directory automatically, can load an expectations file with `--expectations`, and ignores configured presentation or export plugins such as Awesome or TestOps unless you explicitly fall back to the lower-level `ALLURE_AGENT_*` plus `allure run` flow.
+`allure agent` runs with an agent-only profile by default. It creates a fresh output directory automatically, accepts compact inline expectations such as `--goal`, `--expect-tests`, `--expect-test`, `--expect-label`, and `--expect-step-containing`, and can still load an expectations file with `--expectations` when needed. Configured presentation or export plugins such as Awesome or TestOps are ignored for that run.
+
+Agents and setup tools can inspect the local structured capability contract without scraping help text:
+
+```bash
+npx allure agent capabilities --json
+```
+
+After a run, agents can query the output directory without manually reading every manifest:
+
+```bash
+npx allure agent query --latest summary
+npx allure agent query --latest tests --status failed
+npx allure agent query --from ./agent-output findings --severity high
+```
 
 ### Generating Reports Manually
 
@@ -118,6 +132,7 @@ The Allure CLI includes several helpful global options. Use `--help` to explore
 
 ```bash
 npx allure run --help
+npx allure agent capabilities --json
 npx allure agent --help
 npx allure watch --help
 ```

package/dist/commands/agent-run.d.ts

@@ -0,0 +1,21 @@
+import { writeLatestAgentState, type AgentExpectationsInput } from "@allurereport/plugin-agent";
+export declare const formatAgentCommand: (args: string[]) => string;
+export declare const printAgentOutputLinks: (outputDir: string) => void;
+export declare const persistLatestAgentState: (value: Parameters<typeof writeLatestAgentState>[0]) => Promise<void>;
+export type ExecuteAgentModeParams = {
+    configPath?: string;
+    cwd?: string;
+    output?: string;
+    expectations?: string;
+    inlineExpectations?: AgentExpectationsInput;
+    environment?: string;
+    environmentName?: string;
+    silent?: boolean;
+    rerunFrom?: string;
+    rerunLatest?: boolean;
+    rerunPreset?: string;
+    rerunEnvironments?: string[];
+    rerunLabels?: string[];
+    args: string[];
+};
+export declare const executeAgentMode: (params: ExecuteAgentModeParams) => Promise<void>;

package/dist/commands/agent-run.js

@@ -0,0 +1,151 @@
+import * as console from "node:console";
+import { mkdtemp, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import process, { exit } from "node:process";
+import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
+import { createAgentTestPlanContext, AgentUsageError, formatAgentOutputLinks, isPathInside, normalizeAgentRerunPreset, parseAgentLabelFilters, resolveAgentStateDir, writeLatestAgentState, } from "@allurereport/plugin-agent";
+import { normalizeCommandEnvironmentOptions, resolveCommandEnvironment } from "../utils/environment.js";
+import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
+import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
+export const formatAgentCommand = (args) => args.join(" ");
+export const printAgentOutputLinks = (outputDir) => {
+    for (const line of formatAgentOutputLinks(outputDir)) {
+        console.log(line);
+    }
+};
+export const persistLatestAgentState = async (value) => {
+    try {
+        await writeLatestAgentState(value);
+    }
+    catch (error) {
+        console.error(`Could not update latest agent output in ${resolveAgentStateDir(value.cwd)}: ${error.message}`);
+    }
+};
+export const executeAgentMode = async (params) => {
+    const { configPath, cwd: configuredCwd, output, expectations, inlineExpectations, environment, environmentName, silent, rerunFrom, rerunLatest, rerunPreset, rerunEnvironments, rerunLabels, args, } = params;
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    const cwd = await realpath(configuredCwd ?? process.cwd());
+    const commandString = formatAgentCommand(args);
+    const hasRerunSource = !!rerunFrom || !!rerunLatest;
+    const hasRerunFilters = !!rerunPreset || !!rerunEnvironments?.length || !!rerunLabels?.length;
+    if (!hasRerunSource && hasRerunFilters) {
+        throw new AgentUsageError("Use rerun filters only together with --rerun-from <path> or --rerun-latest");
+    }
+    const rerunContext = await createAgentTestPlanContext({
+        cwd,
+        from: rerunFrom,
+        latest: rerunLatest,
+        preset: normalizeAgentRerunPreset(rerunPreset),
+        environments: rerunEnvironments?.length ? rerunEnvironments : undefined,
+        labelFilters: parseAgentLabelFilters(rerunLabels),
+    });
+    const childEnvironmentVariables = {
+        ...createChildAllureCliEnvironment("agent"),
+        ...(rerunContext ? { ALLURE_TESTPLAN_PATH: rerunContext.testPlanPath } : {}),
+    };
+    try {
+        if (getActiveAllureCliCommand()) {
+            console.log(commandString);
+            const exitCode = await executeNestedAllureCommand({
+                command,
+                commandArgs,
+                cwd,
+                ...(rerunContext ? { environmentVariables: { ALLURE_TESTPLAN_PATH: rerunContext.testPlanPath } } : {}),
+                silent,
+            });
+            exit(exitCode ?? -1);
+            return;
+        }
+        const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
+        const expectationsPath = expectations ? resolve(cwd, expectations) : undefined;
+        const environmentOptions = {
+            environment,
+            environmentName,
+        };
+        normalizeCommandEnvironmentOptions(environmentOptions);
+        if (expectationsPath && isPathInside(outputDir, expectationsPath)) {
+            throw new AgentUsageError(`--expectations path ${JSON.stringify(expectationsPath)} must not be inside the agent output directory ${JSON.stringify(outputDir)}`);
+        }
+        const config = await readConfig(cwd, configPath, {
+            output: outputDir,
+            plugins: {
+                agent: {
+                    options: {
+                        outputDir,
+                        command: commandString,
+                        ...(expectationsPath ? { expectationsPath } : {}),
+                        ...(inlineExpectations ? { expectations: inlineExpectations } : {}),
+                    },
+                },
+            },
+        });
+        const resolvedEnvironment = resolveCommandEnvironment(config, environmentOptions);
+        try {
+            await rm(outputDir, { recursive: true });
+        }
+        catch (error) {
+            if (!isFileNotFoundError(error)) {
+                console.error("could not clean output directory", error);
+            }
+        }
+        const startedAt = new Date().toISOString();
+        await persistLatestAgentState({
+            cwd,
+            outputDir,
+            expectationsPath,
+            command: commandString,
+            startedAt,
+            status: "running",
+        });
+        printAgentOutputLinks(outputDir);
+        if (expectationsPath) {
+            console.log(`agent expectations: ${expectationsPath}`);
+        }
+        else if (inlineExpectations) {
+            console.log("agent expectations: CLI options");
+        }
+        console.log(commandString);
+        const allureReport = new AllureReport({
+            ...config,
+            output: outputDir,
+            environment: resolvedEnvironment?.id,
+            open: false,
+            port: undefined,
+            qualityGate: undefined,
+            allureService: undefined,
+            realTime: false,
+            plugins: config.plugins,
+        });
+        const knownIssues = await allureReport.store.allKnownIssues();
+        const { globalExitCode } = await executeAllureRun({
+            allureReport,
+            knownIssues,
+            cwd,
+            command,
+            commandArgs,
+            environmentVariables: childEnvironmentVariables,
+            environment: resolvedEnvironment?.id,
+            withQualityGate: false,
+            logs: "pipe",
+            silent,
+            ignoreLogs: false,
+            logProcessExit: false,
+        });
+        await persistLatestAgentState({
+            cwd,
+            outputDir,
+            expectationsPath,
+            command: commandString,
+            startedAt,
+            finishedAt: new Date().toISOString(),
+            status: "finished",
+            exitCode: globalExitCode.actual ?? globalExitCode.original,
+        });
+        exit(globalExitCode.actual ?? globalExitCode.original);
+    }
+    finally {
+        await rerunContext?.cleanup();
+    }
+};

package/dist/commands/agent.d.ts

@@ -1,4 +1,12 @@
+import { AGENT_TASK_MAP_HELP, createAgentCapabilities, isAgentTaskMapHelpRequest } from "@allurereport/plugin-agent";
 import { Command } from "clipanion";
+export { AGENT_TASK_MAP_HELP, createAgentCapabilities, isAgentTaskMapHelpRequest };
+export declare class AgentCapabilitiesCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    json: boolean;
+    execute(): Promise<void>;
+}
 export declare class AgentCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
@@ -6,6 +14,18 @@ export declare class AgentCommand extends Command {
     cwd: string | undefined;
     output: string | undefined;
     expectations: string | undefined;
+    goal: string[] | undefined;
+    taskId: string[] | undefined;
+    expectTests: string[] | undefined;
+    expectLabels: string[] | undefined;
+    expectEnvironments: string[] | undefined;
+    expectFullNames: string[] | undefined;
+    expectPrefixes: string[] | undefined;
+    forbidLabels: string[] | undefined;
+    expectStepContains: string[] | undefined;
+    expectSteps: string[] | undefined;
+    expectAttachments: string[] | undefined;
+    expectAttachmentFilters: string[] | undefined;
     environment: string | undefined;
     environmentName: string | undefined;
     silent: boolean | undefined;
@@ -29,6 +49,24 @@ export declare class AgentStateDirCommand extends Command {
     cwd: string | undefined;
     execute(): Promise<void>;
 }
+export declare class AgentQueryCommand extends Command {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    view: string | undefined;
+    cwd: string | undefined;
+    from: string | undefined;
+    latest: boolean | undefined;
+    statuses: string[] | undefined;
+    environments: string[] | undefined;
+    labels: string[] | undefined;
+    severities: string[] | undefined;
+    categories: string[] | undefined;
+    checks: string[] | undefined;
+    test: string | undefined;
+    limit: string | undefined;
+    includeMarkdown: boolean | undefined;
+    execute(): Promise<void>;
+}
 export declare class AgentSelectCommand extends Command {
     static paths: string[][];
     static usage: import("clipanion").Usage;
@@ -41,18 +79,3 @@ export declare class AgentSelectCommand extends Command {
     output: string | undefined;
     execute(): Promise<void>;
 }
-export declare const executeAgentMode: (params: {
-    configPath?: string;
-    cwd?: string;
-    output?: string;
-    expectations?: string;
-    environment?: string;
-    environmentName?: string;
-    silent?: boolean;
-    rerunFrom?: string;
-    rerunLatest?: boolean;
-    rerunPreset?: string;
-    rerunEnvironments?: string[];
-    rerunLabels?: string[];
-    args?: string[];
-}) => Promise<void>;