@output.ai/cli 0.3.1-dev.pr156.0 → 0.4.0

package/dist/utils/trace_formatter.js

@@ -1,257 +1,402 @@
 import Table from 'cli-table3';
+import { ux } from '@oclif/core';
 import { formatOutput } from '#utils/output_formatter.js';
-export class TraceFormatter {
-    /**
-     * Format trace data based on the requested format
-     */
-    format(traceData, format = 'text') {
-        // Parse if string
-        const trace = typeof traceData === 'string' ? JSON.parse(traceData) : traceData;
-        if (format === 'json') {
-            return formatOutput(trace, 'json');
+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;
         }
-        // Format as human-readable text
-        return this.formatAsText(trace);
-    }
-    /**
-     * Format trace as human-readable text with tree structure
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    formatAsText(trace) {
-        const output = [];
-        // Add header with workflow info
-        if (trace.root) {
-            output.push(this.formatHeader(trace.root));
-            output.push('');
+        return `${value.substring(0, maxLength)}${suffix}`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        if (recursive) {
+            return value;
         }
-        // Create execution timeline table
-        if (trace.events && trace.events.length > 0) {
-            output.push('Execution Timeline:');
-            output.push(this.formatEventsTable(trace.events));
-            output.push('');
+        return String(value);
+    }
+    if (!recursive) {
+        const str = JSON.stringify(value);
+        if (str.length <= maxLength) {
+            return str;
         }
-        // Show tree structure
-        if (trace.root) {
-            output.push('Execution Tree:');
-            output.push(this.formatTree(trace.root, 0));
+        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 output.join('\n');
-    }
-    /**
-     * Format the header with workflow information
-     */
-    formatHeader(root) {
-        const lines = [];
-        lines.push('═'.repeat(60));
-        lines.push(`Workflow: ${root.workflowName}`);
-        lines.push(`Workflow ID: ${root.workflowId}`);
-        lines.push(`Start Time: ${new Date(root.timestamp).toISOString()}`);
-        if (root.duration) {
-            lines.push(`Duration: ${this.formatDuration(root.duration)}`);
+        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;
         }
-        if (root.phase === 'error' && root.error) {
-            lines.push('Status: ❌ Failed');
-            lines.push(`Error: ${this.formatError(root.error)}`);
+        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));
         }
-        else if (root.phase === 'end') {
-            lines.push('Status: ✅ Completed');
+    }
+    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()}`);
         }
-        else {
-            lines.push('Status: 🔄 In Progress');
+    }
+    if (isValidTimestamp(node.endedAt)) {
+        const endDate = new Date(node.endedAt);
+        if (!isNaN(endDate.getTime())) {
+            details.push(`${prefix}${colors.label('Ended:')}   ${endDate.toISOString()}`);
         }
-        lines.push('═'.repeat(60));
-        return lines.join('\n');
-    }
-    /**
-     * Format events as a timeline table
-     */
-    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) {
-            const time = new Date(event.timestamp).toISOString().substring(11, 23);
-            const eventName = this.getEventName(event);
-            const phase = this.formatPhase(event.phase);
-            const duration = event.duration ? this.formatDuration(event.duration) : '-';
-            const details = this.formatDetails(event.details);
-            table.push([time, eventName, phase, duration, details]);
+    }
+    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 table.toString();
-    }
-    /**
-     * Format trace as a tree structure
-     */
-    formatTree(node, depth) {
-        const lines = [];
-        const indent = '  '.repeat(depth);
-        const marker = depth === 0 ? '🌳' : '├─';
-        // Format current node
-        const nodeName = this.getEventName(node);
-        const phase = this.formatPhase(node.phase);
-        const duration = node.duration ? ` (${this.formatDuration(node.duration)})` : '';
-        lines.push(`${indent}${marker} ${nodeName} ${phase}${duration}`);
-        // Add error details if present
-        if (node.error) {
-            lines.push(`${indent}   └─ ❌ ${this.formatError(node.error)}`);
+        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));
+            });
         }
-        // Add important details
-        if (node.details && typeof node.details === 'object') {
-            const detailLines = this.formatTreeDetails(node.details, depth + 1);
-            if (detailLines) {
-                lines.push(detailLines);
+    }
+    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++;
             }
-        }
-        // Process children
-        if (node.children && node.children.length > 0) {
-            for (const child of node.children) {
-                lines.push(this.formatTree(child, depth + 1));
+            if (event.kind === 'activity') {
+                stats.totalActivities++;
             }
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Get a readable name for an event
-     */
-    getEventName(event) {
-        if (event.kind === 'workflow') {
-            return `Workflow: ${event.workflowName}`;
-        }
-        if (event.kind === 'activity') {
-            return `Activity: ${event.details?.activityName || 'unknown'}`;
-        }
-        if (event.kind === 'step') {
-            return `Step: ${event.details?.stepName || event.details?.name || 'unknown'}`;
-        }
-        return event.kind || 'Unknown Event';
-    }
-    /**
-     * Format the phase with icons
-     */
-    formatPhase(phase) {
-        switch (phase) {
-            case 'start':
-                return '▶️';
-            case 'end':
-                return '✅';
-            case 'error':
-                return '❌';
-            default:
-                return phase;
-        }
-    }
-    /**
-     * Format duration in human-readable format
-     */
-    formatDuration(ms) {
-        if (ms < 1000) {
-            return `${ms}ms`;
-        }
-        if (ms < 60000) {
-            return `${(ms / 1000).toFixed(2)}s`;
-        }
-        const minutes = Math.floor(ms / 60000);
-        const seconds = ((ms % 60000) / 1000).toFixed(0);
-        return `${minutes}m ${seconds}s`;
-    }
-    /**
-     * Format error for display
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    formatError(error) {
-        if (typeof error === 'string') {
-            return error;
-        }
-        if (error.message) {
-            return error.message;
-        }
-        return JSON.stringify(error);
-    }
-    /**
-     * Format details for table display
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    formatDetails(details) {
-        if (!details) {
-            return '-';
-        }
-        if (typeof details === 'string') {
-            return details;
-        }
-        // Extract key information
-        const info = [];
-        if (details.input) {
-            info.push(`Input: ${this.truncateValue(details.input)}`);
-        }
-        if (details.output) {
-            info.push(`Output: ${this.truncateValue(details.output)}`);
-        }
-        if (details.activityName) {
-            info.push(`Activity: ${details.activityName}`);
-        }
-        if (details.stepName || details.name) {
-            info.push(`Step: ${details.stepName || details.name}`);
-        }
-        return info.length > 0 ? info.join(', ') : JSON.stringify(details).substring(0, 50) + '...';
-    }
-    /**
-     * Format details for tree display
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    formatTreeDetails(details, depth) {
-        const lines = [];
-        const indent = '  '.repeat(depth);
-        // Only show key details
-        if (details.input && details.input !== null) {
-            lines.push(`${indent}📥 Input: ${this.truncateValue(details.input)}`);
-        }
-        if (details.output && details.output !== null) {
-            lines.push(`${indent}📤 Output: ${this.truncateValue(details.output)}`);
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Truncate long values for display
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    truncateValue(value, maxLength = 50) {
-        const str = typeof value === 'string' ? value : JSON.stringify(value);
-        if (str.length <= maxLength) {
-            return str;
-        }
-        return str.substring(0, maxLength) + '...';
-    }
-    /**
-     * Get summary statistics from trace
-     */
-    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;
-                }
+            if (event.phase === 'error') {
+                stats.hasErrors = true;
             }
         }
-        return stats;
     }
+    return stats;
+}
+export function displayDebugTree(node) {
+    return buildDebugTreeLines(node, 0, false, '').join('\n');
 }
-export const traceFormatter = new TraceFormatter();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.3.1-dev.pr156.0",
+  "version": "0.4.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -22,7 +22,6 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.1.19",
-    "@aws-sdk/client-s3": "^3.689.0",
     "@inquirer/prompts": "7.9.0",
     "@oclif/core": "4.5.6",
     "@oclif/plugin-help": "6.2.33",
@@ -31,6 +30,7 @@
     "change-case": "5.4.4",
     "cli-progress": "3.12.0",
     "cli-table3": "0.6.5",
+    "date-fns": "4.1.0",
     "dotenv": "16.4.7",
     "handlebars": "4.7.8",
     "json-schema-library": "10.3.0",