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

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

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

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

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

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

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