@outputai/cli 0.1.4-dev.0 → 0.1.4

package/dist/utils/trace_formatter.js

@@ -1,402 +0,0 @@
-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';
-export { formatDuration };
-const TRUNCATION = {
-    SHORT: 50,
-    STANDARD: 120,
-    SUFFIX: '...',
-    SUFFIX_VERBOSE: '... (truncated)'
-};
-const TREE_CHARS = {
-    BRANCH: '├─ ',
-    LAST: '└─ ',
-    VERTICAL: '│  ',
-    SPACE: '   ',
-    DETAIL_BRANCH: '│    ',
-    DETAIL_LAST: '     '
-};
-const HEADER_DIVIDER = '═'.repeat(60);
-const colors = {
-    workflowHeader: (text) => ux.colorize('bold', ux.colorize('cyan', text)),
-    stepHeader: (text) => ux.colorize('yellow', text),
-    internalStep: (text) => ux.colorize('dim', text),
-    label: (text) => ux.colorize('blue', text),
-    error: (text) => ux.colorize('red', text),
-    success: (text) => ux.colorize('green', text)
-};
-const truncate = (value, maxLength = TRUNCATION.STANDARD, suffix = TRUNCATION.SUFFIX_VERBOSE, recursive = false) => {
-    if (value === null || value === undefined) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        if (value.length <= maxLength) {
-            return value;
-        }
-        return `${value.substring(0, maxLength)}${suffix}`;
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-        if (recursive) {
-            return value;
-        }
-        return String(value);
-    }
-    if (!recursive) {
-        const str = JSON.stringify(value);
-        if (str.length <= maxLength) {
-            return str;
-        }
-        return `${str.substring(0, maxLength)}${suffix}`;
-    }
-    if (Array.isArray(value)) {
-        return value.map(item => truncate(item, maxLength, suffix, true));
-    }
-    if (typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, truncate(v, maxLength, suffix, true)]));
-    }
-    return value;
-};
-const truncateShort = (value) => {
-    return truncate(value, TRUNCATION.SHORT, TRUNCATION.SUFFIX, false);
-};
-const truncateRecursive = (value) => {
-    return truncate(value, TRUNCATION.STANDARD, TRUNCATION.SUFFIX_VERBOSE, true);
-};
-const formatPhase = (phase) => {
-    const phaseMap = {
-        start: '[START]',
-        end: '[END]',
-        error: '[ERROR]'
-    };
-    return phaseMap[phase] ?? phase;
-};
-const getNodeName = (node) => {
-    return node.name || node.workflowName || node.stepName || node.activityName || '';
-};
-const getNodeKind = (node) => {
-    return node.kind || node.type || '';
-};
-const getEventName = (event) => {
-    const { kind, workflowName, details } = event;
-    if (kind === 'workflow') {
-        return `Workflow: ${workflowName}`;
-    }
-    if (kind === 'activity') {
-        return `Activity: ${details?.activityName || 'unknown'}`;
-    }
-    if (kind === 'step') {
-        return `Step: ${details?.stepName || details?.name || 'unknown'}`;
-    }
-    return kind || 'Unknown Event';
-};
-const colorizeByKind = (kind, text) => {
-    if (kind === 'workflow') {
-        return colors.workflowHeader(text);
-    }
-    if (kind === 'internal_step') {
-        return colors.internalStep(text);
-    }
-    if (kind === 'step' || kind === 'activity') {
-        return colors.stepHeader(text);
-    }
-    return text;
-};
-const getStatusIndicator = (node) => {
-    if (node.phase === 'error' || node.status === 'failed') {
-        return colors.error('[FAILED]');
-    }
-    if (node.phase === 'end' || node.status === 'completed') {
-        return colors.success('[COMPLETED]');
-    }
-    if (node.status === 'running') {
-        return colors.label('[RUNNING]');
-    }
-    return '';
-};
-const getDebugNodeInfo = (node) => {
-    if (typeof node === 'string') {
-        return node;
-    }
-    if (typeof node !== 'object' || node === null) {
-        return String(node);
-    }
-    const debugNode = node;
-    const kind = getNodeKind(debugNode);
-    const name = getNodeName(debugNode);
-    const status = getStatusIndicator(debugNode);
-    const parts = [];
-    if (kind) {
-        parts.push(colorizeByKind(kind, `[${kind}]`));
-    }
-    if (name) {
-        parts.push(colorizeByKind(kind, name));
-    }
-    if (status) {
-        parts.push(status);
-    }
-    if (parts.length === 0) {
-        const keys = Object.keys(debugNode).filter(k => k !== 'children' && k !== 'parent');
-        if (keys.length > 0) {
-            return `Node {${keys.slice(0, 3).join(', ')}${keys.length > 3 ? ', ...' : ''}}`;
-        }
-        return 'Node';
-    }
-    return parts.join(' ');
-};
-const extractNodeInfo = (node) => {
-    if (isTraceEvent(node)) {
-        return {
-            name: getEventName(node),
-            phase: formatPhase(node.phase),
-            duration: node.duration ? ` (${formatDuration(node.duration)})` : ''
-        };
-    }
-    return {
-        name: getDebugNodeInfo(node),
-        phase: node.phase ? formatPhase(node.phase) : '',
-        duration: node.duration ? ` (${formatDuration(node.duration)})` : ''
-    };
-};
-const formatDetails = (details) => {
-    if (!details) {
-        return '-';
-    }
-    if (typeof details === 'string') {
-        return details;
-    }
-    const info = [];
-    if (details.input) {
-        info.push(`Input: ${truncateShort(details.input)}`);
-    }
-    if (details.output) {
-        info.push(`Output: ${truncateShort(details.output)}`);
-    }
-    if (details.activityName) {
-        info.push(`Activity: ${details.activityName}`);
-    }
-    if (details.stepName || details.name) {
-        info.push(`Step: ${details.stepName || details.name}`);
-    }
-    if (info.length > 0) {
-        return info.join(', ');
-    }
-    return truncateShort(details);
-};
-const formatTreeDetails = (details, depth) => {
-    const indent = '  '.repeat(depth);
-    const lines = [];
-    if (details.input !== null && details.input !== undefined) {
-        lines.push(`${indent}Input: ${truncateShort(details.input)}`);
-    }
-    if (details.output !== null && details.output !== undefined) {
-        lines.push(`${indent}Output: ${truncateShort(details.output)}`);
-    }
-    return lines;
-};
-const formatValueWithIndent = (value, indentPrefix) => {
-    if (value === null || value === undefined) {
-        return String(value);
-    }
-    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        return truncate(value, TRUNCATION.STANDARD, TRUNCATION.SUFFIX_VERBOSE, false);
-    }
-    const truncated = truncateRecursive(value);
-    const jsonStr = JSON.stringify(truncated, null, 2);
-    const lines = jsonStr.split('\n');
-    if (lines.length <= 1) {
-        return jsonStr;
-    }
-    return lines.map((line, i) => {
-        if (i === 0) {
-            return line;
-        }
-        return indentPrefix + line;
-    }).join('\n');
-};
-const formatHeader = (root) => {
-    const isTrace = isTraceEvent(root);
-    const debugRoot = root;
-    const workflowName = isTrace ? root.workflowName : (getNodeName(debugRoot) || 'Unknown');
-    const workflowId = isTrace ? root.workflowId : 'N/A';
-    const timestamp = isTrace ? root.timestamp : debugRoot.startTime;
-    const phase = isTrace ? root.phase : debugRoot.phase;
-    const status = !isTrace ? debugRoot.status : undefined;
-    const lines = [
-        HEADER_DIVIDER,
-        `Workflow: ${workflowName}`,
-        `Workflow ID: ${workflowId}`
-    ];
-    if (isValidTimestamp(timestamp)) {
-        lines.push(`Start Time: ${new Date(timestamp).toISOString()}`);
-    }
-    if (root.duration) {
-        lines.push(`Duration: ${formatDuration(root.duration)}`);
-    }
-    if ((phase === 'error' || status === 'failed') && root.error) {
-        lines.push('Status: Failed', `Error: ${getErrorMessage(root.error)}`);
-    }
-    else if (phase === 'end' || status === 'completed') {
-        lines.push('Status: Completed');
-    }
-    else {
-        lines.push('Status: In Progress');
-    }
-    lines.push(HEADER_DIVIDER);
-    return lines.join('\n');
-};
-const formatEventsTable = (events) => {
-    const table = new Table({
-        head: ['Time', 'Event', 'Phase', 'Duration', 'Details'],
-        style: { head: ['cyan'] },
-        colWidths: [20, 25, 10, 12, null],
-        wordWrap: true
-    });
-    for (const event of events) {
-        table.push([
-            new Date(event.timestamp).toISOString().substring(11, 23),
-            getEventName(event),
-            formatPhase(event.phase),
-            event.duration ? formatDuration(event.duration) : '-',
-            formatDetails(event.details)
-        ]);
-    }
-    return table.toString();
-};
-const formatTree = (node, depth) => {
-    const indent = '  '.repeat(depth);
-    const marker = depth === 0 ? '' : TREE_CHARS.BRANCH;
-    const info = extractNodeInfo(node);
-    const lines = [`${indent}${marker} ${info.name} ${info.phase}${info.duration}`];
-    if (node.error) {
-        lines.push(`${indent}   ${TREE_CHARS.LAST.trim()} ERROR: ${getErrorMessage(node.error)}`);
-    }
-    if (node.details && typeof node.details === 'object') {
-        lines.push(...formatTreeDetails(node.details, depth + 1));
-    }
-    if (node.children && node.children.length > 0) {
-        for (const child of node.children) {
-            lines.push(...formatTree(child, depth + 1));
-        }
-    }
-    return lines;
-};
-const getDebugNodeDetails = (node, prefix) => {
-    if (typeof node !== 'object' || node === null) {
-        return [];
-    }
-    const details = [];
-    const startedAt = node.startedAt || node.timestamp;
-    const inputIndentPrefix = prefix + ' '.repeat(7);
-    const outputIndentPrefix = prefix + ' '.repeat(8);
-    if (isValidTimestamp(startedAt)) {
-        const startDate = new Date(startedAt);
-        if (!isNaN(startDate.getTime())) {
-            details.push(`${prefix}${colors.label('Started:')} ${startDate.toISOString()}`);
-        }
-    }
-    if (isValidTimestamp(node.endedAt)) {
-        const endDate = new Date(node.endedAt);
-        if (!isNaN(endDate.getTime())) {
-            details.push(`${prefix}${colors.label('Ended:')}   ${endDate.toISOString()}`);
-        }
-    }
-    if (typeof node.startedAt === 'number' && typeof node.endedAt === 'number') {
-        details.push(`${prefix}${colors.label('Duration:')} ${formatDuration(node.endedAt - node.startedAt)}`);
-    }
-    else if (node.duration) {
-        details.push(`${prefix}${colors.label('Duration:')} ${formatDuration(node.duration)}`);
-    }
-    if (node.input !== null && node.input !== undefined) {
-        details.push(`${prefix}${colors.label('Input:')} ${formatValueWithIndent(node.input, inputIndentPrefix)}`);
-    }
-    if (node.output !== null && node.output !== undefined) {
-        details.push(`${prefix}${colors.label('Output:')} ${formatValueWithIndent(node.output, outputIndentPrefix)}`);
-    }
-    if (node.error) {
-        details.push(`${prefix}${colors.error('Error:')} ${colors.error(getErrorMessage(node.error))}`);
-    }
-    if (details.length > 0) {
-        details.push('');
-    }
-    return details;
-};
-const buildDebugTreeLines = (node, depth, isLast, prefix) => {
-    if (node === null || node === undefined) {
-        return [];
-    }
-    const isRoot = depth === 0;
-    const getConnector = () => {
-        if (isRoot) {
-            return '';
-        }
-        return isLast ? TREE_CHARS.LAST : TREE_CHARS.BRANCH;
-    };
-    const connector = getConnector();
-    const indent = isRoot ? '' : prefix + connector;
-    const lines = [indent + getDebugNodeInfo(node)];
-    const detailPrefix = isRoot ? '  ' : prefix + (isLast ? TREE_CHARS.DETAIL_LAST : TREE_CHARS.DETAIL_BRANCH);
-    if (typeof node === 'object' && node !== null) {
-        lines.push(...getDebugNodeDetails(node, detailPrefix));
-    }
-    const childPrefix = isRoot ? '' : prefix + (isLast ? TREE_CHARS.SPACE : TREE_CHARS.VERTICAL);
-    if (typeof node === 'object' && node !== null) {
-        const debugNode = node;
-        if (Array.isArray(debugNode.children)) {
-            debugNode.children.forEach((child, i) => {
-                const isLastChild = i === debugNode.children.length - 1;
-                lines.push(...buildDebugTreeLines(child, depth + 1, isLastChild, childPrefix));
-            });
-        }
-    }
-    return lines;
-};
-const formatAsText = (trace) => {
-    const output = [];
-    if (trace.root) {
-        output.push(formatHeader(trace.root), '');
-    }
-    if (trace.events && trace.events.length > 0) {
-        output.push('Execution Timeline:', formatEventsTable(trace.events), '');
-    }
-    if (trace.root) {
-        output.push('Execution Tree:', ...formatTree(trace.root, 0));
-    }
-    return output.join('\n');
-};
-export function format(traceData, outputFormat = 'text') {
-    const trace = typeof traceData === 'string' ? JSON.parse(traceData) : traceData;
-    if (outputFormat === 'json') {
-        return formatOutput(trace, 'json');
-    }
-    return formatAsText(trace);
-}
-export function getSummary(traceData) {
-    const trace = typeof traceData === 'string' ? JSON.parse(traceData) : traceData;
-    const stats = {
-        totalDuration: trace.root?.duration || 0,
-        totalEvents: trace.events?.length || 0,
-        totalSteps: 0,
-        totalActivities: 0,
-        hasErrors: false
-    };
-    if (trace.events) {
-        for (const event of trace.events) {
-            if (event.kind === 'step') {
-                stats.totalSteps++;
-            }
-            if (event.kind === 'activity') {
-                stats.totalActivities++;
-            }
-            if (event.phase === 'error') {
-                stats.hasErrors = true;
-            }
-        }
-    }
-    return stats;
-}
-export function displayDebugTree(node) {
-    return buildDebugTreeLines(node, 0, false, '').join('\n');
-}

package/dist/utils/validation.d.ts

@@ -1,13 +0,0 @@
-/**
- * Validate workflow name format
- * Must contain only letters, numbers, hyphens, and underscores
- */
-export declare function isValidWorkflowName(name: string): boolean;
-/**
- * Validate workflow name and throw descriptive error if invalid
- */
-export declare function validateWorkflowName(name: string): void;
-/**
- * Validate that a directory path is safe to create
- */
-export declare function validateOutputDirectory(outputDir: string): void;

package/dist/utils/validation.js

@@ -1,25 +0,0 @@
-import { InvalidNameError, InvalidOutputDirectoryError } from '#types/errors.js';
-/**
- * Validate workflow name format
- * Must contain only letters, numbers, hyphens, and underscores
- */
-export function isValidWorkflowName(name) {
-    // Must start with a letter or underscore, followed by letters, numbers, hyphens, or underscores
-    return /^[a-z_][a-z0-9_-]*$/i.test(name);
-}
-/**
- * Validate workflow name and throw descriptive error if invalid
- */
-export function validateWorkflowName(name) {
-    if (!isValidWorkflowName(name)) {
-        throw new InvalidNameError(name);
-    }
-}
-/**
- * Validate that a directory path is safe to create
- */
-export function validateOutputDirectory(outputDir) {
-    if (!outputDir || outputDir.trim() === '') {
-        throw new InvalidOutputDirectoryError(outputDir, 'Output directory cannot be empty');
-    }
-}

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

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

package/dist/utils/validation.spec.js

@@ -1,140 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { isValidWorkflowName } from './validation.js';
-describe('isValidWorkflowName', () => {
-    describe('valid workflow names', () => {
-        it('should accept single letter', () => {
-            expect(isValidWorkflowName('a')).toBe(true);
-            expect(isValidWorkflowName('Z')).toBe(true);
-        });
-        it('should accept single underscore', () => {
-            expect(isValidWorkflowName('_')).toBe(true);
-        });
-        it('should accept names starting with letter', () => {
-            expect(isValidWorkflowName('workflow')).toBe(true);
-            expect(isValidWorkflowName('MyWorkflow')).toBe(true);
-            expect(isValidWorkflowName('simpleWorkflow123')).toBe(true);
-        });
-        it('should accept names starting with underscore', () => {
-            expect(isValidWorkflowName('_workflow')).toBe(true);
-            expect(isValidWorkflowName('_private_workflow')).toBe(true);
-            expect(isValidWorkflowName('__double_underscore')).toBe(true);
-        });
-        it('should accept names with numbers after first character', () => {
-            expect(isValidWorkflowName('workflow1')).toBe(true);
-            expect(isValidWorkflowName('workflow_123')).toBe(true);
-            expect(isValidWorkflowName('a123456789')).toBe(true);
-            expect(isValidWorkflowName('_123')).toBe(true);
-        });
-        it('should accept names with hyphens', () => {
-            expect(isValidWorkflowName('my-workflow')).toBe(true);
-            expect(isValidWorkflowName('workflow-name')).toBe(true);
-            expect(isValidWorkflowName('workflow-')).toBe(true);
-            expect(isValidWorkflowName('my-workflow-name')).toBe(true);
-        });
-        it('should accept names with underscores in any position', () => {
-            expect(isValidWorkflowName('my_workflow')).toBe(true);
-            expect(isValidWorkflowName('workflow_name_here')).toBe(true);
-            expect(isValidWorkflowName('a_b_c_d')).toBe(true);
-            expect(isValidWorkflowName('workflow__double')).toBe(true);
-        });
-        it('should accept mixed case names', () => {
-            expect(isValidWorkflowName('WorkFlow')).toBe(true);
-            expect(isValidWorkflowName('myWorkFlow')).toBe(true);
-            expect(isValidWorkflowName('MY_WORKFLOW')).toBe(true);
-            expect(isValidWorkflowName('CamelCaseWorkflow')).toBe(true);
-        });
-        it('should accept long valid names', () => {
-            const longName = 'a'.repeat(100) + '_' + '1'.repeat(100);
-            expect(isValidWorkflowName(longName)).toBe(true);
-        });
-    });
-    describe('invalid workflow names', () => {
-        it('should reject empty string', () => {
-            expect(isValidWorkflowName('')).toBe(false);
-        });
-        it('should reject names starting with numbers', () => {
-            expect(isValidWorkflowName('1workflow')).toBe(false);
-            expect(isValidWorkflowName('123')).toBe(false);
-            expect(isValidWorkflowName('0_workflow')).toBe(false);
-            expect(isValidWorkflowName('9abc')).toBe(false);
-        });
-        it('should reject names starting with hyphens', () => {
-            expect(isValidWorkflowName('-workflow')).toBe(false);
-        });
-        it('should reject names with spaces', () => {
-            expect(isValidWorkflowName('my workflow')).toBe(false);
-            expect(isValidWorkflowName(' workflow')).toBe(false);
-            expect(isValidWorkflowName('workflow ')).toBe(false);
-            expect(isValidWorkflowName('work flow')).toBe(false);
-        });
-        it('should reject names with special characters', () => {
-            expect(isValidWorkflowName('workflow!')).toBe(false);
-            expect(isValidWorkflowName('work@flow')).toBe(false);
-            expect(isValidWorkflowName('workflow#123')).toBe(false);
-            expect(isValidWorkflowName('work$flow')).toBe(false);
-            expect(isValidWorkflowName('workflow%')).toBe(false);
-            expect(isValidWorkflowName('work^flow')).toBe(false);
-            expect(isValidWorkflowName('workflow&')).toBe(false);
-            expect(isValidWorkflowName('work*flow')).toBe(false);
-            expect(isValidWorkflowName('workflow(')).toBe(false);
-            expect(isValidWorkflowName('work)flow')).toBe(false);
-            expect(isValidWorkflowName('work+flow')).toBe(false);
-            expect(isValidWorkflowName('work=flow')).toBe(false);
-            expect(isValidWorkflowName('work[flow')).toBe(false);
-            expect(isValidWorkflowName('work]flow')).toBe(false);
-            expect(isValidWorkflowName('work{flow')).toBe(false);
-            expect(isValidWorkflowName('work}flow')).toBe(false);
-            expect(isValidWorkflowName('work|flow')).toBe(false);
-            expect(isValidWorkflowName('work\\flow')).toBe(false);
-            expect(isValidWorkflowName('work/flow')).toBe(false);
-            expect(isValidWorkflowName('work:flow')).toBe(false);
-            expect(isValidWorkflowName('work;flow')).toBe(false);
-            expect(isValidWorkflowName('work"flow')).toBe(false);
-            expect(isValidWorkflowName('work\'flow')).toBe(false);
-            expect(isValidWorkflowName('work<flow')).toBe(false);
-            expect(isValidWorkflowName('work>flow')).toBe(false);
-            expect(isValidWorkflowName('work,flow')).toBe(false);
-            expect(isValidWorkflowName('work.flow')).toBe(false);
-            expect(isValidWorkflowName('work?flow')).toBe(false);
-            expect(isValidWorkflowName('work`flow')).toBe(false);
-            expect(isValidWorkflowName('work~flow')).toBe(false);
-        });
-        it('should reject names with unicode characters', () => {
-            expect(isValidWorkflowName('wørkflow')).toBe(false);
-            expect(isValidWorkflowName('работа')).toBe(false);
-            expect(isValidWorkflowName('工作流')).toBe(false);
-            expect(isValidWorkflowName('workflow™')).toBe(false);
-            expect(isValidWorkflowName('work✓flow')).toBe(false);
-            expect(isValidWorkflowName('😀workflow')).toBe(false);
-        });
-        it('should reject names with tabs and newlines', () => {
-            expect(isValidWorkflowName('work\tflow')).toBe(false);
-            expect(isValidWorkflowName('work\nflow')).toBe(false);
-            expect(isValidWorkflowName('work\rflow')).toBe(false);
-        });
-        it('should handle string versions of null and undefined', () => {
-            // String(null) returns "null" which is actually a valid workflow name
-            expect(isValidWorkflowName(String(null))).toBe(true);
-            // String(undefined) returns "undefined" which is also a valid workflow name
-            expect(isValidWorkflowName(String(undefined))).toBe(true);
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle boundary conditions', () => {
-            expect(isValidWorkflowName('a0')).toBe(true);
-            expect(isValidWorkflowName('_0')).toBe(true);
-            expect(isValidWorkflowName('Z9')).toBe(true);
-            expect(isValidWorkflowName('_9')).toBe(true);
-        });
-        it('should be case-insensitive for letters', () => {
-            expect(isValidWorkflowName('abc')).toBe(true);
-            expect(isValidWorkflowName('ABC')).toBe(true);
-            expect(isValidWorkflowName('AbC')).toBe(true);
-        });
-        it('should handle only underscores and numbers after initial character', () => {
-            expect(isValidWorkflowName('a_________')).toBe(true);
-            expect(isValidWorkflowName('_000000000')).toBe(true);
-            expect(isValidWorkflowName('a_0_1_2_3')).toBe(true);
-        });
-    });
-});