@ai-setting/roy-agent-cli 1.3.19 → 1.3.22

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

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

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

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

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

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

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

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

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

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