@output.ai/cli 0.4.0 → 0.4.2

package/README.md

@@ -1,194 +1,59 @@
 # @output.ai/cli
 
-CLI tool for generating Output workflows.
+Command-line interface for creating and running Output Framework workflows.
+
+[![npm version](https://img.shields.io/npm/v/@output.ai/cli)](https://www.npmjs.com/package/@output.ai/cli)
+[![Documentation](https://img.shields.io/badge/docs-docs.output.ai-blue)](https://docs.output.ai/packages/cli)
 
 ## Installation
 
 ```bash
-# Install globally from the CLI package
-cd sdk/cli && npm link
-
-# Or run directly from the monorepo
-npx @output.ai/cli
+npm install -g @output.ai/cli
 ```
 
-## Usage
-
-### Initialize a New Project
+## Quick Start
 
 ```bash
-# Create a new Output SDK project
+# Create a new project
 output init my-project
-```
+cd my-project
 
-#### What It Does
-
-Creates a complete Output SDK project structure with:
-- Example workflows demonstrating SDK features
-- TypeScript project configuration
-- Agent configuration files
-
-### Start Development Services
-
-```bash
-# Start with automatic file watching (default)
+# Start development services
 output dev
 
-# Start without file watching
-output dev --no-watch
-```
-
-#### What It Does
-
-The `dev` command orchestrates your entire development environment:
-1. Starts Docker services (Temporal, Redis, PostgreSQL)
-2. Launches the API server for workflow execution
-3. Starts the worker to process workflows
-4. Opens Temporal UI for workflow monitoring
-5. Automatically restarts the worker when source files change
-6. Provides a unified log view of all services
-
-This is the primary command for local development - it handles all the complexity of running multiple services and keeps them synchronized.
-
-#### Automatic File Watching
-
-By default, the worker container automatically restarts when you modify files in:
-- `src/` - Your workflow source files and implementations
-- `package.json` - When dependencies change
-
-This feature uses Docker Compose's native watch functionality (requires Docker Compose v2.22+).
-
-#### Command Options
-
-- `--no-watch` - Disable automatic container restart on file changes
-
-### List Workflows
-
-```bash
-# List all available workflows (simple list, default)
-output workflow list
-
-# List workflows with custom API URL
-API_URL=http://localhost:3001 output workflow list
-
-# List workflows with authentication
-API_AUTH_TOKEN=your-token output workflow list
-
-# Show detailed table view with all information
-output workflow list --format table
-
-# Show detailed table with expanded parameter info
-output workflow list --format table --detailed
-
-# List workflows in JSON format
-output workflow list --format json
-
-# Filter workflows by name (partial match)
-output workflow list --filter simple
+# Run a workflow
+output workflow run simple --input '{"question": "who is ada lovelace?"}'
 ```
 
-#### 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.
-
-### Debug a Workflow Execution
-
-```bash
-# Display trace information for a workflow run
-output workflow debug <workflowId>
-
-# Display trace in JSON format
-output workflow debug <workflowId> --format json
-```
-
-#### What It Does
-
-The `debug` command retrieves and displays detailed execution traces for debugging workflow runs. It shows:
-- Complete execution timeline with all events
-- Hierarchical execution tree showing workflow structure
-- Step and activity inputs/outputs
-- Error details and stack traces
-- Performance metrics and durations
-
-#### Command Options
-
-- `--format, -f` - Output format: `text` (default, human-readable) or `json` (raw trace data)
-
-#### Environment Variables
-
-- `HOST_TRACE_PATH` - When running in Docker, this maps the container's trace log path to the host filesystem path. Set this to your project's `logs` directory (e.g., `${PWD}/logs`). Required for trace files to be accessible from the CLI when workflows run in containers.
-
-### Generate a Workflow
-
-```bash
-# Generate a complete workflow with example steps
-output workflow generate my-workflow --description "My awesome workflow"
-
-# Generate a minimal skeleton workflow
-output workflow generate my-workflow --skeleton
-
-# Generate in a specific directory
-output workflow generate my-workflow --output-dir ./src/workflows
-
-# Force overwrite existing workflow
-output workflow generate my-workflow --force
-```
-
-#### Command Options
-
-- `--description, -d` - Description of the workflow
-- `--skeleton, -s` - Generate minimal skeleton without example steps
-- `--output-dir, -o` - Output directory (default: `src/`)
-- `--force, -f` - Overwrite existing directory
-
-#### Generated Structure
-
-The CLI creates a complete workflow structure:
-
-```
-my-workflow/
-├── workflow.ts          # Main workflow definition
-├── steps.ts          # Activity/step implementations
-├── 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
+## Command Reference
 
-- `--agent-provider` - Specify the coding agent provider (default: `claude-code`)
-- `--force, -f` - Overwrite existing agent configuration files
+| Command | Description |
+|---------|-------------|
+| `output init` | Initialize a new project |
+| `output dev` | Start development services (Temporal, API, Worker) |
+| `output agents init` | Initialize AI agent configurations |
+| `output workflow plan` | Generate a workflow plan from description |
+| `output workflow generate` | Generate a workflow from plan |
+| `output workflow list` | List available workflows |
+| `output workflow run` | Execute a workflow synchronously |
+| `output workflow start` | Start a workflow asynchronously |
+| `output workflow status` | Get workflow execution status |
+| `output workflow result` | Get workflow execution result |
+| `output workflow stop` | Stop a workflow execution |
 
-#### Output Agent Commands
+## Development Services
 
-**`/plan_workflow`** - Guides you through structured workflow planning to create comprehensive implementation blueprints before writing code.
+Running `output dev` starts:
 
-#### Output Sub-Agents
+| Service | URL | Description |
+|---------|-----|-------------|
+| Temporal UI | http://localhost:8080 | Monitor and debug workflows |
+| API Server | http://localhost:3001 | REST API for workflow execution |
+| Worker | — | Processes workflows with auto-reload |
 
-**`workflow_planner`** - A specialized AI agent that helps with workflow architecture and planning, including requirements analysis, schema design, and testing strategy definition.
+## Documentation
 
-## About
+For comprehensive documentation, visit:
 
-Built with [OCLIF](https://oclif.io) - see their documentation for advanced CLI features, plugins, and configuration options.
+- [CLI Reference](https://docs.output.ai/packages/cli)
+- [Getting Started](https://docs.output.ai/quickstart)

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

@@ -54,6 +54,39 @@ export interface TraceInfo {
     /** File destinations for trace data */
     destinations?: TraceInfoDestinations;
 }
+/**
+ * Current run status
+ */
+export type WorkflowRunInfoStatus = typeof WorkflowRunInfoStatus[keyof typeof WorkflowRunInfoStatus];
+export declare const WorkflowRunInfoStatus: {
+    readonly running: "running";
+    readonly completed: "completed";
+    readonly failed: "failed";
+    readonly canceled: "canceled";
+    readonly terminated: "terminated";
+    readonly timed_out: "timed_out";
+    readonly continued: "continued";
+};
+export interface WorkflowRunInfo {
+    /** Unique identifier for this run */
+    workflowId?: string;
+    /** Name of the workflow definition */
+    workflowType?: string;
+    /** Current run status */
+    status?: WorkflowRunInfoStatus;
+    /** ISO 8601 timestamp of run start */
+    startedAt?: string;
+    /**
+     * ISO 8601 timestamp of completion, or null if still running
+     * @nullable
+     */
+    completedAt?: string | null;
+}
+export interface WorkflowRunsResponse {
+    runs?: WorkflowRunInfo[];
+    /** Total number of runs returned */
+    count?: number;
+}
 export type PostWorkflowRunBody = {
     /** The name of the workflow to execute */
     workflowName: string;
@@ -124,6 +157,18 @@ export type GetWorkflowCatalog200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
 };
+export type GetWorkflowRunsParams = {
+    /**
+     * Filter by workflow type/name
+     */
+    workflowType?: string;
+    /**
+     * Maximum number of runs to return
+     * @minimum 1
+     * @maximum 1000
+     */
+    limit?: number;
+};
 export type PostWorkflowIdFeedbackBody = {
     /** The payload to send to the workflow */
     payload?: unknown;
@@ -254,6 +299,27 @@ export type getWorkflowCatalogResponseSuccess = (getWorkflowCatalogResponse200)
 export type getWorkflowCatalogResponse = (getWorkflowCatalogResponseSuccess);
 export declare const getGetWorkflowCatalogUrl: () => string;
 export declare const getWorkflowCatalog: (options?: ApiRequestOptions) => Promise<getWorkflowCatalogResponse>;
+/**
+ * Returns a list of workflow runs with optional filtering by workflow type
+ * @summary List workflow runs
+ */
+export type getWorkflowRunsResponse200 = {
+    data: WorkflowRunsResponse;
+    status: 200;
+};
+export type getWorkflowRunsResponse400 = {
+    data: void;
+    status: 400;
+};
+export type getWorkflowRunsResponseSuccess = (getWorkflowRunsResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowRunsResponseError = (getWorkflowRunsResponse400) & {
+    headers: Headers;
+};
+export type getWorkflowRunsResponse = (getWorkflowRunsResponseSuccess | getWorkflowRunsResponseError);
+export declare const getGetWorkflowRunsUrl: (params?: GetWorkflowRunsParams) => string;
+export declare const getWorkflowRuns: (params?: GetWorkflowRunsParams, options?: ApiRequestOptions) => Promise<getWorkflowRunsResponse>;
 /**
  * @summary Send feedback to a payload
  */

package/dist/api/generated/api.js

@@ -7,6 +7,16 @@
  */
 import { customFetchInstance } from '../http_client.js';
 // eslint-disable-next-line @typescript-eslint/no-redeclare
+export const WorkflowRunInfoStatus = {
+    running: 'running',
+    completed: 'completed',
+    failed: 'failed',
+    canceled: 'canceled',
+    terminated: 'terminated',
+    timed_out: 'timed_out',
+    continued: 'continued',
+};
+// eslint-disable-next-line @typescript-eslint/no-redeclare
 export const GetWorkflowIdStatus200Status = {
     canceled: 'canceled',
     completed: 'completed',
@@ -98,6 +108,22 @@ export const getWorkflowCatalog = async (options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowRunsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/runs?${stringifiedParams}` : `/workflow/runs`;
+};
+export const getWorkflowRuns = async (params, options) => {
+    return customFetchInstance(getGetWorkflowRunsUrl(params), {
+        ...options,
+        method: 'GET'
+    });
+};
 ;
 export const getPostWorkflowIdFeedbackUrl = (id) => {
     return `/workflow/${id}/feedback`;

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,6 @@ services:
       temporal:
         condition: service_healthy
     image: growthxteam/output-api:latest
-    pull_policy: always
     networks:
       - main
     environment:

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

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

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

@@ -0,0 +1,104 @@
+import { Args, Command, Flags } from '@oclif/core';
+import Table from 'cli-table3';
+import { fetchWorkflowRuns } from '#services/workflow_runs.js';
+import { formatDate, formatDurationFromTimestamps } from '#utils/date_formatter.js';
+import { handleApiError } from '#utils/error_handler.js';
+const OUTPUT_FORMAT = {
+    TABLE: 'table',
+    JSON: 'json',
+    TEXT: 'text'
+};
+function createRunsTable(runs) {
+    const table = new Table({
+        head: ['Workflow ID', 'Type', 'Status', 'Started', 'Duration'],
+        colWidths: [40, 20, 12, 22, 10],
+        wordWrap: true,
+        style: {
+            head: ['cyan']
+        }
+    });
+    runs.forEach(run => {
+        table.push([
+            run.workflowId || '-',
+            run.workflowType || '-',
+            run.status || '-',
+            formatDate(run.startedAt),
+            formatDurationFromTimestamps(run.startedAt || '', run.completedAt)
+        ]);
+    });
+    return table.toString();
+}
+function formatRunsAsText(runs) {
+    if (runs.length === 0) {
+        return 'No workflow runs found.';
+    }
+    return runs.map(run => {
+        const duration = formatDurationFromTimestamps(run.startedAt || '', run.completedAt);
+        return `${run.workflowId} (${run.workflowType}) - ${run.status} [${duration}]`;
+    }).join('\n');
+}
+function formatRunsAsJson(runs) {
+    return JSON.stringify(runs, null, 2);
+}
+function formatRuns(runs, format) {
+    if (format === OUTPUT_FORMAT.JSON) {
+        return formatRunsAsJson(runs);
+    }
+    if (format === OUTPUT_FORMAT.TABLE) {
+        return createRunsTable(runs);
+    }
+    return formatRunsAsText(runs);
+}
+export default class WorkflowRunsList extends Command {
+    static description = 'List workflow runs with optional filtering by workflow type';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> simple',
+        '<%= config.bin %> <%= command.id %> simple --limit 10',
+        '<%= config.bin %> <%= command.id %> --format json',
+        '<%= config.bin %> <%= command.id %> --format table'
+    ];
+    static args = {
+        workflowName: Args.string({
+            description: 'Filter by workflow type/name',
+            required: false
+        })
+    };
+    static flags = {
+        limit: Flags.integer({
+            char: 'l',
+            description: 'Maximum number of runs to return',
+            default: 100
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TABLE
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowRunsList);
+        const { runs, count } = await fetchWorkflowRuns({
+            workflowType: args.workflowName,
+            limit: flags.limit
+        });
+        if (runs.length === 0) {
+            const filterMsg = args.workflowName ? ` for workflow type "${args.workflowName}"` : '';
+            this.log(`No workflow runs found${filterMsg}.`);
+            return;
+        }
+        const output = formatRuns(runs, flags.format);
+        this.log(output);
+        if (flags.format !== OUTPUT_FORMAT.JSON) {
+            const filterMsg = args.workflowName ? ` of type "${args.workflowName}"` : '';
+            this.log(`\nFound ${count} run(s)${filterMsg}`);
+        }
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            400: 'Invalid parameters provided.',
+            503: 'Workflow service temporarily unavailable.'
+        });
+    }
+}

package/dist/services/workflow_runs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Workflow runs service for fetching workflow run data from the API
+ */
+import { type WorkflowRunInfo } from '#api/generated/api.js';
+export type WorkflowRun = WorkflowRunInfo;
+export interface WorkflowRunsResult {
+    runs: WorkflowRun[];
+    count: number;
+}
+export interface FetchWorkflowRunsOptions {
+    workflowType?: string;
+    limit?: number;
+}
+export declare function fetchWorkflowRuns(options?: FetchWorkflowRunsOptions): Promise<WorkflowRunsResult>;

package/dist/services/workflow_runs.js

@@ -0,0 +1,24 @@
+/**
+ * Workflow runs service for fetching workflow run data from the API
+ */
+import { getWorkflowRuns } from '#api/generated/api.js';
+export async function fetchWorkflowRuns(options = {}) {
+    const params = {};
+    if (options.limit) {
+        params.limit = options.limit;
+    }
+    if (options.workflowType) {
+        params.workflowType = options.workflowType;
+    }
+    const response = await getWorkflowRuns(params);
+    if (!response) {
+        throw new Error('Failed to connect to API server. Is it running?');
+    }
+    if (!response.data) {
+        throw new Error('API returned invalid response (missing data)');
+    }
+    return {
+        runs: response.data.runs || [],
+        count: response.data.count || 0
+    };
+}

package/dist/templates/project/.gitignore.template

@@ -1,8 +1,5 @@
 # Dependencies
 node_modules/
-package-lock.json
-yarn.lock
-bun.lockb
 
 # Build output
 dist/

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

@@ -30,7 +30,7 @@ Edit `.env` to add:
 ### 3. Start Output Services
 
 ```bash
-output dev
+npx output dev
 ```
 
 This starts:
@@ -44,7 +44,7 @@ This starts:
 In a new terminal:
 
 ```bash
-output workflow run simple --input '{"question": "who really is ada lovelace?"}'
+npx output workflow run simple --input '{"question": "who really is ada lovelace?"}'
 ```
 
 ### 5. Stop Services

package/dist/utils/date_formatter.d.ts

@@ -6,3 +6,18 @@
  * @returns Formatted duration string (e.g., "150ms", "2.50s", "3 minutes 45 seconds")
  */
 export declare function formatDuration(ms: number): string;
+/**
+ * Format an ISO date string to a human-readable format
+ *
+ * @param isoString - ISO 8601 date string
+ * @returns Formatted date string (e.g., "Dec 3, 2025 10:30 AM")
+ */
+export declare function formatDate(isoString: string | null | undefined): string;
+/**
+ * Format a duration between two ISO timestamps
+ *
+ * @param startedAt - ISO 8601 start timestamp
+ * @param completedAt - ISO 8601 end timestamp (or null if still running)
+ * @returns Human-readable duration string (e.g., "5 seconds", "running")
+ */
+export declare function formatDurationFromTimestamps(startedAt: string, completedAt: string | null | undefined): string;

package/dist/utils/date_formatter.js

@@ -1,4 +1,7 @@
-import { formatDuration as formatDurationFns, intervalToDuration } from 'date-fns';
+/**
+ * Date and duration formatting utilities
+ */
+import { format, formatDistanceStrict, formatDuration as formatDurationFns, intervalToDuration, parseISO } from 'date-fns';
 /**
  * Format a duration in milliseconds to a human-readable string.
  * Uses date-fns for durations >= 1 minute, custom formatting for shorter durations.
@@ -17,3 +20,30 @@ export function formatDuration(ms) {
     }
     return formatDurationFns(duration, { format: ['minutes', 'seconds'] });
 }
+/**
+ * Format an ISO date string to a human-readable format
+ *
+ * @param isoString - ISO 8601 date string
+ * @returns Formatted date string (e.g., "Dec 3, 2025 10:30 AM")
+ */
+export function formatDate(isoString) {
+    if (!isoString) {
+        return '-';
+    }
+    return format(parseISO(isoString), 'MMM d, yyyy h:mm a');
+}
+/**
+ * Format a duration between two ISO timestamps
+ *
+ * @param startedAt - ISO 8601 start timestamp
+ * @param completedAt - ISO 8601 end timestamp (or null if still running)
+ * @returns Human-readable duration string (e.g., "5 seconds", "running")
+ */
+export function formatDurationFromTimestamps(startedAt, completedAt) {
+    if (!completedAt) {
+        return 'running';
+    }
+    const start = parseISO(startedAt);
+    const end = parseISO(completedAt);
+    return formatDistanceStrict(start, end, { addSuffix: false });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -43,7 +43,10 @@
     "copyfiles": "2.4.1",
     "orval": "7.13.2"
   },
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
   "imports": {
     "#*": "./dist/*"
   },