@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/debug/formatters/index.js

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Debug Formatters
+ *
+ * Export all formatters for trace and tree visualization
+ */
+export { TraceFormatter } from "./trace-formatter.js";
+export { TreeFormatter } from "./tree-formatter.js";
+export { ReplFormatter } from "./repl-formatter.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview REPL Formatter for Interactive Debugging
+ *
+ * Provides an interactive REPL interface for debugging with:
+ * - Command parsing
+ * - Output formatting
+ * - Help text generation
+ */
+export interface ReplContext {
+    traceId?: string;
+    function?: string;
+    limit?: number;
+}
+export interface ParsedCommand {
+    command: string;
+    args: Record<string, string>;
+}
+/**
+ * Formats output for REPL interface and provides command parsing
+ */
+export declare class ReplFormatter {
+    private context;
+    private history;
+    /**
+     * Get welcome message for REPL
+     */
+    getWelcomeMessage(): string;
+    /**
+     * Format prompt with current context
+     */
+    formatPrompt(context?: Partial<ReplContext>): string;
+    /**
+     * Get help text
+     */
+    getHelpText(): string;
+    /**
+     * Format command result
+     */
+    formatCommandResult(command: string, data: unknown): string;
+    /**
+     * Format list command result
+     */
+    private formatListResult;
+    /**
+     * Format trace command result
+     */
+    private formatTraceResult;
+    /**
+     * Format tree command result
+     */
+    private formatTreeResult;
+    /**
+     * Format a single tree node recursively
+     */
+    private formatTreeNode;
+    /**
+     * Format JSON in compact form
+     */
+    private formatJsonCompact;
+    /**
+     * Parse command string
+     */
+    parseCommand(input: string): ParsedCommand;
+    /**
+     * Update context
+     */
+    setContext(context: Partial<ReplContext>): void;
+    /**
+     * Get current context
+     */
+    getContext(): ReplContext;
+    /**
+     * Add to history
+     */
+    addToHistory(command: string): void;
+    /**
+     * Get history
+     */
+    getHistory(): string[];
+}
+//# sourceMappingURL=repl-formatter.d.ts.map

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

@@ -0,0 +1,309 @@
+/**
+ * @fileoverview REPL Formatter for Interactive Debugging
+ *
+ * Provides an interactive REPL interface for debugging with:
+ * - Command parsing
+ * - Output formatting
+ * - Help text generation
+ */
+/**
+ * Formats output for REPL interface and provides command parsing
+ */
+export class ReplFormatter {
+    context = {};
+    history = [];
+    /**
+     * Get welcome message for REPL
+     */
+    getWelcomeMessage() {
+        return `========================================
+  Debug REPL - Interactive Debugger
+========================================
+
+Commands:
+  list [limit]     - List trace IDs
+  trace [options]  - Show trace details
+  tree [options]   - Show call tree
+  help             - Show this help
+  exit             - Exit REPL
+
+Examples:
+  list 10
+  trace --func llm.invoke
+  tree --trace trace-001
+
+========================================
+`;
+    }
+    /**
+     * Format prompt with current context
+     */
+    formatPrompt(context) {
+        const ctx = { ...this.context, ...context };
+        let prompt = 'debug';
+        if (ctx.traceId) {
+            prompt += `:${ctx.traceId}`;
+        }
+        else if (ctx.function) {
+            prompt += `:${ctx.function}`;
+        }
+        return `${prompt}> `;
+    }
+    /**
+     * Get help text
+     */
+    getHelpText() {
+        return `
+Available Commands:
+==================
+list [n]              - List recent trace IDs (default: 10)
+trace [options]       - Show trace details
+  --func <name>       - Filter by function name
+  --trace <id>        - Show specific trace
+  --pretty            - Pretty print output
+  --limit <n>         - Limit results
+tree [options]        - Show call tree
+  --func <name>       - Show tree for function
+  --trace <id>        - Show tree for trace
+clear                 - Clear screen
+help                  - Show this help
+exit                  - Exit REPL
+`;
+    }
+    /**
+     * Format command result
+     */
+    formatCommandResult(command, data) {
+        switch (command) {
+            case 'list':
+                return this.formatListResult(data);
+            case 'trace':
+                return this.formatTraceResult(data);
+            case 'tree':
+                return this.formatTreeResult(data);
+            default:
+                return `Unknown command: ${command}`;
+        }
+    }
+    /**
+     * Format list command result
+     */
+    formatListResult(data) {
+        const { traceIds, count } = data;
+        if (traceIds.length === 0) {
+            return 'No traces found.';
+        }
+        let output = '\n';
+        output += '  TraceId            First Time              Count\n';
+        output += '  ' + '-'.repeat(70) + '\n';
+        for (const trace of traceIds) {
+            const time = trace.firstTime.replace('T', ' ').substring(0, 19);
+            output += `  ${trace.traceId.padEnd(18)} ${time.padEnd(22)} ${trace.count}\n`;
+        }
+        output += `\n  Total: ${count} traces\n`;
+        return output;
+    }
+    /**
+     * Format trace command result
+     */
+    formatTraceResult(entries) {
+        if (entries.length === 0) {
+            return 'No traces found.';
+        }
+        let output = '';
+        let currentTraceId = null;
+        for (const entry of entries) {
+            if (entry.traceId !== currentTraceId) {
+                currentTraceId = entry.traceId;
+                output += `\n=== Trace: ${entry.traceId} ===\n\n`;
+            }
+            if (entry.action === 'enter') {
+                output += `>>> ${entry.function} enter:`;
+                if (entry.params) {
+                    output += '\n' + this.formatJsonCompact(entry.params);
+                }
+                output += '\n';
+            }
+            else if (entry.action === 'quit') {
+                output += `<<< ${entry.function} quit`;
+                if (entry.durationMs !== undefined) {
+                    output += ` (${entry.durationMs}ms)`;
+                }
+                if (entry.result) {
+                    output += ':\n' + this.formatJsonCompact(entry.result);
+                }
+                output += '\n';
+            }
+            else if (entry.action === 'error') {
+                output += `!!! ${entry.function} error: ${entry.error}\n`;
+            }
+        }
+        return output;
+    }
+    /**
+     * Format tree command result
+     */
+    formatTreeResult(trees) {
+        if (trees.length === 0) {
+            return 'No trees found.';
+        }
+        let output = '';
+        for (const tree of trees) {
+            output += this.formatTreeNode(tree, '');
+        }
+        return output;
+    }
+    /**
+     * Format a single tree node recursively
+     */
+    formatTreeNode(node, prefix) {
+        const duration = node.durationMs !== undefined ? ` (${node.durationMs}ms)` : '';
+        let output = `${prefix}${node.function}${duration}\n`;
+        const childPrefix = prefix + '  ';
+        for (let i = 0; i < node.children.length; i++) {
+            const isLast = i === node.children.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            output += this.formatTreeNode(node.children[i], childPrefix + connector);
+        }
+        return output;
+    }
+    /**
+     * Format JSON in compact form
+     */
+    formatJsonCompact(data, indent = 2) {
+        const spaces = '  '.repeat(indent);
+        if (data === null || data === undefined) {
+            return `${spaces}null\n`;
+        }
+        if (typeof data === 'string') {
+            // Handle long strings
+            if (data.length > 200) {
+                return `${spaces}"${data.substring(0, 200)}..."\n`;
+            }
+            return `${spaces}"${data}"\n`;
+        }
+        if (typeof data === 'number' || typeof data === 'boolean') {
+            return `${spaces}${data}\n`;
+        }
+        if (Array.isArray(data)) {
+            if (data.length === 0)
+                return `${spaces}[]\n`;
+            let output = `${spaces}[\n`;
+            for (const item of data) {
+                output += this.formatJsonCompact(item, indent + 1);
+            }
+            output += `${spaces}]\n`;
+            return output;
+        }
+        if (typeof data === 'object') {
+            const entries = Object.entries(data);
+            if (entries.length === 0)
+                return `${spaces}{}\n`;
+            let output = `${spaces}{\n`;
+            for (const [key, val] of entries) {
+                output += `${spaces}  ${key}: ${JSON.stringify(val).substring(0, 50)}`;
+                if (JSON.stringify(val).length > 50) {
+                    output += '...';
+                }
+                output += '\n';
+            }
+            output += `${spaces}}\n`;
+            return output;
+        }
+        return `${spaces}${String(data)}\n`;
+    }
+    /**
+     * Parse command string
+     */
+    parseCommand(input) {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            return { command: 'help', args: {} };
+        }
+        // Handle exit commands
+        if (['exit', 'quit', 'q'].includes(trimmed.toLowerCase())) {
+            return { command: 'exit', args: {} };
+        }
+        // Handle clear
+        if (trimmed.toLowerCase() === 'clear') {
+            return { command: 'clear', args: {} };
+        }
+        // Handle help
+        if (['help', '?', 'h'].includes(trimmed.toLowerCase())) {
+            return { command: 'help', args: {} };
+        }
+        // Parse command and args
+        const parts = trimmed.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+        if (parts.length === 0) {
+            return { command: 'help', args: {} };
+        }
+        const command = parts[0]?.toLowerCase() ?? '';
+        const args = {};
+        // Parse named arguments
+        for (let i = 1; i < parts.length; i++) {
+            const part = parts[i];
+            if (part.startsWith('--')) {
+                const key = part.substring(2);
+                const next = parts[i + 1];
+                if (next && !next.startsWith('--')) {
+                    args[key] = next;
+                    i++;
+                }
+                else {
+                    args[key] = 'true';
+                }
+            }
+            else if (part.startsWith('-')) {
+                const key = part.substring(1);
+                const next = parts[i + 1];
+                if (next && !next.startsWith('-')) {
+                    args[key] = next;
+                    i++;
+                }
+                else {
+                    args[key] = 'true';
+                }
+            }
+            else {
+                // Positional arguments
+                if (command === 'list' && !args.limit) {
+                    args.limit = part;
+                }
+                else if (command === 'trace' && !args.func) {
+                    args.func = part;
+                }
+                else if (command === 'tree' && !args.func) {
+                    args.func = part;
+                }
+            }
+        }
+        return { command, args };
+    }
+    /**
+     * Update context
+     */
+    setContext(context) {
+        this.context = { ...this.context, ...context };
+    }
+    /**
+     * Get current context
+     */
+    getContext() {
+        return { ...this.context };
+    }
+    /**
+     * Add to history
+     */
+    addToHistory(command) {
+        if (command.trim() && this.history[this.history.length - 1] !== command) {
+            this.history.push(command);
+        }
+    }
+    /**
+     * Get history
+     */
+    getHistory() {
+        return [...this.history];
+    }
+}
+//# sourceMappingURL=repl-formatter.js.map

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

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

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

@@ -0,0 +1,119 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { ReplFormatter } from "./repl-formatter.js";
+// Mock readline
+const mockReadline = {
+    createInterface: mock(() => ({
+        on: mock(() => { }),
+        close: mock(() => { }),
+    })),
+};
+describe('ReplFormatter', () => {
+    let formatter;
+    beforeEach(() => {
+        formatter = new ReplFormatter();
+    });
+    test('should create ReplFormatter instance', () => {
+        expect(formatter).toBeDefined();
+    });
+    test('should have welcome message', () => {
+        const welcome = formatter.getWelcomeMessage();
+        expect(welcome).toContain('Debug REPL');
+        expect(welcome).toContain('Commands:');
+    });
+    test('should format prompt with context', () => {
+        const prompt = formatter.formatPrompt();
+        expect(prompt).toContain('debug');
+    });
+    test('should format prompt with trace context', () => {
+        const prompt = formatter.formatPrompt({ traceId: 'trace-001' });
+        expect(prompt).toContain('trace-001');
+    });
+    test('should format prompt with function context', () => {
+        const prompt = formatter.formatPrompt({ function: 'llm.invoke' });
+        expect(prompt).toContain('llm.invoke');
+    });
+    test('should return help text', () => {
+        const help = formatter.getHelpText();
+        expect(help).toContain('list');
+        expect(help).toContain('trace');
+        expect(help).toContain('tree');
+        expect(help).toContain('exit');
+    });
+    test('should format command result - list', () => {
+        const mockTraces = [
+            { traceId: 'trace-001', firstTime: '2026-04-08T10:00:00', count: 2 },
+            { traceId: 'trace-002', firstTime: '2026-04-08T10:01:00', count: 1 },
+        ];
+        const result = formatter.formatCommandResult('list', { traceIds: mockTraces, count: 2 });
+        expect(result).toContain('trace-001');
+        expect(result).toContain('trace-002');
+    });
+    test('should format command result - trace', () => {
+        const mockEntries = [
+            {
+                traceId: 'trace-001',
+                timestamp: '2026-04-08T10:00:00',
+                function: 'llm.invoke',
+                action: 'enter',
+                params: [{ msg: 'hello' }],
+            },
+            {
+                traceId: 'trace-001',
+                timestamp: '2026-04-08T10:00:01',
+                function: 'llm.invoke',
+                action: 'quit',
+                result: { content: 'hi' },
+                durationMs: 1000,
+            },
+        ];
+        const result = formatter.formatCommandResult('trace', mockEntries);
+        expect(result).toContain('>>>');
+        expect(result).toContain('<<<');
+        expect(result).toContain('llm.invoke');
+    });
+    test('should format command result - tree', () => {
+        const mockTree = {
+            traceId: 'trace-001',
+            function: 'root',
+            startTime: '2026-04-08T10:00:00',
+            children: [
+                {
+                    traceId: 'trace-001',
+                    function: 'child1',
+                    startTime: '2026-04-08T10:00:01',
+                    children: [],
+                    entry: {},
+                },
+            ],
+            entry: {},
+        };
+        const result = formatter.formatCommandResult('tree', [mockTree]);
+        expect(result).toContain('root');
+        expect(result).toContain('child1');
+    });
+    test('should handle empty results', () => {
+        const result = formatter.formatCommandResult('trace', []);
+        expect(result).toContain('No');
+        expect(result).toContain('trace');
+    });
+    test('should handle unknown command', () => {
+        const result = formatter.formatCommandResult('unknown', {});
+        expect(result).toContain('Unknown');
+    });
+    test('should parse simple commands', () => {
+        expect(formatter.parseCommand('list')).toEqual({ command: 'list', args: {} });
+        expect(formatter.parseCommand('list 5')).toEqual({ command: 'list', args: { limit: '5' } });
+        expect(formatter.parseCommand('trace --func llm')).toEqual({ command: 'trace', args: { func: 'llm' } });
+        expect(formatter.parseCommand('trace -f llm')).toEqual({ command: 'trace', args: { f: 'llm' } });
+    });
+    test('should return unknown for invalid command', () => {
+        const result = formatter.parseCommand('invalid command');
+        expect(result.command).toBe('invalid');
+    });
+    test('should handle exit command', () => {
+        expect(formatter.parseCommand('exit')).toEqual({ command: 'exit', args: {} });
+        expect(formatter.parseCommand('quit')).toEqual({ command: 'exit', args: {} });
+        expect(formatter.parseCommand('q')).toEqual({ command: 'exit', args: {} });
+    });
+});
+//# sourceMappingURL=repl-formatter.test.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * @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
+ */
+import type { TraceEntry, FormatOptions } from '../types';
+/**
+ * Formats trace entries for human-readable output
+ */
+export declare class TraceFormatter {
+    /**
+     * Format a single trace entry
+     */
+    formatEntry(entry: TraceEntry, options?: FormatOptions): string;
+    /**
+     * Indent all lines after the first one
+     */
+    private indentMultilineContent;
+    /**
+     * Format multiple trace entries
+     */
+    formatEntries(entries: TraceEntry[], options?: FormatOptions): string;
+    /**
+     * Format data with proper indentation for multi-line content
+     */
+    private formatData;
+    /**
+     * Format data with pretty printing and indentation
+     */
+    private formatPretty;
+    /**
+     * Output as JSON
+     */
+    toJSON(entries: TraceEntry[]): string;
+    /**
+     * Generate a summary of trace entries
+     */
+    toSummary(entries: TraceEntry[]): string;
+}
+//# sourceMappingURL=trace-formatter.d.ts.map