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

package/dist/core/src/env/debug/parser/span-builder.js

@@ -0,0 +1,321 @@
+/**
+ * @fileoverview Span Builder
+ *
+ * Builds TraceEntry objects from parsed log lines and constructs call trees.
+ */
+import { RegexParser } from "./regex-parser.js";
+/**
+ * Span Builder for constructing trace entries and call trees
+ */
+export class SpanBuilder {
+    parser;
+    constructor() {
+        this.parser = new RegexParser();
+    }
+    /**
+     * Build trace entries from parsed log lines
+     */
+    buildTraceEntries(lines) {
+        const entries = [];
+        for (const line of lines) {
+            const entry = this.buildTraceEntry(line);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        // Sort by timestamp
+        entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        return entries;
+    }
+    /**
+     * Build a single trace entry from a parsed log line
+     */
+    buildTraceEntry(line) {
+        // Use requestId from parsed line if available, otherwise extract from raw line
+        const traceId = line.requestId || this.extractTraceId(line.raw);
+        const entry = {
+            // Use traceId if available, otherwise generate a virtual one based on function and timestamp
+            traceId: traceId || this.generateVirtualTraceId(line.method, line.timestamp),
+            timestamp: line.timestamp,
+            function: line.method,
+            action: line.actionType,
+        };
+        // Parse args based on action type
+        switch (line.actionType) {
+            case 'enter':
+                entry.params = this.parser.parseArgs(line.rawArgs);
+                break;
+            case 'quit':
+                entry.result = this.parser.parseArgs(line.rawArgs);
+                break;
+            case 'error':
+                entry.error = line.rawArgs;
+                break;
+        }
+        return entry;
+    }
+    /**
+     * Generate a virtual trace ID when no real traceId is present
+     * Uses function name and timestamp to create a pseudo-traceId
+     */
+    generateVirtualTraceId(functionName, timestamp) {
+        // Create a hash-like ID from function name and timestamp
+        const base = `${functionName}:${timestamp}`;
+        let hash = 0;
+        for (let i = 0; i < base.length; i++) {
+            const char = base.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return `vtrace_${Math.abs(hash).toString(36)}`;
+    }
+    /**
+     * Extract trace ID from log line
+     */
+    extractTraceId(line) {
+        return this.parser.extractTraceId(line);
+    }
+    /**
+     * Calculate duration between enter and quit entries
+     */
+    calculateDuration(enter, quit) {
+        try {
+            const enterTime = new Date(enter.timestamp).getTime();
+            const quitTime = new Date(quit.timestamp).getTime();
+            if (isNaN(enterTime) || isNaN(quitTime)) {
+                return 0;
+            }
+            return quitTime - enterTime;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Pair enter and quit entries
+     */
+    pairEnterQuit(entries) {
+        const paired = [];
+        const enterStack = [];
+        for (const entry of entries) {
+            if (entry.action === 'enter') {
+                enterStack.push(entry);
+            }
+            else if (entry.action === 'quit' && enterStack.length > 0) {
+                // Match with the most recent unmatched enter
+                const enter = enterStack.pop();
+                const duration = this.calculateDuration(enter, entry);
+                paired.push({
+                    enter,
+                    quit: entry,
+                    durationMs: duration,
+                });
+            }
+        }
+        return paired;
+    }
+    /**
+     * Build a call tree from trace entries using call stack tracking
+     *
+     * Enhanced to support both:
+     * 1. Traditional enter/quit pair-based tree building (from log files)
+     * 2. Parent-child hierarchy-based tree building (from SQLite spans)
+     */
+    buildCallTree(entries) {
+        if (entries.length === 0) {
+            return null;
+        }
+        // Check if entries contain parent-child info (from SQLite spans)
+        // Entries from SQLite have spanId/parentSpanId as direct properties
+        const hasSpanHierarchy = entries.some(e => e.spanId !== undefined || e.parentSpanId !== undefined);
+        if (hasSpanHierarchy) {
+            return this.buildCallTreeFromHierarchy(entries);
+        }
+        // Fall back to traditional enter/quit pairing
+        return this.buildCallTreeFromPairs(entries);
+    }
+    /**
+     * Build call tree from parent-child span hierarchy (for SQLite spans)
+     */
+    buildCallTreeFromHierarchy(entries) {
+        // Build a map of spanId -> node
+        const nodeMap = new Map();
+        const rootNodes = [];
+        const addedToRoots = new Set();
+        // Create nodes from entries - only process 'enter' entries for the tree
+        const enterEntries = entries.filter(e => e.action === 'enter');
+        for (const entry of enterEntries) {
+            const spanId = entry.spanId;
+            const parentSpanId = entry.parentSpanId;
+            // Skip if already processed
+            if (spanId && nodeMap.has(spanId)) {
+                continue;
+            }
+            // Create node
+            const node = {
+                traceId: entry.traceId,
+                function: entry.function,
+                startTime: entry.timestamp,
+                // Find corresponding quit entry for duration
+                endTime: undefined,
+                durationMs: entry.durationMs,
+                children: [],
+                entry,
+                spanId,
+                parentSpanId,
+            };
+            if (spanId) {
+                nodeMap.set(spanId, node);
+            }
+            // Track as root candidate if no parent or parent not in same trace
+            if (!parentSpanId || !nodeMap.has(parentSpanId)) {
+                rootNodes.push(node);
+                if (spanId)
+                    addedToRoots.add(spanId);
+            }
+        }
+        // Find quit entries and update endTime/duration
+        const quitEntries = entries.filter(e => e.action === 'quit');
+        for (const quit of quitEntries) {
+            if (quit.spanId) {
+                const node = nodeMap.get(quit.spanId);
+                if (node) {
+                    node.endTime = quit.timestamp;
+                    node.durationMs = quit.durationMs || (node.endTime && node.startTime
+                        ? new Date(node.endTime).getTime() - new Date(node.startTime).getTime()
+                        : undefined);
+                }
+            }
+        }
+        // Build parent-child relationships
+        // Only connect to parent if it belongs to the same trace
+        for (const node of nodeMap.values()) {
+            if (node.parentSpanId && nodeMap.has(node.parentSpanId)) {
+                const parent = nodeMap.get(node.parentSpanId);
+                // Only add as child if parent is in the same trace
+                if (parent.traceId === node.traceId) {
+                    parent.children.push(node);
+                    // Remove from roots if it was added there
+                    rootNodes.splice(rootNodes.indexOf(node), 1);
+                }
+            }
+        }
+        // If no explicit roots, try to find from entries without parentSpanId
+        if (rootNodes.length === 0) {
+            for (const entry of enterEntries) {
+                if (!entry.parentSpanId) {
+                    const spanId = entry.spanId;
+                    if (spanId && nodeMap.has(spanId) && !addedToRoots.has(spanId)) {
+                        rootNodes.push(nodeMap.get(spanId));
+                    }
+                }
+            }
+        }
+        // Sort roots by start time
+        rootNodes.sort((a, b) => a.startTime.localeCompare(b.startTime));
+        // Merge multiple root nodes into a single tree if needed
+        if (rootNodes.length === 0) {
+            return null;
+        }
+        if (rootNodes.length === 1) {
+            return rootNodes[0];
+        }
+        // Create a virtual root node if multiple roots exist
+        const allStartTimes = rootNodes.map(n => new Date(n.startTime).getTime());
+        const allEndTimes = rootNodes.map(n => n.endTime ? new Date(n.endTime).getTime() : 0).filter(t => t > 0);
+        return {
+            traceId: entries[0]?.traceId || 'merged',
+            function: '(root)',
+            children: rootNodes,
+            startTime: new Date(Math.min(...allStartTimes)).toISOString(),
+            endTime: allEndTimes.length > 0
+                ? new Date(Math.max(...allEndTimes)).toISOString()
+                : undefined,
+            durationMs: allEndTimes.length > 0 && allStartTimes.length > 0
+                ? Math.max(...allEndTimes) - Math.min(...allStartTimes)
+                : undefined,
+        };
+    }
+    /**
+     * Build call tree from traditional enter/quit pairs (for log files)
+     */
+    buildCallTreeFromPairs(entries) {
+        // Sort entries by timestamp to ensure correct call stack order
+        const sortedEntries = [...entries].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        // Pair enter/quit entries first
+        const paired = this.pairEnterQuit(sortedEntries);
+        if (paired.length === 0) {
+            return null;
+        }
+        // Build tree using call stack simulation
+        const stack = [];
+        let root = null;
+        // Process sorted entries sequentially to track call depth
+        for (const entry of sortedEntries) {
+            if (entry.action === 'enter') {
+                // Find the paired quit for this enter
+                const span = paired.find(p => p.enter === entry);
+                if (!span)
+                    continue;
+                const node = this.buildNodeFromPaired(span);
+                if (stack.length === 0) {
+                    // This is the root
+                    root = node;
+                }
+                else {
+                    // Add to current parent's children
+                    stack[stack.length - 1].node.children.push(node);
+                }
+                stack.push({ node, paired: span });
+            }
+            else if (entry.action === 'quit' && stack.length > 0) {
+                // Pop the stack - the function is returning
+                stack.pop();
+            }
+        }
+        return root;
+    }
+    /**
+     * Build a tree node from a paired span
+     */
+    buildNodeFromPaired(span) {
+        return {
+            traceId: span.enter.traceId,
+            function: span.enter.function,
+            startTime: span.enter.timestamp,
+            endTime: span.quit.timestamp,
+            durationMs: span.durationMs,
+            children: [],
+            entry: span.enter,
+        };
+    }
+    /**
+     * Merge entries from multiple functions into a single call tree
+     */
+    buildMergedTree(entriesByFunction) {
+        // Get all entries across functions, sorted by timestamp
+        const allEntries = [];
+        for (const entries of entriesByFunction.values()) {
+            allEntries.push(...entries);
+        }
+        allEntries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        return this.buildCallTree(allEntries);
+    }
+    /**
+     * Get duration summary for entries
+     */
+    getDurationSummary(entries) {
+        const summary = new Map();
+        const paired = this.pairEnterQuit(entries);
+        for (const span of paired) {
+            const func = span.enter.function;
+            const existing = summary.get(func) || { count: 0, totalMs: 0, avgMs: 0 };
+            existing.count++;
+            existing.totalMs += span.durationMs;
+            existing.avgMs = Math.round(existing.totalMs / existing.count);
+            summary.set(func, existing);
+        }
+        return summary;
+    }
+}
+//# sourceMappingURL=span-builder.js.map

package/dist/core/src/env/debug/parser/span-builder.test.d.ts

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

package/dist/core/src/env/debug/parser/span-builder.test.js

@@ -0,0 +1,207 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { SpanBuilder } from "./span-builder.js";
+describe('SpanBuilder', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new SpanBuilder();
+    });
+    describe('buildTraceEntries', () => {
+        test('should build entries from parsed lines', () => {
+            const lines = [
+                {
+                    raw: '2026-04-08 19:12:36.134 [INFO] [source][traced:llm] [TRACE] >>> llm.invoke enter: [{}]',
+                    timestamp: '2026-04-08T19:12:36.134',
+                    level: 'INFO',
+                    source: 'source',
+                    category: 'traced:llm',
+                    action: '>>>',
+                    method: 'llm.invoke',
+                    actionType: 'enter',
+                    rawArgs: '[{}]',
+                },
+                {
+                    raw: '2026-04-08 19:12:39.213 [INFO] [source][traced:llm] [TRACE] <<< llm.invoke quit: {}',
+                    timestamp: '2026-04-08T19:12:39.213',
+                    level: 'INFO',
+                    source: 'source',
+                    category: 'traced:llm',
+                    action: '<<<',
+                    method: 'llm.invoke',
+                    actionType: 'quit',
+                    rawArgs: '{}',
+                },
+            ];
+            const entries = builder.buildTraceEntries(lines);
+            expect(entries).toHaveLength(2);
+            expect(entries[0].action).toBe('enter');
+            expect(entries[1].action).toBe('quit');
+        });
+        test('should extract params from enter action', () => {
+            const lines = [
+                {
+                    raw: 'test',
+                    timestamp: '2026-04-08T19:12:36.134',
+                    level: 'INFO',
+                    source: 'source',
+                    category: 'traced:llm',
+                    action: '>>>',
+                    method: 'llm.invoke',
+                    actionType: 'enter',
+                    rawArgs: '[{"messages":[]},{"model":"gpt-4"}]',
+                },
+            ];
+            const entries = builder.buildTraceEntries(lines);
+            expect(entries[0].params).toEqual([{ messages: [] }, { model: 'gpt-4' }]);
+        });
+        test('should extract result from quit action', () => {
+            const lines = [
+                {
+                    raw: 'test',
+                    timestamp: '2026-04-08T19:12:39.213',
+                    level: 'INFO',
+                    source: 'source',
+                    category: 'traced:llm',
+                    action: '<<<',
+                    method: 'llm.invoke',
+                    actionType: 'quit',
+                    rawArgs: '{"output":"Hello","latencyMs":100}',
+                },
+            ];
+            const entries = builder.buildTraceEntries(lines);
+            expect(entries[0].result).toEqual({ output: 'Hello', latencyMs: 100 });
+        });
+        test('should extract error from error action', () => {
+            const lines = [
+                {
+                    raw: 'test',
+                    timestamp: '2026-04-08T19:12:39.213',
+                    level: 'ERROR',
+                    source: 'source',
+                    category: 'traced:llm',
+                    action: '!!!',
+                    method: 'llm.invoke',
+                    actionType: 'error',
+                    rawArgs: 'Connection timeout',
+                },
+            ];
+            const entries = builder.buildTraceEntries(lines);
+            expect(entries[0].error).toBe('Connection timeout');
+        });
+        test('should extract traceId from category', () => {
+            const lines = [
+                {
+                    raw: '2026-04-08 19:12:36.134 [INFO] [source][requestId=req_123][traced:llm] [TRACE] >>> llm.invoke enter: [{}]',
+                    timestamp: '2026-04-08T19:12:36.134',
+                    level: 'INFO',
+                    source: 'source',
+                    category: 'requestId=req_123][traced:llm',
+                    action: '>>>',
+                    method: 'llm.invoke',
+                    actionType: 'enter',
+                    rawArgs: '[{}]',
+                },
+            ];
+            const entries = builder.buildTraceEntries(lines);
+            expect(entries[0].traceId).toBe('req_123');
+        });
+    });
+    describe('calculateDuration', () => {
+        test('should calculate duration between enter and quit', () => {
+            const enter = {
+                traceId: 'req_123',
+                timestamp: '2026-04-08T19:12:36.134',
+                function: 'llm.invoke',
+                action: 'enter',
+            };
+            const quit = {
+                traceId: 'req_123',
+                timestamp: '2026-04-08T19:12:39.213',
+                function: 'llm.invoke',
+                action: 'quit',
+            };
+            const duration = builder.calculateDuration(enter, quit);
+            expect(duration).toBe(3079); // ~3079ms
+        });
+        test('should return 0 for invalid timestamps', () => {
+            const enter = {
+                traceId: 'req_123',
+                timestamp: 'invalid',
+                function: 'llm.invoke',
+                action: 'enter',
+            };
+            const quit = {
+                traceId: 'req_123',
+                timestamp: '2026-04-08T19:12:39.213',
+                function: 'llm.invoke',
+                action: 'quit',
+            };
+            const duration = builder.calculateDuration(enter, quit);
+            expect(duration).toBe(0);
+        });
+    });
+    describe('buildCallTree', () => {
+        test('should build single node tree', () => {
+            const entries = [
+                {
+                    traceId: 'req_123',
+                    timestamp: '2026-04-08T19:12:36.134',
+                    function: 'llm.invoke',
+                    action: 'enter',
+                },
+                {
+                    traceId: 'req_123',
+                    timestamp: '2026-04-08T19:12:39.213',
+                    function: 'llm.invoke',
+                    action: 'quit',
+                    durationMs: 3079,
+                },
+            ];
+            const tree = builder.buildCallTree(entries);
+            expect(tree).not.toBeNull();
+            expect(tree.function).toBe('llm.invoke');
+            expect(tree.durationMs).toBe(3079);
+            expect(tree.children).toHaveLength(0);
+        });
+        test('should return null for empty entries', () => {
+            const tree = builder.buildCallTree([]);
+            expect(tree).toBeNull();
+        });
+        test('should return null for unmatched enter/quit', () => {
+            const entries = [
+                {
+                    traceId: 'req_123',
+                    timestamp: '2026-04-08T19:12:36.134',
+                    function: 'llm.invoke',
+                    action: 'enter',
+                },
+            ];
+            const tree = builder.buildCallTree(entries);
+            expect(tree).toBeNull();
+        });
+    });
+    describe('pairEnterQuit', () => {
+        test('should pair enter and quit entries', () => {
+            const entries = [
+                {
+                    traceId: 'req_123',
+                    timestamp: '2026-04-08T19:12:36.134',
+                    function: 'llm.invoke',
+                    action: 'enter',
+                    params: [{ arg1: 'value1' }],
+                },
+                {
+                    traceId: 'req_123',
+                    timestamp: '2026-04-08T19:12:39.213',
+                    function: 'llm.invoke',
+                    action: 'quit',
+                    result: { output: 'result' },
+                },
+            ];
+            const paired = builder.pairEnterQuit(entries);
+            expect(paired).toHaveLength(1);
+            expect(paired[0].enter.params).toEqual([{ arg1: 'value1' }]);
+            expect(paired[0].quit.result).toEqual({ output: 'result' });
+        });
+    });
+});
+//# sourceMappingURL=span-builder.test.js.map

package/dist/core/src/env/debug/reader/log-reader.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Log Reader
+ *
+ * Reads log files with support for streaming and filtering.
+ */
+import type { ParserOptions } from '../types';
+/**
+ * Get XDG data home directory
+ */
+export declare function getXDGDataHome(): string;
+/**
+ * Log Reader for reading and parsing log files
+ */
+export declare class LogReader {
+    private logDir;
+    constructor(options?: {
+        logDir?: string;
+    });
+    /**
+     * Get the full path to a log file
+     */
+    getLogPath(filename?: string): string;
+    /**
+     * Find log files matching a pattern
+     *
+     * Uses forward slashes for glob patterns to ensure cross-platform compatibility.
+     * The glob library requires forward slashes regardless of OS.
+     */
+    findLogFiles(pattern?: string): Promise<string[]>;
+    /**
+     * Get default log directory
+     */
+    getDefaultLogDir(): string;
+    /**
+     * Read lines from a log file with optional filtering
+     */
+    readLines(filepath: string, options?: ParserOptions): AsyncGenerator<string>;
+    /**
+     * Extract timestamp from a log line
+     */
+    extractTimestamp(line: string): number | null;
+    /**
+     * Parse time string to timestamp
+     * Supports ISO format and relative time like "1h", "30m"
+     */
+    parseTime(timeStr: string): number;
+    /**
+     * Read file content directly (for small files)
+     */
+    readFile(filepath: string): Promise<string>;
+    /**
+     * Check if a log file exists
+     */
+    exists(filepath: string): boolean;
+}
+//# sourceMappingURL=log-reader.d.ts.map