voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/cli/contract.js

@@ -0,0 +1,480 @@
+import { z } from "zod";
+import { listModes, listOperators, } from "../contracts/list.js";
+const nonEmptyStringSchema = z.string().min(1, "must not be empty");
+const positiveIntegerSchema = z
+    .number()
+    .int("must be an integer")
+    .positive("must be greater than 0");
+const optionalNonEmptyStringArraySchema = z
+    .array(nonEmptyStringSchema)
+    .min(1, "must include at least one value")
+    .optional();
+export const externalExecutionOperators = [
+    "spec",
+    "run",
+    "reduce",
+    "verify",
+    "message",
+    "apply",
+    "prune",
+];
+export const externalInspectionOperators = listOperators;
+export const externalInspectionModes = listModes;
+export const externalExecutionOperatorSchema = z.enum(externalExecutionOperators);
+export const externalInspectionOperatorSchema = z.enum(externalInspectionOperators);
+export const externalInspectionModeSchema = z.enum(externalInspectionModes);
+export const externalSpecExecutionInputSchema = z
+    .object({
+    description: nonEmptyStringSchema,
+    agentIds: optionalNonEmptyStringArraySchema,
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    title: nonEmptyStringSchema.optional(),
+    extraContext: optionalNonEmptyStringArraySchema,
+})
+    .strict();
+export const externalRunExecutionInputSchema = z
+    .object({
+    specPath: nonEmptyStringSchema,
+    agentIds: optionalNonEmptyStringArraySchema,
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    branch: z.boolean().optional(),
+    extraContext: optionalNonEmptyStringArraySchema,
+})
+    .strict();
+export const externalReduceExecutionInputSchema = z
+    .object({
+    target: z
+        .object({
+        type: z.enum(["spec", "run", "reduce", "verify", "message"]),
+        id: nonEmptyStringSchema,
+    })
+        .strict(),
+    agentIds: optionalNonEmptyStringArraySchema,
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: optionalNonEmptyStringArraySchema,
+})
+    .strict();
+export const externalMessageExecutionInputSchema = z
+    .object({
+    prompt: nonEmptyStringSchema,
+    agentIds: optionalNonEmptyStringArraySchema,
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: optionalNonEmptyStringArraySchema,
+})
+    .strict();
+export const externalVerifyExecutionInputSchema = z
+    .object({
+    target: z
+        .object({
+        kind: z.enum(["spec", "run", "reduce", "message"]),
+        sessionId: nonEmptyStringSchema,
+    })
+        .strict(),
+    agentIds: optionalNonEmptyStringArraySchema,
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: optionalNonEmptyStringArraySchema,
+})
+    .strict();
+export const externalApplyExecutionInputSchema = z
+    .object({
+    runId: nonEmptyStringSchema,
+    agentId: nonEmptyStringSchema,
+    ignoreBaseMismatch: z.boolean().optional(),
+    commit: z.boolean().optional(),
+})
+    .strict();
+const externalPruneExecutionBaseSchema = z
+    .object({
+    purge: z.boolean().optional(),
+    confirmed: z.literal(true),
+})
+    .strict();
+export const externalPruneExecutionInputSchema = z.discriminatedUnion("scope", [
+    externalPruneExecutionBaseSchema.extend({
+        scope: z.literal("run"),
+        runId: nonEmptyStringSchema,
+    }),
+    externalPruneExecutionBaseSchema.extend({
+        scope: z.literal("all"),
+    }),
+]);
+const externalListInspectionBaseSchema = z
+    .object({
+    operator: externalInspectionOperatorSchema,
+    verbose: z.boolean().optional(),
+    limit: positiveIntegerSchema.optional(),
+})
+    .strict();
+export const externalListTableInputSchema = externalListInspectionBaseSchema.extend({
+    mode: z.literal("table"),
+});
+export const externalListDetailInputSchema = externalListInspectionBaseSchema.extend({
+    mode: z.literal("detail"),
+    sessionId: nonEmptyStringSchema,
+});
+export const externalListInspectionInputSchema = z.discriminatedUnion("mode", [
+    externalListTableInputSchema,
+    externalListDetailInputSchema,
+]);
+export const externalExecutionInputSchemas = {
+    spec: externalSpecExecutionInputSchema,
+    run: externalRunExecutionInputSchema,
+    reduce: externalReduceExecutionInputSchema,
+    verify: externalVerifyExecutionInputSchema,
+    message: externalMessageExecutionInputSchema,
+    apply: externalApplyExecutionInputSchema,
+    prune: externalPruneExecutionInputSchema,
+};
+export const externalInspectionInputSchemas = {
+    list: {
+        table: externalListTableInputSchema,
+        detail: externalListDetailInputSchema,
+        union: externalListInspectionInputSchema,
+    },
+};
+export const externalAdapterContractReference = {
+    execution: {
+        operators: externalExecutionOperators,
+        envelope: {
+            authoritativeType: "OperatorResultEnvelope",
+            versioned: true,
+        },
+        exitCodesAreContract: true,
+    },
+    inspection: {
+        command: "list",
+        jsonOnly: true,
+        operators: externalInspectionOperators,
+        modes: externalInspectionModes,
+        authoritativeType: "ListJsonOutput",
+        versioned: false,
+    },
+    excludedCommands: ["init", "auto"],
+    compatibility: {
+        additiveChangesAreNonBreaking: true,
+        breakingChangesRequireExecutionEnvelopeVersionBump: true,
+        breakingChanges: [
+            "remove an existing field",
+            "change a field type",
+            "change the semantic meaning of an existing field",
+            "change required-vs-optional status in a way that breaks clients",
+        ],
+    },
+    semantics: {
+        executionWarningsField: "alerts",
+        executionFailuresField: "error",
+        inspectionWarningsField: "warnings",
+        listNotFoundReturnsDetailWithNullSession: true,
+        listNotFoundExitCode: 0,
+        adaptersMustNotParseHumanTranscriptOutput: true,
+    },
+};
+const specCommandActionOptionsSchema = z
+    .object({
+    description: nonEmptyStringSchema,
+    agent: z.array(nonEmptyStringSchema).optional(),
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    title: nonEmptyStringSchema.optional(),
+    extraContext: z.array(nonEmptyStringSchema).optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const runCommandActionOptionsSchema = z
+    .object({
+    spec: nonEmptyStringSchema,
+    agent: z.array(nonEmptyStringSchema).optional(),
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    branch: z.boolean().optional(),
+    extraContext: z.array(nonEmptyStringSchema).optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const reduceCommandActionOptionsSchema = z
+    .object({
+    spec: nonEmptyStringSchema.optional(),
+    run: nonEmptyStringSchema.optional(),
+    reduce: nonEmptyStringSchema.optional(),
+    verify: nonEmptyStringSchema.optional(),
+    message: nonEmptyStringSchema.optional(),
+    agent: z.array(nonEmptyStringSchema).optional(),
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: z.array(nonEmptyStringSchema).optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const messageCommandActionOptionsSchema = z
+    .object({
+    prompt: nonEmptyStringSchema,
+    agent: z.array(nonEmptyStringSchema).optional(),
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: z.array(nonEmptyStringSchema).optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const verifyCommandActionOptionsSchema = z
+    .object({
+    spec: nonEmptyStringSchema.optional(),
+    run: nonEmptyStringSchema.optional(),
+    reduce: nonEmptyStringSchema.optional(),
+    message: nonEmptyStringSchema.optional(),
+    agent: z.array(nonEmptyStringSchema).optional(),
+    profile: nonEmptyStringSchema.optional(),
+    maxParallel: positiveIntegerSchema.optional(),
+    extraContext: z.array(nonEmptyStringSchema).optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const applyCommandActionOptionsSchema = z
+    .object({
+    run: nonEmptyStringSchema,
+    agent: nonEmptyStringSchema,
+    ignoreBaseMismatch: z.boolean().optional(),
+    commit: z.boolean().optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const listCommandActionOptionsSchema = z
+    .object({
+    spec: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
+    run: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
+    reduce: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
+    verify: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
+    message: z.union([z.literal(true), nonEmptyStringSchema]).optional(),
+    limit: positiveIntegerSchema.optional(),
+    verbose: z.boolean().optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+const pruneCommandActionOptionsSchema = z
+    .object({
+    run: nonEmptyStringSchema.optional(),
+    all: z.boolean().optional(),
+    purge: z.boolean().optional(),
+    yes: z.boolean().optional(),
+    json: z.boolean().optional(),
+})
+    .strict();
+export function parseSpecExecutionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(specCommandActionOptionsSchema, options, command);
+    return parseCommandOptions(externalSpecExecutionInputSchema, {
+        description: parsed.description,
+        agentIds: normalizeOptionalStringArray(parsed.agent),
+        profile: parsed.profile,
+        maxParallel: parsed.maxParallel,
+        title: parsed.title,
+        extraContext: normalizeOptionalStringArray(parsed.extraContext),
+    }, command);
+}
+export function parseRunExecutionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(runCommandActionOptionsSchema, options, command);
+    return parseCommandOptions(externalRunExecutionInputSchema, {
+        specPath: parsed.spec,
+        agentIds: normalizeOptionalStringArray(parsed.agent),
+        profile: parsed.profile,
+        maxParallel: parsed.maxParallel,
+        branch: normalizeOptionalBoolean(parsed.branch),
+        extraContext: normalizeOptionalStringArray(parsed.extraContext),
+    }, command);
+}
+export function parseReduceExecutionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(reduceCommandActionOptionsSchema, options, command);
+    const selected = resolveExclusiveStringSelection([
+        { key: "spec", flag: "--spec", value: "spec" },
+        { key: "run", flag: "--run", value: "run" },
+        { key: "reduce", flag: "--reduce", value: "reduce" },
+        { key: "verify", flag: "--verify", value: "verify" },
+        { key: "message", flag: "--message", value: "message" },
+    ], parsed, command, "target flag");
+    return parseCommandOptions(externalReduceExecutionInputSchema, {
+        target: {
+            type: selected.value,
+            id: selected.argument,
+        },
+        agentIds: normalizeOptionalStringArray(parsed.agent),
+        profile: parsed.profile,
+        maxParallel: parsed.maxParallel,
+        extraContext: normalizeOptionalStringArray(parsed.extraContext),
+    }, command);
+}
+export function parseMessageExecutionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(messageCommandActionOptionsSchema, options, command);
+    return parseCommandOptions(externalMessageExecutionInputSchema, {
+        prompt: parsed.prompt,
+        agentIds: normalizeOptionalStringArray(parsed.agent),
+        profile: parsed.profile,
+        maxParallel: parsed.maxParallel,
+        extraContext: normalizeOptionalStringArray(parsed.extraContext),
+    }, command);
+}
+export function parseVerifyExecutionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(verifyCommandActionOptionsSchema, options, command);
+    const selected = resolveExclusiveStringSelection([
+        { key: "spec", flag: "--spec", value: "spec" },
+        { key: "run", flag: "--run", value: "run" },
+        { key: "reduce", flag: "--reduce", value: "reduce" },
+        { key: "message", flag: "--message", value: "message" },
+    ], parsed, command, "target flag");
+    return parseCommandOptions(externalVerifyExecutionInputSchema, {
+        target: {
+            kind: selected.value,
+            sessionId: selected.argument,
+        },
+        agentIds: normalizeOptionalStringArray(parsed.agent),
+        profile: parsed.profile,
+        maxParallel: parsed.maxParallel,
+        extraContext: normalizeOptionalStringArray(parsed.extraContext),
+    }, command);
+}
+export function parseApplyExecutionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(applyCommandActionOptionsSchema, options, command);
+    return parseCommandOptions(externalApplyExecutionInputSchema, {
+        runId: parsed.run,
+        agentId: parsed.agent,
+        ignoreBaseMismatch: normalizeOptionalBoolean(parsed.ignoreBaseMismatch),
+        commit: normalizeOptionalBoolean(parsed.commit),
+    }, command);
+}
+export function parseExternalPruneExecutionInput(input) {
+    const result = externalPruneExecutionInputSchema.safeParse(input);
+    if (result.success) {
+        return result.data;
+    }
+    const requiresConfirmation = result.error.issues.some((issue) => issue.path.length === 1 &&
+        issue.path[0] === "confirmed" &&
+        issue.code === "invalid_value");
+    if (requiresConfirmation) {
+        throw new Error("JSON-mode prune requires explicit confirmation.");
+    }
+    const firstIssue = result.error.issues[0];
+    throw new Error(firstIssue?.message ?? "Invalid external prune execution input.");
+}
+export function parseListInspectionCommandOptions(options, command) {
+    const parsed = parseCommandOptions(listCommandActionOptionsSchema, options, command);
+    const selected = resolveExclusiveOptionalStringSelection([
+        { key: "spec", flag: "--spec", value: "spec" },
+        { key: "run", flag: "--run", value: "run" },
+        { key: "reduce", flag: "--reduce", value: "reduce" },
+        { key: "verify", flag: "--verify", value: "verify" },
+        { key: "message", flag: "--message", value: "message" },
+    ], parsed, command, "operator flag");
+    return parseCommandOptions(externalListInspectionInputSchema, {
+        operator: selected.value,
+        mode: selected.argument ? "detail" : "table",
+        ...(selected.argument ? { sessionId: selected.argument } : {}),
+        limit: parsed.limit,
+        verbose: normalizeOptionalBoolean(parsed.verbose),
+    }, command);
+}
+export function parsePruneCommandSelection(options, command) {
+    const parsed = parseCommandOptions(pruneCommandActionOptionsSchema, options, command);
+    const hasRun = typeof parsed.run === "string" && parsed.run.length > 0;
+    const wantsAll = Boolean(parsed.all);
+    if (!hasRun && !wantsAll) {
+        failCommand(command, "either --run <run-id> or --all must be provided");
+    }
+    return {
+        runId: parsed.run,
+        all: wantsAll,
+        purge: normalizeOptionalBoolean(parsed.purge),
+        yes: normalizeOptionalBoolean(parsed.yes),
+    };
+}
+function parseCommandOptions(schema, input, command) {
+    const result = schema.safeParse(input);
+    if (result.success) {
+        return result.data;
+    }
+    const firstIssue = result.error.issues[0];
+    const path = firstIssue && firstIssue.path.length > 0
+        ? `${formatIssuePath(firstIssue.path)} `
+        : "";
+    failCommand(command, `${path}${firstIssue?.message ?? "contains invalid values"}`.trim());
+}
+function resolveExclusiveStringSelection(definitions, options, command, subject) {
+    const entries = definitions
+        .map((definition) => ({
+        ...definition,
+        argument: options[definition.key],
+    }))
+        .filter((entry) => typeof entry.argument === "string" && entry.argument.length > 0);
+    if (entries.length !== 1) {
+        failExclusiveSelection(command, subject, definitions, entries);
+    }
+    const selected = entries[0];
+    if (!selected) {
+        failExclusiveSelection(command, subject, definitions, entries);
+    }
+    return selected;
+}
+function resolveExclusiveOptionalStringSelection(definitions, options, command, subject) {
+    const entries = definitions
+        .map((definition) => ({
+        ...definition,
+        raw: options[definition.key],
+    }))
+        .filter((entry) => entry.raw !== undefined);
+    if (entries.length !== 1) {
+        failExclusiveSelection(command, subject, definitions, entries);
+    }
+    const selected = entries[0];
+    if (!selected) {
+        failExclusiveSelection(command, subject, definitions, entries);
+    }
+    return {
+        value: selected.value,
+        argument: typeof selected.raw === "string" ? selected.raw : undefined,
+    };
+}
+function failExclusiveSelection(command, subject, definitions, entries) {
+    const flags = formatFlagList(definitions.map((definition) => definition.flag));
+    const detail = entries.length === 0
+        ? `No ${subject} was provided.`
+        : `Provided: ${entries.map((entry) => entry.flag).join(", ")}.`;
+    failCommand(command, `exactly one ${subject} is required: ${flags} (${detail})`);
+}
+function failCommand(command, message) {
+    command.error(`error: ${message}`, { exitCode: 1 });
+    throw new Error("Unreachable");
+}
+function formatFlagList(flags) {
+    if (flags.length === 0) {
+        return "";
+    }
+    if (flags.length === 1) {
+        return `\`${flags[0]}\``;
+    }
+    if (flags.length === 2) {
+        return `\`${flags[0]}\` or \`${flags[1]}\``;
+    }
+    const head = flags
+        .slice(0, -1)
+        .map((flag) => `\`${flag}\``)
+        .join(", ");
+    const tail = flags[flags.length - 1];
+    return `${head}, or \`${tail}\``;
+}
+function formatIssuePath(path) {
+    if (path.length === 0) {
+        return "input";
+    }
+    const rendered = path
+        .filter((part) => typeof part !== "symbol")
+        .map(String)
+        .join(".");
+    return `${rendered} must`;
+}
+function normalizeOptionalStringArray(value) {
+    return value && value.length > 0 ? [...value] : undefined;
+}
+function normalizeOptionalBoolean(value) {
+    return value ? true : undefined;
+}

package/dist/cli/errors.d.ts

@@ -5,4 +5,7 @@ export declare class CliError extends HintedError {
 export declare class NonInteractiveShellError extends CliError {
     constructor();
 }
+export declare class RunNotFoundCliError extends CliError {
+    constructor(runId: string);
+}
 export declare function toCliError(error: unknown): CliError;

package/dist/cli/errors.js

@@ -1,16 +1,28 @@
 import { HintedError, toErrorMessage } from "../utils/errors.js";
+const DEFAULT_CLI_ERROR_HINT = "Inspect the error details and retry.";
 export class CliError extends HintedError {
-    constructor(headline, detailLines = [], hintLines = []) {
-        super(headline, { detailLines, hintLines });
+    constructor(headline, detailLines = [], hintLines) {
+        super(headline, {
+            detailLines,
+            hintLines: hintLines === undefined
+                ? [DEFAULT_CLI_ERROR_HINT]
+                : Array.from(hintLines),
+        });
         this.name = "CliError";
     }
 }
 export class NonInteractiveShellError extends CliError {
     constructor() {
-        super("Non-interactive shell detected; re-run with --yes to accept defaults.");
+        super("Interactive confirmation is required.", [], ["Re-run with `--yes` to accept defaults."]);
         this.name = "NonInteractiveShellError";
     }
 }
+export class RunNotFoundCliError extends CliError {
+    constructor(runId) {
+        super(`Run \`${runId}\` not found.`, [], ["Check available runs with `voratiq list --run`."]);
+        this.name = "RunNotFoundCliError";
+    }
+}
 export function toCliError(error) {
     if (error instanceof CliError) {
         return error;
@@ -18,5 +30,11 @@ export function toCliError(error) {
     if (error instanceof HintedError) {
         return new CliError(error.headline, error.detailLines, error.hintLines);
     }
+    if (error instanceof AggregateError) {
+        const detailLines = error.errors
+            .slice(0, 3)
+            .map((entry) => toErrorMessage(entry));
+        return new CliError("Multiple errors occurred.", detailLines);
+    }
     return new CliError(toErrorMessage(error));
 }

package/dist/cli/init.d.ts

@@ -1,10 +1,15 @@
 import { Command } from "commander";
 import type { InitCommandResult } from "../commands/init/types.js";
+import type { AgentPreset } from "../workspace/templates.js";
+import { type CommandOutputWriter } from "./output.js";
 export interface RunInitCommandResult extends InitCommandResult {
     body: string;
 }
 export interface InitCommandOptions {
     yes?: boolean;
+    preset?: AgentPreset;
+    presetProvided?: boolean;
+    writeOutput?: CommandOutputWriter;
 }
 export declare function runInitCommand(options?: InitCommandOptions): Promise<RunInitCommandResult>;
 export declare function createInitCommand(): Command;

package/dist/cli/init.js

@@ -1,27 +1,46 @@
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { executeInitCommand } from "../commands/init/command.js";
 import { resolveCliContext } from "../preflight/index.js";
 import { renderInitTranscript } from "../render/transcripts/init.js";
+import { AGENT_PRESET_CHOICES } from "../workspace/templates.js";
 import { createConfirmationWorkflow } from "./confirmation.js";
 import { NonInteractiveShellError } from "./errors.js";
 import { writeCommandOutput } from "./output.js";
 export async function runInitCommand(options = {}) {
+    const { writeOutput = writeCommandOutput } = options;
+    writeOutput({
+        alerts: [{ severity: "info", message: "Initializing Voratiq…" }],
+    });
     const { root } = await resolveCliContext({ requireWorkspace: false });
     const assumeYes = Boolean(options.yes);
+    const preset = options.preset ?? "pro";
+    const presetProvided = Boolean(options.presetProvided);
     const confirmation = createConfirmationWorkflow({
         assumeYes,
         onUnavailable: () => {
             throw new NonInteractiveShellError();
         },
     });
+    let wroteConfiguringPreface = false;
     try {
         const initResult = await executeInitCommand({
             root,
+            preset,
+            presetProvided,
+            onPresetResolved: () => {
+                writeOutput({
+                    alerts: [{ severity: "info", message: "Configuring workspace…" }],
+                });
+                wroteConfiguringPreface = true;
+            },
+            assumeYes,
             interactive: confirmation.interactive,
             confirm: confirmation.confirm,
             prompt: confirmation.prompt,
         });
-        const body = renderInitTranscript(initResult);
+        const body = renderInitTranscript(initResult, {
+            includeConfigurationHeading: !wroteConfiguringPreface,
+        });
         return { ...initResult, body };
     }
     finally {
@@ -29,12 +48,21 @@ export async function runInitCommand(options = {}) {
     }
 }
 export function createInitCommand() {
+    const presetOption = new Option("--preset <preset>", "Select a preset")
+        .choices(AGENT_PRESET_CHOICES)
+        .default("pro");
     return new Command("init")
-        .description("Bootstrap the Voratiq workspace")
-        .option("-y, --yes", "Assume yes for all prompts")
+        .description("Initialize the Voratiq workspace")
+        .addOption(presetOption)
+        .option("-y, --yes", "Assume yes and accept defaults")
         .allowExcessArguments(false)
-        .action(async (commandOptions) => {
-        const result = await runInitCommand(commandOptions);
+        .action(async (commandOptions, command) => {
+        const presetSource = command.getOptionValueSource("preset");
+        const presetProvided = typeof presetSource === "string" && presetSource !== "default";
+        const result = await runInitCommand({
+            ...commandOptions,
+            presetProvided,
+        });
         writeCommandOutput({
             body: result.body,
         });

package/dist/cli/list.d.ts

@@ -1,14 +1,16 @@
 import { Command } from "commander";
+import type { ListJsonOutput, ListOperator } from "../contracts/list.js";
 import { type Alert } from "./output.js";
 export interface ListCommandOptions {
+    operator: ListOperator;
+    sessionId?: string;
     limit?: number;
-    spec?: string;
-    run?: string;
-    includePruned?: boolean;
+    verbose?: boolean;
 }
 export interface ListCommandResult {
     alerts: Alert[];
     body: string;
+    json: ListJsonOutput;
 }
-export declare function runListCommand(options?: ListCommandOptions): Promise<ListCommandResult>;
+export declare function runListCommand(options: ListCommandOptions): Promise<ListCommandResult>;
 export declare function createListCommand(): Command;