@output.ai/cli 0.0.1 → 0.0.3

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

@@ -16,6 +16,6 @@ export default class WorkflowList extends Command {
         filter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<void>;
-    private handleError;
+    catch(error: Error): Promise<void>;
 }
 export {};

package/dist/commands/workflow/list.js

@@ -2,7 +2,7 @@ import { Command, Flags } from '@oclif/core';
 import Table from 'cli-table3';
 import { getWorkflowCatalog } from '../../api/generated/api.js';
 import { parseWorkflowDefinition, formatParameters } from '../../api/parser.js';
-import { config } from '../../config.js';
+import { handleApiError } from '../../utils/error_handler.js';
 const OUTPUT_FORMAT = {
     LIST: 'list',
     TABLE: 'table',
@@ -119,51 +119,35 @@ export default class WorkflowList extends Command {
     };
     async run() {
         const { flags } = await this.parse(WorkflowList);
-        try {
-            this.log('Fetching workflow catalog...');
-            const response = await getWorkflowCatalog();
-            if (!response) {
-                this.error('Failed to connect to API server. Is it running?', { exit: 1 });
-            }
-            if (!response.data) {
-                this.error('API returned invalid response (missing data)', { exit: 1 });
-            }
-            if (!response.data.workflows) {
-                this.error('API returned invalid response (missing workflows)', { exit: 1 });
-            }
-            if (response.data.workflows.length === 0) {
-                this.log('No workflows found in catalog.');
-                return;
-            }
-            const workflows = flags.filter ?
-                response.data.workflows.filter(matchName(flags.filter)) :
-                response.data.workflows;
-            if (workflows.length === 0 && flags.filter) {
-                this.log(`No workflows matching filter: ${flags.filter}`);
-                return;
-            }
-            const output = formatWorkflows(workflows, flags.format, flags.detailed);
-            this.log(output);
-            this.log(`\nFound ${workflows.length} workflow(s)`);
+        this.log('Fetching workflow catalog...');
+        const response = await getWorkflowCatalog();
+        if (!response) {
+            this.error('Failed to connect to API server. Is it running?', { exit: 1 });
         }
-        catch (error) {
-            this.handleError(error);
+        if (!response.data) {
+            this.error('API returned invalid response (missing data)', { exit: 1 });
         }
-    }
-    handleError(error) {
-        const apiError = error;
-        if (apiError.code === 'ECONNREFUSED') {
-            this.error(`Connection refused to ${config.apiUrl}`, { exit: 1 });
-        }
-        if (apiError.response?.status === 401) {
-            this.error('Authentication failed.', { exit: 1 });
+        if (!response.data.workflows) {
+            this.error('API returned invalid response (missing workflows)', { exit: 1 });
         }
-        if (apiError.response?.status === 404) {
-            this.error('Not found.', { exit: 1 });
+        if (response.data.workflows.length === 0) {
+            this.log('No workflows found in catalog.');
+            return;
         }
-        if (apiError.message) {
-            this.error(`Failed to fetch workflow catalog: ${apiError.message}`, { exit: 1 });
+        const workflows = flags.filter ?
+            response.data.workflows.filter(matchName(flags.filter)) :
+            response.data.workflows;
+        if (workflows.length === 0 && flags.filter) {
+            this.log(`No workflows matching filter: ${flags.filter}`);
+            return;
         }
-        this.error('Failed to fetch workflow catalog: Unknown error', { exit: 1 });
+        const output = formatWorkflows(workflows, flags.format, flags.detailed);
+        this.log(output);
+        this.log(`\nFound ${workflows.length} workflow(s)`);
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Catalog not found.'
+        });
     }
 }

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

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

package/dist/commands/workflow/output.js

@@ -0,0 +1,49 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getWorkflowIdOutput } 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 WorkflowOutput extends Command {
+    static description = 'Get workflow execution output';
+    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 output 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(WorkflowOutput);
+        this.log(`Fetching output for workflow: ${args.workflowId}...`);
+        const response = await getWorkflowIdOutput(args.workflowId);
+        if (!response || !response.data) {
+            this.error('API returned invalid response', { exit: 1 });
+        }
+        const output = formatOutput(response.data, flags.format, (result) => {
+            const lines = [
+                `Workflow ID: ${result.workflowId || 'unknown'}`,
+                '',
+                'Output:',
+                JSON.stringify(result.output, null, 2)
+            ];
+            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/output.test.d.ts

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

package/dist/commands/workflow/output.test.js

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

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

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

package/dist/commands/workflow/run.js

@@ -0,0 +1,66 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { postWorkflowRun } from '../../api/generated/api.js';
+import { OUTPUT_FORMAT } from '../../utils/constants.js';
+import { parseInputFlag } from '../../utils/input_parser.js';
+import { formatOutput } from '../../utils/output_formatter.js';
+import { handleApiError } from '../../utils/error_handler.js';
+export default class WorkflowRun extends Command {
+    static description = 'Execute a workflow synchronously and wait for completion';
+    static examples = [
+        '<%= 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"}\' --format 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
+        })
+    };
+    static flags = {
+        input: Flags.string({
+            char: 'i',
+            description: 'Workflow input as JSON string or file path',
+            required: true
+        }),
+        '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 = parseInputFlag(flags.input);
+        this.log(`Executing workflow: ${args.workflowName}...`);
+        const response = await postWorkflowRun({
+            workflowName: args.workflowName,
+            input,
+            taskQueue: flags['task-queue']
+        });
+        if (!response || !response.data) {
+            this.error('API returned invalid response', { exit: 1 });
+        }
+        const output = formatOutput(response.data, flags.format, (result) => {
+            const lines = [
+                `Workflow ID: ${result.workflowId || 'unknown'}`,
+                '',
+                'Output:',
+                JSON.stringify(result.output, null, 2)
+            ];
+            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 name.'
+        });
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../../api/generated/api.js', () => ({
+    postWorkflowRun: vi.fn()
+}));
+describe('workflow run command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    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(true);
+        });
+    });
+});

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

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

package/dist/commands/workflow/start.js

@@ -0,0 +1,57 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { postWorkflowStart } from '../../api/generated/api.js';
+import { parseInputFlag } from '../../utils/input_parser.js';
+import { handleApiError } from '../../utils/error_handler.js';
+export default class WorkflowStart extends Command {
+    static description = 'Start a workflow asynchronously without waiting for completion';
+    static examples = [
+        '<%= 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
+        })
+    };
+    static flags = {
+        input: Flags.string({
+            char: 'i',
+            description: 'Workflow input as JSON string or file path',
+            required: true
+        }),
+        'task-queue': Flags.string({
+            char: 'q',
+            description: 'Task queue name for workflow execution'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowStart);
+        const input = parseInputFlag(flags.input);
+        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 output ${result.workflowId || '<workflow-id>'}" to get the workflow output 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.test.d.ts

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

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

@@ -0,0 +1,23 @@
+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(true);
+        });
+    });
+});

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

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

package/dist/commands/workflow/status.js

@@ -0,0 +1,56 @@
+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 output = formatOutput(response.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.test.d.ts

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

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

@@ -0,0 +1,33 @@
+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

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

package/dist/commands/workflow/stop.js

@@ -0,0 +1,31 @@
+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.test.d.ts

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

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

@@ -0,0 +1,17 @@
+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');
+        });
+    });
+});

package/dist/templates/agent_instructions/AGENTS.md.template

@@ -0,0 +1,30 @@
+---
+generated_by: "@output.ai/cli"
+version: "{{cliVersion}}"
+generated_on: "{{date}}"
+---
+
+# Output SDK Workflow Planning Agent Configuration
+
+This directory contains AI agent configuration for workflow planning assistance in Output SDK development. Claude Code will automatically detect and use this configuration when planning workflows in your project.
+
+## Available Agent
+
+### 🤖 workflow_planner
+- **Purpose**: Assists with workflow architecture and planning
+- **Capabilities**: System design, workflow structure, step organization, requirements analysis
+- **Usage**: Planning new workflows, architectural decisions, creating implementation blueprints
+
+## Integration
+
+This agent configuration integrates with:
+- **Claude Code**: AI-powered development assistant
+- **Output SDK**: Temporal-based workflow orchestration framework
+- **TypeScript**: Type-safe development patterns
+- **XML Process Flow**: Structured planning with validation checkpoints
+
+## Usage
+
+The workflow planning agent is automatically available when using Claude Code in projects with this configuration. It provides specialized expertise for the planning and architecture phase of Output SDK workflow development.
+
+To regenerate this configuration: `output-cli agents init --force`