@outputai/cli 0.1.2 → 0.1.3-dev.0

package/dist/utils/scenario_resolver.spec.js

@@ -0,0 +1,214 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { resolveScenarioPath, getScenarioNotFoundMessage, extractWorkflowRelativePath, listScenariosForWorkflow } from './scenario_resolver.js';
+import * as fs from 'node:fs';
+import * as api from '#api/generated/api.js';
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn(),
+    readdirSync: vi.fn()
+}));
+vi.mock('#api/generated/api.js', () => ({
+    getWorkflowCatalog: vi.fn()
+}));
+function mockCatalog(workflows) {
+    vi.mocked(api.getWorkflowCatalog).mockResolvedValue({
+        data: { workflows },
+        status: 200,
+        headers: new Headers()
+    });
+}
+function mockCatalogFailure() {
+    vi.mocked(api.getWorkflowCatalog).mockRejectedValue(new Error('API unavailable'));
+}
+describe('extractWorkflowRelativePath', () => {
+    it('should extract relative path from workflow.js path', () => {
+        expect(extractWorkflowRelativePath('/app/dist/workflows/basic_research/workflow.js'))
+            .toBe('basic_research');
+    });
+    it('should extract nested relative path', () => {
+        expect(extractWorkflowRelativePath('/app/dist/workflows/viz_examples/01_simple_linear/workflow.js'))
+            .toBe('viz_examples/01_simple_linear');
+    });
+    it('should handle workflow.ts extension', () => {
+        expect(extractWorkflowRelativePath('/src/workflows/my_flow/workflow.ts'))
+            .toBe('my_flow');
+    });
+    it('should return null for non-matching paths', () => {
+        expect(extractWorkflowRelativePath('/app/dist/other/workflow.js')).toBeNull();
+        expect(extractWorkflowRelativePath('/app/dist/workflows/')).toBeNull();
+    });
+});
+describe('resolveScenarioPath', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('when API returns workflow with path', () => {
+        it('should resolve scenario using catalog path', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test_scenario.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/my_workflow/scenarios/test_scenario.json');
+        });
+        it('should resolve when workflow name differs from folder name', async () => {
+            mockCatalog([{ name: 'simpleLinear', path: '/app/dist/workflows/viz_examples/01_simple_linear/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/viz_examples/01_simple_linear/scenarios/basic.json');
+            });
+            const result = await resolveScenarioPath('simpleLinear', 'basic', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/viz_examples/01_simple_linear/scenarios/basic.json');
+        });
+        it('should handle nested workflow directories', async () => {
+            mockCatalog([{ name: 'deep_flow', path: '/app/dist/workflows/category/sub/deep_flow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/category/sub/deep_flow/scenarios/test.json');
+            });
+            const result = await resolveScenarioPath('deep_flow', 'test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/category/sub/deep_flow/scenarios/test.json');
+        });
+        it('should return not found when scenario file does not exist', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = await resolveScenarioPath('my_workflow', 'missing', '/project');
+            expect(result.found).toBe(false);
+            expect(result.searchedPaths.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should fall back to convention when catalog path has no scenario but convention does', async () => {
+            mockCatalog([{ name: 'renamedFlow', path: '/app/dist/workflows/actual_folder/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                // Not found at catalog-resolved path, but found at convention path
+                return String(path).includes('src/workflows/renamedFlow/scenarios/test.json');
+            });
+            const result = await resolveScenarioPath('renamedFlow', 'test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/renamedFlow/scenarios/test.json');
+        });
+    });
+    describe('when API is unavailable', () => {
+        it('should fall back to convention-based lookup', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test_scenario.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/my_workflow/scenarios/test_scenario.json');
+        });
+    });
+    describe('when workflow is not in catalog', () => {
+        it('should fall back to convention-based lookup', async () => {
+            mockCatalog([{ name: 'other_workflow', path: '/app/dist/workflows/other/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/my_workflow/scenarios/test.json');
+        });
+    });
+    describe('json extension normalization', () => {
+        it('should handle scenario name with .json extension', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test_scenario.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario.json', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('test_scenario.json');
+            expect(result.path).not.toContain('test_scenario.json.json');
+        });
+    });
+    describe('workflows fallback directory', () => {
+        it('should find scenario in workflows/ fallback path', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('workflows/my_workflow/scenarios/test_scenario.json') &&
+                    !String(path).includes('src/workflows');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('workflows/my_workflow/scenarios/test_scenario.json');
+        });
+    });
+    describe('subdirectory scenarios', () => {
+        it('should support subdirectory paths in scenario name', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/complex/deep_test.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'complex/deep_test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('complex/deep_test.json');
+        });
+    });
+});
+describe('listScenariosForWorkflow', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should return scenario names from scenarios directory', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/my_workflow/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['basic.json', 'advanced.json', 'README.md']);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual(['basic', 'advanced']);
+    });
+    it('should use workflowPath from catalog to derive directory', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/viz_examples/01_simple_linear/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['test.json']);
+        const result = listScenariosForWorkflow('simpleLinear', '/app/dist/workflows/viz_examples/01_simple_linear/workflow.js', '/project');
+        expect(result).toEqual(['test']);
+    });
+    it('should fall back to workflowName when workflowPath is undefined', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/my_workflow/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['scenario_a.json']);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual(['scenario_a']);
+    });
+    it('should fall back to workflowName when path extraction returns null', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/my_workflow/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['test.json']);
+        const result = listScenariosForWorkflow('my_workflow', '/invalid/path.js', '/project');
+        expect(result).toEqual(['test']);
+    });
+    it('should return empty array when no scenarios directory exists', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual([]);
+    });
+    it('should try workflows/ fallback when src/workflows/ does not exist', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => {
+            const p = String(path);
+            return p.includes('workflows/my_workflow/scenarios') && !p.includes('src/workflows');
+        });
+        vi.mocked(fs.readdirSync).mockReturnValue(['fallback.json']);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual(['fallback']);
+    });
+    it('should return empty array for empty scenarios directory', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readdirSync).mockReturnValue([]);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual([]);
+    });
+});
+describe('getScenarioNotFoundMessage', () => {
+    it('should return a helpful error message', () => {
+        const searchedPaths = [
+            '/project/src/workflows/my_workflow/scenarios/test.json',
+            '/project/workflows/my_workflow/scenarios/test.json'
+        ];
+        const message = getScenarioNotFoundMessage('my_workflow', 'test', searchedPaths);
+        expect(message).toContain('Scenario \'test\' not found for workflow \'my_workflow\'');
+        expect(message).toContain('Searched in:');
+        expect(message).toContain(searchedPaths[0]);
+        expect(message).toContain(searchedPaths[1]);
+        expect(message).toContain('Tip:');
+        expect(message).toContain('--input');
+    });
+});

package/dist/utils/secret_sanitizer.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeSecrets(value: unknown): unknown;

package/dist/utils/secret_sanitizer.js

@@ -0,0 +1,29 @@
+import { DeepRedact } from '@hackylabs/deep-redact/index.ts';
+const redactor = new DeepRedact({
+    blacklistedKeys: [
+        /^(.*_)?(secret|password|passwd|credential|private_key)(_.*)?$/i,
+        /^(.*_)?(api_key|apikey|access_key|auth_token)(_.*)?$/i
+    ],
+    stringTests: [
+        {
+            pattern: /sk-[a-zA-Z0-9_-]{20,}/g,
+            replacer: (value, pattern) => value.replace(pattern, 'sk-***REDACTED***')
+        },
+        {
+            pattern: /AKIA[A-Z0-9]{16}/g,
+            replacer: (value, pattern) => value.replace(pattern, 'AKIA***REDACTED***')
+        },
+        {
+            pattern: /eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g,
+            replacer: (value, pattern) => value.replace(pattern, '***JWT_REDACTED***')
+        },
+        {
+            pattern: /Bearer\s+[a-zA-Z0-9_.-]{20,}/g,
+            replacer: (value, pattern) => value.replace(pattern, 'Bearer ***REDACTED***')
+        }
+    ],
+    serialize: false
+});
+export function sanitizeSecrets(value) {
+    return redactor.redact(value);
+}

package/dist/utils/sleep.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolves after the given delay in milliseconds.
+ * @param ms - Delay in milliseconds
+ */
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/utils/sleep.js

@@ -0,0 +1,5 @@
+/**
+ * Resolves after the given delay in milliseconds.
+ * @param ms - Delay in milliseconds
+ */
+export const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

package/dist/utils/template.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Process a template string with variables
+ */
+export declare function processTemplate(templateContent: string, variables: Record<string, string>): string;
+/**
+ * Prepare template variables from workflow name and description
+ */
+export declare function prepareTemplateVariables(workflowName: string, description: string): Record<string, string>;
+export { camelCase, pascalCase } from 'change-case';

package/dist/utils/template.js

@@ -0,0 +1,30 @@
+import Handlebars from 'handlebars';
+import { camelCase, pascalCase } from 'change-case';
+/**
+ * Create a Handlebars compiler with custom helpers
+ */
+function createCompiler() {
+    const compiler = Handlebars.create();
+    compiler.registerHelper('camelCase', (str) => camelCase(str));
+    compiler.registerHelper('pascalCase', (str) => pascalCase(str));
+    return compiler;
+}
+/**
+ * Process a template string with variables
+ */
+export function processTemplate(templateContent, variables) {
+    const compiler = createCompiler();
+    const template = compiler.compile(templateContent);
+    return template(variables);
+}
+/**
+ * Prepare template variables from workflow name and description
+ */
+export function prepareTemplateVariables(workflowName, description) {
+    return {
+        workflowName: camelCase(workflowName),
+        WorkflowName: pascalCase(workflowName),
+        description: description || `A ${workflowName} workflow`
+    };
+}
+export { camelCase, pascalCase } from 'change-case';

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

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

package/dist/utils/template.spec.js

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { camelCase, pascalCase, processTemplate, prepareTemplateVariables } from './template.js';
+describe('Template Utilities', () => {
+    describe('pascalCase', () => {
+        it('should convert kebab-case to PascalCase', () => {
+            expect(pascalCase('my-workflow-name')).toBe('MyWorkflowName');
+        });
+        it('should convert snake_case to PascalCase', () => {
+            expect(pascalCase('my_workflow_name')).toBe('MyWorkflowName');
+        });
+        it('should handle single word', () => {
+            expect(pascalCase('workflow')).toBe('Workflow');
+        });
+        it('should handle mixed separators', () => {
+            expect(pascalCase('my-workflow_name')).toBe('MyWorkflowName');
+        });
+    });
+    describe('camelCase', () => {
+        it('should convert kebab-case to camelCase', () => {
+            expect(camelCase('my-workflow-name')).toBe('myWorkflowName');
+        });
+        it('should convert snake_case to camelCase', () => {
+            expect(camelCase('my_workflow_name')).toBe('myWorkflowName');
+        });
+        it('should handle single word', () => {
+            expect(camelCase('workflow')).toBe('workflow');
+        });
+    });
+    describe('processTemplate', () => {
+        it('should replace single variable', () => {
+            const template = 'Hello {{name}}!';
+            const variables = { name: 'World' };
+            expect(processTemplate(template, variables)).toBe('Hello World!');
+        });
+        it('should replace multiple variables', () => {
+            const template = 'Workflow {{workflowName}} - {{description}}';
+            const variables = {
+                workflowName: 'myWorkflow',
+                description: 'A test workflow'
+            };
+            expect(processTemplate(template, variables))
+                .toBe('Workflow myWorkflow - A test workflow');
+        });
+        it('should replace multiple occurrences of same variable', () => {
+            const template = '{{name}} says hello to {{name}}';
+            const variables = { name: 'Alice' };
+            expect(processTemplate(template, variables))
+                .toBe('Alice says hello to Alice');
+        });
+        it('should use Handlebars helpers for case transformations', () => {
+            const template = '{{camelCase name}} and {{pascalCase name}}';
+            const variables = { name: 'my-workflow-name' };
+            expect(processTemplate(template, variables))
+                .toBe('myWorkflowName and MyWorkflowName');
+        });
+        it('should preserve escaped curly braces for Liquid.js examples', () => {
+            const template = 'Use Liquid: \\{{ variable }} and {% if %}...{% endif %}';
+            const variables = {};
+            expect(processTemplate(template, variables))
+                .toBe('Use Liquid: {{ variable }} and {% if %}...{% endif %}');
+        });
+    });
+    describe('prepareTemplateVariables', () => {
+        it('should prepare variables from workflow name and description', () => {
+            const variables = prepareTemplateVariables('my-test-workflow', 'A test workflow for testing');
+            expect(variables).toEqual({
+                workflowName: 'myTestWorkflow',
+                WorkflowName: 'MyTestWorkflow',
+                description: 'A test workflow for testing'
+            });
+        });
+        it('should provide default description if not provided', () => {
+            const variables = prepareTemplateVariables('test-workflow', '');
+            expect(variables.description).toBe('A test-workflow workflow');
+        });
+    });
+});

package/dist/utils/trace_extractor.d.ts

@@ -0,0 +1,27 @@
+export interface ExtractedDataset {
+    input: Record<string, unknown>;
+    output: unknown;
+    executionTimeMs?: number;
+}
+interface TraceFile {
+    input?: unknown;
+    output?: unknown;
+    startedAt?: number;
+    endedAt?: number;
+    duration?: number;
+    root?: {
+        startTime?: number;
+        endTime?: number;
+        duration?: number;
+    };
+    events?: Array<{
+        phase: string;
+        details?: unknown;
+    }>;
+    children?: Array<{
+        input?: unknown;
+        output?: unknown;
+    }>;
+}
+export declare function extractDatasetFromTrace(traceData: TraceFile): ExtractedDataset;
+export {};

package/dist/utils/trace_extractor.js

@@ -0,0 +1,53 @@
+function isRecord(value) {
+    return value !== null && value !== undefined && typeof value === 'object';
+}
+function unwrapOutput(output) {
+    if (isRecord(output) && 'output' in output && 'trace' in output) {
+        return output.output;
+    }
+    return output;
+}
+function findInput(trace) {
+    if (isRecord(trace.input)) {
+        return trace.input;
+    }
+    const startEvent = trace.events?.find(e => e.phase === 'start');
+    const eventInput = startEvent?.details?.input;
+    if (isRecord(eventInput)) {
+        return eventInput;
+    }
+    const childInput = trace.children?.[0]?.input;
+    return isRecord(childInput) ? childInput : undefined;
+}
+function findOutput(trace) {
+    if (trace.output !== undefined) {
+        return unwrapOutput(trace.output);
+    }
+    const endEvent = trace.events ?
+        [...trace.events].reverse().find(e => e.phase === 'end') :
+        undefined;
+    const eventOutput = endEvent?.details?.output;
+    if (eventOutput !== undefined) {
+        return unwrapOutput(eventOutput);
+    }
+    const childOutput = trace.children?.[0]?.output;
+    return childOutput !== undefined ? unwrapOutput(childOutput) : undefined;
+}
+function computeExecutionTime(trace) {
+    if (trace.startedAt && trace.endedAt) {
+        return trace.endedAt - trace.startedAt;
+    }
+    if (trace.root?.startTime && trace.root?.endTime) {
+        return trace.root.endTime - trace.root.startTime;
+    }
+    return trace.duration ?? trace.root?.duration ?? undefined;
+}
+export function extractDatasetFromTrace(traceData) {
+    const input = findInput(traceData);
+    if (!input) {
+        throw new Error('Could not extract input from trace data. Trace may be incomplete.');
+    }
+    const output = findOutput(traceData);
+    const executionTimeMs = computeExecutionTime(traceData);
+    return { input, output, executionTimeMs };
+}

package/dist/utils/trace_formatter.d.ts

@@ -0,0 +1,11 @@
+import { formatDuration } from '#utils/date_formatter.js';
+export { formatDuration };
+export declare function format(traceData: string | object, outputFormat?: 'json' | 'text'): string;
+export declare function getSummary(traceData: string | object): {
+    totalDuration: number;
+    totalEvents: number;
+    totalSteps: number;
+    totalActivities: number;
+    hasErrors: boolean;
+};
+export declare function displayDebugTree(node: unknown): string;