@output.ai/cli 0.0.0 → 0.0.1

package/README.md

@@ -14,6 +14,39 @@ npx @output.ai/cli
 
 ## Usage
 
+### List Workflows
+
+```bash
+# List all available workflows (simple list, default)
+output-cli workflow list
+
+# List workflows with custom API URL
+API_URL=http://localhost:3001 output-cli workflow list
+
+# List workflows with authentication
+API_AUTH_TOKEN=your-token output-cli workflow list
+
+# Show detailed table view with all information
+output-cli workflow list --format table
+
+# Show detailed table with expanded parameter info
+output-cli workflow list --format table --detailed
+
+# List workflows in JSON format
+output-cli workflow list --format json
+
+# Filter workflows by name (partial match)
+output-cli workflow list --filter simple
+```
+
+#### Command Options
+
+- `--format, -f` - Output format: `list` (default, simple column), `table`, or `json`
+- `--detailed, -d` - Show detailed parameter information in table view
+- `--filter` - Filter workflows by name (case-insensitive partial match)
+
+The list command connects to the API server and retrieves all available workflows. By default, it displays a simple list of workflow names (like `ls`). Use `--format table` for detailed information.
+
 ### Generate a Workflow
 
 ```bash
@@ -44,7 +77,7 @@ The CLI creates a complete workflow structure:
 ```
 my-workflow/
 ├── index.ts          # Main workflow definition
-├── steps.ts          # Activity/step implementations  
+├── steps.ts          # Activity/step implementations
 ├── types.ts          # TypeScript interfaces
 ├── prompt@v1.prompt  # LLM prompt template (if not skeleton)
 └── README.md         # Workflow documentation

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

@@ -0,0 +1,272 @@
+export type JSONSchemaProperties = {
+    [key: string]: JSONSchema;
+};
+export type JSONSchemaPropertyNames = {
+    type?: string;
+};
+export interface JSONSchema {
+    $schema?: string;
+    type?: string;
+    properties?: JSONSchemaProperties;
+    items?: JSONSchema;
+    required?: string[];
+    description?: string;
+    additionalProperties?: boolean;
+    propertyNames?: JSONSchemaPropertyNames;
+    anyOf?: JSONSchema[];
+    [key: string]: unknown;
+}
+export interface Workflow {
+    /** The name of the workflow */
+    name: string;
+    /** The description of the workflow */
+    description?: string;
+    inputSchema?: JSONSchema;
+    outputSchema?: JSONSchema;
+}
+export type PostWorkflowRunBody = {
+    /** The name of the workflow to execute */
+    workflowName: string;
+    /** The payload to send to the workflow */
+    input: unknown;
+    /** The name of the task queue to send the workflow to */
+    taskQueue?: string;
+};
+export type PostWorkflowRun200 = {
+    /** The workflow execution id */
+    workflowId?: string;
+    /** The output of the the workflow */
+    output?: unknown;
+};
+export type PostWorkflowStartBody = {
+    /** The name of the workflow to execute */
+    workflowName: string;
+    /** The payload to send to the workflow */
+    input: unknown;
+    /** The name of the task queue to send the workflow to */
+    taskQueue?: string;
+};
+export type PostWorkflowStart200 = {
+    /** The id of the started workflow */
+    workflowId?: string;
+};
+/**
+ * The workflow execution status
+ */
+export type GetWorkflowIdStatus200Status = typeof GetWorkflowIdStatus200Status[keyof typeof GetWorkflowIdStatus200Status];
+export declare const GetWorkflowIdStatus200Status: {
+    readonly canceled: "canceled";
+    readonly completed: "completed";
+    readonly continued_as_new: "continued_as_new";
+    readonly failed: "failed";
+    readonly running: "running";
+    readonly terminated: "terminated";
+    readonly timed_out: "timed_out";
+    readonly unspecified: "unspecified";
+};
+export type GetWorkflowIdStatus200 = {
+    /** The id of workflow */
+    workflowId?: string;
+    /** The workflow execution status */
+    status?: GetWorkflowIdStatus200Status;
+    /** An epoch timestamp representing when the workflow started */
+    startedAt?: number;
+    /** An epoch timestamp representing when the workflow ended */
+    completedAt?: number;
+};
+/**
+ * The output of workflow
+ */
+export type GetWorkflowIdOutput200Output = {
+    [key: string]: unknown;
+};
+export type GetWorkflowIdOutput200 = {
+    /** The workflow execution id */
+    workflowId?: string;
+    /** The output of workflow */
+    output?: GetWorkflowIdOutput200Output;
+};
+export type GetWorkflowCatalogId200 = {
+    /** Each workflow available in this catalog */
+    workflows?: Workflow[];
+};
+export type GetWorkflowCatalog200 = {
+    /** Each workflow available in this catalog */
+    workflows?: Workflow[];
+};
+export type PostWorkflowIdFeedbackBody = {
+    /** The payload to send to the workflow */
+    payload?: unknown;
+};
+/**
+ * @summary Health check the API
+ */
+export type getHealthResponse200 = {
+    data: void;
+    status: 200;
+};
+export type getHealthResponseSuccess = (getHealthResponse200) & {
+    headers: Headers;
+};
+export type getHealthResponse = (getHealthResponseSuccess);
+export declare const getGetHealthUrl: () => string;
+export declare const getHealth: (options?: RequestInit) => Promise<getHealthResponse>;
+/**
+ * Executes a workflow and waits for it to complete before returning the result
+ * @summary Execute a workflow synchronously
+ */
+export type postWorkflowRunResponse200 = {
+    data: PostWorkflowRun200;
+    status: 200;
+};
+export type postWorkflowRunResponseSuccess = (postWorkflowRunResponse200) & {
+    headers: Headers;
+};
+export type postWorkflowRunResponse = (postWorkflowRunResponseSuccess);
+export declare const getPostWorkflowRunUrl: () => string;
+export declare const postWorkflowRun: (postWorkflowRunBody: PostWorkflowRunBody, options?: RequestInit) => Promise<postWorkflowRunResponse>;
+/**
+ * @summary Start a workflow asynchronously
+ */
+export type postWorkflowStartResponse200 = {
+    data: PostWorkflowStart200;
+    status: 200;
+};
+export type postWorkflowStartResponseSuccess = (postWorkflowStartResponse200) & {
+    headers: Headers;
+};
+export type postWorkflowStartResponse = (postWorkflowStartResponseSuccess);
+export declare const getPostWorkflowStartUrl: () => string;
+export declare const postWorkflowStart: (postWorkflowStartBody: PostWorkflowStartBody, options?: RequestInit) => Promise<postWorkflowStartResponse>;
+/**
+ * @summary Get workflow execution status
+ */
+export type getWorkflowIdStatusResponse200 = {
+    data: GetWorkflowIdStatus200;
+    status: 200;
+};
+export type getWorkflowIdStatusResponse404 = {
+    data: void;
+    status: 404;
+};
+export type getWorkflowIdStatusResponseSuccess = (getWorkflowIdStatusResponse200) & {
+    headers: Headers;
+};
+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>;
+/**
+ * @summary Stop a workflow execution
+ */
+export type patchWorkflowIdStopResponse200 = {
+    data: void;
+    status: 200;
+};
+export type patchWorkflowIdStopResponse404 = {
+    data: void;
+    status: 404;
+};
+export type patchWorkflowIdStopResponseSuccess = (patchWorkflowIdStopResponse200) & {
+    headers: Headers;
+};
+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>;
+/**
+ * @summary Return the output of a workflow
+ */
+export type getWorkflowIdOutputResponse200 = {
+    data: GetWorkflowIdOutput200;
+    status: 200;
+};
+export type getWorkflowIdOutputResponse404 = {
+    data: void;
+    status: 404;
+};
+export type getWorkflowIdOutputResponseSuccess = (getWorkflowIdOutputResponse200) & {
+    headers: Headers;
+};
+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>;
+/**
+ * @summary Return the trace of a workflow execution
+ */
+export type getWorkflowIdTraceResponse200 = {
+    data: string[];
+    status: 200;
+};
+export type getWorkflowIdTraceResponse404 = {
+    data: void;
+    status: 404;
+};
+export type getWorkflowIdTraceResponseSuccess = (getWorkflowIdTraceResponse200) & {
+    headers: Headers;
+};
+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>;
+/**
+ * @summary Get a specific workflow catalog by ID
+ */
+export type getWorkflowCatalogIdResponse200 = {
+    data: GetWorkflowCatalogId200;
+    status: 200;
+};
+export type getWorkflowCatalogIdResponseSuccess = (getWorkflowCatalogIdResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowCatalogIdResponse = (getWorkflowCatalogIdResponseSuccess);
+export declare const getGetWorkflowCatalogIdUrl: (id: unknown) => string;
+export declare const getWorkflowCatalogId: (id: unknown, options?: RequestInit) => Promise<getWorkflowCatalogIdResponse>;
+/**
+ * @summary Get the default workflow catalog
+ */
+export type getWorkflowCatalogResponse200 = {
+    data: GetWorkflowCatalog200;
+    status: 200;
+};
+export type getWorkflowCatalogResponseSuccess = (getWorkflowCatalogResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowCatalogResponse = (getWorkflowCatalogResponseSuccess);
+export declare const getGetWorkflowCatalogUrl: () => string;
+export declare const getWorkflowCatalog: (options?: RequestInit) => Promise<getWorkflowCatalogResponse>;
+/**
+ * @summary Send feedback to a payload
+ */
+export type postWorkflowIdFeedbackResponse200 = {
+    data: void;
+    status: 200;
+};
+export type postWorkflowIdFeedbackResponseSuccess = (postWorkflowIdFeedbackResponse200) & {
+    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>;
+/**
+ * @summary A dummy post endpoint for test only
+ */
+export type postHeartbeatResponse204 = {
+    data: void;
+    status: 204;
+};
+export type postHeartbeatResponseSuccess = (postHeartbeatResponse204) & {
+    headers: Headers;
+};
+export type postHeartbeatResponse = (postHeartbeatResponseSuccess);
+export declare const getPostHeartbeatUrl: () => string;
+export declare const postHeartbeat: (options?: RequestInit) => Promise<postHeartbeatResponse>;

package/dist/api/generated/api.js

@@ -0,0 +1,131 @@
+/**
+ * Generated by orval v7.13.0 🍺
+ * Do not edit manually.
+ * Output.ai SDK API
+ * API for managing and executing Temporal workflows through Flow SDK
+ * OpenAPI spec version: 1.0.0
+ */
+import { customFetchInstance } from '../http_client.js';
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const GetWorkflowIdStatus200Status = {
+    canceled: 'canceled',
+    completed: 'completed',
+    continued_as_new: 'continued_as_new',
+    failed: 'failed',
+    running: 'running',
+    terminated: 'terminated',
+    timed_out: 'timed_out',
+    unspecified: 'unspecified',
+};
+;
+export const getGetHealthUrl = () => {
+    return `/health`;
+};
+export const getHealth = async (options) => {
+    return customFetchInstance(getGetHealthUrl(), {
+        ...options,
+        method: 'GET'
+    });
+};
+;
+export const getPostWorkflowRunUrl = () => {
+    return `/workflow/run`;
+};
+export const postWorkflowRun = async (postWorkflowRunBody, options) => {
+    return customFetchInstance(getPostWorkflowRunUrl(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(postWorkflowRunBody)
+    });
+};
+;
+export const getPostWorkflowStartUrl = () => {
+    return `/workflow/start`;
+};
+export const postWorkflowStart = async (postWorkflowStartBody, options) => {
+    return customFetchInstance(getPostWorkflowStartUrl(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(postWorkflowStartBody)
+    });
+};
+export const getGetWorkflowIdStatusUrl = (id) => {
+    return `/workflow/${id}/status`;
+};
+export const getWorkflowIdStatus = async (id, options) => {
+    return customFetchInstance(getGetWorkflowIdStatusUrl(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getPatchWorkflowIdStopUrl = (id) => {
+    return `/workflow/${id}/stop`;
+};
+export const patchWorkflowIdStop = async (id, options) => {
+    return customFetchInstance(getPatchWorkflowIdStopUrl(id), {
+        ...options,
+        method: 'PATCH'
+    });
+};
+export const getGetWorkflowIdOutputUrl = (id) => {
+    return `/workflow/${id}/output`;
+};
+export const getWorkflowIdOutput = async (id, options) => {
+    return customFetchInstance(getGetWorkflowIdOutputUrl(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdTraceUrl = (id) => {
+    return `/workflow/${id}/trace`;
+};
+export const getWorkflowIdTrace = async (id, options) => {
+    return customFetchInstance(getGetWorkflowIdTraceUrl(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+;
+export const getGetWorkflowCatalogIdUrl = (id) => {
+    return `/workflow/catalog/${id}`;
+};
+export const getWorkflowCatalogId = async (id, options) => {
+    return customFetchInstance(getGetWorkflowCatalogIdUrl(id), {
+        ...options,
+        method: 'GET'
+    });
+};
+;
+export const getGetWorkflowCatalogUrl = () => {
+    return `/workflow/catalog`;
+};
+export const getWorkflowCatalog = async (options) => {
+    return customFetchInstance(getGetWorkflowCatalogUrl(), {
+        ...options,
+        method: 'GET'
+    });
+};
+;
+export const getPostWorkflowIdFeedbackUrl = (id) => {
+    return `/workflow/${id}/feedback`;
+};
+export const postWorkflowIdFeedback = async (id, postWorkflowIdFeedbackBody, options) => {
+    return customFetchInstance(getPostWorkflowIdFeedbackUrl(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(postWorkflowIdFeedbackBody)
+    });
+};
+;
+export const getPostHeartbeatUrl = () => {
+    return `/heartbeat`;
+};
+export const postHeartbeat = async (options) => {
+    return customFetchInstance(getPostHeartbeatUrl(), {
+        ...options,
+        method: 'POST'
+    });
+};

package/dist/api/http_client.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Custom ky-based HTTP client for Orval-generated API
+ */
+export declare const customFetchInstance: <T>(url: string, options: RequestInit & {
+    params?: Record<string, unknown>;
+}) => Promise<T>;

package/dist/api/http_client.js

@@ -0,0 +1,41 @@
+/**
+ * Custom ky-based HTTP client for Orval-generated API
+ */
+import ky from 'ky';
+import { config } from '../config.js';
+const api = ky.create({
+    prefixUrl: config.apiUrl,
+    timeout: config.requestTimeout,
+    retry: {
+        limit: 2,
+        methods: ['get', 'put', 'head', 'delete', 'options', 'trace'],
+        statusCodes: [408, 413, 429, 500, 502, 503, 504]
+    },
+    hooks: {
+        beforeRequest: [
+            request => {
+                // Add auth token if available
+                if (config.apiToken) {
+                    request.headers.set('Authorization', `Basic ${config.apiToken}`);
+                }
+            }
+        ]
+    }
+});
+const stripLeadingSlash = (url) => url.startsWith('/') ? url.slice(1) : url;
+const buildKyOptions = (options) => ({
+    method: options.method,
+    headers: options.headers,
+    searchParams: options.params,
+    body: options.body && options.method !== 'GET' ? options.body : undefined
+});
+const wrapResponse = (response, data) => ({
+    data,
+    status: response.status,
+    headers: response.headers
+});
+export const customFetchInstance = async (url, options) => {
+    const response = await api(stripLeadingSlash(url), buildKyOptions(options));
+    const data = await response.json().catch(() => undefined);
+    return wrapResponse(response, data);
+};

package/dist/api/orval_post_process.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Orval post-generation hook to fix ES module imports by adding .js extensions.
+ * This is necessary because the SDK uses "type": "module" in package.json,
+ * which requires all relative imports to have explicit .js extensions.
+ */
+export declare function fixEsmImports(outputPath: string): Promise<void>;
+/**
+ * Run ESLint fix on generated files to ensure they follow project standards
+ */
+export declare function runEslintFix(): Promise<void>;

package/dist/api/orval_post_process.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+/**
+ * Orval post-generation hook to fix ES module imports by adding .js extensions.
+ * This is necessary because the SDK uses "type": "module" in package.json,
+ * which requires all relative imports to have explicit .js extensions.
+ */
+export async function fixEsmImports(outputPath) {
+    const content = readFileSync(outputPath, 'utf8');
+    const fixedContent = content.replace(/from '\.\.\/http_client'/g, 'from \'../http_client.js\'');
+    writeFileSync(outputPath, fixedContent, 'utf8');
+    console.log('✅ Fixed ESM imports in Orval generated file');
+}
+/**
+ * Run ESLint fix on generated files to ensure they follow project standards
+ */
+export async function runEslintFix() {
+    try {
+        execSync('npx eslint --fix src/api/generated/api.ts', {
+            cwd: process.cwd(),
+            stdio: 'pipe' // Suppress output
+        });
+        console.log('✅ Applied ESLint fixes to generated file');
+    }
+    catch (error) {
+        if (error instanceof Error && 'status' in error && error.status === 1) {
+            console.log('✅ Applied ESLint fixes to generated file (with warnings)');
+        }
+        else {
+            console.warn('⚠️  ESLint fix encountered an issue:', error instanceof Error ? error.message : error);
+        }
+    }
+}

package/dist/api/parser.d.ts

@@ -0,0 +1,17 @@
+import type { Workflow } from './generated/api.js';
+interface WorkflowParameter {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+}
+interface ParsedWorkflow {
+    name: string;
+    description?: string;
+    inputs: WorkflowParameter[];
+    outputs: WorkflowParameter[];
+}
+export declare function parseWorkflowDefinition(workflow: Workflow): ParsedWorkflow;
+export declare function formatParameterType(param: WorkflowParameter): string;
+export declare function formatParameters(params: WorkflowParameter[]): string;
+export {};

package/dist/api/parser.js

@@ -0,0 +1,71 @@
+// json-schema-library is a CommonJS module that doesn't properly export named exports for ESM.
+// We need to use the default import pattern and destructure from it.
+import pkg from 'json-schema-library';
+const { compileSchema, draft07 } = pkg;
+function formatType(schema) {
+    if (!schema) {
+        return 'any';
+    }
+    if (schema.type === 'array') {
+        const itemsType = schema.items?.type || 'any';
+        return `array<${itemsType}>`;
+    }
+    return schema.type || 'any';
+}
+function processProperties(properties, prefix = '', requiredList = []) {
+    return Object.entries(properties).flatMap(([key, propSchema]) => {
+        const prop = propSchema;
+        const propName = prefix ? `${prefix}.${key}` : key;
+        if (prop.type === 'object' && prop.properties) {
+            const nestedRequired = prop.required || [];
+            return processProperties(prop.properties, propName, nestedRequired);
+        }
+        return {
+            name: propName,
+            type: formatType(prop),
+            required: requiredList.includes(key),
+            description: prop.description
+        };
+    });
+}
+function extractParametersFromSchema(schema) {
+    if (!schema) {
+        return [];
+    }
+    const schemaNode = compileSchema(schema, { drafts: [draft07] });
+    const compiledSchema = schemaNode.schema;
+    if (compiledSchema.type === 'object' && compiledSchema.properties) {
+        const required = compiledSchema.required || [];
+        return processProperties(compiledSchema.properties, '', required);
+    }
+    if (compiledSchema.type) {
+        return [{
+                name: 'value',
+                type: compiledSchema.type,
+                required: true,
+                description: compiledSchema.description
+            }];
+    }
+    return [];
+}
+export function parseWorkflowDefinition(workflow) {
+    return {
+        name: workflow.name,
+        description: workflow.description,
+        inputs: extractParametersFromSchema(workflow.inputSchema),
+        outputs: extractParametersFromSchema(workflow.outputSchema)
+    };
+}
+export function formatParameterType(param) {
+    const typeStr = param.type;
+    const reqStr = param.required ? '' : '?';
+    return `${typeStr}${reqStr}`;
+}
+export function formatParameters(params) {
+    if (params.length === 0) {
+        return 'none';
+    }
+    return params
+        .map(p => `${p.name}: ${formatParameterType(p)}`)
+        .join(', ');
+}

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

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+import { type Workflow } from '../../api/generated/api.js';
+interface WorkflowDisplay {
+    name: string;
+    description: string;
+    inputs: string;
+    outputs: string;
+}
+export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
+export default class WorkflowList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        detailed: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        filter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private handleError;
+}
+export {};

package/dist/commands/workflow/list.js

@@ -0,0 +1,169 @@
+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';
+const OUTPUT_FORMAT = {
+    LIST: 'list',
+    TABLE: 'table',
+    JSON: 'json'
+};
+export function parseWorkflowForDisplay(workflow) {
+    const parsed = parseWorkflowDefinition(workflow);
+    return {
+        name: parsed.name,
+        description: parsed.description || 'No description',
+        inputs: formatParameters(parsed.inputs),
+        outputs: formatParameters(parsed.outputs)
+    };
+}
+function caseInsensitiveIncludes(str, filter) {
+    return str.toLowerCase().includes(filter.toLowerCase());
+}
+function matchName(filterString) {
+    return workflow => {
+        const name = workflow.name || '';
+        return caseInsensitiveIncludes(name, filterString);
+    };
+}
+function sortWorkflowsByName(workflows) {
+    return [...workflows].sort((a, b) => {
+        const nameA = (a.name || '').toLowerCase();
+        const nameB = (b.name || '').toLowerCase();
+        return nameA.localeCompare(nameB);
+    });
+}
+function createWorkflowTable(workflows, detailed) {
+    const table = new Table({
+        head: ['Name', 'Description', 'Inputs', 'Outputs'],
+        colWidths: detailed ? [25, 40, 40, 40] : [20, 30, 25, 25],
+        wordWrap: true,
+        style: {
+            head: ['cyan']
+        }
+    });
+    const sortedWorkflows = sortWorkflowsByName(workflows);
+    sortedWorkflows.forEach(workflow => {
+        const display = parseWorkflowForDisplay(workflow);
+        if (detailed) {
+            const inputs = display.inputs.split(', ').join('\n');
+            const outputs = display.outputs.split(', ').join('\n');
+            table.push([display.name, display.description, inputs, outputs]);
+        }
+        else {
+            const maxLen = 22;
+            const inputs = display.inputs.length > maxLen ?
+                display.inputs.substring(0, maxLen) + '...' :
+                display.inputs;
+            const outputs = display.outputs.length > maxLen ?
+                display.outputs.substring(0, maxLen) + '...' :
+                display.outputs;
+            table.push([display.name, display.description, inputs, outputs]);
+        }
+    });
+    return table.toString();
+}
+function formatWorkflowsAsList(workflows) {
+    const sortedWorkflows = sortWorkflowsByName(workflows);
+    const names = sortedWorkflows.map(w => parseWorkflowForDisplay(w).name);
+    return `\nWorkflows:\n\n${names.map(name => `- ${name}`).join('\n')}`;
+}
+function formatWorkflowsAsJson(workflows) {
+    const output = {
+        workflows: workflows.map(w => {
+            const display = parseWorkflowForDisplay(w);
+            return {
+                name: display.name,
+                description: display.description,
+                inputs: display.inputs.split(', '),
+                outputs: display.outputs.split(', '),
+                raw: w
+            };
+        })
+    };
+    return JSON.stringify(output, null, 2);
+}
+function formatWorkflows(workflows, format, detailed) {
+    if (format === OUTPUT_FORMAT.JSON) {
+        return formatWorkflowsAsJson(workflows);
+    }
+    if (format === OUTPUT_FORMAT.TABLE) {
+        return createWorkflowTable(workflows, detailed);
+    }
+    return formatWorkflowsAsList(workflows);
+}
+export default class WorkflowList extends Command {
+    static description = 'List available workflows from the catalog';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --format table',
+        '<%= config.bin %> <%= command.id %> --format json',
+        '<%= config.bin %> <%= command.id %> --detailed',
+        '<%= config.bin %> <%= command.id %> --filter simple'
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.LIST, OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON],
+            default: OUTPUT_FORMAT.LIST
+        }),
+        detailed: Flags.boolean({
+            char: 'd',
+            description: 'Show detailed parameter information',
+            default: false
+        }),
+        filter: Flags.string({
+            description: 'Filter workflows by name'
+        })
+    };
+    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)`);
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    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 (apiError.response?.status === 404) {
+            this.error('Not found.', { exit: 1 });
+        }
+        if (apiError.message) {
+            this.error(`Failed to fetch workflow catalog: ${apiError.message}`, { exit: 1 });
+        }
+        this.error('Failed to fetch workflow catalog: Unknown error', { exit: 1 });
+    }
+}

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

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

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

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+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?');
+    });
+    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');
+    });
+    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/config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * CLI configuration
+ */
+export declare const config: {
+    /**
+     * Base URL for the Output.ai API server
+     * Can be overridden with API_URL environment variable
+     */
+    apiUrl: string;
+    /**
+     * API authentication token
+     * Set via API_AUTH_TOKEN environment variable
+     */
+    apiToken: string | undefined;
+    /**
+     * Default timeout for API requests (in milliseconds)
+     */
+    requestTimeout: number;
+};

package/dist/config.js

@@ -0,0 +1,19 @@
+/**
+ * CLI configuration
+ */
+export const config = {
+    /**
+     * Base URL for the Output.ai API server
+     * Can be overridden with API_URL environment variable
+     */
+    apiUrl: process.env.API_URL || 'http://localhost:3001',
+    /**
+     * API authentication token
+     * Set via API_AUTH_TOKEN environment variable
+     */
+    apiToken: process.env.API_AUTH_TOKEN,
+    /**
+     * Default timeout for API requests (in milliseconds)
+     */
+    requestTimeout: 30000
+};

package/dist/templates/workflow/README.md.template

@@ -159,8 +159,8 @@ export const llmStep = step( {
   },
   outputSchema: { type: 'string' },
   fn: async ( input: { userInput: string } ) => {
-    const prompt = loadPrompt( 'prompt@v1', { 
-      userInput: input.userInput 
+    const prompt = loadPrompt( 'prompt@v1', {
+      userInput: input.userInput
     } );
     const response = await generateText( prompt as Prompt );
     return response;

package/dist/templates/workflow/workflow.ts.template

@@ -5,7 +5,7 @@ import { exampleLLMStep, processDataStep } from './steps.js';
 const inputSchema = {
   type: 'object',
   properties: {
-    prompt: { 
+    prompt: {
       type: 'string',
       description: 'The prompt to send to the LLM'
     },
@@ -60,7 +60,7 @@ export default workflow( {
     } );
 
     // Process data if provided, otherwise use defaults
-    const processedData = await processDataStep( 
+    const processedData = await processDataStep(
       input.data || { value: 42, type: 'default' }
     );
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@output.ai/cli",
   "description": "CLI for Output.ai workflow generation",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "author": "Ben Church",
   "bin": {
     "output-cli": "./bin/run.js"
@@ -12,14 +12,19 @@
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-plugins": "^5",
     "change-case": "^5.4.4",
-    "handlebars": "^4.7.8"
+    "cli-table3": "^0.6.5",
+    "handlebars": "^4.7.8",
+    "json-schema-library": "^10.2.1",
+    "ky": "^1.11.0"
   },
   "devDependencies": {
     "@oclif/test": "^4",
     "@types/handlebars": "^4.0.40",
     "@types/node": "^18",
     "copyfiles": "^2.4.1",
-    "oclif": "^4"
+    "oclif": "^4",
+    "orval": "^7.13.0",
+    "slash": "^5.1.0"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -54,7 +59,9 @@
   "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"
+    "test": "vitest run",
+    "generate:api": "orval --config ./orval.config.ts",
+    "prebuild": "npm run generate:api"
   },
   "types": "dist/index.d.ts"
 }