@output.ai/cli 0.0.2 → 0.0.3

package/README.md

@@ -18,25 +18,25 @@ npx @output.ai/cli
 
 ```bash
 # List all available workflows (simple list, default)
-output-cli workflow list
+output workflow list
 
 # List workflows with custom API URL
-API_URL=http://localhost:3001 output-cli workflow list
+API_URL=http://localhost:3001 output workflow list
 
 # List workflows with authentication
-API_AUTH_TOKEN=your-token output-cli workflow list
+API_AUTH_TOKEN=your-token output workflow list
 
 # Show detailed table view with all information
-output-cli workflow list --format table
+output workflow list --format table
 
 # Show detailed table with expanded parameter info
-output-cli workflow list --format table --detailed
+output workflow list --format table --detailed
 
 # List workflows in JSON format
-output-cli workflow list --format json
+output workflow list --format json
 
 # Filter workflows by name (partial match)
-output-cli workflow list --filter simple
+output workflow list --filter simple
 ```
 
 #### Command Options
@@ -51,16 +51,16 @@ The list command connects to the API server and retrieves all available workflow
 
 ```bash
 # Generate a complete workflow with example steps
-output-cli workflow generate my-workflow --description "My awesome workflow"
+output workflow generate my-workflow --description "My awesome workflow"
 
 # Generate a minimal skeleton workflow
-output-cli workflow generate my-workflow --skeleton
+output workflow generate my-workflow --skeleton
 
 # Generate in a specific directory
-output-cli workflow generate my-workflow --output-dir ./src/workflows
+output workflow generate my-workflow --output-dir ./src/workflows
 
 # Force overwrite existing workflow
-output-cli workflow generate my-workflow --force
+output workflow generate my-workflow --force
 ```
 
 #### Command Options

package/dist/api/generated/api.d.ts

@@ -35,7 +35,7 @@ export type PostWorkflowRunBody = {
 export type PostWorkflowRun200 = {
     /** The workflow execution id */
     workflowId?: string;
-    /** The output of the the workflow */
+    /** The output of the workflow */
     output?: unknown;
 };
 export type PostWorkflowStartBody = {
@@ -156,8 +156,8 @@ export type getWorkflowIdStatusResponseError = (getWorkflowIdStatusResponse404)
     headers: Headers;
 };
 export type getWorkflowIdStatusResponse = (getWorkflowIdStatusResponseSuccess | getWorkflowIdStatusResponseError);
-export declare const getGetWorkflowIdStatusUrl: (id: unknown) => string;
-export declare const getWorkflowIdStatus: (id: unknown, options?: RequestInit) => Promise<getWorkflowIdStatusResponse>;
+export declare const getGetWorkflowIdStatusUrl: (id: string) => string;
+export declare const getWorkflowIdStatus: (id: string, options?: RequestInit) => Promise<getWorkflowIdStatusResponse>;
 /**
  * @summary Stop a workflow execution
  */
@@ -176,8 +176,8 @@ export type patchWorkflowIdStopResponseError = (patchWorkflowIdStopResponse404)
     headers: Headers;
 };
 export type patchWorkflowIdStopResponse = (patchWorkflowIdStopResponseSuccess | patchWorkflowIdStopResponseError);
-export declare const getPatchWorkflowIdStopUrl: (id: unknown) => string;
-export declare const patchWorkflowIdStop: (id: unknown, options?: RequestInit) => Promise<patchWorkflowIdStopResponse>;
+export declare const getPatchWorkflowIdStopUrl: (id: string) => string;
+export declare const patchWorkflowIdStop: (id: string, options?: RequestInit) => Promise<patchWorkflowIdStopResponse>;
 /**
  * @summary Return the output of a workflow
  */
@@ -196,8 +196,8 @@ export type getWorkflowIdOutputResponseError = (getWorkflowIdOutputResponse404)
     headers: Headers;
 };
 export type getWorkflowIdOutputResponse = (getWorkflowIdOutputResponseSuccess | getWorkflowIdOutputResponseError);
-export declare const getGetWorkflowIdOutputUrl: (id: unknown) => string;
-export declare const getWorkflowIdOutput: (id: unknown, options?: RequestInit) => Promise<getWorkflowIdOutputResponse>;
+export declare const getGetWorkflowIdOutputUrl: (id: string) => string;
+export declare const getWorkflowIdOutput: (id: string, options?: RequestInit) => Promise<getWorkflowIdOutputResponse>;
 /**
  * @summary Return the trace of a workflow execution
  */
@@ -216,8 +216,8 @@ export type getWorkflowIdTraceResponseError = (getWorkflowIdTraceResponse404) &
     headers: Headers;
 };
 export type getWorkflowIdTraceResponse = (getWorkflowIdTraceResponseSuccess | getWorkflowIdTraceResponseError);
-export declare const getGetWorkflowIdTraceUrl: (id: unknown) => string;
-export declare const getWorkflowIdTrace: (id: unknown, options?: RequestInit) => Promise<getWorkflowIdTraceResponse>;
+export declare const getGetWorkflowIdTraceUrl: (id: string) => string;
+export declare const getWorkflowIdTrace: (id: string, options?: RequestInit) => Promise<getWorkflowIdTraceResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */
@@ -229,8 +229,8 @@ export type getWorkflowCatalogIdResponseSuccess = (getWorkflowCatalogIdResponse2
     headers: Headers;
 };
 export type getWorkflowCatalogIdResponse = (getWorkflowCatalogIdResponseSuccess);
-export declare const getGetWorkflowCatalogIdUrl: (id: unknown) => string;
-export declare const getWorkflowCatalogId: (id: unknown, options?: RequestInit) => Promise<getWorkflowCatalogIdResponse>;
+export declare const getGetWorkflowCatalogIdUrl: (id: string) => string;
+export declare const getWorkflowCatalogId: (id: string, options?: RequestInit) => Promise<getWorkflowCatalogIdResponse>;
 /**
  * @summary Get the default workflow catalog
  */
@@ -255,8 +255,8 @@ export type postWorkflowIdFeedbackResponseSuccess = (postWorkflowIdFeedbackRespo
     headers: Headers;
 };
 export type postWorkflowIdFeedbackResponse = (postWorkflowIdFeedbackResponseSuccess);
-export declare const getPostWorkflowIdFeedbackUrl: (id: unknown) => string;
-export declare const postWorkflowIdFeedback: (id: unknown, postWorkflowIdFeedbackBody: PostWorkflowIdFeedbackBody, options?: RequestInit) => Promise<postWorkflowIdFeedbackResponse>;
+export declare const getPostWorkflowIdFeedbackUrl: (id: string) => string;
+export declare const postWorkflowIdFeedback: (id: string, postWorkflowIdFeedbackBody: PostWorkflowIdFeedbackBody, options?: RequestInit) => Promise<postWorkflowIdFeedbackResponse>;
 /**
  * @summary A dummy post endpoint for test only
  */

package/dist/api/generated/api.js

@@ -2,7 +2,7 @@
  * Generated by orval v7.13.0 🍺
  * Do not edit manually.
  * Output.ai SDK API
- * API for managing and executing Temporal workflows through Flow SDK
+ * API for managing and executing Temporal workflows through Output SDK
  * OpenAPI spec version: 1.0.0
  */
 import { customFetchInstance } from '../http_client.js';

package/dist/commands/workflow/generate.js

@@ -38,7 +38,6 @@ export default class Generate extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(Generate);
-        // Check if skeleton flag is required
         if (!flags.skeleton) {
             this.error('Full workflow generation not implemented yet. Please use --skeleton flag');
         }

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

@@ -3,32 +3,27 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import Generate from './generate.js';
 import { generateWorkflow } from '../../services/workflow_generator.js';
 import { InvalidNameError, WorkflowExistsError } from '../../types/errors.js';
-// Mock the generateWorkflow function
 vi.mock('../../services/workflow_generator.js');
 describe('Generate Command', () => {
     let mockGenerateWorkflow;
     let logSpy;
     const createCommand = () => {
         const cmd = new Generate([], {});
-        // Mock OCLIF methods
         cmd.log = vi.fn();
         cmd.error = vi.fn((message) => {
             throw new Error(message);
         });
-        // Mock parse method
         cmd.parse = vi.fn();
         logSpy = cmd.log;
         return cmd;
     };
     beforeEach(() => {
         vi.clearAllMocks();
-        // Mock generateWorkflow function
         mockGenerateWorkflow = vi.mocked(generateWorkflow);
     });
     describe('successful workflow generation', () => {
         it('should generate workflow with skeleton flag', async () => {
             const cmd = createCommand();
-            // Mock parse return
             cmd.parse.mockResolvedValue({
                 args: { name: 'test-workflow' },
                 flags: {
@@ -38,7 +33,6 @@ describe('Generate Command', () => {
                     force: false
                 }
             });
-            // Mock successful generation
             mockGenerateWorkflow.mockResolvedValue({
                 workflowName: 'test-workflow',
                 targetDir: '/tmp/test-workflow',

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/workflow/README.md.template

@@ -192,7 +192,7 @@ Please provide a helpful response.
 To test your workflow:
 
 1. Build the parent project containing this workflow
-2. Start the Flow worker
+2. Start the Output worker
 3. Execute the workflow using the Output SDK API
 
 Example execution:
@@ -210,6 +210,6 @@ curl -X POST http://localhost:3001/workflow \
 
 ## Resources
 
-- [Output SDK Documentation](https://github.com/growthxai/flow-sdk)
+- [Output SDK Documentation](https://github.com/growthxai/output-sdk)
 - [Temporal Documentation](https://docs.temporal.io)
 - [AI SDK Documentation](https://sdk.vercel.ai/docs)

package/dist/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const OUTPUT_FORMAT: {
+    readonly JSON: "json";
+    readonly TEXT: "text";
+};
+export type OutputFormat = typeof OUTPUT_FORMAT[keyof typeof OUTPUT_FORMAT];

package/dist/utils/constants.js

@@ -0,0 +1,4 @@
+export const OUTPUT_FORMAT = {
+    JSON: 'json',
+    TEXT: 'text'
+};

package/dist/utils/error_handler.d.ts

@@ -0,0 +1,8 @@
+type ErrorOverrides = {
+    [statusCode: number]: string;
+    ECONNREFUSED?: string;
+};
+export declare function handleApiError(error: unknown, errorFn: (...args: [message: string, options: {
+    exit: number;
+}]) => never, overrides?: ErrorOverrides): never;
+export {};

package/dist/utils/error_handler.js

@@ -0,0 +1,25 @@
+import { config } from '../config.js';
+const DEFAULT_MESSAGES = {
+    ECONNREFUSED: `Connection refused to ${config.apiUrl}. Is the API server running?`,
+    401: 'Authentication failed. Check your API_AUTH_TOKEN.',
+    404: 'Resource not found.',
+    UNKNOWN: 'An unknown error occurred.'
+};
+export function handleApiError(error, errorFn, overrides = {}) {
+    const apiError = error;
+    const errorMessages = { ...DEFAULT_MESSAGES, ...overrides };
+    if (apiError.code === 'ECONNREFUSED') {
+        return errorFn(errorMessages.ECONNREFUSED, { exit: 1 });
+    }
+    if (apiError.response?.status) {
+        const status = apiError.response.status;
+        const message = errorMessages[status];
+        if (message) {
+            return errorFn(message, { exit: 1 });
+        }
+    }
+    if (apiError.message) {
+        return errorFn(apiError.message, { exit: 1 });
+    }
+    return errorFn(errorMessages.UNKNOWN, { exit: 1 });
+}

package/dist/utils/input_parser.d.ts

@@ -0,0 +1 @@
+export declare function parseInputFlag(input: string): unknown;

package/dist/utils/input_parser.js

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs';
+export function parseInputFlag(input) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        try {
+            const fileContent = readFileSync(input, 'utf-8');
+            return JSON.parse(fileContent);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                throw new Error(`Input file not found: ${input}`);
+            }
+            throw new Error(`Invalid JSON input: ${err.message}`);
+        }
+    }
+}

package/dist/utils/output_formatter.d.ts

@@ -0,0 +1,2 @@
+import { OutputFormat } from './constants.js';
+export declare function formatOutput<T>(result: T, format: OutputFormat, textFormatter?: (result: T) => string): string;

package/dist/utils/output_formatter.js

@@ -0,0 +1,11 @@
+import { OUTPUT_FORMAT } from './constants.js';
+export function formatOutput(result, format, textFormatter = result => JSON.stringify(result, null, 2)) {
+    switch (format) {
+        case OUTPUT_FORMAT.JSON:
+            return JSON.stringify(result, null, 2);
+        case OUTPUT_FORMAT.TEXT:
+            return textFormatter(result);
+        default:
+            return textFormatter(result);
+    }
+}

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "@output.ai/cli",
+  "version": "0.0.3",
   "description": "CLI for Output.ai workflow generation",
-  "version": "0.0.2",
-  "author": "Ben Church",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "./bin",
+    "./dist",
+    "./oclif.manifest.json"
+  ],
   "bin": {
-    "output-cli": "./bin/run.js"
+    "output": "./bin/run.js"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && tsc && copyfiles -u 1 './src/templates/**/*.template' './src/templates/**/.env.template' './src/templates/**/*.prompt.template' dist",
+    "test": "vitest run",
+    "generate:api": "orval --config ./orval.config.ts",
+    "prebuild": "npm run generate:api"
   },
-  "bugs": "https://github.com/growthxai/flow-sdk/issues",
   "dependencies": {
     "@oclif/core": "^4",
     "@oclif/plugin-help": "^6",
@@ -26,24 +38,10 @@
     "orval": "^7.13.0",
     "slash": "^5.1.0"
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "./bin",
-    "./dist",
-    "./oclif.manifest.json"
-  ],
-  "homepage": "https://github.com/growthxai/flow-sdk",
-  "keywords": [
-    "oclif"
-  ],
-  "license": "MIT",
-  "main": "dist/index.js",
-  "type": "module",
+  "license": "UNLICENSED",
   "oclif": {
-    "bin": "output-cli",
-    "dirname": "output-cli",
+    "bin": "output",
+    "dirname": "output",
     "commands": "./dist/commands",
     "plugins": [
       "@oclif/plugin-help",
@@ -63,13 +61,5 @@
         }
       }
     }
-  },
-  "repository": "sdk/cli",
-  "scripts": {
-    "build": "rm -rf ./dist && tsc && copyfiles -u 1 './src/templates/**/*.template' './src/templates/**/.env.template' './src/templates/**/*.prompt.template' dist",
-    "test": "vitest run",
-    "generate:api": "orval --config ./orval.config.ts",
-    "prebuild": "npm run generate:api"
-  },
-  "types": "dist/index.d.ts"
+  }
 }