allure 3.10.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>;

package/dist/commands/agent.js

@@ -1,42 +1,20 @@
 import * as console from "node:console";
-import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, realpath, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import process, { exit } from "node:process";
-import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
+import { AGENT_FINDING_CATEGORIES, AGENT_FINDING_SEVERITIES, AGENT_TASK_MAP_HELP, AGENT_TEST_STATUSES, AgentExpectationUsageError, buildAgentInlineExpectations, buildAgentQueryPayload, createAgentCapabilities, formatAgentOutputLinks, isAgentExpectationUsageError, isAgentTaskMapHelpRequest, isAgentUsageError, loadAgentOutput, normalizeAgentQueryLimit, normalizeAgentQueryView, normalizeAgentRerunPreset, normalizeRepeatedEnumValues, normalizeRepeatedStringValues, parseAgentLabelFilters, readLatestAgentState, resolveAgentSelectionOutputDir, resolveAgentStateDir, selectAgentTestPlan, validateAgentExpectationsFile, writeLatestAgentState, writeInvalidAgentExpectationOutput, } from "@allurereport/plugin-agent";
 import { Command, Option, UsageError } from "clipanion";
-import { createAgentTestPlanContext, normalizeAgentRerunPreset, parseAgentLabelFilters, resolveAgentSelectionOutputDir, selectAgentTestPlan, } from "../utils/agent-select.js";
-import { readLatestAgentState, resolveAgentStateDir, writeLatestAgentState } from "../utils/agent-state.js";
-import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
-import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
-import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
-const withProcessEnv = async (overrides, fn) => {
-    const previousValues = new Map();
-    for (const [key, value] of Object.entries(overrides)) {
-        previousValues.set(key, process.env[key]);
-        if (value === undefined) {
-            delete process.env[key];
-            continue;
-        }
-        process.env[key] = value;
-    }
-    try {
-        return await fn();
-    }
-    finally {
-        for (const [key, value] of previousValues) {
-            if (value === undefined) {
-                delete process.env[key];
-                continue;
-            }
-            process.env[key] = value;
-        }
+export { AGENT_TASK_MAP_HELP, createAgentCapabilities, isAgentTaskMapHelpRequest };
+const readOptionalString = (value) => (typeof value === "string" ? value : undefined);
+const readOptionalBoolean = (value) => value === true;
+const readOptionalStringArray = (value) => (Array.isArray(value) ? value : undefined);
+const formatAgentCommand = (args) => args.join(" ");
+const printAgentOutputLinks = (outputDir) => {
+    for (const line of formatAgentOutputLinks(outputDir)) {
+        console.log(line);
     }
 };
-const isPathInside = (parentPath, candidatePath) => {
-    const rel = relative(parentPath, candidatePath);
-    return rel === "" || (!rel.startsWith("..") && rel !== "." && !rel.startsWith("../"));
-};
 const persistLatestAgentState = async (value) => {
     try {
         await writeLatestAgentState(value);
@@ -45,9 +23,38 @@ const persistLatestAgentState = async (value) => {
         console.error(`Could not update latest agent output in ${resolveAgentStateDir(value.cwd)}: ${error.message}`);
     }
 };
-const readOptionalString = (value) => (typeof value === "string" ? value : undefined);
-const readOptionalBoolean = (value) => value === true;
-const readOptionalStringArray = (value) => (Array.isArray(value) ? value : undefined);
+const agentEnvironmentOption = () => Option.String("--environment,--env", {
+    description: "Force specific environment ID to all tests in the run. Given environment has higher priority than the one defined in the config file (default: empty string)",
+});
+const agentEnvironmentNameOption = () => Option.String("--environment-name", {
+    description: "Force specific environment display name to all tests in the run. Has lower priority than --environment and higher than the config value (default: empty string)",
+});
+const throwCliUsageError = (error) => {
+    if (isAgentUsageError(error)) {
+        throw new UsageError(error.message);
+    }
+    throw error;
+};
+export class AgentCapabilitiesCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.json = Option.Boolean("--json", true, {
+            description: "Print capabilities as JSON (default: true)",
+        });
+    }
+    async execute() {
+        console.log(JSON.stringify(createAgentCapabilities(), null, 2));
+    }
+}
+AgentCapabilitiesCommand.paths = [["agent", "capabilities"]];
+AgentCapabilitiesCommand.usage = Command.Usage({
+    description: "Print structured Allure agent capability information",
+    details: "This command prints the locally supported agent-mode commands, expectation controls, output files, rerun support, and known unsupported capability families as JSON.",
+    examples: [
+        ["agent capabilities", "Print agent capabilities as JSON"],
+        ["agent capabilities --json", "Print agent capabilities as JSON explicitly"],
+    ],
+});
 export class AgentCommand extends Command {
     constructor() {
         super(...arguments);
@@ -63,8 +70,44 @@ export class AgentCommand extends Command {
         this.expectations = Option.String("--expectations", {
             description: "The path to a YAML or JSON expectations file",
         });
-        this.environment = environmentOption();
-        this.environmentName = environmentNameOption();
+        this.goal = Option.Array("--goal", {
+            description: "The review goal to record in inline agent expectations",
+        });
+        this.taskId = Option.Array("--task-id", {
+            description: "The task or feature id to record in inline agent expectations",
+        });
+        this.expectTests = Option.Array("--expect-tests", {
+            description: "The expected number of visible logical tests in the intended scope",
+        });
+        this.expectLabels = Option.Array("--expect-label", {
+            description: "Expected label selector in name=value form. Repeat the option for multiple selectors",
+        });
+        this.expectEnvironments = Option.Array("--expect-env", {
+            description: "Expected environment id. Repeat the option for multiple environments",
+        });
+        this.expectFullNames = Option.Array("--expect-test", {
+            description: "Expected full test name. Repeat the option for multiple tests",
+        });
+        this.expectPrefixes = Option.Array("--expect-prefix", {
+            description: "Expected full-name prefix. Repeat the option for multiple prefixes",
+        });
+        this.forbidLabels = Option.Array("--forbid-label", {
+            description: "Forbidden label selector in name=value form. Repeat the option for multiple selectors",
+        });
+        this.expectStepContains = Option.Array("--expect-step-containing", {
+            description: "Require a test-scoped step name containing this text per evidence-target logical test",
+        });
+        this.expectSteps = Option.Array("--expect-steps", {
+            description: "Require at least this many meaningful steps per expected logical test",
+        });
+        this.expectAttachments = Option.Array("--expect-attachments", {
+            description: "Require at least this many non-missing attachments per expected logical test",
+        });
+        this.expectAttachmentFilters = Option.Array("--expect-attachment", {
+            description: "Require a matching non-missing attachment per expected logical test. Use a file name or name=value/content-type=value",
+        });
+        this.environment = agentEnvironmentOption();
+        this.environmentName = agentEnvironmentNameOption();
         this.silent = Option.Boolean("--silent", {
             description: "Don't pipe the process output logs to console (default: false)",
         });
@@ -87,21 +130,80 @@ export class AgentCommand extends Command {
     }
     async execute() {
         const args = this.commandToRun.filter((arg) => arg !== "--");
-        await executeAgentMode({
-            configPath: readOptionalString(this.config),
-            cwd: readOptionalString(this.cwd),
-            output: readOptionalString(this.output),
-            expectations: readOptionalString(this.expectations),
-            environment: readOptionalString(this.environment),
-            environmentName: readOptionalString(this.environmentName),
-            silent: readOptionalBoolean(this.silent),
-            rerunFrom: readOptionalString(this.rerunFrom),
-            rerunLatest: readOptionalBoolean(this.rerunLatest),
-            rerunPreset: readOptionalString(this.rerunPreset),
-            rerunEnvironments: readOptionalStringArray(this.rerunEnvironments),
-            rerunLabels: readOptionalStringArray(this.rerunLabels),
-            args,
-        });
+        const configPath = readOptionalString(this.config);
+        const configuredCwd = readOptionalString(this.cwd);
+        const output = readOptionalString(this.output);
+        const expectations = readOptionalString(this.expectations);
+        if (!args || !args.length) {
+            throw new UsageError("expecting command to be specified after --, e.g. allure agent -- npm run test");
+        }
+        try {
+            const inlineExpectations = buildAgentInlineExpectations({
+                goal: this.goal,
+                taskId: this.taskId,
+                expectTests: this.expectTests,
+                expectLabels: readOptionalStringArray(this.expectLabels),
+                expectEnvironments: readOptionalStringArray(this.expectEnvironments),
+                expectFullNames: readOptionalStringArray(this.expectFullNames),
+                expectPrefixes: readOptionalStringArray(this.expectPrefixes),
+                forbidLabels: readOptionalStringArray(this.forbidLabels),
+                expectStepContains: readOptionalStringArray(this.expectStepContains),
+                expectSteps: this.expectSteps,
+                expectAttachments: this.expectAttachments,
+                expectAttachmentFilters: readOptionalStringArray(this.expectAttachmentFilters),
+            });
+            if (expectations && inlineExpectations) {
+                throw new AgentExpectationUsageError("Use either --expectations <file> or inline expectation flags, not both", "--expectations");
+            }
+            await validateAgentExpectationsFile({
+                cwd: await realpath(configuredCwd ?? process.cwd()),
+                output,
+                expectations,
+            });
+            const { executeAgentMode } = await import("./agent-run.js");
+            await executeAgentMode({
+                configPath,
+                cwd: configuredCwd,
+                output,
+                expectations,
+                inlineExpectations: inlineExpectations,
+                environment: readOptionalString(this.environment),
+                environmentName: readOptionalString(this.environmentName),
+                silent: readOptionalBoolean(this.silent),
+                rerunFrom: readOptionalString(this.rerunFrom),
+                rerunLatest: readOptionalBoolean(this.rerunLatest),
+                rerunPreset: readOptionalString(this.rerunPreset),
+                rerunEnvironments: readOptionalStringArray(this.rerunEnvironments),
+                rerunLabels: readOptionalStringArray(this.rerunLabels),
+                args,
+            });
+        }
+        catch (error) {
+            if (!isAgentExpectationUsageError(error)) {
+                throwCliUsageError(error);
+            }
+            const expectationError = error;
+            const cwd = await realpath(configuredCwd ?? process.cwd());
+            const outputDir = output ? resolve(cwd, output) : await mkdtemp(join(tmpdir(), "allure-agent-"));
+            const commandString = formatAgentCommand(args);
+            const { generatedAt } = await writeInvalidAgentExpectationOutput({
+                outputDir,
+                command: commandString,
+                error: expectationError,
+            });
+            await persistLatestAgentState({
+                cwd,
+                outputDir,
+                command: commandString,
+                startedAt: generatedAt,
+                finishedAt: generatedAt,
+                status: "finished",
+                exitCode: 1,
+            });
+            printAgentOutputLinks(outputDir);
+            console.error(expectationError.message);
+            exit(1);
+        }
     }
 }
 AgentCommand.paths = [["agent"]];
@@ -139,16 +241,19 @@ export class AgentLatestCommand extends Command {
             exit(1);
             return;
         }
-        console.log(latestState.outputDir);
+        printAgentOutputLinks(latestState.outputDir);
     }
 }
 AgentLatestCommand.paths = [["agent", "latest"]];
 AgentLatestCommand.usage = Command.Usage({
-    description: "Print the latest Allure agent output directory for the current project",
-    details: "This command prints the latest agent output directory recorded for the resolved project cwd.",
+    description: "Print the latest Allure agent output directory and index path for the current project",
+    details: "This command prints the latest agent output directory and index.md path recorded for the resolved project cwd.",
     examples: [
-        ["agent latest", "Print the latest agent output directory for the current project"],
-        ["agent latest --cwd ./packages/cli", "Print the latest agent output directory for a specific project cwd"],
+        ["agent latest", "Print the latest agent output directory and index path for the current project"],
+        [
+            "agent latest --cwd ./packages/cli",
+            "Print the latest agent output directory and index path for a specific project cwd",
+        ],
     ],
 });
 export class AgentStateDirCommand extends Command {
@@ -172,6 +277,95 @@ AgentStateDirCommand.usage = Command.Usage({
         ["agent state-dir --cwd ./packages/cli", "Print the resolved state directory for a specific project cwd"],
     ],
 });
+export class AgentQueryCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.view = Option.String({
+            required: false,
+            name: "Query view: summary, tests, findings, or test (default: summary)",
+        });
+        this.cwd = Option.String("--cwd", {
+            description: "The project directory used to resolve --latest and relative paths (default: current working directory)",
+        });
+        this.from = Option.String("--from", {
+            description: "The prior agent output directory to query",
+        });
+        this.latest = Option.Boolean("--latest", {
+            description: "Use the latest recorded agent output for the current project cwd",
+        });
+        this.statuses = Option.Array("--status", {
+            description: "Filter tests by status: failed, broken, unknown, skipped, or passed. Repeat for multiple statuses",
+        });
+        this.environments = Option.Array("--environment", {
+            description: "Filter tests by environment id. Repeat the option for multiple environments",
+        });
+        this.labels = Option.Array("--label", {
+            description: "Filter tests by exact label name=value. Repeat the option for multiple filters",
+        });
+        this.severities = Option.Array("--severity", {
+            description: "Filter findings by severity: high, warning, or info. Repeat for multiple severities",
+        });
+        this.categories = Option.Array("--category", {
+            description: "Filter findings by category. Repeat the option for multiple categories",
+        });
+        this.checks = Option.Array("--check", {
+            description: "Filter findings by check name. Repeat the option for multiple checks",
+        });
+        this.test = Option.String("--test", {
+            description: "Filter to one test by full name, test result id, history id, or markdown path",
+        });
+        this.limit = Option.String("--limit", {
+            description: "Limit returned tests or findings to this non-negative count",
+        });
+        this.includeMarkdown = Option.Boolean("--include-markdown", {
+            description: "Include the per-test markdown content for the test view",
+        });
+    }
+    async execute() {
+        try {
+            const cwd = await realpath(readOptionalString(this.cwd) ?? process.cwd());
+            const view = normalizeAgentQueryView(readOptionalString(this.view));
+            const outputDir = await resolveAgentSelectionOutputDir({
+                cwd,
+                from: readOptionalString(this.from),
+                latest: readOptionalBoolean(this.latest),
+            });
+            const output = await loadAgentOutput(outputDir);
+            const payload = await buildAgentQueryPayload(output, view, {
+                environments: normalizeRepeatedStringValues(readOptionalStringArray(this.environments)),
+                labelFilters: parseAgentLabelFilters(readOptionalStringArray(this.labels)),
+                statuses: normalizeRepeatedEnumValues(readOptionalStringArray(this.statuses), AGENT_TEST_STATUSES, "--status"),
+                severities: normalizeRepeatedEnumValues(readOptionalStringArray(this.severities), AGENT_FINDING_SEVERITIES, "--severity"),
+                categories: normalizeRepeatedEnumValues(readOptionalStringArray(this.categories), AGENT_FINDING_CATEGORIES, "--category"),
+                checks: normalizeRepeatedStringValues(readOptionalStringArray(this.checks)),
+                test: readOptionalString(this.test),
+                limit: normalizeAgentQueryLimit(readOptionalString(this.limit)),
+                includeMarkdown: readOptionalBoolean(this.includeMarkdown),
+            });
+            console.log(JSON.stringify(payload, null, 2));
+        }
+        catch (error) {
+            throwCliUsageError(error);
+        }
+    }
+}
+AgentQueryCommand.paths = [["agent", "query"]];
+AgentQueryCommand.usage = Command.Usage({
+    description: "Query an existing Allure agent output directory as focused JSON",
+    details: "This command reads a prior agent output directory and prints focused JSON for a run summary, test list, findings list, or one test. Use --latest to query the latest recorded output for the project, or --from to query a specific output directory.",
+    examples: [
+        ["agent query --latest summary", "Print a summary for the latest agent output"],
+        ["agent query --from ./out/agent-output tests --status failed", "List failed tests from a prior output"],
+        [
+            "agent query --from ./out/agent-output findings --severity high",
+            "List high-severity findings from a prior output",
+        ],
+        [
+            'agent query --latest test --test "suite should pass" --include-markdown',
+            "Print one test summary with its per-test markdown",
+        ],
+    ],
+});
 export class AgentSelectCommand extends Command {
     constructor() {
         super(...arguments);
@@ -198,177 +392,52 @@ export class AgentSelectCommand extends Command {
         });
     }
     async execute() {
-        const cwd = await realpath(readOptionalString(this.cwd) ?? process.cwd());
-        const environments = readOptionalStringArray(this.environments);
-        const labels = readOptionalStringArray(this.labels);
-        const outputDir = await resolveAgentSelectionOutputDir({
-            cwd,
-            from: readOptionalString(this.from),
-            latest: readOptionalBoolean(this.latest),
-        });
-        const selection = await selectAgentTestPlan({
-            outputDir,
-            preset: normalizeAgentRerunPreset(readOptionalString(this.preset)),
-            environments: environments?.length ? environments : undefined,
-            labelFilters: parseAgentLabelFilters(labels),
-        });
-        if (!selection.testPlan.tests.length) {
-            console.error(`No tests matched selection in ${selection.outputDir}`);
-            exit(1);
-            return;
+        try {
+            const cwd = await realpath(readOptionalString(this.cwd) ?? process.cwd());
+            const environments = readOptionalStringArray(this.environments);
+            const labels = readOptionalStringArray(this.labels);
+            const outputDir = await resolveAgentSelectionOutputDir({
+                cwd,
+                from: readOptionalString(this.from),
+                latest: readOptionalBoolean(this.latest),
+            });
+            const selection = await selectAgentTestPlan({
+                outputDir,
+                preset: normalizeAgentRerunPreset(readOptionalString(this.preset)),
+                environments: environments?.length ? environments : undefined,
+                labelFilters: parseAgentLabelFilters(labels),
+            });
+            if (!selection.testPlan.tests.length) {
+                console.error(`No tests matched selection in ${selection.outputDir}`);
+                exit(1);
+                return;
+            }
+            const serialized = `${JSON.stringify(selection.testPlan, null, 2)}\n`;
+            const output = readOptionalString(this.output);
+            if (!output) {
+                console.log(serialized.trimEnd());
+                return;
+            }
+            const outputPath = resolve(cwd, output);
+            await mkdir(dirname(outputPath), { recursive: true });
+            await writeFile(outputPath, serialized, "utf-8");
+            console.log(`agent testplan: ${outputPath}`);
+            console.log(`agent selection source: ${selection.outputDir}`);
+            console.log(`agent selection preset: ${selection.preset}`);
+            console.log(`agent selection tests: ${selection.selectedTests.length}`);
         }
-        const serialized = `${JSON.stringify(selection.testPlan, null, 2)}\n`;
-        const output = readOptionalString(this.output);
-        if (!output) {
-            console.log(serialized.trimEnd());
-            return;
+        catch (error) {
+            throwCliUsageError(error);
         }
-        const outputPath = resolve(cwd, output);
-        await mkdir(dirname(outputPath), { recursive: true });
-        await writeFile(outputPath, serialized, "utf-8");
-        console.log(outputPath);
     }
 }
 AgentSelectCommand.paths = [["agent", "select"]];
 AgentSelectCommand.usage = Command.Usage({
     description: "Select tests from an existing agent output and emit a test plan",
-    details: "This command resolves a set of tests from a prior agent run and prints or writes a testplan.json payload.",
+    details: "This command resolves a set of tests from a prior agent run and prints or writes a testplan.json payload. When --output is used, stdout contains the written test plan path, source output directory, preset, and selected test count.",
     examples: [
         ["agent select --from ./out/agent-output", "Print a test plan for the default review-targeted tests"],
         ["agent select --latest --preset failed", "Print a test plan for failed tests from the latest project run"],
         ["agent select --from ./out/agent-output --output ./testplan.json", "Write the selected test plan to a file"],
     ],
 });
-export const executeAgentMode = async (params) => {
-    const { configPath, cwd: configuredCwd, output, expectations, environment, environmentName, silent, rerunFrom, rerunLatest, rerunPreset, rerunEnvironments, rerunLabels, args, } = params;
-    if (!args || !args.length) {
-        throw new UsageError("expecting command to be specified after --, e.g. allure agent -- npm run test");
-    }
-    const command = args[0];
-    const commandArgs = args.slice(1);
-    const cwd = await realpath(configuredCwd ?? process.cwd());
-    const commandString = `${command} ${commandArgs.join(" ")}`;
-    const hasRerunSource = !!rerunFrom || !!rerunLatest;
-    const hasRerunFilters = !!rerunPreset || !!rerunEnvironments?.length || !!rerunLabels?.length;
-    if (!hasRerunSource && hasRerunFilters) {
-        throw new UsageError("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 UsageError(`--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,
-                    },
-                },
-            },
-        });
-        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",
-        });
-        console.log(`agent output: ${outputDir}`);
-        if (expectationsPath) {
-            console.log(`agent expectations: ${expectationsPath}`);
-        }
-        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 withProcessEnv({
-            ALLURE_AGENT_OUTPUT: outputDir,
-            ALLURE_AGENT_EXPECTATIONS: expectationsPath,
-            ALLURE_AGENT_COMMAND: commandString,
-            ALLURE_AGENT_PROJECT_ROOT: cwd,
-            ALLURE_AGENT_NAME: undefined,
-            ALLURE_AGENT_LOOP_ID: undefined,
-            ALLURE_AGENT_TASK_ID: undefined,
-            ALLURE_AGENT_CONVERSATION_ID: undefined,
-        }, async () => 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/run.js

@@ -1,6 +1,5 @@
 import * as console from "node:console";
 import { realpath, rm } from "node:fs/promises";
-import { resolve } from "node:path";
 import process, { exit } from "node:process";
 import { AllureReport, isFileNotFoundError, readConfig } from "@allurereport/core";
 import Awesome from "@allurereport/plugin-awesome";
@@ -9,7 +8,6 @@ import { Command, Option, UsageError } from "clipanion";
 import { red } from "yoctocolors";
 import { environmentNameOption, environmentOption, normalizeCommandEnvironmentOptions, resolveCommandEnvironment, } from "../utils/environment.js";
 import { createChildAllureCliEnvironment, getActiveAllureCliCommand } from "../utils/execution-context.js";
-import { executeAgentMode } from "./agent.js";
 import { executeAllureRun, executeNestedAllureCommand } from "./commons/run.js";
 export class RunCommand extends Command {
     constructor() {
@@ -65,22 +63,6 @@ export class RunCommand extends Command {
         if (!args || !args.length) {
             throw new UsageError("expecting command to be specified after --, e.g. allure run -- npm run test");
         }
-        const legacyAgentOutput = process.env.ALLURE_AGENT_OUTPUT;
-        if (legacyAgentOutput) {
-            await executeAgentMode({
-                configPath: this.config,
-                cwd: this.cwd,
-                output: resolve(process.cwd(), legacyAgentOutput),
-                expectations: process.env.ALLURE_AGENT_EXPECTATIONS
-                    ? resolve(process.cwd(), process.env.ALLURE_AGENT_EXPECTATIONS)
-                    : undefined,
-                environment: this.environment,
-                environmentName: this.environmentName,
-                silent: this.silent,
-                args,
-            });
-            return;
-        }
         const before = new Date().getTime();
         process.on("exit", (exitCode) => {
             const after = new Date().getTime();

package/dist/index.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
-import { argv } from "node:process";
+import process, { argv } from "node:process";
 import { Builtins, Cli } from "clipanion";
-import { AgentCommand, AgentLatestCommand, AgentSelectCommand, AgentStateDirCommand, Allure2Command, AwesomeCommand, CheckCommand, ClassicCommand, CsvCommand, DashboardCommand, GenerateCommand, HistoryCommand, JiraClearCommand, KnownIssueCommand, LogCommand, OpenCommand, QualityGateCommand, ResultsPackCommand, ResultsUnpackCommand, RunCommand, SlackCommand, TestPlanCommand, WatchCommand, } from "./commands/index.js";
+import { AgentCommand, AGENT_TASK_MAP_HELP, AgentCapabilitiesCommand, 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";
 const [node, app, ...args] = argv;
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 const cli = new Cli({
@@ -11,7 +11,9 @@ const cli = new Cli({
 });
 cli.register(AwesomeCommand);
 cli.register(Allure2Command);
+cli.register(AgentCapabilitiesCommand);
 cli.register(AgentLatestCommand);
+cli.register(AgentQueryCommand);
 cli.register(AgentSelectCommand);
 cli.register(AgentStateDirCommand);
 cli.register(AgentCommand);
@@ -34,6 +36,17 @@ cli.register(ResultsPackCommand);
 cli.register(ResultsUnpackCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);
-cli.runExit(args);
+void cli
+    .run(args)
+    .then((exitCode) => {
+    if (exitCode === 0 && isAgentTaskMapHelpRequest(args)) {
+        process.stdout.write(`\n${AGENT_TASK_MAP_HELP}`);
+    }
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});
 export { defineConfig } from "@allurereport/plugin-api";
 export { defaultChartsConfig } from "@allurereport/charts-api";

package/dist/utils/index.d.ts

@@ -2,6 +2,4 @@ export * from "./process.js";
 export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
-export * from "./agent-state.js";
-export * from "./agent-select.js";
 export * from "./fileSystem.js";

package/dist/utils/index.js

@@ -2,6 +2,4 @@ export * from "./process.js";
 export * from "./terminal.js";
 export * from "./logs.js";
 export * from "./execution-context.js";
-export * from "./agent-state.js";
-export * from "./agent-select.js";
 export * from "./fileSystem.js";

package/package.json

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

package/dist/utils/agent-select.d.ts

@@ -1,41 +0,0 @@
-import type { TestPlan } from "@allurereport/core-api";
-import { type AgentTestManifestLine } from "@allurereport/plugin-agent";
-export type AgentRerunPreset = "review" | "failed" | "unsuccessful" | "all";
-export type AgentLabelFilter = {
-    name: string;
-    value: string;
-};
-export type AgentSelectionResult = {
-    outputDir: string;
-    preset: AgentRerunPreset;
-    selectedTests: AgentTestManifestLine[];
-    testPlan: TestPlan;
-};
-export type AgentTestPlanContext = {
-    outputDir: string;
-    preset: AgentRerunPreset;
-    selectedCount: number;
-    testPlanPath: string;
-    cleanup: () => Promise<void>;
-};
-export declare const normalizeAgentRerunPreset: (value?: string) => AgentRerunPreset;
-export declare const parseAgentLabelFilters: (values?: string[]) => AgentLabelFilter[];
-export declare const resolveAgentSelectionOutputDir: (params: {
-    cwd: string;
-    from?: string;
-    latest?: boolean;
-}) => Promise<string>;
-export declare const selectAgentTestPlan: (params: {
-    outputDir: string;
-    preset?: AgentRerunPreset;
-    environments?: string[];
-    labelFilters?: AgentLabelFilter[];
-}) => Promise<AgentSelectionResult>;
-export declare const createAgentTestPlanContext: (params: {
-    cwd: string;
-    from?: string;
-    latest?: boolean;
-    preset?: AgentRerunPreset;
-    environments?: string[];
-    labelFilters?: AgentLabelFilter[];
-}) => Promise<AgentTestPlanContext | undefined>;

package/dist/utils/agent-select.js

@@ -1,141 +0,0 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { loadAgentOutput, planAgentEnrichmentReview, } from "@allurereport/plugin-agent";
-import { UsageError } from "clipanion";
-import { readLatestAgentState } from "./agent-state.js";
-const AGENT_RERUN_PRESETS = ["review", "failed", "unsuccessful", "all"];
-const ALLURE_ID_LABEL = "ALLURE_ID";
-const isAgentRerunPreset = (value) => AGENT_RERUN_PRESETS.includes(value);
-const readAllureId = (labels) => labels.find((label) => label.name === ALLURE_ID_LABEL)?.value;
-const matchesLabelFilters = (labels, filters) => filters.every((filter) => labels.some((label) => label.name === filter.name && label.value === filter.value));
-const buildTestPlan = (tests) => {
-    const seenSelectors = new Set();
-    const seenIds = new Set();
-    const selected = [];
-    for (const test of tests) {
-        const selector = test.full_name || undefined;
-        const id = readAllureId(test.labels);
-        if (selector && !seenSelectors.has(selector)) {
-            seenSelectors.add(selector);
-            if (id) {
-                seenIds.add(id);
-            }
-            selected.push({
-                selector,
-                ...(id ? { id } : {}),
-            });
-            continue;
-        }
-        if (id && !seenIds.has(id)) {
-            seenIds.add(id);
-            selected.push({ id });
-        }
-    }
-    return {
-        version: "1.0",
-        tests: selected,
-    };
-};
-const selectTestsByPreset = (output, preset) => {
-    switch (preset) {
-        case "review": {
-            const review = planAgentEnrichmentReview(output);
-            const targeted = new Set(review.rerun.targetedTests);
-            return output.tests.filter((test) => targeted.has(test.full_name));
-        }
-        case "failed":
-            return output.tests.filter((test) => test.status === "failed" || test.status === "broken");
-        case "unsuccessful":
-            return output.tests.filter((test) => test.status !== "passed");
-        case "all":
-            return output.tests;
-    }
-};
-export const normalizeAgentRerunPreset = (value) => {
-    if (!value) {
-        return "review";
-    }
-    const normalized = value.trim().toLowerCase();
-    if (!isAgentRerunPreset(normalized)) {
-        throw new UsageError(`Invalid rerun preset ${JSON.stringify(value)}. Expected one of: ${AGENT_RERUN_PRESETS.join(", ")}`);
-    }
-    return normalized;
-};
-export const parseAgentLabelFilters = (values) => (values ?? []).map((value) => {
-    const separatorIndex = value.indexOf("=");
-    if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
-        throw new UsageError(`Invalid label filter ${JSON.stringify(value)}. Expected the form name=value, for example feature=checkout`);
-    }
-    const name = value.slice(0, separatorIndex).trim();
-    const filterValue = value.slice(separatorIndex + 1).trim();
-    if (!name || !filterValue) {
-        throw new UsageError(`Invalid label filter ${JSON.stringify(value)}. Expected the form name=value, for example feature=checkout`);
-    }
-    return {
-        name,
-        value: filterValue,
-    };
-});
-export const resolveAgentSelectionOutputDir = async (params) => {
-    const { cwd, from, latest } = params;
-    if (from && latest) {
-        throw new UsageError("Use either --from or --latest, not both");
-    }
-    if (!from && !latest) {
-        throw new UsageError("Expected either --from <path> or --latest");
-    }
-    if (from) {
-        return resolve(cwd, from);
-    }
-    const latestState = await readLatestAgentState(cwd);
-    if (!latestState) {
-        throw new UsageError(`No latest agent output found for ${cwd}`);
-    }
-    return latestState.outputDir;
-};
-export const selectAgentTestPlan = async (params) => {
-    const preset = params.preset ?? "review";
-    const output = await loadAgentOutput(params.outputDir);
-    const selectedTests = selectTestsByPreset(output, preset)
-        .filter((test) => (params.environments?.length ? params.environments.includes(test.environment_id) : true))
-        .filter((test) => (params.labelFilters?.length ? matchesLabelFilters(test.labels, params.labelFilters) : true));
-    return {
-        outputDir: output.outputDir,
-        preset,
-        selectedTests,
-        testPlan: buildTestPlan(selectedTests),
-    };
-};
-export const createAgentTestPlanContext = async (params) => {
-    const { from, latest } = params;
-    if (!from && !latest) {
-        return undefined;
-    }
-    const outputDir = await resolveAgentSelectionOutputDir({
-        cwd: params.cwd,
-        from,
-        latest,
-    });
-    const selection = await selectAgentTestPlan({
-        outputDir,
-        preset: params.preset,
-        environments: params.environments,
-        labelFilters: params.labelFilters,
-    });
-    if (!selection.testPlan.tests.length) {
-        throw new UsageError(`No tests matched rerun selection in ${selection.outputDir}. Adjust the preset or filters before rerunning.`);
-    }
-    const tempDir = await mkdtemp(join(tmpdir(), "allure-agent-select-"));
-    const testPlanPath = join(tempDir, "testplan.json");
-    await writeFile(testPlanPath, `${JSON.stringify(selection.testPlan, null, 2)}\n`, "utf-8");
-    return {
-        outputDir: selection.outputDir,
-        preset: selection.preset,
-        selectedCount: selection.testPlan.tests.length,
-        testPlanPath,
-        cleanup: async () => {
-            await rm(tempDir, { recursive: true, force: true });
-        },
-    };
-};

package/dist/utils/agent-state.d.ts

@@ -1,15 +0,0 @@
-export type AgentLatestState = {
-    schema: "allure-agent-latest/v1";
-    cwd: string;
-    outputDir: string;
-    expectationsPath?: string;
-    command: string;
-    startedAt: string;
-    finishedAt?: string;
-    status: "running" | "finished";
-    exitCode?: number | null;
-};
-export declare const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
-export declare const resolveAgentStateDir: (cwd: string) => string;
-export declare const writeLatestAgentState: (value: Omit<AgentLatestState, "schema">) => Promise<AgentLatestState>;
-export declare const readLatestAgentState: (cwd: string) => Promise<AgentLatestState | undefined>;

package/dist/utils/agent-state.js

@@ -1,83 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-const AGENT_STATE_SCHEMA = "allure-agent-latest/v1";
-export const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
-const isFileNotFoundError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-const projectHash = (cwd) => createHash("sha256").update(cwd).digest("hex").slice(0, 16);
-export const resolveAgentStateDir = (cwd) => {
-    const configuredDir = process.env[ALLURE_AGENT_STATE_DIR_ENV]?.trim();
-    if (configuredDir) {
-        return resolve(configuredDir);
-    }
-    return join(tmpdir(), `allure-agent-state-${projectHash(resolve(cwd))}`);
-};
-const projectStatePath = (cwd) => join(resolveAgentStateDir(cwd), "latest.json");
-const writeJsonAtomic = async (filePath, value) => {
-    await mkdir(dirname(filePath), { recursive: true });
-    const tempPath = `${filePath}.${process.pid}.tmp`;
-    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
-    await rename(tempPath, filePath);
-};
-const isAgentLatestState = (value) => {
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    const candidate = value;
-    return (candidate.schema === AGENT_STATE_SCHEMA &&
-        typeof candidate.cwd === "string" &&
-        typeof candidate.outputDir === "string" &&
-        typeof candidate.command === "string" &&
-        typeof candidate.startedAt === "string" &&
-        (candidate.expectationsPath === undefined || typeof candidate.expectationsPath === "string") &&
-        (candidate.finishedAt === undefined || typeof candidate.finishedAt === "string") &&
-        (candidate.status === "running" || candidate.status === "finished") &&
-        (candidate.exitCode === undefined || typeof candidate.exitCode === "number" || candidate.exitCode === null));
-};
-export const writeLatestAgentState = async (value) => {
-    const normalizedState = {
-        schema: AGENT_STATE_SCHEMA,
-        cwd: resolve(value.cwd),
-        outputDir: resolve(value.outputDir),
-        expectationsPath: value.expectationsPath ? resolve(value.expectationsPath) : undefined,
-        command: value.command,
-        startedAt: value.startedAt,
-        finishedAt: value.finishedAt,
-        status: value.status,
-        exitCode: value.exitCode,
-    };
-    await writeJsonAtomic(projectStatePath(normalizedState.cwd), normalizedState);
-    return normalizedState;
-};
-export const readLatestAgentState = async (cwd) => {
-    const normalizedCwd = resolve(cwd);
-    const statePath = projectStatePath(normalizedCwd);
-    let raw;
-    try {
-        raw = await readFile(statePath, "utf-8");
-    }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            return undefined;
-        }
-        throw error;
-    }
-    const parsed = JSON.parse(raw);
-    if (!isAgentLatestState(parsed)) {
-        throw new Error(`Invalid latest agent state in ${statePath}`);
-    }
-    if (parsed.cwd !== normalizedCwd) {
-        return undefined;
-    }
-    try {
-        await stat(parsed.outputDir);
-    }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            return undefined;
-        }
-        throw error;
-    }
-    return parsed;
-};