@outputai/cli 0.1.1 → 0.1.2

package/dist/commands/workflow/result.spec.js

@@ -1,23 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
-    getWorkflowIdResult: vi.fn()
-}));
-describe('workflow result command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowResult = (await import('./result.js')).default;
-            expect(WorkflowResult).toBeDefined();
-            expect(WorkflowResult.description).toContain('Get workflow execution result');
-            expect(WorkflowResult.args).toHaveProperty('workflowId');
-            expect(WorkflowResult.flags).toHaveProperty('format');
-        });
-        it('should have correct flag configuration', async () => {
-            const WorkflowResult = (await import('./result.js')).default;
-            expect(WorkflowResult.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowResult.flags.format.default).toBe('text');
-        });
-    });
-});

package/dist/commands/workflow/run.d.ts

@@ -1,16 +0,0 @@
-import { Command } from '@oclif/core';
-export default class WorkflowRun extends Command {
-    static description: string;
-    static examples: string[];
-    static args: {
-        workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-        scenario: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
-    };
-    static flags: {
-        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'task-queue': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-}

package/dist/commands/workflow/run.js

@@ -1,97 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { postWorkflowRun } from '#api/generated/api.js';
-import { OUTPUT_FORMAT } from '#utils/constants.js';
-import { formatOutput } from '#utils/output_formatter.js';
-import { formatWorkflowResult, ERROR_STATUSES } from '#utils/format_workflow_result.js';
-import { handleApiError } from '#utils/error_handler.js';
-import { resolveInput } from '#utils/resolve_input.js';
-import { getRetryDelayFromResponse } from '#utils/header_utils.js';
-import { sleep } from '#utils/sleep.js';
-import { HttpError } from '#api/http_client.js';
-const MAX_RETRIES = 3;
-async function executeWorkflow(args) {
-    const { body, options, log, attempt = 0 } = args;
-    try {
-        return await postWorkflowRun(body, options);
-    }
-    catch (error) {
-        if (!(error instanceof HttpError) || attempt >= MAX_RETRIES) {
-            throw error;
-        }
-        const { response } = error;
-        const delay = getRetryDelayFromResponse(response);
-        if (delay === null) {
-            throw error;
-        }
-        log(`Server returned ${response.status} with header "Retry-After". Retrying in ${delay / 1000}s...`);
-        await sleep(delay);
-        return executeWorkflow({ body, options, log, attempt: attempt + 1 });
-    }
-}
-export default class WorkflowRun extends Command {
-    static description = 'Execute a workflow synchronously and wait for completion';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> simple basic_input',
-        '<%= config.bin %> <%= command.id %> simple my_scenario --format json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
-        '<%= config.bin %> <%= command.id %> simple --input input.json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --task-queue my-queue'
-    ];
-    static args = {
-        workflowName: Args.string({
-            description: 'Name of the workflow to execute',
-            required: true
-        }),
-        scenario: Args.string({
-            description: 'Scenario name (resolved from the workflow\'s scenarios/ directory)',
-            required: false
-        })
-    };
-    static flags = {
-        input: Flags.string({
-            char: 'i',
-            description: 'Workflow input as JSON string or file path (overrides scenario)',
-            required: false
-        }),
-        'task-queue': Flags.string({
-            char: 'q',
-            description: 'Task queue name for workflow execution'
-        }),
-        format: Flags.string({
-            char: 'f',
-            description: 'Output format',
-            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
-            default: OUTPUT_FORMAT.TEXT
-        })
-    };
-    async run() {
-        const { args, flags } = await this.parse(WorkflowRun);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run');
-        this.log(`Executing workflow: ${args.workflowName}...`);
-        const response = await executeWorkflow({
-            body: {
-                workflowName: args.workflowName,
-                input,
-                taskQueue: flags['task-queue']
-            },
-            options: { config: { timeout: 600000 } },
-            log: msg => this.log(msg)
-        });
-        if (!response || !response.data) {
-            this.error('API returned invalid response', { exit: 1 });
-        }
-        const data = response.data;
-        const output = formatOutput(data, flags.format, formatWorkflowResult);
-        this.log(`\n${output}`);
-        if (ERROR_STATUSES.has(data.status)) {
-            process.exitCode = 1;
-        }
-    }
-    async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
-            404: 'Workflow not found. Check the workflow name.',
-            500: 'Workflow execution failed.',
-            503: 'Workflow service temporarily unavailable.'
-        });
-    }
-}

package/dist/commands/workflow/run.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/workflow/run.spec.js

@@ -1,110 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HttpError } from '#api/http_client.js';
-vi.mock('#api/generated/api.js', () => ({
-    postWorkflowRun: vi.fn()
-}));
-vi.mock('#utils/resolve_input.js', () => ({
-    resolveInput: vi.fn()
-}));
-vi.mock('#utils/sleep.js', () => ({
-    sleep: vi.fn().mockResolvedValue(undefined)
-}));
-describe('workflow run command', () => {
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        const { resolveInput } = await import('#utils/resolve_input.js');
-        const { sleep } = await import('#utils/sleep.js');
-        vi.mocked(resolveInput).mockResolvedValue({});
-        vi.mocked(sleep).mockResolvedValue(undefined);
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowRun = (await import('./run.js')).default;
-            expect(WorkflowRun).toBeDefined();
-            expect(WorkflowRun.description).toContain('Execute a workflow');
-            expect(WorkflowRun.args).toHaveProperty('workflowName');
-            expect(WorkflowRun.flags).toHaveProperty('input');
-            expect(WorkflowRun.flags).toHaveProperty('format');
-            expect(WorkflowRun.flags).toHaveProperty('task-queue');
-        });
-        it('should have correct flag configuration', async () => {
-            const WorkflowRun = (await import('./run.js')).default;
-            expect(WorkflowRun.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowRun.flags.format.default).toBe('text');
-            expect(WorkflowRun.flags.input.required).toBe(false);
-        });
-        it('should have optional scenario argument', async () => {
-            const WorkflowRun = (await import('./run.js')).default;
-            expect(WorkflowRun.args).toHaveProperty('scenario');
-            expect(WorkflowRun.args.scenario.required).toBe(false);
-        });
-    });
-    describe('run()', () => {
-        const createCommand = async () => {
-            const WorkflowRun = (await import('./run.js')).default;
-            const { postWorkflowRun } = await import('#api/generated/api.js');
-            const { resolveInput } = await import('#utils/resolve_input.js');
-            const cmd = new WorkflowRun(['my_workflow'], {});
-            cmd.log = vi.fn();
-            cmd.error = vi.fn(() => {
-                throw new Error('error called');
-            });
-            cmd.parse = vi.fn().mockResolvedValue({
-                args: { workflowName: 'my_workflow', scenario: undefined },
-                flags: { input: undefined, 'task-queue': undefined, format: 'text' }
-            });
-            return { cmd, postWorkflowRun: vi.mocked(postWorkflowRun), resolveInput: vi.mocked(resolveInput) };
-        };
-        it('calls postWorkflowRun and logs output on success', async () => {
-            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
-            resolveInput.mockResolvedValue({ key: 'value' });
-            postWorkflowRun.mockResolvedValue({
-                data: { status: 'completed', result: { output: 'ok' } },
-                status: 200,
-                headers: new Headers()
-            });
-            await cmd.run();
-            expect(postWorkflowRun).toHaveBeenCalledTimes(1);
-            expect(postWorkflowRun).toHaveBeenCalledWith({ workflowName: 'my_workflow', input: { key: 'value' }, taskQueue: undefined }, expect.objectContaining({ config: { timeout: 600000 } }));
-            expect(cmd.log).toHaveBeenCalledWith('Executing workflow: my_workflow...');
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringMatching(/\n/));
-        });
-        it('retries when response has Retry-After and succeeds on second attempt', async () => {
-            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
-            resolveInput.mockResolvedValue({});
-            const headers = new Headers({ 'Retry-After': '1' });
-            postWorkflowRun
-                .mockRejectedValueOnce(new HttpError('Unavailable', { status: 503, headers }))
-                .mockResolvedValueOnce({
-                data: { status: 'completed', result: {} },
-                status: 200,
-                headers: new Headers()
-            });
-            await cmd.run();
-            expect(postWorkflowRun).toHaveBeenCalledTimes(2);
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringMatching(/Retry-After.*Retrying in/));
-        });
-        it('does not retry when response has no Retry-After and throws', async () => {
-            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
-            resolveInput.mockResolvedValue({});
-            postWorkflowRun.mockRejectedValue(new HttpError('Unavailable', { status: 503, headers: new Headers() }));
-            await expect(cmd.run()).rejects.toThrow(HttpError);
-            expect(postWorkflowRun).toHaveBeenCalledTimes(1);
-        });
-        it('does not retry on non-503 error and throws', async () => {
-            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
-            resolveInput.mockResolvedValue({});
-            postWorkflowRun.mockRejectedValue(new HttpError('Not found', { status: 404 }));
-            await expect(cmd.run()).rejects.toThrow(HttpError);
-            expect(postWorkflowRun).toHaveBeenCalledTimes(1);
-        });
-        it('calls error when API returns no data', async () => {
-            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
-            resolveInput.mockResolvedValue({});
-            postWorkflowRun.mockResolvedValue({ data: undefined, status: 200, headers: new Headers() });
-            await expect(cmd.run()).rejects.toThrow('error called');
-            expect(cmd.error).toHaveBeenCalledWith('API returned invalid response', { exit: 1 });
-        });
-    });
-});

package/dist/commands/workflow/runs/list.d.ts

@@ -1,14 +0,0 @@
-import { Command } from '@oclif/core';
-export default class WorkflowRunsList extends Command {
-    static description: string;
-    static examples: string[];
-    static args: {
-        workflowName: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
-    };
-    static flags: {
-        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
-        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-}

package/dist/commands/workflow/runs/list.js

@@ -1,104 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import Table from 'cli-table3';
-import { fetchWorkflowRuns } from '#services/workflow_runs.js';
-import { formatDate, formatDurationFromTimestamps } from '#utils/date_formatter.js';
-import { handleApiError } from '#utils/error_handler.js';
-const OUTPUT_FORMAT = {
-    TABLE: 'table',
-    JSON: 'json',
-    TEXT: 'text'
-};
-function createRunsTable(runs) {
-    const table = new Table({
-        head: ['Workflow ID', 'Type', 'Status', 'Started', 'Duration'],
-        colWidths: [null, 20, 12, 22, 10],
-        wordWrap: true,
-        style: {
-            head: ['cyan']
-        }
-    });
-    runs.forEach(run => {
-        table.push([
-            run.workflowId || '-',
-            run.workflowType || '-',
-            run.status || '-',
-            formatDate(run.startedAt),
-            formatDurationFromTimestamps(run.startedAt || '', run.completedAt)
-        ]);
-    });
-    return table.toString();
-}
-function formatRunsAsText(runs) {
-    if (runs.length === 0) {
-        return 'No workflow runs found.';
-    }
-    return runs.map(run => {
-        const duration = formatDurationFromTimestamps(run.startedAt || '', run.completedAt);
-        return `${run.workflowId} (${run.workflowType}) - ${run.status} [${duration}]`;
-    }).join('\n');
-}
-function formatRunsAsJson(runs) {
-    return JSON.stringify(runs, null, 2);
-}
-function formatRuns(runs, format) {
-    if (format === OUTPUT_FORMAT.JSON) {
-        return formatRunsAsJson(runs);
-    }
-    if (format === OUTPUT_FORMAT.TABLE) {
-        return createRunsTable(runs);
-    }
-    return formatRunsAsText(runs);
-}
-export default class WorkflowRunsList extends Command {
-    static description = 'List workflow runs with optional filtering by workflow type';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> simple',
-        '<%= config.bin %> <%= command.id %> simple --limit 10',
-        '<%= config.bin %> <%= command.id %> --format json',
-        '<%= config.bin %> <%= command.id %> --format table'
-    ];
-    static args = {
-        workflowName: Args.string({
-            description: 'Filter by workflow type/name',
-            required: false
-        })
-    };
-    static flags = {
-        limit: Flags.integer({
-            char: 'l',
-            description: 'Maximum number of runs to return',
-            default: 100
-        }),
-        format: Flags.string({
-            char: 'f',
-            description: 'Output format',
-            options: [OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
-            default: OUTPUT_FORMAT.TABLE
-        })
-    };
-    async run() {
-        const { args, flags } = await this.parse(WorkflowRunsList);
-        const { runs, count } = await fetchWorkflowRuns({
-            workflowType: args.workflowName,
-            limit: flags.limit
-        });
-        if (runs.length === 0) {
-            const filterMsg = args.workflowName ? ` for workflow type "${args.workflowName}"` : '';
-            this.log(`No workflow runs found${filterMsg}.`);
-            return;
-        }
-        const output = formatRuns(runs, flags.format);
-        this.log(output);
-        if (flags.format !== OUTPUT_FORMAT.JSON) {
-            const filterMsg = args.workflowName ? ` of type "${args.workflowName}"` : '';
-            this.log(`\nFound ${count} run(s)${filterMsg}`);
-        }
-    }
-    async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
-            400: 'Invalid parameters provided.',
-            503: 'Workflow service temporarily unavailable.'
-        });
-    }
-}

package/dist/commands/workflow/start.d.ts

@@ -1,15 +0,0 @@
-import { Command } from '@oclif/core';
-export default class WorkflowStart extends Command {
-    static description: string;
-    static examples: string[];
-    static args: {
-        workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-        scenario: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
-    };
-    static flags: {
-        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'task-queue': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-}

package/dist/commands/workflow/start.js

@@ -1,62 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { postWorkflowStart } from '#api/generated/api.js';
-import { handleApiError } from '#utils/error_handler.js';
-import { resolveInput } from '#utils/resolve_input.js';
-export default class WorkflowStart extends Command {
-    static description = 'Start a workflow asynchronously without waiting for completion';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> simple basic_input',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
-        '<%= config.bin %> <%= command.id %> simple --input input.json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --task-queue my-queue'
-    ];
-    static args = {
-        workflowName: Args.string({
-            description: 'Name of the workflow to start',
-            required: true
-        }),
-        scenario: Args.string({
-            description: 'Scenario name (resolved from the workflow\'s scenarios/ directory)',
-            required: false
-        })
-    };
-    static flags = {
-        input: Flags.string({
-            char: 'i',
-            description: 'Workflow input as JSON string or file path (overrides scenario)',
-            required: false
-        }),
-        'task-queue': Flags.string({
-            char: 'q',
-            description: 'Task queue name for workflow execution'
-        })
-    };
-    async run() {
-        const { args, flags } = await this.parse(WorkflowStart);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start');
-        this.log(`Starting workflow: ${args.workflowName}...`);
-        const response = await postWorkflowStart({
-            workflowName: args.workflowName,
-            input,
-            taskQueue: flags['task-queue']
-        });
-        if (!response || !response.data) {
-            this.error('API returned invalid response', { exit: 1 });
-        }
-        const result = response.data;
-        const output = [
-            'Workflow started successfully',
-            '',
-            `Workflow ID: ${result.workflowId || 'unknown'}`,
-            '',
-            `Use "workflow status ${result.workflowId || '<workflow-id>'}" to check the workflow status`,
-            `Use "workflow result ${result.workflowId || '<workflow-id>'}" to get the workflow result when complete`
-        ].join('\n');
-        this.log(`\n${output}`);
-    }
-    async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
-            404: 'Workflow not found. Check the workflow name.'
-        });
-    }
-}

package/dist/commands/workflow/start.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/workflow/start.spec.js

@@ -1,28 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
-    postWorkflowStart: vi.fn()
-}));
-describe('workflow start command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowStart = (await import('./start.js')).default;
-            expect(WorkflowStart).toBeDefined();
-            expect(WorkflowStart.description).toContain('Start a workflow');
-            expect(WorkflowStart.args).toHaveProperty('workflowName');
-            expect(WorkflowStart.flags).toHaveProperty('input');
-            expect(WorkflowStart.flags).toHaveProperty('task-queue');
-        });
-        it('should have correct flag configuration', async () => {
-            const WorkflowStart = (await import('./start.js')).default;
-            expect(WorkflowStart.flags.input.required).toBe(false);
-        });
-        it('should have optional scenario argument', async () => {
-            const WorkflowStart = (await import('./start.js')).default;
-            expect(WorkflowStart.args).toHaveProperty('scenario');
-            expect(WorkflowStart.args.scenario.required).toBe(false);
-        });
-    });
-});

package/dist/commands/workflow/status.d.ts

@@ -1,13 +0,0 @@
-import { Command } from '@oclif/core';
-export default class WorkflowStatus extends Command {
-    static description: string;
-    static examples: string[];
-    static args: {
-        workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
-    static flags: {
-        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-}

package/dist/commands/workflow/status.js

@@ -1,57 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { getWorkflowIdStatus } from '#api/generated/api.js';
-import { OUTPUT_FORMAT } from '#utils/constants.js';
-import { formatOutput } from '#utils/output_formatter.js';
-import { handleApiError } from '#utils/error_handler.js';
-export default class WorkflowStatus extends Command {
-    static description = 'Get workflow execution status';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> wf-12345',
-        '<%= config.bin %> <%= command.id %> wf-12345 --format json'
-    ];
-    static args = {
-        workflowId: Args.string({
-            description: 'The workflow ID to check status for',
-            required: true
-        })
-    };
-    static flags = {
-        format: Flags.string({
-            char: 'f',
-            description: 'Output format',
-            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
-            default: OUTPUT_FORMAT.TEXT
-        })
-    };
-    async run() {
-        const { args, flags } = await this.parse(WorkflowStatus);
-        this.log(`Fetching status for workflow: ${args.workflowId}...`);
-        const response = await getWorkflowIdStatus(args.workflowId);
-        if (!response || !response.data) {
-            this.error('API returned invalid response', { exit: 1 });
-        }
-        const data = response.data;
-        const output = formatOutput(data, flags.format, (result) => {
-            const lines = [
-                `Workflow ID: ${result.workflowId || 'unknown'}`,
-                `Status: ${result.status || 'unknown'}`,
-                ''
-            ];
-            if (result.startedAt) {
-                const startDate = new Date(result.startedAt);
-                lines.push(`Started At: ${startDate.toISOString()}`);
-            }
-            if (result.completedAt) {
-                const completedDate = new Date(result.completedAt);
-                lines.push(`Completed At: ${completedDate.toISOString()}`);
-            }
-            return lines.join('\n');
-        });
-        this.log(`\n${output}`);
-    }
-    async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
-            404: 'Workflow not found. Check the workflow ID.'
-        });
-    }
-}

package/dist/commands/workflow/status.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/workflow/status.spec.js

@@ -1,33 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
-    getWorkflowIdStatus: vi.fn(),
-    GetWorkflowIdStatus200Status: {
-        canceled: 'canceled',
-        completed: 'completed',
-        continued_as_new: 'continued_as_new',
-        failed: 'failed',
-        running: 'running',
-        terminated: 'terminated',
-        timed_out: 'timed_out',
-        unspecified: 'unspecified'
-    }
-}));
-describe('workflow status command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowStatus = (await import('./status.js')).default;
-            expect(WorkflowStatus).toBeDefined();
-            expect(WorkflowStatus.description).toContain('Get workflow execution status');
-            expect(WorkflowStatus.args).toHaveProperty('workflowId');
-            expect(WorkflowStatus.flags).toHaveProperty('format');
-        });
-        it('should have correct flag configuration', async () => {
-            const WorkflowStatus = (await import('./status.js')).default;
-            expect(WorkflowStatus.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowStatus.flags.format.default).toBe('text');
-        });
-    });
-});

package/dist/commands/workflow/stop.d.ts

@@ -1,10 +0,0 @@
-import { Command } from '@oclif/core';
-export default class WorkflowStop extends Command {
-    static description: string;
-    static examples: string[];
-    static args: {
-        workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
-    run(): Promise<void>;
-    catch(error: Error): Promise<void>;
-}

package/dist/commands/workflow/stop.js

@@ -1,31 +0,0 @@
-import { Args, Command } from '@oclif/core';
-import { patchWorkflowIdStop } from '#api/generated/api.js';
-import { handleApiError } from '#utils/error_handler.js';
-export default class WorkflowStop extends Command {
-    static description = 'Stop a workflow execution';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> wf-12345'
-    ];
-    static args = {
-        workflowId: Args.string({
-            description: 'The workflow ID to stop',
-            required: true
-        })
-    };
-    async run() {
-        const { args } = await this.parse(WorkflowStop);
-        this.log(`Stopping workflow: ${args.workflowId}...`);
-        await patchWorkflowIdStop(args.workflowId);
-        const output = [
-            'Workflow stopped successfully',
-            '',
-            `Workflow ID: ${args.workflowId}`
-        ].join('\n');
-        this.log(`\n${output}`);
-    }
-    async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
-            404: 'Workflow not found. Check the workflow ID.'
-        });
-    }
-}

package/dist/commands/workflow/stop.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/workflow/stop.spec.js

@@ -1,17 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
-    patchWorkflowIdStop: vi.fn()
-}));
-describe('workflow stop command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowStop = (await import('./stop.js')).default;
-            expect(WorkflowStop).toBeDefined();
-            expect(WorkflowStop.description).toContain('Stop a workflow execution');
-            expect(WorkflowStop.args).toHaveProperty('workflowId');
-        });
-    });
-});