@outputai/cli 0.8.2-next.c12766f.0 → 0.8.2-next.e1cd79b.0

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

@@ -1,12 +1,13 @@
 import { Command } from '@oclif/core';
-import { WorkflowStatusResponse } from '#api/generated/api.js';
 export default class WorkflowStatus 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<WorkflowStatusResponse>;
+    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/status.js

@@ -1,27 +1,14 @@
-import { Args, Command } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
 import { getWorkflowIdStatus } from '#api/generated/api.js';
+import { OUTPUT_FORMAT } from '#utils/constants.js';
+import { formatOutput } from '#utils/output_formatter.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { normalizeWorkflowStatus } from '#utils/normalize_workflow_status.js';
-function formatStatusText(result) {
-    const lines = [
-        `Workflow ID: ${result.workflowId || 'unknown'}`,
-        `Status: ${result.status || 'unknown'}`,
-        ''
-    ];
-    if (result.startedAt) {
-        lines.push(`Started At: ${new Date(result.startedAt).toISOString()}`);
-    }
-    if (result.completedAt) {
-        lines.push(`Completed At: ${new Date(result.completedAt).toISOString()}`);
-    }
-    return lines.join('\n');
-}
 export default class WorkflowStatus extends Command {
     static description = 'Get workflow execution status';
-    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({
@@ -29,8 +16,16 @@ export default class WorkflowStatus 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(WorkflowStatus);
+        const { args, flags } = await this.parse(WorkflowStatus);
         this.log(`Fetching status for workflow: ${args.workflowId}...`);
         const response = await getWorkflowIdStatus(args.workflowId);
         if (!response || !response.data) {
@@ -41,8 +36,23 @@ export default class WorkflowStatus extends Command {
             ...rawData,
             status: normalizeWorkflowStatus(rawData.status)
         };
-        this.log(`\n${formatStatusText(data)}`);
-        return data;
+        const output = formatOutput(data, flags.format, (result) => {
+            const lines = [
+                `Workflow ID: ${result.workflowId || 'unknown'}`,
+                `Status: ${result.status || 'unknown'}`,
+                ''
+            ];
+            if (result.startedAt) {
+                const startDate = new Date(result.startedAt);
+                lines.push(`Started At: ${startDate.toISOString()}`);
+            }
+            if (result.completedAt) {
+                const completedDate = new Date(result.completedAt);
+                lines.push(`Completed At: ${completedDate.toISOString()}`);
+            }
+            return lines.join('\n');
+        });
+        this.log(`\n${output}`);
     }
     async catch(error) {
         return handleApiError(error, (...args) => this.error(...args), {

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

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

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

@@ -1,9 +1,7 @@
 import { Command } from '@oclif/core';
-import type { EvalOutput } from '@outputai/evals';
 export default class WorkflowTest extends Command {
     static aliases: string[];
     static description: string;
-    static enableJsonFlag: boolean;
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
@@ -12,8 +10,9 @@ export default class WorkflowTest extends Command {
         cached: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         save: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         dataset: 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<EvalOutput>;
+    run(): Promise<void>;
     private ensureEvalWorkflowRegistered;
     private validateDatasets;
     private runWorkflowForDatasets;

package/dist/commands/workflow/test_eval.js

@@ -9,13 +9,12 @@ import { getEvalWorkflowName, renderEvalOutput, computeExitCode, EvalOutputSchem
 export default class WorkflowTest extends Command {
     static aliases = ['workflow:test'];
     static description = 'Run evaluations against a workflow using its datasets';
-    static enableJsonFlag = true;
     static examples = [
         '<%= config.bin %> <%= command.id %> simple',
         '<%= config.bin %> <%= command.id %> simple --cached',
         '<%= config.bin %> <%= command.id %> simple --save',
         '<%= config.bin %> <%= command.id %> simple --dataset basic_input,edge_case',
-        '<%= config.bin %> <%= command.id %> simple --json'
+        '<%= config.bin %> <%= command.id %> simple --format json'
     ];
     static args = {
         workflowName: Args.string({
@@ -37,6 +36,12 @@ export default class WorkflowTest extends Command {
         dataset: Flags.string({
             description: 'Comma-separated list of dataset names to run',
             char: 'd'
+        }),
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: ['json', 'text'],
+            default: 'text'
         })
     };
     async run() {
@@ -67,11 +72,16 @@ export default class WorkflowTest extends Command {
         if (flags.save) {
             await this.saveEvalResults(evalOutput, preparedDatasets, dir);
         }
-        if (!this.jsonEnabled()) {
+        if (flags.format === 'json') {
+            this.log(JSON.stringify(evalOutput, null, 2));
+        }
+        else {
             this.log(renderEvalOutput(evalOutput, evalName));
         }
-        process.exitCode = computeExitCode(evalOutput);
-        return evalOutput;
+        const exitCode = computeExitCode(evalOutput);
+        if (exitCode !== 0) {
+            this.exit(exitCode);
+        }
     }
     async ensureEvalWorkflowRegistered(workflowName, evalName) {
         const catalog = await fetchWorkflowCatalog().catch(() => null);

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.8.2-next.c12766f.0"
+    "framework": "0.8.2-next.e1cd79b.0"
 }

package/dist/hooks/init.d.ts

@@ -2,7 +2,6 @@ import { Hook } from '@oclif/core';
 export declare const INTERACTIVE_FLAGS: string[];
 export declare const GLOBAL_FLAGS: Set<string>;
 export declare const hasInteractiveFlag: (argv: string[]) => boolean;
-export declare const hasJsonFlag: (argv: string[]) => boolean;
 export declare const stripGlobalFlags: (argv: string[]) => void;
 declare const hook: Hook<'init'>;
 export default hook;

package/dist/hooks/init.js

@@ -6,10 +6,6 @@ const debug = debugFactory('output-cli:init');
 export const INTERACTIVE_FLAGS = ['--yes', '--non-interactive'];
 export const GLOBAL_FLAGS = new Set(INTERACTIVE_FLAGS);
 export const hasInteractiveFlag = (argv) => argv.some(arg => INTERACTIVE_FLAGS.includes(arg));
-// The version banner must never reach stdout in JSON mode, where it would
-// corrupt the machine-readable output. oclif only suppresses `this.log` inside
-// the command, not hook output, so we detect `--json` ourselves.
-export const hasJsonFlag = (argv) => argv.includes('--json');
 export const stripGlobalFlags = (argv) => {
     const kept = argv.filter(arg => !GLOBAL_FLAGS.has(arg));
     if (kept.length !== argv.length) {
@@ -23,43 +19,37 @@ const hook = async function (opts) {
     if (interactive) {
         setNonInteractive(true);
     }
-    // Guard only the version-check IO: a broken or unreadable cache must never
-    // block CLI execution, so a failure is treated as "no cached result". Banner
-    // rendering below is intentionally left unguarded — a fault there is a real
-    // bug that should surface, not fail dark.
-    const result = await readCachedResult(this.config.version, this.config.cacheDir)
-        .catch((error) => {
-        debug('Version check failed: %O', error);
-        return null;
-    });
-    if (!result) {
-        spawnBackgroundRefresh(this.config.version, this.config.cacheDir);
-        return;
+    try {
+        // Only the local cache is read here; the registry roundtrip happens in a
+        // detached child so it never delays the invoked command.
+        const result = await readCachedResult(this.config.version, this.config.cacheDir);
+        if (!result) {
+            spawnBackgroundRefresh(this.config.version, this.config.cacheDir);
+            return;
+        }
+        if (!result.updateAvailable) {
+            return;
+        }
+        const border = ux.colorize('dim', '─'.repeat(80));
+        const warning = ux.colorize('yellow', 'Uhoh! Your Output.ai CLI is behind!');
+        const latestVer = ux.colorize('green', `v${result.latestVersion}`);
+        const currentVer = ux.colorize('yellow', `v${result.currentVersion}`);
+        const updateCmd = ux.colorize('cyan', 'npx output update');
+        ux.stdout('');
+        ux.stdout(border);
+        ux.stdout('');
+        ux.stdout(`  ⚠️  ${warning}`);
+        ux.stdout('');
+        ux.stdout(`     Latest is ${latestVer}, and you're using ${currentVer}`);
+        ux.stdout('');
+        ux.stdout(`     Run \`${updateCmd}\` to update`);
+        ux.stdout('');
+        ux.stdout(border);
+        ux.stdout('');
     }
-    if (!result.updateAvailable) {
-        return;
+    catch (error) {
+        // Never block CLI execution
+        debug('Version banner failed: %O', error);
     }
-    // Skip the banner entirely in JSON mode: even on stderr it is pure noise to
-    // a script consuming the command's structured output.
-    if (hasJsonFlag(opts.argv) || hasJsonFlag(process.argv)) {
-        return;
-    }
-    const border = ux.colorize('dim', '─'.repeat(80));
-    const warning = ux.colorize('yellow', 'Uhoh! Your Output.ai CLI is behind!');
-    const latestVer = ux.colorize('green', `v${result.latestVersion}`);
-    const currentVer = ux.colorize('yellow', `v${result.currentVersion}`);
-    const updateCmd = ux.colorize('cyan', 'npx output update');
-    // Advisory notice goes to stderr so stdout stays clean for piping in every mode.
-    ux.stderr('');
-    ux.stderr(border);
-    ux.stderr('');
-    ux.stderr(`  ⚠️  ${warning}`);
-    ux.stderr('');
-    ux.stderr(`     Latest is ${latestVer}, and you're using ${currentVer}`);
-    ux.stderr('');
-    ux.stderr(`     Run \`${updateCmd}\` to update`);
-    ux.stderr('');
-    ux.stderr(border);
-    ux.stderr('');
 };
 export default hook;

package/dist/hooks/init.spec.js

@@ -12,12 +12,11 @@ vi.mock('#utils/interactive.js', () => ({
 vi.mock('@oclif/core', () => ({
     ux: {
         stdout: vi.fn(),
-        stderr: vi.fn(),
         colorize: vi.fn((_color, text) => text)
     }
 }));
 import { ux } from '@oclif/core';
-import hook, { hasInteractiveFlag, hasJsonFlag, stripGlobalFlags } from './init.js';
+import hook, { hasInteractiveFlag, stripGlobalFlags } from './init.js';
 describe('init hook', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -25,7 +24,7 @@ describe('init hook', () => {
     const createHookContext = (version = '0.8.4') => ({
         config: { version, cacheDir: '/tmp/test-cache' }
     });
-    it('should display warning on stderr when cached result says an update is available', async () => {
+    it('should display warning when cached result says an update is available', async () => {
         vi.mocked(readCachedResult).mockResolvedValue({
             updateAvailable: true,
             currentVersion: '0.8.4',
@@ -35,25 +34,13 @@ describe('init hook', () => {
         await hook.call(ctx, { argv: [], id: undefined });
         expect(readCachedResult).toHaveBeenCalledWith('0.8.4', '/tmp/test-cache');
         expect(spawnBackgroundRefresh).not.toHaveBeenCalled();
-        expect(ux.stderr).toHaveBeenCalled();
-        expect(ux.stdout).not.toHaveBeenCalled();
-        const output = vi.mocked(ux.stderr).mock.calls.map(c => c[0]).join('\n');
+        expect(ux.stdout).toHaveBeenCalled();
+        const output = vi.mocked(ux.stdout).mock.calls.map(c => c[0]).join('\n');
         expect(output).toContain('Uhoh');
         expect(output).toContain('v1.0.0');
         expect(output).toContain('v0.8.4');
         expect(output).toContain('npx output update');
     });
-    it('should suppress the warning entirely in JSON mode', async () => {
-        vi.mocked(readCachedResult).mockResolvedValue({
-            updateAvailable: true,
-            currentVersion: '0.8.4',
-            latestVersion: '1.0.0'
-        });
-        const ctx = createHookContext();
-        await hook.call(ctx, { argv: ['--json'], id: undefined });
-        expect(ux.stderr).not.toHaveBeenCalled();
-        expect(ux.stdout).not.toHaveBeenCalled();
-    });
     it('should not display anything when up to date', async () => {
         vi.mocked(readCachedResult).mockResolvedValue({
             updateAvailable: false,
@@ -134,17 +121,6 @@ describe('init hook', () => {
             expect(hasInteractiveFlag([])).toBe(false);
         });
     });
-    describe('hasJsonFlag', () => {
-        it('returns true when --json is present', () => {
-            expect(hasJsonFlag(['workflow', 'runs', 'list', '--json'])).toBe(true);
-        });
-        it('returns false when --json is absent', () => {
-            expect(hasJsonFlag(['workflow', 'runs', 'list', '--format', 'table'])).toBe(false);
-        });
-        it('returns false for an empty argv', () => {
-            expect(hasJsonFlag([])).toBe(false);
-        });
-    });
     describe('stripGlobalFlags', () => {
         it('mutates argv in place to remove global flags', () => {
             const argv = ['init', '--yes', 'foo', '--non-interactive'];

package/dist/utils/constants.d.ts

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

package/dist/utils/constants.js

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

package/dist/utils/format_workflow_result.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { formatWorkflowResult } from './format_workflow_result.js';
+import { formatOutput } from './output_formatter.js';
 describe('formatWorkflowResult', () => {
     it('should display output for completed workflows', () => {
         const result = formatWorkflowResult({
@@ -75,4 +76,16 @@ describe('formatWorkflowResult', () => {
         expect(result).toContain('Status: failed');
         expect(result).not.toContain('Error:');
     });
+    it('should work with formatOutput for json format', () => {
+        const data = {
+            workflowId: 'wf-456',
+            status: 'failed',
+            output: null,
+            error: 'Activity task failed'
+        };
+        const output = formatOutput(data, 'json', formatWorkflowResult);
+        const parsed = JSON.parse(output);
+        expect(parsed.status).toBe('failed');
+        expect(parsed.error).toBe('Activity task failed');
+    });
 });

package/dist/utils/output_formatter.d.ts

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

package/dist/utils/output_formatter.js

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

package/dist/utils/trace_formatter.js

@@ -1,5 +1,6 @@
 import Table from 'cli-table3';
 import { ux } from '@oclif/core';
+import { formatOutput } from '#utils/output_formatter.js';
 import { formatDuration } from '#utils/date_formatter.js';
 import { getErrorMessage } from '#utils/error_utils.js';
 import { isTraceEvent, isValidTimestamp } from '#types/trace.js';
@@ -368,7 +369,7 @@ const formatAsText = (trace) => {
 export function format(traceData, outputFormat = 'text') {
     const trace = typeof traceData === 'string' ? JSON.parse(traceData) : traceData;
     if (outputFormat === 'json') {
-        return JSON.stringify(trace, null, 2);
+        return formatOutput(trace, 'json');
     }
     return formatAsText(trace);
 }