@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/debug/formatters/trace-formatter.js

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview Trace Formatter
+ *
+ * Formats trace entries for console output with support for:
+ * - Pretty printing with indentation
+ * - Multi-line content handling
+ * - JSON output
+ * - Depth-limited nested object display
+ */
+/**
+ * Formats trace entries for human-readable output
+ */
+export class TraceFormatter {
+    /**
+     * Format a single trace entry
+     */
+    formatEntry(entry, options = {}) {
+        const { pretty = false } = options;
+        const actionSymbol = entry.action === 'enter' ? '>>>' :
+            entry.action === 'error' ? '!!!' : '<<<';
+        let output = `${actionSymbol} ${entry.function} ${entry.action}`;
+        if (entry.action === 'enter' && entry.params) {
+            output += '\n' + this.formatData(entry.params, options);
+        }
+        else if (entry.action === 'quit') {
+            if (entry.durationMs !== undefined) {
+                output += ` (${entry.durationMs}ms)`;
+            }
+            if (entry.result) {
+                output += '\n' + this.formatData(entry.result, options);
+            }
+        }
+        else if (entry.action === 'error' && entry.error) {
+            output += `: ${entry.error}`;
+        }
+        // Handle multi-line content by indenting continuation lines
+        if (pretty) {
+            output = this.indentMultilineContent(output);
+        }
+        return output;
+    }
+    /**
+     * Indent all lines after the first one
+     */
+    indentMultilineContent(text, indent = '  ') {
+        const lines = text.split('\n');
+        if (lines.length <= 1)
+            return text;
+        return lines.map((line, i) => i === 0 ? line : `${indent}${line}`).join('\n');
+    }
+    /**
+     * Format multiple trace entries
+     */
+    formatEntries(entries, options = {}) {
+        if (entries.length === 0) {
+            return 'No trace entries';
+        }
+        const formatted = entries.map(entry => this.formatEntry(entry, options));
+        // Use separator only for pretty mode, otherwise join without separator
+        if (options.pretty) {
+            return formatted.join('\n' + '-'.repeat(80) + '\n');
+        }
+        return formatted.join('\n');
+    }
+    /**
+     * Format data with proper indentation for multi-line content
+     */
+    formatData(data, options = {}) {
+        const { pretty = false, maxDepth = 10 } = options;
+        if (pretty) {
+            return this.formatPretty(data, 0, maxDepth);
+        }
+        // Compact JSON - no newlines
+        return JSON.stringify(data);
+    }
+    /**
+     * Format data with pretty printing and indentation
+     */
+    formatPretty(data, indent = 0, maxDepth) {
+        const baseIndent = '  '.repeat(indent);
+        const nextIndent = '  '.repeat(indent + 1);
+        if (data === null || data === undefined) {
+            return String(data);
+        }
+        if (typeof data === 'string') {
+            // Handle multi-line strings - indent each line
+            if (data.includes('\n')) {
+                return data.split('\n').map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join('\n');
+            }
+            return data;
+        }
+        if (typeof data === 'number' || typeof data === 'boolean') {
+            return String(data);
+        }
+        if (Array.isArray(data)) {
+            if (data.length === 0)
+                return '[]';
+            const items = data.map(item => {
+                const formatted = this.formatPretty(item, indent + 1, maxDepth);
+                // Indent each line of the formatted item
+                return formatted.split('\n').map(line => `  ${line}`).join('\n');
+            });
+            return '[\n' + items.join(',\n') + '\n' + baseIndent + ']';
+        }
+        if (typeof data === 'object') {
+            const obj = data;
+            const keys = Object.keys(obj);
+            if (keys.length === 0)
+                return '{}';
+            if (indent >= maxDepth) {
+                return '{...}';
+            }
+            const entries = keys.map(key => {
+                const value = obj[key];
+                let formatted;
+                if (typeof value === 'object' && value !== null) {
+                    formatted = this.formatPretty(value, indent + 1, maxDepth);
+                }
+                else if (typeof value === 'string' && value.includes('\n')) {
+                    // Handle multi-line string values - indent each line
+                    formatted = value.split('\n').map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join('\n');
+                }
+                else {
+                    formatted = JSON.stringify(value);
+                }
+                // Indent all lines of the formatted value
+                return `  ${key}: ` + formatted.split('\n').map((line, i) => i === 0 ? line : nextIndent + line).join('\n');
+            });
+            return '{\n' + entries.join(',\n') + '\n' + baseIndent + '}';
+        }
+        return JSON.stringify(data);
+    }
+    /**
+     * Output as JSON
+     */
+    toJSON(entries) {
+        return JSON.stringify(entries, null, 2);
+    }
+    /**
+     * Generate a summary of trace entries
+     */
+    toSummary(entries) {
+        if (entries.length === 0) {
+            return 'No trace entries';
+        }
+        const functions = new Set(entries.map(e => e.function));
+        const actions = entries.reduce((acc, e) => {
+            acc[e.action] = (acc[e.action] || 0) + 1;
+            return acc;
+        }, {});
+        let summary = `Trace Summary (${entries.length} entries)\n`;
+        summary += `Functions: ${[...functions].join(', ')}\n`;
+        summary += `Actions: ${Object.entries(actions).map(([k, v]) => `${k}=${v}`).join(', ')}`;
+        return summary;
+    }
+}
+//# sourceMappingURL=trace-formatter.js.map

package/dist/core/src/env/debug/formatters/trace-formatter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trace-formatter.test.d.ts.map

package/dist/core/src/env/debug/formatters/trace-formatter.test.js

@@ -0,0 +1,102 @@
+import { describe, test, expect } from 'bun:test';
+import { TraceFormatter } from "./trace-formatter.js";
+describe('TraceFormatter', () => {
+    const formatter = new TraceFormatter();
+    const mockEnterEntry = {
+        traceId: 'trace-001',
+        timestamp: '2026-04-08T10:00:00.000',
+        function: 'llm.component.invoke',
+        action: 'enter',
+        params: [
+            [{ role: 'user', content: 'Hello' }],
+            { providerId: 'openai', model: 'gpt-4' }
+        ],
+    };
+    const mockQuitEntry = {
+        traceId: 'trace-001',
+        timestamp: '2026-04-08T10:00:01.000',
+        function: 'llm.component.invoke',
+        action: 'quit',
+        result: { content: 'Hi there!', finishReason: 'stop' },
+        durationMs: 1000,
+    };
+    test('formatEntry - should format enter entry', () => {
+        const result = formatter.formatEntry(mockEnterEntry);
+        expect(result).toContain('>>>');
+        expect(result).toContain('llm.component.invoke');
+        expect(result).toContain('enter');
+    });
+    test('formatEntry - should format quit entry with duration', () => {
+        const result = formatter.formatEntry(mockQuitEntry);
+        expect(result).toContain('<<<');
+        expect(result).toContain('llm.component.invoke');
+        expect(result).toContain('1000ms');
+    });
+    test('formatEntry - should handle multi-line content without breaking layout', () => {
+        const entryWithMultiline = {
+            ...mockQuitEntry,
+            result: {
+                content: 'This is a\nmulti-line\nresponse',
+                finishReason: 'stop'
+            },
+        };
+        const result = formatter.formatEntry(entryWithMultiline, { pretty: true });
+        // Should handle newlines gracefully - indent continuation lines
+        const lines = result.split('\n');
+        expect(lines.length).toBeGreaterThan(1);
+        // Second line onwards should be indented
+        for (let i = 1; i < lines.length; i++) {
+            expect(lines[i].startsWith('  ')).toBe(true);
+        }
+    });
+    test('formatEntry - should handle deep nesting', () => {
+        const deepEntry = {
+            ...mockQuitEntry,
+            result: {
+                level1: {
+                    level2: {
+                        level3: {
+                            level4: 'deep value'
+                        }
+                    }
+                }
+            },
+        };
+        const result = formatter.formatEntry(deepEntry, { pretty: true, maxDepth: 2 });
+        // Should truncate at maxDepth
+        expect(result).toContain('level1');
+        expect(result).toContain('...');
+    });
+    test('formatEntries - should format multiple entries', () => {
+        const entries = [mockEnterEntry, mockQuitEntry];
+        const result = formatter.formatEntries(entries);
+        expect(result).toContain('>>>');
+        expect(result).toContain('<<<');
+    });
+    test('formatEntries - should respect pretty option', () => {
+        const entries = [mockEnterEntry, mockQuitEntry];
+        const prettyResult = formatter.formatEntries(entries, { pretty: true });
+        const jsonResult = formatter.formatEntries(entries, { pretty: false });
+        // Pretty should have newlines and indentation
+        expect(prettyResult).toContain('\n');
+        // Pretty should have separator line
+        expect(prettyResult).toContain('-'.repeat(40));
+        // JSON should be compact (no separator line between entries)
+        expect(jsonResult).not.toContain('-'.repeat(40));
+    });
+    test('toJSON - should output valid JSON', () => {
+        const entries = [mockEnterEntry, mockQuitEntry];
+        const result = formatter.toJSON(entries);
+        const parsed = JSON.parse(result);
+        expect(parsed).toHaveLength(2);
+        expect(parsed[0].action).toBe('enter');
+        expect(parsed[1].action).toBe('quit');
+    });
+    test('toSummary - should return trace summary', () => {
+        const entries = [mockEnterEntry, mockQuitEntry];
+        const result = formatter.toSummary(entries);
+        expect(result).toContain('llm.component.invoke');
+        expect(result).toContain('2 entries');
+    });
+});
+//# sourceMappingURL=trace-formatter.test.js.map

package/dist/core/src/env/debug/formatters/tree-formatter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Tree Formatter
+ *
+ * Formats trace call trees for console output with:
+ * - ANSI color support
+ * - Duration display with percentage
+ * - Time bar visualization
+ * - Proper indentation
+ */
+import type { TraceTreeNode } from '../types';
+/**
+ * Options for tree formatting
+ */
+export interface TreeFormatOptions {
+    /** Show duration percentage (default: true) */
+    showPercent?: boolean;
+    /** Show time bar (default: false) */
+    showTimeBar?: boolean;
+    /** Width of time bar (default: 10) */
+    barWidth?: number;
+}
+/**
+ * Formats trace call trees for human-readable output
+ */
+export declare class TreeFormatter {
+    private options;
+    constructor(options?: TreeFormatOptions);
+    /**
+     * Color function based on percentage
+     */
+    private colorByPercent;
+    /**
+     * Format a single trace tree
+     */
+    formatTree(node: TraceTreeNode): string;
+    /**
+     * Format a single node
+     */
+    private formatNode;
+    /**
+     * Recursively format children
+     */
+    private formatChildren;
+    /**
+     * Render a time bar showing relative duration
+     */
+    private renderTimeBar;
+    /**
+     * Format duration in human-readable form
+     */
+    private formatDuration;
+    /**
+     * Format multiple trace trees
+     */
+    formatTrees(trees: TraceTreeNode[]): string;
+    /**
+     * Output as JSON
+     */
+    toJSON(trees: TraceTreeNode[]): string;
+    /**
+     * Generate a summary table of all spans sorted by duration
+     */
+    formatSummary(node: TraceTreeNode): string;
+    /**
+     * Format tree with timeline visualization
+     */
+    formatTimeline(node: TraceTreeNode): string;
+    /**
+     * Build timeline visualization with absolute positioning
+     */
+    private buildTimeline;
+}
+//# sourceMappingURL=tree-formatter.d.ts.map

package/dist/core/src/env/debug/formatters/tree-formatter.js

@@ -0,0 +1,252 @@
+/**
+ * @fileoverview Tree Formatter
+ *
+ * Formats trace call trees for console output with:
+ * - ANSI color support
+ * - Duration display with percentage
+ * - Time bar visualization
+ * - Proper indentation
+ */
+/**
+ * ANSI color codes
+ */
+const Colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+};
+/**
+ * Apply color to text
+ */
+function color(text, colorCode) {
+    return `${colorCode}${text}${Colors.reset}`;
+}
+/**
+ * Tree drawing characters
+ */
+const CHARS = {
+    VERTICAL: '│',
+    VERTICAL_CONNECTOR: '├──',
+    LAST_CONNECTOR: '└──',
+    SPACE: ' ',
+    BAR: '█',
+    EMPTY: '░',
+    DASH: '─',
+};
+/**
+ * Formats trace call trees for human-readable output
+ */
+export class TreeFormatter {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            showPercent: true,
+            showTimeBar: false, // Default off, use --bar flag to enable
+            barWidth: 10,
+            ...options,
+        };
+    }
+    /**
+     * Color function based on percentage
+     */
+    colorByPercent(percent) {
+        if (percent >= 80)
+            return Colors.red;
+        if (percent >= 50)
+            return Colors.yellow;
+        if (percent >= 20)
+            return Colors.cyan;
+        return Colors.dim;
+    }
+    /**
+     * Format a single trace tree
+     */
+    formatTree(node) {
+        const lines = [];
+        const totalDuration = node.durationMs || 0;
+        // Use sum of direct children for percentage base (better for virtual root nodes)
+        const percentBase = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0) || totalDuration;
+        // Root node line
+        lines.push(this.formatNode(node, totalDuration, percentBase, '', true, true));
+        // Process children recursively
+        this.formatChildren(node.children, '', lines, totalDuration, percentBase);
+        return lines.join('\n');
+    }
+    /**
+     * Format a single node
+     */
+    formatNode(node, totalDuration, percentBase, prefix, isLast, isRoot) {
+        // Tree connector
+        const connector = isRoot ? '' : (isLast ? CHARS.LAST_CONNECTOR : CHARS.VERTICAL_CONNECTOR);
+        const prefixStr = isRoot ? '' : prefix;
+        let line = `${prefixStr}${connector} ${node.function}`;
+        // Duration
+        if (node.durationMs !== undefined) {
+            line += color(` (${this.formatDuration(node.durationMs)})`, Colors.dim);
+        }
+        // Percentage - skip for:
+        // 1. Virtual root nodes (function is '(root)')
+        // 2. Actual root of tree (isRoot=true) - root is 100% by definition
+        if (this.options.showPercent && percentBase > 0 && node.durationMs !== undefined &&
+            node.function !== '(root)' && !isRoot) {
+            const percent = Math.round((node.durationMs / percentBase) * 100);
+            const percentStr = ` [${percent}%]`;
+            line += color(percentStr, this.colorByPercent(percent));
+        }
+        // Time bar - only show for nested spans where totalDuration is meaningful
+        if (this.options.showTimeBar && node.durationMs !== undefined && totalDuration > 0 && !isRoot) {
+            line += ' ' + this.renderTimeBar(node.durationMs, totalDuration);
+        }
+        return isRoot ? color(line, Colors.bold) : line;
+    }
+    /**
+     * Recursively format children
+     */
+    formatChildren(children, prefix, lines, totalDuration, percentBase) {
+        children.forEach((child, index) => {
+            const isLast = index === children.length - 1;
+            const newPrefix = prefix + (isLast ? '    ' : `${CHARS.VERTICAL}   `);
+            lines.push(this.formatNode(child, totalDuration, percentBase, prefix, isLast, false));
+            if (child.children.length > 0) {
+                this.formatChildren(child.children, newPrefix, lines, totalDuration, percentBase);
+            }
+        });
+    }
+    /**
+     * Render a time bar showing relative duration
+     */
+    renderTimeBar(duration, total) {
+        const width = this.options.barWidth || 10;
+        const filledWidth = Math.round((duration / total) * width);
+        const emptyWidth = width - filledWidth;
+        const bar = CHARS.BAR.repeat(filledWidth) + CHARS.EMPTY.repeat(emptyWidth);
+        return color(`[${bar}]`, Colors.dim);
+    }
+    /**
+     * Format duration in human-readable form
+     */
+    formatDuration(ms) {
+        if (ms < 1000) {
+            return `${ms}ms`;
+        }
+        else if (ms < 60000) {
+            return `${(ms / 1000).toFixed(2)}s`;
+        }
+        else if (ms < 3600000) { // < 1 hour
+            const mins = Math.floor(ms / 60000);
+            const secs = Math.round((ms % 60000) / 1000);
+            return `${mins}m ${secs}s`;
+        }
+        else {
+            const hours = Math.floor(ms / 3600000);
+            const mins = Math.floor((ms % 3600000) / 60000);
+            return `${hours}h ${mins}m`;
+        }
+    }
+    /**
+     * Format multiple trace trees
+     */
+    formatTrees(trees) {
+        if (trees.length === 0) {
+            return 'No trace trees';
+        }
+        return trees.map(tree => this.formatTree(tree)).join('\n\n');
+    }
+    /**
+     * Output as JSON
+     */
+    toJSON(trees) {
+        return JSON.stringify(trees, null, 2);
+    }
+    /**
+     * Generate a summary table of all spans sorted by duration
+     */
+    formatSummary(node) {
+        const rows = [];
+        // For virtual root nodes with multiple children, use the root's own duration
+        // which is calculated from children's time span
+        const total = node.durationMs || 0;
+        // Calculate sum of direct children durations for percentage base
+        const childrenTotal = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0);
+        const percentBase = total > 0 ? total : childrenTotal;
+        const collect = (n, depth) => {
+            if (n.durationMs !== undefined) {
+                rows.push({
+                    func: n.function,
+                    duration: n.durationMs,
+                    percent: percentBase > 0 ? Math.round((n.durationMs / percentBase) * 100) : 0,
+                    depth,
+                });
+            }
+            n.children.forEach(child => collect(child, depth + 1));
+        };
+        collect(node, 0);
+        // Sort by duration descending
+        rows.sort((a, b) => b.duration - a.duration);
+        const lines = [];
+        lines.push(color('\n=== Duration Summary ===', Colors.bold));
+        lines.push(color('(sorted by time consumption)\n', Colors.dim));
+        // Table header
+        lines.push(color(`  ${'─'.repeat(65)}`, Colors.dim));
+        lines.push(color(`  ${'FUNCTION'.padEnd(35)} ${'TIME'.padEnd(12)} %`, Colors.dim));
+        lines.push(color(`  ${'─'.repeat(65)}`, Colors.dim));
+        for (const row of rows) {
+            const indent = '  '.repeat(row.depth);
+            const funcDisplay = row.depth > 0 ? '└─ '.repeat(row.depth) + row.func : row.func;
+            const percentStr = String(row.percent).padStart(3) + '%';
+            const percentColor = row.percent >= 50 ? Colors.red :
+                row.percent >= 20 ? Colors.yellow :
+                    Colors.dim;
+            lines.push(`  ${indent}${funcDisplay.substring(0, 35).padEnd(35)}${this.formatDuration(row.duration).padEnd(12)} ${color(percentStr, percentColor)}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format tree with timeline visualization
+     */
+    formatTimeline(node) {
+        const lines = [];
+        const totalDuration = node.durationMs || 0;
+        lines.push(color(`\n=== Timeline: ${node.function} ===`, Colors.bold));
+        lines.push(color(`Total: ${this.formatDuration(totalDuration)}\n`, Colors.dim));
+        // Build timeline
+        const timeline = this.buildTimeline(node, totalDuration, 0, 0);
+        lines.push(...timeline);
+        return lines.join('\n');
+    }
+    /**
+     * Build timeline visualization with absolute positioning
+     */
+    buildTimeline(node, totalDuration, absoluteOffset, depth) {
+        const lines = [];
+        const width = 40;
+        // Calculate position based on absolute offset
+        const startPos = Math.round((absoluteOffset / totalDuration) * width);
+        const durationWidth = node.durationMs !== undefined
+            ? Math.max(2, Math.round((node.durationMs / totalDuration) * width))
+            : 2;
+        // Build the bar with proper positioning
+        const bar = ' '.repeat(Math.max(0, startPos)) + CHARS.BAR.repeat(durationWidth);
+        // Format line
+        const indent = '  '.repeat(depth);
+        const funcName = node.function.length > 25 ? '...' + node.function.slice(-22) : node.function;
+        const time = node.durationMs !== undefined ? this.formatDuration(node.durationMs) : '-';
+        const percent = node.durationMs !== undefined
+            ? ` [${Math.round((node.durationMs / totalDuration) * 100)}%]`
+            : '';
+        lines.push(`${indent}${funcName.padEnd(25)} ${bar} ${color(time + percent, Colors.dim)}`);
+        // Process children with absolute offset within this node
+        let childOffset = absoluteOffset;
+        for (const child of node.children) {
+            lines.push(...this.buildTimeline(child, totalDuration, childOffset, depth + 1));
+            childOffset += child.durationMs || 0;
+        }
+        return lines;
+    }
+}
+//# sourceMappingURL=tree-formatter.js.map

package/dist/core/src/env/debug/formatters/tree-formatter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tree-formatter.test.d.ts.map

package/dist/core/src/env/debug/formatters/tree-formatter.test.js

@@ -0,0 +1,91 @@
+import { describe, test, expect } from 'bun:test';
+import { TreeFormatter } from "./tree-formatter.js";
+describe('TreeFormatter', () => {
+    const formatter = new TreeFormatter();
+    const mockRootNode = {
+        traceId: 'trace-001',
+        function: 'agent.execute',
+        startTime: '2026-04-08T10:00:00.000',
+        endTime: '2026-04-08T10:00:05.000',
+        durationMs: 5000,
+        children: [
+            {
+                traceId: 'trace-001',
+                function: 'llm.component.invoke',
+                startTime: '2026-04-08T10:00:01.000',
+                endTime: '2026-04-08T10:00:03.000',
+                durationMs: 2000,
+                children: [],
+                entry: {},
+            },
+            {
+                traceId: 'trace-001',
+                function: 'tool.execute',
+                startTime: '2026-04-08T10:00:03.000',
+                endTime: '2026-04-08T10:00:04.000',
+                durationMs: 1000,
+                children: [],
+                entry: {},
+            },
+        ],
+        entry: {},
+    };
+    test('formatTree - should format tree with proper indentation', () => {
+        const result = formatter.formatTree(mockRootNode);
+        // Should show root function
+        expect(result).toContain('agent.execute');
+        // Should show duration (5s because it's > 1000ms)
+        expect(result).toContain('5.00s');
+        // Should have tree branch connectors
+        expect(result).toContain('├──');
+        expect(result).toContain('└──');
+    });
+    test('formatTree - should show children with correct markers', () => {
+        const result = formatter.formatTree(mockRootNode);
+        // Should show children
+        expect(result).toContain('llm.component.invoke');
+        expect(result).toContain('tool.execute');
+    });
+    test('formatTree - should handle empty children', () => {
+        const leafNode = {
+            traceId: 'trace-001',
+            function: 'leaf.function',
+            startTime: '2026-04-08T10:00:00.000',
+            children: [],
+            entry: {},
+        };
+        const result = formatter.formatTree(leafNode);
+        expect(result).toContain('leaf.function');
+        expect(result).not.toContain('children');
+    });
+    test('formatTree - should format duration', () => {
+        const result = formatter.formatTree(mockRootNode);
+        // Duration should be visible (formatted as seconds for values >= 1000ms)
+        expect(result).toContain('5.00s'); // 5000ms
+        expect(result).toContain('2.00s'); // 2000ms
+        expect(result).toContain('1.00s'); // 1000ms
+    });
+    test('formatTrees - should format multiple trees', () => {
+        const node2 = {
+            ...mockRootNode,
+            traceId: 'trace-002',
+            function: 'another.function',
+        };
+        const result = formatter.formatTrees([mockRootNode, node2]);
+        // Should have two separate trees
+        expect(result.split('\n\n')).toHaveLength(2);
+        expect(result).toContain('agent.execute');
+        expect(result).toContain('another.function');
+    });
+    test('formatTrees - should handle empty array', () => {
+        const result = formatter.formatTrees([]);
+        expect(result).toBe('No trace trees');
+    });
+    test('toJSON - should output valid JSON', () => {
+        const result = formatter.toJSON([mockRootNode]);
+        const parsed = JSON.parse(result);
+        expect(parsed).toHaveLength(1);
+        expect(parsed[0].function).toBe('agent.execute');
+    });
+});
+//# sourceMappingURL=tree-formatter.test.js.map