@outputai/cli 0.1.2 → 0.1.3-dev.0

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

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockListScenarios = vi.fn().mockReturnValue([]);
+vi.mock('#utils/scenario_resolver.js', () => ({
+    listScenariosForWorkflow: mockListScenarios
+}));
+describe('workflow list command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command functionality', () => {
+        it('should export a valid OCLIF command', async () => {
+            const WorkflowList = (await import('./list.js')).default;
+            expect(WorkflowList).toBeDefined();
+            expect(WorkflowList.description).toContain('List available workflows');
+            expect(WorkflowList.flags).toHaveProperty('format');
+            expect(WorkflowList.flags).toHaveProperty('detailed');
+            expect(WorkflowList.flags).toHaveProperty('filter');
+        });
+        it('should have correct flag configuration', async () => {
+            const WorkflowList = (await import('./list.js')).default;
+            expect(WorkflowList.flags.format.options).toEqual(['list', 'table', 'json']);
+            expect(WorkflowList.flags.format.default).toBe('list');
+            expect(WorkflowList.flags.detailed.default).toBe(false);
+        });
+    });
+});
+describe('workflow list parsing', () => {
+    it('should parse workflow definitions correctly', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'test-workflow',
+            description: 'A test workflow',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    message: { type: 'string', description: 'The message' },
+                    count: { type: 'number', description: 'The count' }
+                },
+                required: ['message']
+            },
+            outputSchema: {
+                type: 'object',
+                properties: {
+                    result: { type: 'string' }
+                }
+            }
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.name).toBe('test-workflow');
+        expect(parsed.description).toBe('A test workflow');
+        expect(parsed.inputs).toContain('message: string');
+        expect(parsed.inputs).toContain('count: number?');
+        expect(parsed.outputs).toContain('result: string?');
+        expect(parsed.scenarios).toBe('none');
+    });
+    it('should handle workflows without schemas', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'simple-workflow',
+            description: 'No parameters'
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.name).toBe('simple-workflow');
+        expect(parsed.inputs).toBe('none');
+        expect(parsed.outputs).toBe('none');
+        expect(parsed.scenarios).toBe('none');
+    });
+    it('should include scenario names when scenarios exist', async () => {
+        mockListScenarios.mockReturnValueOnce(['basic', 'advanced', 'stress_test']);
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'workflow-with-scenarios',
+            description: 'Has scenarios'
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.scenarios).toBe('basic, advanced, stress_test');
+    });
+    it('should format nested parameters correctly', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'nested-workflow',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    user: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            email: { type: 'string' }
+                        }
+                    }
+                }
+            }
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.inputs).toContain('user.name: string');
+        expect(parsed.inputs).toContain('user.email: string');
+    });
+});

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

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class WorkflowPlan extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'force-agent-file-write': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private planModificationLoop;
+    private planGenerationLoop;
+}

package/dist/commands/workflow/plan.js

@@ -0,0 +1,66 @@
+import { Command, Flags, ux } from '@oclif/core';
+import { input } from '@inquirer/prompts';
+import { generatePlanName, updateAgentTemplates, writePlanFile } from '#services/workflow_planner.js';
+import { ensureOutputAISystem } from '#services/coding_agents.js';
+import { invokePlanWorkflow, PLAN_COMMAND_OPTIONS, replyToClaude } from '#services/claude_client.js';
+export default class WorkflowPlan extends Command {
+    static description = 'Generate a workflow plan from a description';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --description "A workflow to take a question and answer it"',
+        '<%= config.bin %> <%= command.id %> --force-agent-file-write'
+    ];
+    static flags = {
+        'force-agent-file-write': Flags.boolean({
+            description: 'Force overwrite of agent template files',
+            default: false
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Workflow description',
+            required: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowPlan);
+        const projectRoot = process.cwd();
+        this.log('Checking .outputai directory structure...');
+        await ensureOutputAISystem(projectRoot);
+        if (flags['force-agent-file-write']) {
+            this.log('Updating agent templates...');
+            await updateAgentTemplates(projectRoot);
+            this.log('Templates updated successfully\n');
+        }
+        const description = flags.description ?? await input({
+            message: 'Describe the workflow you want to create:',
+            validate: (value) => value.length >= 10
+        });
+        this.log('\nGenerating plan name...');
+        const planName = await generatePlanName(description);
+        this.log(`Plan name: ${planName}`);
+        await this.planGenerationLoop(description, planName, projectRoot);
+    }
+    async planModificationLoop(originalPlanContent) {
+        const acceptKey = 'ACCEPT';
+        this.log('=========');
+        this.log(originalPlanContent);
+        this.log('=========');
+        const modifications = await input({
+            message: ux.colorize('gray', `Reply or type ${acceptKey} to accept the plan as is: `),
+            validate: (value) => value.length >= 10 || value === acceptKey
+        });
+        if (modifications === acceptKey) {
+            return originalPlanContent;
+        }
+        const modifiedPlanContent = await replyToClaude(modifications, PLAN_COMMAND_OPTIONS);
+        return this.planModificationLoop(modifiedPlanContent);
+    }
+    async planGenerationLoop(promptDescription, planName, projectRoot) {
+        this.log('\nInvoking the /outputai:plan_workflow command...');
+        this.log('This may take a moment...\n');
+        const planContent = await invokePlanWorkflow(promptDescription);
+        const modifiedPlanContent = await this.planModificationLoop(planContent);
+        const modifiedSavedPath = await writePlanFile(planName, modifiedPlanContent, projectRoot);
+        this.log(`✅ Plan saved to: ${modifiedSavedPath}\n`);
+    }
+}

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

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

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

@@ -0,0 +1,341 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import WorkflowPlan from './plan.js';
+import { generatePlanName, writePlanFile, updateAgentTemplates } from '#services/workflow_planner.js';
+import { ensureOutputAISystem } from '#services/coding_agents.js';
+import { invokePlanWorkflow, replyToClaude, ClaudeInvocationError } from '#services/claude_client.js';
+import { input } from '@inquirer/prompts';
+vi.mock('#services/workflow_planner.js');
+vi.mock('#services/coding_agents.js');
+vi.mock('#services/claude_client.js');
+vi.mock('@inquirer/prompts');
+describe('WorkflowPlan Command', () => {
+    const createCommand = () => {
+        const cmd = new WorkflowPlan([], {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.error = vi.fn();
+        const mockedCmd = cmd;
+        mockedCmd.parse = vi.fn();
+        return mockedCmd;
+    };
+    const setupSuccessfulMocks = (description, planName, planContent) => {
+        // Mock input to return description first, then 'ACCEPT' to stop the modification loop
+        const state = { inputCallCount: 0 };
+        vi.mocked(input).mockImplementation((async () => {
+            state.inputCallCount++;
+            if (state.inputCallCount === 1) {
+                return description;
+            }
+            return 'ACCEPT'; // Always accept on second call to stop recursion
+        }));
+        vi.mocked(ensureOutputAISystem).mockResolvedValue();
+        vi.mocked(generatePlanName).mockResolvedValue(planName);
+        vi.mocked(invokePlanWorkflow).mockResolvedValue(planContent);
+        vi.mocked(replyToClaude).mockResolvedValue(planContent);
+        vi.mocked(writePlanFile).mockResolvedValue(`/project/.outputai/plans/${planName}/PLAN.md`);
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command metadata', () => {
+        it('should have correct description', () => {
+            expect(WorkflowPlan.description).toBeDefined();
+            expect(WorkflowPlan.description).toContain('workflow');
+            expect(WorkflowPlan.description).toContain('plan');
+        });
+        it('should have examples', () => {
+            expect(WorkflowPlan.examples).toBeDefined();
+            expect(Array.isArray(WorkflowPlan.examples)).toBe(true);
+            expect(WorkflowPlan.examples.length).toBeGreaterThan(0);
+        });
+        it('should define force-agent-file-write flag', () => {
+            expect(WorkflowPlan.flags).toBeDefined();
+            expect(WorkflowPlan.flags['force-agent-file-write']).toBeDefined();
+            expect(WorkflowPlan.flags['force-agent-file-write'].type).toBe('boolean');
+        });
+        it('should have force flag default to false', () => {
+            expect(WorkflowPlan.flags['force-agent-file-write'].default).toBe(false);
+        });
+    });
+    describe('successful execution flow', () => {
+        it('should execute complete workflow', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Build a user authentication system', '2025_10_06_user_authentication', '# Workflow Plan\n\nPlan content here');
+            await command.run();
+            expect(ensureOutputAISystem).toHaveBeenCalled();
+            expect(generatePlanName).toHaveBeenCalledWith('Build a user authentication system');
+            expect(invokePlanWorkflow).toHaveBeenCalledWith('Build a user authentication system');
+            expect(writePlanFile).toHaveBeenCalledWith('2025_10_06_user_authentication', '# Workflow Plan\n\nPlan content here', expect.any(String));
+        });
+        it('should update templates when force flag is true', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': true }
+            });
+            setupSuccessfulMocks('Test workflow description', '2025_10_06_test', '# Plan');
+            vi.mocked(updateAgentTemplates).mockResolvedValue();
+            await command.run();
+            expect(updateAgentTemplates).toHaveBeenCalled();
+        });
+    });
+    describe('user input validation', () => {
+        it('should validate description is at least 10 characters', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const state = { callCount: 0 };
+            const inputMock = vi.fn().mockImplementation(async (config) => {
+                state.callCount++;
+                if (state.callCount === 1 && config.validate) {
+                    const shortResult = config.validate('short');
+                    expect(shortResult).toBe(false);
+                    const validResult = config.validate('This is a valid description');
+                    expect(validResult).toBe(true);
+                    return 'Valid description here';
+                }
+                return 'ACCEPT'; // Second call from modification loop
+            });
+            vi.mocked(input).mockImplementation(inputMock);
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
+            vi.mocked(replyToClaude).mockResolvedValue('# Plan');
+            vi.mocked(writePlanFile).mockResolvedValue('/test/PLAN.md');
+            await command.run();
+            expect(inputMock).toHaveBeenCalled();
+        });
+    });
+    describe('error handling', () => {
+        it('should handle missing ANTHROPIC_API_KEY', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(new Error('ANTHROPIC_API_KEY environment variable is required'));
+            await expect(command.run()).rejects.toThrow(/ANTHROPIC_API_KEY/i);
+        });
+        it('should handle Claude SDK errors gracefully', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const claudeError = new ClaudeInvocationError('Failed to invoke claude-code: API error');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(claudeError);
+            try {
+                await command.run();
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBe(claudeError);
+            }
+        });
+        it('should handle file system errors', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const state = { inputCallCount: 0 };
+            vi.mocked(input).mockImplementation((async () => {
+                state.inputCallCount++;
+                return state.inputCallCount === 1 ? 'Test workflow' : 'ACCEPT';
+            }));
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
+            vi.mocked(replyToClaude).mockResolvedValue('# Plan');
+            const fsError = new Error('Permission denied');
+            fsError.code = 'EACCES';
+            vi.mocked(writePlanFile).mockRejectedValue(fsError);
+            await expect(command.run()).rejects.toThrow(/Permission denied/i);
+        });
+    });
+    describe('plan display', () => {
+        it('should display plan content to user', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const planContent = '# Workflow Plan\n\nDetailed plan content';
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', planContent);
+            await command.run();
+            expect(command.log).toHaveBeenCalledWith(expect.stringContaining(planContent));
+        });
+    });
+    describe('E2E workflow execution', () => {
+        it('should execute complete workflow with template variable injection', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const description = 'Build a user authentication workflow';
+            const planName = '2025_10_06_user_authentication';
+            const planContent = '# Workflow Plan: UserAuthentication\n\n' +
+                '> Generated: 2025_10_06_user_authentication\n' +
+                '> Description: Build a user authentication workflow';
+            setupSuccessfulMocks(description, planName, planContent);
+            await command.run();
+            // Verify workflow planner receives correct description
+            expect(invokePlanWorkflow).toHaveBeenCalledWith(description);
+            // Verify plan name generation
+            expect(generatePlanName).toHaveBeenCalledWith(description);
+            // Verify plan file creation with correct parameters
+            expect(writePlanFile).toHaveBeenCalledWith(planName, expect.stringContaining('2025_10_06_user_authentication'), expect.any(String));
+            // Verify user sees success message
+            expect(command.log).toHaveBeenCalledWith(expect.stringContaining('✅'));
+        });
+        it('should handle complex workflow descriptions', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const complexDescription = 'Build a multi-step data processing workflow with validation, transformation, and error handling';
+            setupSuccessfulMocks(complexDescription, '2025_10_06_data_processing', '# Workflow Plan\n\nComplex plan content');
+            await command.run();
+            expect(invokePlanWorkflow).toHaveBeenCalledWith(complexDescription);
+            expect(generatePlanName).toHaveBeenCalledWith(complexDescription);
+        });
+        it('should verify plan output path matches expected format', async () => {
+            const command = createCommand();
+            const planName = '2025_10_06_test_workflow';
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Test workflow', planName, '# Plan');
+            await command.run();
+            const writePlanFileCall = vi.mocked(writePlanFile).mock.calls[0];
+            expect(writePlanFileCall[0]).toBe(planName);
+            expect(writePlanFileCall[2]).toMatch(/\/.*$/); // Should be absolute path
+        });
+    });
+    describe('edge cases and error scenarios', () => {
+        it('should handle empty plan content gracefully', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', '');
+            await command.run();
+            expect(writePlanFile).toHaveBeenCalledWith('2025_10_06_test', '', expect.any(String));
+        });
+        it('should handle network timeout errors', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const timeoutError = new Error('Request timeout');
+            timeoutError.name = 'TimeoutError';
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(timeoutError);
+            await expect(command.run()).rejects.toThrow(/timeout/i);
+        });
+        it('should handle rate limit errors', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const rateLimitError = new ClaudeInvocationError('Rate limit exceeded');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(rateLimitError);
+            await expect(command.run()).rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should handle disk full errors when writing plan file', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            const state = { inputCallCount: 0 };
+            vi.mocked(input).mockImplementation((async () => {
+                state.inputCallCount++;
+                return state.inputCallCount === 1 ? 'Test workflow' : 'ACCEPT';
+            }));
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            vi.mocked(invokePlanWorkflow).mockResolvedValue('# Plan');
+            vi.mocked(replyToClaude).mockResolvedValue('# Plan');
+            const diskFullError = new Error('No space left on device');
+            diskFullError.code = 'ENOSPC';
+            vi.mocked(writePlanFile).mockRejectedValue(diskFullError);
+            await expect(command.run()).rejects.toThrow(/space/i);
+        });
+        it('should handle directory creation race conditions', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            // First call fails with ENOENT, second succeeds
+            vi.mocked(ensureOutputAISystem).mockRejectedValueOnce(Object.assign(new Error('Directory does not exist'), { code: 'ENOENT' }));
+            await expect(command.run()).rejects.toThrow();
+        });
+        it('should handle malformed API responses', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            vi.mocked(ensureOutputAISystem).mockResolvedValue();
+            vi.mocked(input).mockResolvedValue('Test workflow');
+            vi.mocked(generatePlanName).mockResolvedValue('2025_10_06_test');
+            const malformedError = new ClaudeInvocationError('Invalid JSON response');
+            vi.mocked(invokePlanWorkflow).mockRejectedValue(malformedError);
+            await expect(command.run()).rejects.toThrow(ClaudeInvocationError);
+        });
+    });
+    describe('template integration', () => {
+        it('should ensure agent templates are current when force flag is set', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': true }
+            });
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', '# Plan');
+            vi.mocked(updateAgentTemplates).mockResolvedValue();
+            await command.run();
+            // Verify templates are updated before plan generation
+            const ensureCall = vi.mocked(ensureOutputAISystem).mock.invocationCallOrder[0];
+            const updateCall = vi.mocked(updateAgentTemplates).mock.invocationCallOrder[0];
+            expect(updateCall).toBeGreaterThan(ensureCall);
+        });
+        it('should not update templates when force flag is false', async () => {
+            const command = createCommand();
+            command.parse.mockResolvedValue({
+                args: {},
+                flags: { 'force-agent-file-write': false }
+            });
+            setupSuccessfulMocks('Test workflow', '2025_10_06_test', '# Plan');
+            await command.run();
+            expect(updateAgentTemplates).not.toHaveBeenCalled();
+        });
+    });
+});

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

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

package/dist/commands/workflow/reset.js

@@ -0,0 +1,51 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { postWorkflowIdReset } from '#api/generated/api.js';
+import { handleApiError } from '#utils/error_handler.js';
+export default class WorkflowReset extends Command {
+    static description = 'Reset a workflow to re-run from after a specific step';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> wf-12345 --step generateBlogPost',
+        '<%= config.bin %> <%= command.id %> wf-12345 --step consolidateCompetitors --reason "Retry with updated prompt"'
+    ];
+    static args = {
+        workflowId: Args.string({
+            description: 'The workflow ID to reset',
+            required: true
+        })
+    };
+    static flags = {
+        step: Flags.string({
+            char: 's',
+            description: 'The step name to reset after',
+            required: true
+        }),
+        reason: Flags.string({
+            char: 'r',
+            description: 'Reason for the reset'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowReset);
+        this.log(`Resetting workflow: ${args.workflowId} to after step: ${flags.step}...`);
+        const response = await postWorkflowIdReset(args.workflowId, { stepName: flags.step, reason: flags.reason });
+        if (!response || !response.data) {
+            this.error('API returned invalid response', { exit: 1 });
+        }
+        const data = response.data;
+        const output = [
+            'Workflow reset successfully',
+            '',
+            `Workflow ID: ${args.workflowId}`,
+            `New Run ID: ${data.runId}`,
+            `Reset after step: ${flags.step}`,
+            flags.reason ? `Reason: ${flags.reason}` : ''
+        ].filter(Boolean).join('\n');
+        this.log(`\n${output}`);
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow or step not found. Check the workflow ID and step name.',
+            409: 'Step has not completed yet. Cannot reset to an incomplete step.'
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class WorkflowResult 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/result.js

@@ -0,0 +1,46 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getWorkflowIdResult } 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';
+export default class WorkflowResult extends Command {
+    static description = 'Get workflow execution result';
+    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 get result 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(WorkflowResult);
+        this.log(`Fetching result for workflow: ${args.workflowId}...`);
+        const response = await getWorkflowIdResult(args.workflowId);
+        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 ID.'
+        });
+    }
+}

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

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