@outputai/cli 0.1.2-dev.0 → 0.1.2

package/dist/utils/scenario_resolver.spec.js

@@ -1,214 +0,0 @@
-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

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

package/dist/utils/secret_sanitizer.js

@@ -1,29 +0,0 @@
-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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,30 +0,0 @@
-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

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

package/dist/utils/template.spec.js

@@ -1,77 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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;