@output.ai/cli 0.0.0 → 0.0.2

package/README.md

@@ -1,6 +1,6 @@
 # @output.ai/cli
 
-CLI tool for generating Output.ai workflows.
+CLI tool for generating Output workflows.
 
 ## Installation
 
@@ -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,12 +77,44 @@ 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
 ```
 
+### Initialize Agent Configuration
+
+```bash
+# Initialize agent configuration for your coding agent
+output-cli agents init
+
+# Specify your agent provider (default: claude-code)
+output-cli agents init --agent-provider claude-code
+
+# Force overwrite existing configuration
+output-cli agents init --force
+```
+
+#### What It Does
+
+Sets up your coding agent of choice with context files, sub-agents, and slash commands for working with the Output SDK effectively. It creates a `.outputai/` directory and wires up your coding agent to the context files.
+
+**Note:** Currently this only works for [Claude Code](https://claude.ai/code), but we plan to add support for other coding agents over time.
+
+#### Command Options
+
+- `--agent-provider` - Specify the coding agent provider (default: `claude-code`)
+- `--force, -f` - Overwrite existing agent configuration files
+
+#### Output Agent Commands
+
+**`/plan_workflow`** - Guides you through structured workflow planning to create comprehensive implementation blueprints before writing code.
+
+#### Output Sub-Agents
+
+**`workflow_planner`** - A specialized AI agent that helps with workflow architecture and planning, including requirements analysis, schema design, and testing strategy definition.
+
 ## About
 
 Built with [OCLIF](https://oclif.io) - see their documentation for advanced CLI features, plugins, and configuration options.

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(', ');
+}