@outputai/cli 0.8.2-next.2da7213.0 → 0.8.2-next.e1cd79b.0

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

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.2da7213.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.e1cd79b.0}
     init: true
     networks:
       - main

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

@@ -1,17 +1,16 @@
 import { Command } from '@oclif/core';
-import type { CostReport } from '#types/cost.js';
 export default class WorkflowCost extends Command {
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         tracePath: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<CostReport>;
+    run(): Promise<void>;
     private loadLocalTrace;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/cost.js

@@ -2,17 +2,18 @@ import { Args, Command, Flags } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { calculateCost, loadPricingConfig } from '#services/cost_calculator.js';
 import { getTrace } from '#services/trace_reader.js';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
 import { formatCostReport } from '#utils/cost_formatter.js';
 import { getErrorCode } from '#utils/error_utils.js';
 import { handleApiError } from '#utils/error_handler.js';
+import { formatOutput } from '#utils/output_formatter.js';
 export default class WorkflowCost extends Command {
     static description = 'Calculate the cost of a workflow execution';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> my_workflow_id',
         '<%= config.bin %> <%= command.id %> my_workflow_id --verbose',
         '<%= config.bin %> <%= command.id %> my_workflow_id path/to/trace.json',
-        '<%= config.bin %> <%= command.id %> my_workflow_id --json'
+        '<%= config.bin %> <%= command.id %> my_workflow_id --format json'
     ];
     static args = {
         workflowId: Args.string({
@@ -25,6 +26,12 @@ export default class WorkflowCost extends Command {
         })
     };
     static flags = {
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TEXT
+        }),
         verbose: Flags.boolean({
             description: 'Show detailed per-call breakdown',
             default: false
@@ -38,8 +45,8 @@ export default class WorkflowCost extends Command {
         const config = loadPricingConfig();
         const traceNode = traceData;
         const report = calculateCost(traceNode, config, traceFile);
-        this.log(formatCostReport(report, { verbose: flags.verbose }));
-        return report;
+        const formatted = formatOutput(report, flags.format, r => formatCostReport(r, { verbose: flags.verbose }));
+        this.log(formatted);
     }
     async loadLocalTrace(tracePath) {
         try {

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

@@ -20,6 +20,7 @@ describe('workflow cost command', () => {
             expect(WorkflowCost).toBeDefined();
             expect(WorkflowCost.description).toBeDefined();
             expect(WorkflowCost.args).toHaveProperty('workflowId');
+            expect(WorkflowCost.flags).toHaveProperty('format');
             expect(WorkflowCost.flags).toHaveProperty('verbose');
         });
         it('should have workflowId as required arg', async () => {
@@ -33,7 +34,8 @@ describe('workflow cost command', () => {
         });
         it('should have correct flag configuration', async () => {
             const WorkflowCost = (await import('./cost.js')).default;
-            expect(WorkflowCost.enableJsonFlag).toBe(true);
+            expect(WorkflowCost.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowCost.flags.format.default).toBe('text');
             expect(WorkflowCost.flags.verbose.default).toBe(false);
         });
         it('should have correct examples', async () => {

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

@@ -1,8 +1,6 @@
 import { Command } from '@oclif/core';
-import type { DatasetInfo } from '#services/datasets.js';
 export default class DatasetList extends Command {
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
@@ -10,5 +8,5 @@ export default class DatasetList extends Command {
     static flags: {
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<DatasetInfo[]>;
+    run(): Promise<void>;
 }

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

@@ -3,6 +3,7 @@ import Table from 'cli-table3';
 import { listDatasets } from '#services/datasets.js';
 const OutputFormat = {
     TABLE: 'table',
+    JSON: 'json',
     TEXT: 'text'
 };
 function createDatasetsTable(datasets) {
@@ -36,7 +37,13 @@ function formatDatasetsAsText(datasets) {
         return `${dataset.name} ${cached}${outputDate}${evalDate}`;
     }).join('\n');
 }
+function formatDatasetsAsJson(datasets) {
+    return JSON.stringify(datasets, null, 2);
+}
 function formatDatasets(datasets, format) {
+    if (format === OutputFormat.JSON) {
+        return formatDatasetsAsJson(datasets);
+    }
     if (format === OutputFormat.TABLE) {
         return createDatasetsTable(datasets);
     }
@@ -44,10 +51,9 @@ function formatDatasets(datasets, format) {
 }
 export default class DatasetList extends Command {
     static description = 'List datasets for a workflow';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple',
-        '<%= config.bin %> <%= command.id %> simple --json',
+        '<%= config.bin %> <%= command.id %> simple --format json',
         '<%= config.bin %> <%= command.id %> simple --format table'
     ];
     static args = {
@@ -59,25 +65,23 @@ export default class DatasetList extends Command {
     static flags = {
         format: Flags.string({
             char: 'f',
-            description: 'Output format (use --json for JSON output)',
-            options: [OutputFormat.TABLE, OutputFormat.TEXT],
+            description: 'Output format',
+            options: [OutputFormat.TABLE, OutputFormat.JSON, OutputFormat.TEXT],
             default: OutputFormat.TABLE
         })
     };
     async run() {
         const { args, flags } = await this.parse(DatasetList);
         const datasets = await listDatasets(args.workflowName);
-        if (this.jsonEnabled()) {
-            return datasets;
-        }
         if (datasets.length === 0) {
             this.log(`No datasets found for workflow "${args.workflowName}".`);
             this.log('Generate datasets with: output workflow dataset generate');
-            return datasets;
+            return;
         }
         const output = formatDatasets(datasets, flags.format);
         this.log(output);
-        this.log(`\nFound ${datasets.length} dataset(s) for "${args.workflowName}"`);
-        return datasets;
+        if (flags.format !== OutputFormat.JSON) {
+            this.log(`\nFound ${datasets.length} dataset(s) for "${args.workflowName}"`);
+        }
     }
 }

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

@@ -1,12 +1,16 @@
 import { Command } from '@oclif/core';
 export default class WorkflowDebug extends Command {
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
-    run(): Promise<unknown>;
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private conditionalLog;
+    private outputJson;
     private displayTextTrace;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/debug.js

@@ -1,13 +1,14 @@
-import { Args, Command } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
 import { displayDebugTree } from '#utils/trace_formatter.js';
 import { getTrace } from '#services/trace_reader.js';
 import { handleApiError } from '#utils/error_handler.js';
 export default class WorkflowDebug extends Command {
     static description = 'Get and display workflow execution trace for debugging';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> wf-12345',
-        '<%= config.bin %> <%= command.id %> wf-12345 --json'
+        '<%= config.bin %> <%= command.id %> wf-12345 --format json',
+        '<%= config.bin %> <%= command.id %> wf-12345 --format text'
     ];
     static args = {
         workflowId: Args.string({
@@ -15,23 +16,41 @@ export default class WorkflowDebug extends Command {
             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 } = await this.parse(WorkflowDebug);
-        this.log(`Fetching debug information for workflow: ${args.workflowId}...`);
+        const { args, flags } = await this.parse(WorkflowDebug);
+        const isJsonFormat = flags.format === OUTPUT_FORMAT.JSON;
+        this.conditionalLog(`Fetching debug information for workflow: ${args.workflowId}...`, isJsonFormat);
         const { data: traceData, location } = await getTrace(args.workflowId);
         const source = location.isRemote ? 'remote' : 'local';
-        this.log(`Trace source: ${source}${!location.isRemote ? ` (${location.path})` : ''}`);
-        if (!this.jsonEnabled()) {
-            this.displayTextTrace(traceData);
+        this.conditionalLog(`Trace source: ${source}${!location.isRemote ? ` (${location.path})` : ''}`, isJsonFormat);
+        if (isJsonFormat) {
+            this.outputJson(traceData);
+            return;
         }
-        return traceData;
+        this.displayTextTrace(traceData);
+    }
+    conditionalLog(message, disabled) {
+        if (!disabled) {
+            this.log(message);
+        }
+    }
+    outputJson(data) {
+        this.log(JSON.stringify(data, null, 2));
     }
     displayTextTrace(traceData) {
         this.log('\nTrace Log:');
         this.log('─'.repeat(80));
         this.log(displayDebugTree(traceData));
         this.log('\n' + '─'.repeat(80));
-        this.log('Tip: Use --json for the full untruncated trace');
+        this.log('Tip: Use --format json for the full untruncated trace');
     }
     async catch(error) {
         return handleApiError(error, (...args) => this.error(...args), {

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

@@ -17,10 +17,13 @@ describe('workflow debug command', () => {
             expect(WorkflowDebug).toBeDefined();
             expect(WorkflowDebug.description).toContain('Get and display workflow execution trace for debugging');
             expect(WorkflowDebug.args).toHaveProperty('workflowId');
+            expect(WorkflowDebug.flags).toHaveProperty('format');
         });
-        it('enables the built-in --json flag', async () => {
+        it('should have correct flag configuration', async () => {
             const WorkflowDebug = (await import('./debug.js')).default;
-            expect(WorkflowDebug.enableJsonFlag).toBe(true);
+            // Format flag
+            expect(WorkflowDebug.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowDebug.flags.format.default).toBe('text');
         });
         it('should have correct examples', async () => {
             const WorkflowDebug = (await import('./debug.js')).default;

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

@@ -12,7 +12,6 @@ export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDis
 export declare function formatWorkflowsAsList(workflows: Workflow[]): string;
 export default class WorkflowList extends Command {
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -20,9 +19,7 @@ export default class WorkflowList extends Command {
         detailed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         filter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<{
-        workflows: unknown[];
-    }>;
+    run(): Promise<void>;
     catch(error: Error): Promise<void>;
 }
 export {};

package/dist/commands/workflow/list.js

@@ -6,7 +6,8 @@ import { handleApiError } from '#utils/error_handler.js';
 import { listScenariosForWorkflow } from '#utils/scenario_resolver.js';
 const OUTPUT_FORMAT = {
     LIST: 'list',
-    TABLE: 'table'
+    TABLE: 'table',
+    JSON: 'json'
 };
 export function parseWorkflowForDisplay(workflow) {
     const parsed = parseWorkflowDefinition(workflow);
@@ -73,7 +74,7 @@ export function formatWorkflowsAsList(workflows) {
     return `\nWorkflows:\n\n${lines.join('\n')}`;
 }
 function formatWorkflowsAsJson(workflows) {
-    return {
+    const output = {
         workflows: workflows.map(w => {
             const display = parseWorkflowForDisplay(w);
             return {
@@ -87,8 +88,12 @@ function formatWorkflowsAsJson(workflows) {
             };
         })
     };
+    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);
     }
@@ -96,11 +101,10 @@ function formatWorkflows(workflows, format, detailed) {
 }
 export default class WorkflowList extends Command {
     static description = 'List available workflows from the catalog';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --format table',
-        '<%= config.bin %> <%= command.id %> --json',
+        '<%= config.bin %> <%= command.id %> --format json',
         '<%= config.bin %> <%= command.id %> --detailed',
         '<%= config.bin %> <%= command.id %> --filter simple',
         '<%= config.bin %> <%= command.id %> --catalog my-catalog'
@@ -116,8 +120,8 @@ export default class WorkflowList extends Command {
         }),
         format: Flags.string({
             char: 'f',
-            description: 'Output format (use --json for JSON output)',
-            options: [OUTPUT_FORMAT.LIST, OUTPUT_FORMAT.TABLE],
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.LIST, OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON],
             default: OUTPUT_FORMAT.LIST
         }),
         detailed: Flags.boolean({
@@ -133,20 +137,20 @@ export default class WorkflowList extends Command {
         const { flags } = await this.parse(WorkflowList);
         this.log(flags.catalog ? `Fetching workflow catalog: ${flags.catalog}...` : 'Fetching workflow catalog...');
         const catalogWorkflows = await fetchWorkflowCatalog(flags.catalog);
-        const workflows = flags.filter ?
-            catalogWorkflows.filter(matchName(flags.filter)) :
-            catalogWorkflows;
         if (catalogWorkflows.length === 0) {
             this.log('No workflows found in catalog.');
+            return;
         }
-        else if (workflows.length === 0 && flags.filter) {
+        const workflows = flags.filter ?
+            catalogWorkflows.filter(matchName(flags.filter)) :
+            catalogWorkflows;
+        if (workflows.length === 0 && flags.filter) {
             this.log(`No workflows matching filter: ${flags.filter}`);
+            return;
         }
-        else {
-            this.log(formatWorkflows(workflows, flags.format, flags.detailed));
-            this.log(`\nFound ${workflows.length} workflow(s)`);
-        }
-        return formatWorkflowsAsJson(workflows);
+        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), {

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

@@ -28,8 +28,7 @@ describe('workflow list command', () => {
         });
         it('should have correct flag configuration', async () => {
             const WorkflowList = (await import('./list.js')).default;
-            expect(WorkflowList.enableJsonFlag).toBe(true);
-            expect(WorkflowList.flags.format.options).toEqual(['list', 'table']);
+            expect(WorkflowList.flags.format.options).toEqual(['list', 'table', 'json']);
             expect(WorkflowList.flags.format.default).toBe('list');
             expect(WorkflowList.flags.detailed.default).toBe(false);
         });

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

@@ -1,12 +1,13 @@
 import { Command } from '@oclif/core';
-import { type WorkflowResultResponse } from '#api/generated/api.js';
 export default class WorkflowResult extends Command {
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
-    run(): Promise<WorkflowResultResponse>;
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/result.js

@@ -1,13 +1,14 @@
-import { Args, Command } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
 import { getWorkflowIdResult } from '#api/generated/api.js';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
+import { formatOutput } from '#utils/output_formatter.js';
 import { formatWorkflowResult, ERROR_STATUSES } from '#utils/format_workflow_result.js';
 import { handleApiError } from '#utils/error_handler.js';
 export default class WorkflowResult extends Command {
     static description = 'Get workflow execution result';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> wf-12345',
-        '<%= config.bin %> <%= command.id %> wf-12345 --json'
+        '<%= config.bin %> <%= command.id %> wf-12345 --format json'
     ];
     static args = {
         workflowId: Args.string({
@@ -15,19 +16,27 @@ export default class WorkflowResult extends Command {
             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 } = await this.parse(WorkflowResult);
+        const { args, flags } = await this.parse(WorkflowResult);
         this.log(`Fetching result for workflow: ${args.workflowId}...`);
         const response = await getWorkflowIdResult(args.workflowId);
         if (!response || !response.data) {
             this.error('API returned invalid response', { exit: 1 });
         }
         const data = response.data;
-        this.log(`\n${formatWorkflowResult(data)}`);
+        const output = formatOutput(data, flags.format, formatWorkflowResult);
+        this.log(`\n${output}`);
         if (ERROR_STATUSES.has(data.status)) {
             process.exitCode = 1;
         }
-        return data;
     }
     async catch(error) {
         return handleApiError(error, (...args) => this.error(...args), {

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

@@ -12,10 +12,12 @@ describe('workflow result command', () => {
             expect(WorkflowResult).toBeDefined();
             expect(WorkflowResult.description).toContain('Get workflow execution result');
             expect(WorkflowResult.args).toHaveProperty('workflowId');
+            expect(WorkflowResult.flags).toHaveProperty('format');
         });
-        it('enables the built-in --json flag', async () => {
+        it('should have correct flag configuration', async () => {
             const WorkflowResult = (await import('./result.js')).default;
-            expect(WorkflowResult.enableJsonFlag).toBe(true);
+            expect(WorkflowResult.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowResult.flags.format.default).toBe('text');
         });
     });
 });

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

@@ -1,8 +1,6 @@
 import { Command } from '@oclif/core';
-import { type WorkflowResultResponse } from '#api/generated/api.js';
 export default class WorkflowRun extends Command {
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
@@ -11,7 +9,8 @@ export default class WorkflowRun extends Command {
     static flags: {
         input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<WorkflowResultResponse>;
+    run(): Promise<void>;
     catch(error: Error): Promise<void>;
 }

package/dist/commands/workflow/run.js

@@ -1,5 +1,7 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { postWorkflowRun } from '#api/generated/api.js';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
+import { formatOutput } from '#utils/output_formatter.js';
 import { formatWorkflowResult, ERROR_STATUSES } from '#utils/format_workflow_result.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { resolveInput } from '#utils/resolve_input.js';
@@ -28,10 +30,9 @@ async function executeWorkflow(args) {
 }
 export default class WorkflowRun extends Command {
     static description = 'Execute a workflow synchronously and wait for completion';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple basic_input',
-        '<%= config.bin %> <%= command.id %> simple my_scenario --json',
+        '<%= config.bin %> <%= command.id %> simple my_scenario --format json',
         '<%= 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"}\' --catalog my-catalog'
@@ -59,6 +60,12 @@ export default class WorkflowRun extends Command {
             deprecateAliases: true,
             description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
             env: 'OUTPUT_CATALOG_ID'
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
+            default: OUTPUT_FORMAT.TEXT
         })
     };
     async run() {
@@ -78,11 +85,11 @@ export default class WorkflowRun extends Command {
             this.error('API returned invalid response', { exit: 1 });
         }
         const data = response.data;
-        this.log(`\n${formatWorkflowResult(data)}`);
+        const output = formatOutput(data, flags.format, formatWorkflowResult);
+        this.log(`\n${output}`);
         if (ERROR_STATUSES.has(data.status)) {
             process.exitCode = 1;
         }
-        return data;
     }
     async catch(error) {
         return handleApiError(error, (...args) => this.error(...args), {

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

@@ -26,11 +26,13 @@ describe('workflow run command', () => {
             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('catalog');
         });
         it('should have correct flag configuration', async () => {
             const WorkflowRun = (await import('./run.js')).default;
-            expect(WorkflowRun.enableJsonFlag).toBe(true);
+            expect(WorkflowRun.flags.format.options).toEqual(['json', 'text']);
+            expect(WorkflowRun.flags.format.default).toBe('text');
             expect(WorkflowRun.flags.input.required).toBe(false);
         });
         it('should have optional scenario argument', async () => {

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

@@ -1,8 +1,6 @@
 import { Command } from '@oclif/core';
-import { type WorkflowRun } from '#services/workflow_runs.js';
 export default class WorkflowRunsList extends Command {
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
@@ -12,6 +10,6 @@ export default class WorkflowRunsList extends Command {
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<WorkflowRun[]>;
+    run(): Promise<void>;
     catch(error: Error): Promise<void>;
 }

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

@@ -5,6 +5,7 @@ import { formatDate, formatDurationFromTimestamps } from '#utils/date_formatter.
 import { handleApiError } from '#utils/error_handler.js';
 const OUTPUT_FORMAT = {
     TABLE: 'table',
+    JSON: 'json',
     TEXT: 'text'
 };
 function createRunsTable(runs) {
@@ -36,7 +37,13 @@ function formatRunsAsText(runs) {
         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);
     }
@@ -44,13 +51,12 @@ function formatRuns(runs, format) {
 }
 export default class WorkflowRunsList extends Command {
     static description = 'List workflow runs with optional filtering by workflow type';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> simple',
         '<%= config.bin %> <%= command.id %> simple --limit 10',
         '<%= config.bin %> <%= command.id %> --catalog my-catalog',
-        '<%= config.bin %> <%= command.id %> --json',
+        '<%= config.bin %> <%= command.id %> --format json',
         '<%= config.bin %> <%= command.id %> --format table'
     ];
     static args = {
@@ -72,8 +78,8 @@ export default class WorkflowRunsList extends Command {
         }),
         format: Flags.string({
             char: 'f',
-            description: 'Output format (use --json for JSON output)',
-            options: [OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.TEXT],
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON, OUTPUT_FORMAT.TEXT],
             default: OUTPUT_FORMAT.TABLE
         })
     };
@@ -84,19 +90,17 @@ export default class WorkflowRunsList extends Command {
             catalog: flags.catalog,
             limit: flags.limit
         });
-        if (this.jsonEnabled()) {
-            return runs;
-        }
         if (runs.length === 0) {
             const filterMsg = args.workflowName ? ` for workflow type "${args.workflowName}"` : '';
             this.log(`No workflow runs found${filterMsg}.`);
-            return runs;
+            return;
         }
         const output = formatRuns(runs, flags.format);
         this.log(output);
-        const filterMsg = args.workflowName ? ` of type "${args.workflowName}"` : '';
-        this.log(`\nFound ${count} run(s)${filterMsg}`);
-        return runs;
+        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), {