@outputai/cli 0.1.1 → 0.1.2

package/dist/commands/update.js

@@ -1,120 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
-import { fetchLatestVersion, getGlobalInstalledVersion, getLocalInstalledVersion, updateGlobal, updateLocal, isOutdated } from '#services/npm_update_service.js';
-import { ensureClaudePlugin } from '#services/coding_agents.js';
-import { getErrorMessage } from '#utils/error_utils.js';
-export default class Update extends Command {
-    static description = 'Update Output CLI and agent configuration';
-    static examples = [
-        '<%= config.bin %> update',
-        '<%= config.bin %> update --cli',
-        '<%= config.bin %> update --agents'
-    ];
-    static flags = {
-        cli: Flags.boolean({
-            description: 'Update CLI packages only'
-        }),
-        agents: Flags.boolean({
-            description: 'Update Claude Code agent configuration'
-        })
-    };
-    async run() {
-        const { flags } = await this.parse(Update);
-        const updateAll = !flags.cli && !flags.agents;
-        if (updateAll || flags.cli) {
-            await this.updateCli();
-        }
-        if (updateAll || flags.agents) {
-            await this.updateAgents();
-        }
-    }
-    async updateCli() {
-        const latest = await fetchLatestVersion();
-        if (!latest) {
-            this.error('Could not fetch the latest version from npm. Check your network connection.');
-        }
-        this.log(`\nLatest @outputai/cli version: v${latest}\n`);
-        await this.handleGlobalUpdate(latest);
-        await this.handleLocalUpdate(latest);
-    }
-    async updateAgents() {
-        this.log('\nUpdating Claude Code agent configuration...');
-        try {
-            await ensureClaudePlugin(process.cwd());
-            this.log('Claude Code agent configuration updated successfully.');
-        }
-        catch (error) {
-            this.warn(`Failed to update agent configuration: ${getErrorMessage(error)}`);
-        }
-    }
-    async handleGlobalUpdate(latest) {
-        const globalVersion = await getGlobalInstalledVersion();
-        if (!globalVersion) {
-            this.log('Global install: not found');
-            return false;
-        }
-        if (!isOutdated(globalVersion, latest)) {
-            this.log(`Global install: v${globalVersion} (up to date)`);
-            return false;
-        }
-        this.log(`Global install: v${globalVersion} (outdated)`);
-        const shouldUpdate = await confirm({
-            message: `Update global install from v${globalVersion} to v${latest}?`
-        });
-        if (!shouldUpdate) {
-            return false;
-        }
-        try {
-            await updateGlobal();
-            const newVersion = await getGlobalInstalledVersion();
-            if (newVersion) {
-                this.log(`\nGlobal install updated to v${newVersion}`);
-            }
-            else {
-                this.log('\nGlobal update completed (could not verify new version)');
-            }
-            return true;
-        }
-        catch (error) {
-            this.warn(`Failed to update global install: ${getErrorMessage(error)}`);
-            return false;
-        }
-    }
-    async handleLocalUpdate(latest) {
-        const cwd = process.cwd();
-        const localVersion = await getLocalInstalledVersion(cwd);
-        if (!localVersion) {
-            return false;
-        }
-        if (!isOutdated(localVersion, latest)) {
-            this.log(`\nLocal install: v${localVersion} (up to date)`);
-            return false;
-        }
-        this.log(`\nLocal install: v${localVersion} (outdated)`);
-        const shouldUpdate = await confirm({
-            message: `Update local install from v${localVersion} to v${latest}?`
-        });
-        if (!shouldUpdate) {
-            return false;
-        }
-        try {
-            await updateLocal(cwd);
-            const newLocalVersion = await getLocalInstalledVersion(cwd);
-            if (newLocalVersion) {
-                this.log(`\nLocal install updated to v${newLocalVersion}`);
-                if (isOutdated(newLocalVersion, latest)) {
-                    this.warn(`Your package.json constrains @outputai/output which limits @outputai/cli to v${newLocalVersion}. ` +
-                        'Update the @outputai/output version range in package.json to get the latest CLI.');
-                }
-            }
-            else {
-                this.log('\nLocal update completed (could not verify new version)');
-            }
-            return true;
-        }
-        catch (error) {
-            this.warn(`Failed to update local install: ${getErrorMessage(error)}`);
-            return false;
-        }
-    }
-}

package/dist/commands/update.spec.d.ts

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

package/dist/commands/update.spec.js

@@ -1,178 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import Update from './update.js';
-import { fetchLatestVersion, getGlobalInstalledVersion, getLocalInstalledVersion, updateGlobal, updateLocal, isOutdated } from '#services/npm_update_service.js';
-import { ensureClaudePlugin } from '#services/coding_agents.js';
-import { confirm } from '@inquirer/prompts';
-vi.mock('#services/npm_update_service.js', () => ({
-    fetchLatestVersion: vi.fn(),
-    getGlobalInstalledVersion: vi.fn(),
-    getLocalInstalledVersion: vi.fn(),
-    updateGlobal: vi.fn(),
-    updateLocal: vi.fn(),
-    isOutdated: vi.fn()
-}));
-vi.mock('#services/coding_agents.js', () => ({
-    ensureClaudePlugin: vi.fn()
-}));
-vi.mock('@inquirer/prompts', () => ({
-    confirm: vi.fn()
-}));
-describe('update command', () => {
-    const createTestCommand = (flags = {}) => {
-        const cmd = new Update([], {});
-        cmd.log = vi.fn();
-        cmd.warn = vi.fn();
-        cmd.error = vi.fn();
-        cmd.debug = vi.fn();
-        cmd.parse = vi.fn().mockResolvedValue({ flags, args: {} });
-        return cmd;
-    };
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
-        vi.mocked(getGlobalInstalledVersion).mockResolvedValue('0.8.4');
-        vi.mocked(getLocalInstalledVersion).mockResolvedValue(null);
-        vi.mocked(isOutdated).mockReturnValue(true);
-        vi.mocked(confirm).mockResolvedValue(true);
-        vi.mocked(updateGlobal).mockResolvedValue();
-        vi.mocked(updateLocal).mockResolvedValue();
-        vi.mocked(ensureClaudePlugin).mockResolvedValue();
-    });
-    describe('command structure', () => {
-        it('should have correct description', () => {
-            expect(Update.description).toContain('Update Output CLI');
-        });
-        it('should have cli and agents flags', () => {
-            expect(Update.flags).toHaveProperty('cli');
-            expect(Update.flags).toHaveProperty('agents');
-        });
-    });
-    describe('no flags (update all)', () => {
-        it('should update cli and agents when no flags provided', async () => {
-            vi.mocked(getGlobalInstalledVersion)
-                .mockResolvedValueOnce('0.8.4')
-                .mockResolvedValueOnce('1.0.0');
-            const cmd = createTestCommand();
-            await cmd.run();
-            expect(fetchLatestVersion).toHaveBeenCalled();
-            expect(ensureClaudePlugin).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('--cli flag', () => {
-        it('should only update cli when --cli flag is set', async () => {
-            vi.mocked(getGlobalInstalledVersion)
-                .mockResolvedValueOnce('0.8.4')
-                .mockResolvedValueOnce('1.0.0');
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(fetchLatestVersion).toHaveBeenCalled();
-            expect(ensureClaudePlugin).not.toHaveBeenCalled();
-        });
-    });
-    describe('--agents flag', () => {
-        it('should only update agents when --agents flag is set', async () => {
-            const cmd = createTestCommand({ agents: true });
-            await cmd.run();
-            expect(fetchLatestVersion).not.toHaveBeenCalled();
-            expect(ensureClaudePlugin).toHaveBeenCalledTimes(1);
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('agent configuration updated'));
-        });
-        it('should warn on agent update failure', async () => {
-            vi.mocked(ensureClaudePlugin).mockRejectedValue(new Error('agent error'));
-            const cmd = createTestCommand({ agents: true });
-            await cmd.run();
-            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to update agent'));
-        });
-    });
-    describe('fetch failure', () => {
-        it('should error when cannot fetch latest version', async () => {
-            vi.mocked(fetchLatestVersion).mockResolvedValue(null);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Could not fetch'));
-        });
-    });
-    describe('global update', () => {
-        it('should prompt and update global install when outdated', async () => {
-            vi.mocked(getGlobalInstalledVersion)
-                .mockResolvedValueOnce('0.8.4')
-                .mockResolvedValueOnce('1.0.0');
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({ message: expect.stringContaining('v0.8.4') }));
-            expect(updateGlobal).toHaveBeenCalled();
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('v1.0.0'));
-        });
-        it('should skip global update when user declines', async () => {
-            vi.mocked(confirm).mockResolvedValue(false);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(updateGlobal).not.toHaveBeenCalled();
-        });
-        it('should show up-to-date when global is current', async () => {
-            vi.mocked(isOutdated).mockReturnValue(false);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('up to date'));
-            expect(updateGlobal).not.toHaveBeenCalled();
-        });
-        it('should show not found when global is not installed', async () => {
-            vi.mocked(getGlobalInstalledVersion).mockResolvedValue(null);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('not found'));
-        });
-        it('should handle null version after global update', async () => {
-            vi.mocked(getGlobalInstalledVersion)
-                .mockResolvedValueOnce('0.8.4')
-                .mockResolvedValueOnce(null);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(updateGlobal).toHaveBeenCalled();
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('could not verify'));
-        });
-        it('should warn on global update failure', async () => {
-            vi.mocked(updateGlobal).mockRejectedValue(new Error('permission denied'));
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to update global'));
-        });
-    });
-    describe('local update', () => {
-        it('should prompt and update local install when outdated', async () => {
-            vi.mocked(getLocalInstalledVersion)
-                .mockResolvedValueOnce('0.8.3')
-                .mockResolvedValueOnce('1.0.0');
-            vi.mocked(isOutdated)
-                .mockReturnValueOnce(true)
-                .mockReturnValueOnce(true)
-                .mockReturnValueOnce(false);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(updateLocal).toHaveBeenCalled();
-        });
-        it('should handle null version after local update', async () => {
-            vi.mocked(getGlobalInstalledVersion).mockResolvedValue(null);
-            vi.mocked(getLocalInstalledVersion)
-                .mockResolvedValueOnce('0.8.3')
-                .mockResolvedValueOnce(null);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(updateLocal).toHaveBeenCalled();
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('could not verify'));
-        });
-        it('should warn about package.json constraint when post-update version < latest', async () => {
-            vi.mocked(getLocalInstalledVersion)
-                .mockResolvedValueOnce('0.8.3')
-                .mockResolvedValueOnce('0.8.5');
-            vi.mocked(isOutdated)
-                .mockReturnValueOnce(true)
-                .mockReturnValueOnce(true)
-                .mockReturnValueOnce(true);
-            const cmd = createTestCommand({ cli: true });
-            await cmd.run();
-            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('package.json constrains'));
-        });
-    });
-});

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

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

package/dist/commands/workflow/cost.js

@@ -1,71 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { readFile } from 'node:fs/promises';
-import { calculateCost, loadPricingConfig } from '#services/cost_calculator.js';
-import { getTrace } from '#services/trace_reader.js';
-import { OUTPUT_FORMAT } from '#utils/constants.js';
-import { formatCostReport } from '#utils/cost_formatter.js';
-import { getErrorCode } from '#utils/error_utils.js';
-import { handleApiError } from '#utils/error_handler.js';
-import { formatOutput } from '#utils/output_formatter.js';
-export default class WorkflowCost extends Command {
-    static description = 'Calculate the cost of a workflow execution';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> my_workflow',
-        '<%= config.bin %> <%= command.id %> my_workflow --verbose',
-        '<%= config.bin %> <%= command.id %> my_workflow path/to/trace.json',
-        '<%= config.bin %> <%= command.id %> my_workflow --format json'
-    ];
-    static args = {
-        workflowId: Args.string({
-            description: 'Workflow ID to calculate cost for',
-            required: true
-        }),
-        tracePath: Args.string({
-            description: 'Path to a trace JSON file (optional, fetches latest trace if omitted)',
-            required: false
-        })
-    };
-    static flags = {
-        format: Flags.string({
-            char: 'f',
-            description: 'Output format',
-            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
-            default: OUTPUT_FORMAT.TEXT
-        }),
-        verbose: Flags.boolean({
-            description: 'Show detailed per-call breakdown',
-            default: false
-        })
-    };
-    async run() {
-        const { args, flags } = await this.parse(WorkflowCost);
-        const { traceData, traceFile } = args.tracePath ?
-            await this.loadLocalTrace(args.tracePath) :
-            { traceData: (await getTrace(args.workflowId)).data, traceFile: undefined };
-        const config = loadPricingConfig();
-        const traceNode = traceData;
-        const report = calculateCost(traceNode, config, traceFile);
-        const formatted = formatOutput(report, flags.format, r => formatCostReport(r, { verbose: flags.verbose }));
-        this.log(formatted);
-    }
-    async loadLocalTrace(tracePath) {
-        try {
-            const content = await readFile(tracePath, 'utf-8');
-            return { traceData: JSON.parse(content), traceFile: tracePath };
-        }
-        catch (error) {
-            if (getErrorCode(error) === 'ENOENT') {
-                this.error(`Trace file not found: ${tracePath}`, { exit: 1 });
-            }
-            if (error instanceof SyntaxError) {
-                this.error(`Invalid JSON in trace file: ${tracePath}`, { exit: 1 });
-            }
-            throw error;
-        }
-    }
-    async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
-            404: 'Workflow not found. Check the workflow ID and try again.'
-        });
-    }
-}

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

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

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

@@ -1,47 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock the services and utilities
-vi.mock('../../services/trace_reader.js', () => ({
-    getTrace: vi.fn()
-}));
-vi.mock('../../services/cost_calculator.js', () => ({
-    calculateCost: vi.fn(),
-    loadPricingConfig: vi.fn()
-}));
-vi.mock('../../utils/cost_formatter.js', () => ({
-    formatCostReport: vi.fn()
-}));
-describe('workflow cost command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowCost = (await import('./cost.js')).default;
-            expect(WorkflowCost).toBeDefined();
-            expect(WorkflowCost.description).toBeDefined();
-            expect(WorkflowCost.args).toHaveProperty('workflowId');
-            expect(WorkflowCost.flags).toHaveProperty('format');
-            expect(WorkflowCost.flags).toHaveProperty('verbose');
-        });
-        it('should have workflowId as required arg', async () => {
-            const WorkflowCost = (await import('./cost.js')).default;
-            expect(WorkflowCost.args.workflowId.required).toBe(true);
-        });
-        it('should have tracePath as optional arg', async () => {
-            const WorkflowCost = (await import('./cost.js')).default;
-            expect(WorkflowCost.args).toHaveProperty('tracePath');
-            expect(WorkflowCost.args.tracePath.required).toBeFalsy();
-        });
-        it('should have correct flag configuration', async () => {
-            const WorkflowCost = (await import('./cost.js')).default;
-            expect(WorkflowCost.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowCost.flags.format.default).toBe('text');
-            expect(WorkflowCost.flags.verbose.default).toBe(false);
-        });
-        it('should have correct examples', async () => {
-            const WorkflowCost = (await import('./cost.js')).default;
-            expect(WorkflowCost.examples).toBeDefined();
-            expect(WorkflowCost.examples.length).toBeGreaterThan(0);
-        });
-    });
-});

package/dist/commands/workflow/dataset/generate.d.ts

@@ -1,22 +0,0 @@
-import { Command } from '@oclif/core';
-export default class DatasetGenerate 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: {
-        trace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        download: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
-        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-    private generateFromScenario;
-    private generateFromTrace;
-    private generateFromS3;
-    private resolveScenarioInput;
-    catch(error: Error): Promise<void>;
-}

package/dist/commands/workflow/dataset/generate.js

@@ -1,143 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { Args, Command, Flags, ux } from '@oclif/core';
-import { postWorkflowRun } from '#api/generated/api.js';
-import { writeDataset, resolveDefaultDatasetsDir, buildDataset, getExecutionTime, extractDatasetName } from '#services/datasets.js';
-import { listRemoteTraces, downloadRemoteTrace } from '#services/s3_trace_downloader.js';
-import { extractDatasetFromTrace } from '#utils/trace_extractor.js';
-import { resolveScenarioPath, getScenarioNotFoundMessage } from '#utils/scenario_resolver.js';
-import { parseInputFlag } from '#utils/input_parser.js';
-import { handleApiError } from '#utils/error_handler.js';
-export default class DatasetGenerate extends Command {
-    static description = 'Generate a dataset for a workflow from a scenario, trace file, or S3';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> simple basic_input',
-        '<%= config.bin %> <%= command.id %> simple --trace logs/runs/simple/trace.json --name edge_case',
-        '<%= config.bin %> <%= command.id %> simple --download --limit 5'
-    ];
-    static args = {
-        workflowName: Args.string({
-            description: 'Name of the workflow',
-            required: true
-        }),
-        scenario: Args.string({
-            description: 'Scenario name (resolved from the workflow\'s scenarios/ directory)',
-            required: false
-        })
-    };
-    static flags = {
-        trace: Flags.string({
-            char: 't',
-            description: 'Path to a local trace file to extract dataset from',
-            exclusive: ['download']
-        }),
-        name: Flags.string({
-            char: 'n',
-            description: 'Dataset name (defaults to scenario name or trace filename)'
-        }),
-        download: Flags.boolean({
-            char: 'd',
-            description: 'Download traces from S3 and create datasets',
-            default: false,
-            exclusive: ['trace']
-        }),
-        limit: Flags.integer({
-            char: 'l',
-            description: 'Maximum number of traces to download from S3',
-            default: 5
-        }),
-        input: Flags.string({
-            char: 'i',
-            description: 'Workflow input as JSON string or file path (overrides scenario)'
-        })
-    };
-    async run() {
-        const { args, flags } = await this.parse(DatasetGenerate);
-        if (flags.download) {
-            await this.generateFromS3(args.workflowName, flags.limit);
-            return;
-        }
-        if (flags.trace) {
-            await this.generateFromTrace(args.workflowName, flags.trace, flags.name);
-            return;
-        }
-        await this.generateFromScenario(args.workflowName, args.scenario, flags.input, flags.name);
-    }
-    async generateFromScenario(workflowName, scenario, inputFlag, nameOverride) {
-        const resolvedInput = await this.resolveScenarioInput(workflowName, scenario, inputFlag);
-        const datasetName = nameOverride ?? scenario ?? 'dataset';
-        this.log(`Running workflow "${workflowName}"...`);
-        const response = await postWorkflowRun({
-            workflowName,
-            input: resolvedInput
-        }, {
-            config: { timeout: 600000 }
-        });
-        if (!response?.data) {
-            this.error('API returned invalid response', { exit: 1 });
-        }
-        const { workflowId, output } = response.data;
-        const executionTimeMs = await getExecutionTime(workflowId);
-        const dataset = buildDataset(datasetName, resolvedInput, output, executionTimeMs);
-        const dir = resolveDefaultDatasetsDir(workflowName);
-        const filePath = join(dir, `${datasetName}.yml`);
-        await writeDataset(dataset, filePath);
-        this.log(`Dataset saved: ${filePath}`);
-    }
-    async generateFromTrace(workflowName, tracePath, nameOverride) {
-        this.log(`Reading trace: ${tracePath}`);
-        const content = await readFile(tracePath, 'utf-8');
-        const traceData = JSON.parse(content);
-        const extracted = extractDatasetFromTrace(traceData);
-        const datasetName = nameOverride ?? extractDatasetName(tracePath);
-        const dataset = buildDataset(datasetName, extracted.input, extracted.output, extracted.executionTimeMs);
-        const dir = resolveDefaultDatasetsDir(workflowName);
-        const filePath = join(dir, `${datasetName}.yml`);
-        await writeDataset(dataset, filePath);
-        this.log(`Dataset saved: ${filePath}`);
-    }
-    async generateFromS3(workflowName, limit) {
-        this.log(`Listing remote traces for "${workflowName}"...`);
-        const traces = await listRemoteTraces(workflowName, { limit });
-        if (traces.length === 0) {
-            this.log('No remote traces found.');
-            return;
-        }
-        this.log(`Found ${traces.length} trace(s). Downloading...`);
-        const dir = resolveDefaultDatasetsDir(workflowName);
-        for (const trace of traces) {
-            const traceData = await downloadRemoteTrace(trace.key);
-            const extracted = extractDatasetFromTrace(traceData);
-            const datasetName = extractDatasetName(trace.key);
-            const dataset = buildDataset(datasetName, extracted.input, extracted.output, extracted.executionTimeMs);
-            const filePath = join(dir, `${datasetName}.yml`);
-            await writeDataset(dataset, filePath);
-            this.log(`  Saved: ${filePath}`);
-        }
-        this.log(`\nGenerated ${traces.length} dataset(s)`);
-    }
-    async resolveScenarioInput(workflowName, scenario, inputFlag) {
-        if (inputFlag && scenario) {
-            return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
-        }
-        if (inputFlag) {
-            return parseInputFlag(inputFlag);
-        }
-        if (scenario) {
-            const resolution = await resolveScenarioPath(workflowName, scenario);
-            if (!resolution.found) {
-                return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
-            }
-            return parseInputFlag(resolution.path);
-        }
-        return ux.error('Input required. Provide either:\n' +
-            '  - A scenario: output workflow dataset generate <workflow> <scenario>\n' +
-            '  - An input flag: output workflow dataset generate <workflow> --input <json>', { exit: 1 });
-    }
-    async catch(error) {
-        return handleApiError(error, (...args) => this.error(...args), {
-            404: 'Workflow not found. Check the workflow name.',
-            500: 'Workflow execution failed.'
-        });
-    }
-}

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

@@ -1,12 +0,0 @@
-import { Command } from '@oclif/core';
-export default class DatasetList extends Command {
-    static description: string;
-    static examples: string[];
-    static args: {
-        workflowName: 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>;
-}