@outputai/cli 0.1.3 → 0.1.4-dev.0

package/dist/utils/format_workflow_result.spec.js

@@ -0,0 +1,81 @@
+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({
+            workflowId: 'wf-123',
+            status: 'completed',
+            output: { values: [1, 2, 3] },
+            error: null
+        });
+        expect(result).toContain('Workflow ID: wf-123');
+        expect(result).toContain('Output:');
+        expect(result).toContain('"values"');
+        expect(result).not.toContain('Status:');
+    });
+    it('should display error details for failed workflows', () => {
+        const result = formatWorkflowResult({
+            workflowId: 'wf-456',
+            status: 'failed',
+            output: null,
+            error: 'Activity task failed'
+        });
+        expect(result).toContain('Workflow ID: wf-456');
+        expect(result).toContain('Status: failed');
+        expect(result).toContain('Error: Activity task failed');
+        expect(result).not.toContain('Output:');
+    });
+    it('should display status for terminated workflows', () => {
+        const result = formatWorkflowResult({
+            workflowId: 'wf-term',
+            status: 'terminated',
+            output: null,
+            error: 'Workflow terminated by user'
+        });
+        expect(result).toContain('Status: terminated');
+        expect(result).toContain('Error: Workflow terminated by user');
+    });
+    it('should display status for canceled workflows', () => {
+        const result = formatWorkflowResult({
+            workflowId: 'wf-cancel',
+            status: 'canceled',
+            output: null,
+            error: 'Workflow was canceled'
+        });
+        expect(result).toContain('Status: canceled');
+        expect(result).toContain('Error: Workflow was canceled');
+    });
+    it('should display status without error line for continued workflows', () => {
+        const result = formatWorkflowResult({
+            workflowId: 'wf-cont',
+            status: 'continued',
+            output: null,
+            error: null
+        });
+        expect(result).toContain('Status: continued');
+        expect(result).not.toContain('Error:');
+    });
+    it('should omit error line when error is null on failed workflow', () => {
+        const result = formatWorkflowResult({
+            workflowId: 'wf-789',
+            status: 'failed',
+            output: null,
+            error: null
+        });
+        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/framework_version.d.ts

@@ -0,0 +1,4 @@
+export interface FrameworkVersion {
+    framework: string;
+}
+export declare function getFrameworkVersion(): Promise<FrameworkVersion>;

package/dist/utils/framework_version.js

@@ -0,0 +1,4 @@
+import frameworkVersion from '../generated/framework_version.json' with { type: 'json' };
+export async function getFrameworkVersion() {
+    return frameworkVersion;
+}

package/dist/utils/framework_version.spec.d.ts

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

package/dist/utils/framework_version.spec.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import { getFrameworkVersion } from './framework_version.js';
+describe('getFrameworkVersion', () => {
+    it('should return the framework version', async () => {
+        const version = await getFrameworkVersion();
+        expect(version).toHaveProperty('framework');
+    });
+    it('should return version in semver format', async () => {
+        const version = await getFrameworkVersion();
+        const semverPattern = /^\d+\.\d+\.\d+$/;
+        expect(version.framework).toMatch(semverPattern);
+    });
+});

package/dist/utils/header_utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read, extract and parse the value from "Retry-After" header from Fetch's Response Headers object.
+ * - If provided as string number, convert it to milliseconds.
+ * - If provided as date, subtracts the current date and return the difference in milliseconds.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Retry-After}
+ * @param value - The HTTP Response Headers object
+ * @returns Delay in ms or or null if not parseable
+ */
+export declare function getRetryDelayFromResponse(response: {
+    headers?: Headers;
+}): number | null;

package/dist/utils/header_utils.js

@@ -0,0 +1,29 @@
+/**
+ * Read, extract and parse the value from "Retry-After" header from Fetch's Response Headers object.
+ * - If provided as string number, convert it to milliseconds.
+ * - If provided as date, subtracts the current date and return the difference in milliseconds.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Retry-After}
+ * @param value - The HTTP Response Headers object
+ * @returns Delay in ms or or null if not parseable
+ */
+export function getRetryDelayFromResponse(response) {
+    if (!response.headers || !response.headers.has('retry-after')) {
+        return null;
+    }
+    const value = response.headers.get('retry-after');
+    // test if it is number
+    if (/^\d+$/.test(value)) {
+        return Number(value) * 1000;
+    }
+    // test if has letters: RFC 1123 (IMF-fixdate), RFC 850 or ANSI C asctime()
+    if (/[a-z]/i.test(value)) {
+        const date = new Date(value);
+        if (Number.isNaN(date.valueOf())) {
+            return null;
+        }
+        const delta = date.getTime() - Date.now();
+        return Math.max(delta, 0);
+    }
+    return null;
+}

package/dist/utils/header_utils.spec.d.ts

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

package/dist/utils/header_utils.spec.js

@@ -0,0 +1,52 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { getRetryDelayFromResponse } from './header_utils.js';
+/** Builds a response-like object with optional Retry-After header. */
+const buildResponse = (retryAfter) => retryAfter !== null ?
+    { headers: new Headers({ 'Retry-After': retryAfter }) } :
+    { headers: new Headers() };
+describe('getRetryDelayFromResponse', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2025-02-25T12:00:00.000Z'));
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe('delay-seconds (integer)', () => {
+        it('returns ms for positive integer seconds', () => {
+            expect(getRetryDelayFromResponse(buildResponse('0'))).toBe(0);
+            expect(getRetryDelayFromResponse(buildResponse('1'))).toBe(1000);
+            expect(getRetryDelayFromResponse(buildResponse('120'))).toBe(120_000);
+        });
+        it('returns null for negative integer', () => {
+            expect(getRetryDelayFromResponse(buildResponse('-1'))).toBeNull();
+        });
+        it('returns null for non-integer number', () => {
+            expect(getRetryDelayFromResponse(buildResponse('12.34'))).toBeNull();
+        });
+    });
+    describe('HTTP-date', () => {
+        it('returns 0 when date is in the past', () => {
+            expect(getRetryDelayFromResponse(buildResponse('Wed, 21 Oct 2015 07:28:00 GMT'))).toBe(0);
+        });
+        it('returns ms until future date', () => {
+            const future = 'Tue, 25 Feb 2025 12:00:02 GMT';
+            expect(getRetryDelayFromResponse(buildResponse(future))).toBe(2000);
+        });
+    });
+    describe('invalid or missing header', () => {
+        it('returns null for empty string', () => {
+            expect(getRetryDelayFromResponse(buildResponse(''))).toBeNull();
+        });
+        it('returns null for non-numeric non-date string', () => {
+            expect(getRetryDelayFromResponse(buildResponse('invalid'))).toBeNull();
+            expect(getRetryDelayFromResponse(buildResponse('abc123'))).toBeNull();
+        });
+        it('returns null when Retry-After header is absent', () => {
+            expect(getRetryDelayFromResponse(buildResponse(null))).toBeNull();
+        });
+        it('returns null when response has no headers property', () => {
+            expect(getRetryDelayFromResponse({})).toBeNull();
+        });
+    });
+});

package/dist/utils/input_parser.d.ts

@@ -0,0 +1 @@
+export declare function parseInputFlag(input: string): unknown;

package/dist/utils/input_parser.js

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs';
+export function parseInputFlag(input) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        try {
+            const fileContent = readFileSync(input, 'utf-8');
+            return JSON.parse(fileContent);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                throw new Error(`Input file not found: ${input}`);
+            }
+            throw new Error(`Invalid JSON input: ${err.message}`);
+        }
+    }
+}

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/paths.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Template directory paths
+ */
+export declare const TEMPLATE_DIRS: {
+    readonly workflow: string;
+    readonly agent_instructions: string;
+};
+/**
+ * Default output directories
+ */
+export declare const DEFAULT_OUTPUT_DIRS: {
+    readonly workflows: "src/workflows";
+};
+/**
+ * Resolve the output directory path
+ */
+export declare function resolveOutputDir(outputDir: string): string;
+/**
+ * Create target directory path for a workflow
+ */
+export declare function createTargetDir(outputDir: string, workflowName: string): string;
+/**
+ * Get the template directory for a specific template type
+ */
+export declare function getTemplateDir(templateType: keyof typeof TEMPLATE_DIRS): string;

package/dist/utils/paths.js

@@ -0,0 +1,36 @@
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Template directory paths
+ */
+export const TEMPLATE_DIRS = {
+    workflow: path.join(__dirname, '..', 'templates', 'workflow'),
+    agent_instructions: path.join(__dirname, '..', 'templates', 'agent_instructions')
+};
+/**
+ * Default output directories
+ */
+export const DEFAULT_OUTPUT_DIRS = {
+    workflows: 'src/workflows'
+};
+/**
+ * Resolve the output directory path
+ */
+export function resolveOutputDir(outputDir) {
+    return path.resolve(process.cwd(), outputDir);
+}
+/**
+ * Create target directory path for a workflow
+ */
+export function createTargetDir(outputDir, workflowName) {
+    const resolvedOutputDir = resolveOutputDir(outputDir);
+    return path.join(resolvedOutputDir, workflowName);
+}
+/**
+ * Get the template directory for a specific template type
+ */
+export function getTemplateDir(templateType) {
+    return TEMPLATE_DIRS[templateType];
+}

package/dist/utils/process.d.ts

@@ -0,0 +1,4 @@
+export declare function executeCommand(command: string, args: string[], cwd: string): Promise<{
+    stderr: string[];
+}>;
+export declare function executeCommandWithMessages(command: () => Promise<void>, startMessage: string, successMessage: string): Promise<boolean>;

package/dist/utils/process.js

@@ -0,0 +1,50 @@
+import { spawn } from 'node:child_process';
+import { ux } from '@oclif/core';
+import debugFactory from 'debug';
+import { getErrorMessage } from './error_utils.js';
+const debug = debugFactory('output-cli:process');
+export async function executeCommand(command, args, cwd) {
+    const stderrLines = [];
+    const proc = spawn(command, args, { cwd });
+    const handleStdout = (data) => {
+        const line = data.toString().trim();
+        if (line) {
+            debug(line);
+        }
+    };
+    const handleStderr = (data) => {
+        const line = data.toString().trim();
+        if (line) {
+            stderrLines.push(line);
+            debug(line);
+        }
+    };
+    proc.stdout.on('data', handleStdout);
+    proc.stderr.on('data', handleStderr);
+    return new Promise((resolve, reject) => {
+        proc.on('error', (error) => {
+            reject(new Error(`Failed to run ${command}: ${error.message}`));
+        });
+        proc.on('exit', (code) => {
+            if (code !== 0) {
+                reject(new Error(`${command} exited with code ${code || 'unknown'}`));
+            }
+            else {
+                resolve({ stderr: stderrLines });
+            }
+        });
+    });
+}
+export async function executeCommandWithMessages(command, startMessage, successMessage) {
+    try {
+        ux.stdout(startMessage);
+        await command();
+        ux.stdout(successMessage);
+        return true;
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        ux.warn(`⚠️  ${message}`);
+        return false;
+    }
+}

package/dist/utils/resolve_input.d.ts

@@ -0,0 +1 @@
+export declare function resolveInput(workflowName: string, scenario: string | undefined, inputFlag: string | undefined, commandName: string): Promise<unknown>;

package/dist/utils/resolve_input.js

@@ -0,0 +1,22 @@
+import { ux } from '@oclif/core';
+import { parseInputFlag } from '#utils/input_parser.js';
+import { resolveScenarioPath, getScenarioNotFoundMessage } from '#utils/scenario_resolver.js';
+export async function resolveInput(workflowName, scenario, inputFlag, commandName) {
+    if (inputFlag && scenario) {
+        return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
+    }
+    if (inputFlag) {
+        return parseInputFlag(inputFlag);
+    }
+    if (scenario) {
+        const resolution = await resolveScenarioPath(workflowName, scenario);
+        if (!resolution.found) {
+            return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
+        }
+        ux.stdout(`Using scenario: ${resolution.path}\n`);
+        return parseInputFlag(resolution.path);
+    }
+    return ux.error('Input required. Provide either:\n' +
+        `  - A scenario name: output workflow ${commandName} <workflow> <scenario>\n` +
+        `  - An input flag: output workflow ${commandName} <workflow> --input <json-or-file>`, { exit: 1 });
+}

package/dist/utils/scenario_resolver.d.ts

@@ -0,0 +1,9 @@
+export interface ScenarioResolutionResult {
+    found: boolean;
+    path?: string;
+    searchedPaths: string[];
+}
+export declare function extractWorkflowRelativePath(path: string): string | null;
+export declare function resolveScenarioPath(workflowName: string, scenarioName: string, basePath?: string): Promise<ScenarioResolutionResult>;
+export declare function listScenariosForWorkflow(workflowName: string, workflowPath?: string, basePath?: string): string[];
+export declare function getScenarioNotFoundMessage(workflowName: string, scenarioName: string, searchedPaths: string[]): string;

package/dist/utils/scenario_resolver.js

@@ -0,0 +1,93 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getWorkflowCatalog } from '#api/generated/api.js';
+const SCENARIOS_DIR = 'scenarios';
+const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
+export function extractWorkflowRelativePath(path) {
+    const match = path.match(/workflows\/(.+)\/workflow\.[jt]s$/);
+    return match ? match[1] : null;
+}
+async function fetchWorkflowDirectory(workflowName) {
+    try {
+        const response = await getWorkflowCatalog();
+        const data = response?.data;
+        const workflows = data?.workflows;
+        if (!workflows) {
+            return null;
+        }
+        const workflow = workflows.find(w => w.name === workflowName);
+        if (!workflow) {
+            return null;
+        }
+        const workflowPath = workflow.path;
+        if (!workflowPath) {
+            return null;
+        }
+        return extractWorkflowRelativePath(workflowPath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveScenarioFromDirectory(relativeDir, scenarioFileName, basePath) {
+    const searchedPaths = [];
+    for (const workflowsDir of WORKFLOWS_PATHS) {
+        const candidatePath = resolve(basePath, workflowsDir, relativeDir, SCENARIOS_DIR, scenarioFileName);
+        searchedPaths.push(candidatePath);
+        if (existsSync(candidatePath)) {
+            return { found: true, path: candidatePath, searchedPaths };
+        }
+    }
+    return { found: false, searchedPaths };
+}
+export async function resolveScenarioPath(workflowName, scenarioName, basePath = process.cwd()) {
+    const scenarioFileName = scenarioName.endsWith('.json') ?
+        scenarioName :
+        `${scenarioName}.json`;
+    const catalogDir = await fetchWorkflowDirectory(workflowName);
+    if (catalogDir) {
+        const result = resolveScenarioFromDirectory(catalogDir, scenarioFileName, basePath);
+        if (result.found) {
+            return result;
+        }
+        // Catalog resolved but scenario not found at that path — still try convention fallback
+        // in case the catalog path differs from local source layout
+        if (catalogDir !== workflowName) {
+            const fallback = resolveScenarioFromDirectory(workflowName, scenarioFileName, basePath);
+            return {
+                found: fallback.found,
+                path: fallback.path,
+                searchedPaths: [...result.searchedPaths, ...fallback.searchedPaths]
+            };
+        }
+        return result;
+    }
+    // API unavailable or workflow not in catalog — fall back to convention
+    return resolveScenarioFromDirectory(workflowName, scenarioFileName, basePath);
+}
+export function listScenariosForWorkflow(workflowName, workflowPath, basePath = process.cwd()) {
+    const relativeDir = (workflowPath && extractWorkflowRelativePath(workflowPath)) || workflowName;
+    for (const workflowsDir of WORKFLOWS_PATHS) {
+        const scenariosDir = resolve(basePath, workflowsDir, relativeDir, SCENARIOS_DIR);
+        if (existsSync(scenariosDir)) {
+            return readdirSync(scenariosDir)
+                .filter(f => f.endsWith('.json'))
+                .map(f => f.replace(/\.json$/, ''));
+        }
+    }
+    return [];
+}
+export function getScenarioNotFoundMessage(workflowName, scenarioName, searchedPaths) {
+    const pathsList = searchedPaths.map(p => `  - ${p}`).join('\n');
+    return [
+        `Scenario '${scenarioName}' not found for workflow '${workflowName}'.`,
+        '',
+        'Searched in:',
+        pathsList,
+        '',
+        'Tip: Create a scenario file in your workflow\'s scenarios/ directory.',
+        '',
+        'Or use --input to specify a custom path:',
+        `  output workflow run ${workflowName} --input /path/to/input.json`
+    ].join('\n');
+}

package/dist/utils/scenario_resolver.spec.d.ts

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