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

package/dist/core/src/env/debug/reader/log-reader.js

@@ -1,163 +0,0 @@
-/**
- * @fileoverview Log Reader
- *
- * Reads log files with support for streaming and filtering.
- */
-import * as fs from 'fs';
-import * as readline from 'readline';
-import * as path from 'path';
-import { glob } from 'glob';
-/**
- * Default XDG log directory
- */
-const DEFAULT_LOG_DIR = '.local/share/roy-agent/logs';
-/**
- * Get XDG data home directory
- */
-export function getXDGDataHome() {
-    return process.env.XDG_DATA_HOME ||
-        path.join(process.env.HOME || '/home/' + (process.env.USER || 'user'), '.local', 'share');
-}
-/**
- * Log Reader for reading and parsing log files
- */
-export class LogReader {
-    logDir;
-    constructor(options) {
-        this.logDir = options?.logDir ||
-            path.join(getXDGDataHome(), 'roy-agent', 'logs');
-    }
-    /**
-     * Get the full path to a log file
-     */
-    getLogPath(filename) {
-        if (!filename) {
-            return path.join(this.logDir, 'app.log');
-        }
-        // If absolute path, use directly
-        if (path.isAbsolute(filename)) {
-            return filename;
-        }
-        return path.join(this.logDir, filename);
-    }
-    /**
-     * 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.
-     */
-    async findLogFiles(pattern = '*.log') {
-        try {
-            // Use forward slashes for glob pattern to ensure Windows compatibility
-            const normalizedDir = this.logDir.replace(/\\/g, "/");
-            const fullPattern = `${normalizedDir}/${pattern}`;
-            const files = await glob(fullPattern);
-            return files.sort(); // Sort by name
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Get default log directory
-     */
-    getDefaultLogDir() {
-        return this.logDir;
-    }
-    /**
-     * Read lines from a log file with optional filtering
-     */
-    async *readLines(filepath, options) {
-        const sinceTime = options?.since ? this.parseTime(options.since) : null;
-        const untilTime = options?.until ? this.parseTime(options.until) : null;
-        // Check if file exists
-        if (!fs.existsSync(filepath)) {
-            return;
-        }
-        const fileStream = fs.createReadStream(filepath, { encoding: 'utf-8' });
-        const rl = readline.createInterface({
-            input: fileStream,
-            crlfDelay: Infinity,
-        });
-        try {
-            for await (const line of rl) {
-                if (!line.trim())
-                    continue;
-                // Filter by time if specified
-                if (sinceTime || untilTime) {
-                    const lineTime = this.extractTimestamp(line);
-                    if (lineTime) {
-                        if (sinceTime && lineTime < sinceTime)
-                            continue;
-                        if (untilTime && lineTime > untilTime)
-                            continue;
-                    }
-                }
-                yield line;
-            }
-        }
-        finally {
-            rl.close();
-            fileStream.destroy();
-        }
-    }
-    /**
-     * Extract timestamp from a log line
-     */
-    extractTimestamp(line) {
-        // Match format: 2026-04-08 19:12:36.134 or 2026-04-08T19:12:36.134
-        const match = line.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})/);
-        if (!match)
-            return null;
-        const datePart = match[1];
-        const timePart = match[2]; // Keep original format (10:00:00)
-        const isoString = `${datePart}T${timePart}`;
-        const timestamp = new Date(isoString).getTime();
-        return isNaN(timestamp) ? null : timestamp;
-    }
-    /**
-     * Parse time string to timestamp
-     * Supports ISO format and relative time like "1h", "30m"
-     */
-    parseTime(timeStr) {
-        const now = Date.now();
-        // Normalize the time string (replace T with space for parsing)
-        const normalizedStr = timeStr.replace('T', ' ');
-        // Try parsing as absolute time
-        const absoluteTime = new Date(normalizedStr).getTime();
-        if (!isNaN(absoluteTime) && absoluteTime > 0) {
-            return absoluteTime;
-        }
-        // Also try original format
-        const originalTime = new Date(timeStr).getTime();
-        if (!isNaN(originalTime) && originalTime > 0) {
-            return originalTime;
-        }
-        // Parse relative time
-        const relativeMatch = timeStr.match(/^(\d+)([hms])$/);
-        if (relativeMatch) {
-            const value = parseInt(relativeMatch[1], 10);
-            const unit = relativeMatch[2];
-            switch (unit) {
-                case 'h': return now - value * 60 * 60 * 1000;
-                case 'm': return now - value * 60 * 1000;
-                case 's': return now - value * 1000;
-            }
-        }
-        // Default to current time if parsing fails
-        return now;
-    }
-    /**
-     * Read file content directly (for small files)
-     */
-    async readFile(filepath) {
-        return fs.promises.readFile(filepath, 'utf-8');
-    }
-    /**
-     * Check if a log file exists
-     */
-    exists(filepath) {
-        return fs.existsSync(filepath);
-    }
-}
-//# sourceMappingURL=log-reader.js.map

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

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

package/dist/core/src/env/debug/reader/log-reader.test.js

@@ -1,132 +0,0 @@
-import { describe, expect, test, beforeAll, afterAll } from 'bun:test';
-import { writeFileSync, mkdirSync, rmSync } from 'fs';
-import { join } from 'path';
-import { LogReader } from "./log-reader.js";
-describe('LogReader', () => {
-    const testDir = '/tmp/roy-debug-test';
-    let reader;
-    beforeAll(() => {
-        mkdirSync(testDir, { recursive: true });
-        reader = new LogReader({ logDir: testDir });
-    });
-    afterAll(() => {
-        rmSync(testDir, { recursive: true });
-    });
-    describe('getLogPath', () => {
-        test('should return default app.log path', () => {
-            const path = reader.getLogPath();
-            expect(path).toContain('app.log');
-        });
-        test('should return custom filename path', () => {
-            const path = reader.getLogPath('custom.log');
-            expect(path).toContain('custom.log');
-        });
-        test('should use absolute path directly', () => {
-            const absPath = '/absolute/path/server.log';
-            const path = reader.getLogPath(absPath);
-            expect(path).toBe(absPath);
-        });
-    });
-    describe('findLogFiles', () => {
-        test('should return array of files', async () => {
-            const files = await reader.findLogFiles();
-            expect(Array.isArray(files)).toBe(true);
-        });
-        test('should handle custom pattern', async () => {
-            // Create test log file
-            writeFileSync(join(testDir, 'custom.log'), 'test log');
-            const files = await reader.findLogFiles('custom.log');
-            expect(Array.isArray(files)).toBe(true);
-        });
-        test('should use forward slashes for glob pattern (Windows compatibility)', async () => {
-            // Create test log files
-            writeFileSync(join(testDir, 'app.log'), 'test');
-            writeFileSync(join(testDir, 'error.log'), 'test');
-            const files = await reader.findLogFiles('*.log');
-            // Verify files are found (proves glob pattern works)
-            expect(files.length).toBeGreaterThanOrEqual(2);
-            // Verify returned paths use forward slashes (not backslashes)
-            for (const file of files) {
-                expect(file).not.toContain('\\');
-                expect(file).toContain('/');
-            }
-        });
-    });
-    describe('readLines', () => {
-        test('should read lines from file', async () => {
-            const testFile = join(testDir, 'read-test.log');
-            writeFileSync(testFile, 'line1\nline2\nline3\n');
-            const lines = [];
-            for await (const line of reader.readLines(testFile)) {
-                lines.push(line);
-            }
-            expect(lines).toEqual(['line1', 'line2', 'line3']);
-        });
-        test('should handle empty file', async () => {
-            const testFile = join(testDir, 'empty.log');
-            writeFileSync(testFile, '');
-            const lines = [];
-            for await (const line of reader.readLines(testFile)) {
-                lines.push(line);
-            }
-            expect(lines).toEqual([]);
-        });
-        test('should handle file with trailing newline', async () => {
-            const testFile = join(testDir, 'trailing.log');
-            writeFileSync(testFile, 'line1\nline2\n');
-            const lines = [];
-            for await (const line of reader.readLines(testFile)) {
-                lines.push(line);
-            }
-            expect(lines).toEqual(['line1', 'line2']);
-        });
-    });
-    describe('filterByTime', () => {
-        test('should filter by since time', async () => {
-            const testFile = join(testDir, 'time-filter.log');
-            writeFileSync(testFile, '2026-04-08 10:00:00.000 line1\n' +
-                '2026-04-08 11:00:00.000 line2\n' +
-                '2026-04-08 12:00:00.000 line3\n');
-            const lines = [];
-            for await (const line of reader.readLines(testFile, {
-                since: '2026-04-08T11:00:00'
-            })) {
-                lines.push(line);
-            }
-            expect(lines.length).toBe(2);
-            expect(lines[0]).toContain('11:00:00');
-            expect(lines[1]).toContain('12:00:00');
-        });
-        test('should filter by until time', async () => {
-            const testFile = join(testDir, 'until-filter.log');
-            writeFileSync(testFile, '2026-04-08 10:00:00.000 line1\n' +
-                '2026-04-08 11:00:00.000 line2\n' +
-                '2026-04-08 12:00:00.000 line3\n');
-            const lines = [];
-            for await (const line of reader.readLines(testFile, {
-                until: '2026-04-08T11:30:00'
-            })) {
-                lines.push(line);
-            }
-            expect(lines.length).toBe(2);
-            expect(lines[0]).toContain('10:00:00');
-            expect(lines[1]).toContain('11:00:00');
-        });
-        test('should filter by both since and until', async () => {
-            const testFile = join(testDir, 'range-filter.log');
-            writeFileSync(testFile, '2026-04-08 10:00:00.000 line1\n' +
-                '2026-04-08 11:00:00.000 line2\n' +
-                '2026-04-08 12:00:00.000 line3\n');
-            const lines = [];
-            for await (const line of reader.readLines(testFile, {
-                since: '2026-04-08T10:30:00',
-                until: '2026-04-08T11:30:00'
-            })) {
-                lines.push(line);
-            }
-            expect(lines.length).toBe(1);
-            expect(lines[0]).toContain('11:00:00');
-        });
-    });
-});
-//# sourceMappingURL=log-reader.test.js.map

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

@@ -1,71 +0,0 @@
-/**
- * @fileoverview Span DB Reader - Read spans from SQLite database
- *
- * This reader fetches trace data directly from SQLite span storage,
- * which is used for persisting spans in production environments.
- */
-import type { TraceEntry, TraceSummary } from '../types';
-import type { SpanStorage } from '../../log-trace/types';
-/**
- * Options for SpanDbReader
- */
-export interface SpanDbReaderOptions {
-    /** Database path (for file-based SQLite) */
-    dbPath?: string;
-    /** Storage instance to use directly */
-    storage?: SpanStorage;
-}
-/**
- * Span Database Reader
- *
- * Reads span data from SQLite storage for trace debugging and analysis.
- */
-export declare class SpanDbReader {
-    private storage;
-    private dbPath;
-    private sqliteDb;
-    constructor(options?: SpanDbReaderOptions);
-    /**
-     * Initialize the reader with storage
-     */
-    initialize(): Promise<void>;
-    /**
-     * Initialize SQLite storage directly
-     */
-    private initSqliteStorage;
-    /**
-     * Get trace entries for a specific traceId
-     */
-    getTraceEntries(traceId: string): Promise<TraceEntry[]>;
-    /**
-     * List all trace IDs
-     */
-    listTraceIds(limit?: number): Promise<TraceSummary>;
-    /**
-     * Convert spans to TraceEntry format
-     *
-     * Now properly extracts spanId and parentSpanId for tree building
-     */
-    private spansToEntries;
-    /**
-     * Convert span attributes to params format
-     */
-    private attributesToParams;
-    /**
-     * Get the underlying storage
-     */
-    getStorage(): SpanStorage | null;
-    /**
-     * Close the reader and cleanup resources
-     */
-    close(): void;
-}
-/**
- * Create a SpanDbReader from a database path
- */
-export declare function createSpanDbReader(dbPath: string): Promise<SpanDbReader>;
-/**
- * Create a SpanDbReader from an existing storage instance
- */
-export declare function createSpanDbReaderFromStorage(storage: SpanStorage): SpanDbReader;
-//# sourceMappingURL=span-db-reader.d.ts.map

package/dist/core/src/env/debug/reader/span-db-reader.js

@@ -1,167 +0,0 @@
-/**
- * @fileoverview Span DB Reader - Read spans from SQLite database
- *
- * This reader fetches trace data directly from SQLite span storage,
- * which is used for persisting spans in production environments.
- */
-/**
- * Span Database Reader
- *
- * Reads span data from SQLite storage for trace debugging and analysis.
- */
-export class SpanDbReader {
-    storage = null;
-    dbPath = null;
-    sqliteDb = null;
-    constructor(options) {
-        if (options?.storage) {
-            this.storage = options.storage;
-        }
-        else if (options?.dbPath) {
-            this.dbPath = options.dbPath;
-        }
-    }
-    /**
-     * Initialize the reader with storage
-     */
-    async initialize() {
-        if (this.storage) {
-            await this.storage.initialize();
-        }
-        else if (this.dbPath) {
-            // Lazy load SQLite storage
-            await this.initSqliteStorage();
-        }
-    }
-    /**
-     * Initialize SQLite storage directly
-     */
-    async initSqliteStorage() {
-        try {
-            // Dynamic import to avoid hard dependency
-            const { SQLiteSpanStorage } = await import('../../log-trace/span-storage');
-            this.storage = new SQLiteSpanStorage(this.dbPath);
-            await this.storage.initialize();
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize SQLite storage: ${error}`);
-        }
-    }
-    /**
-     * Get trace entries for a specific traceId
-     */
-    async getTraceEntries(traceId) {
-        if (!this.storage) {
-            throw new Error('Storage not initialized. Call initialize() first.');
-        }
-        const spans = this.storage.findByTraceId(traceId);
-        if (spans.length === 0) {
-            return [];
-        }
-        // Convert spans to TraceEntry format
-        return this.spansToEntries(spans);
-    }
-    /**
-     * List all trace IDs
-     */
-    async listTraceIds(limit = 20) {
-        if (!this.storage) {
-            throw new Error('Storage not initialized. Call initialize() first.');
-        }
-        const traceInfos = this.storage.listTraces(limit);
-        const traceIds = traceInfos.map(info => ({
-            traceId: info.traceId,
-            firstTime: new Date(info.startTime).toISOString(),
-            lastTime: info.endTime ? new Date(info.endTime).toISOString() : undefined,
-            count: info.spanCount,
-        }));
-        return {
-            traceIds,
-            count: traceInfos.length,
-        };
-    }
-    /**
-     * Convert spans to TraceEntry format
-     *
-     * Now properly extracts spanId and parentSpanId for tree building
-     */
-    spansToEntries(spans) {
-        const entries = [];
-        // Create entries for each span (enter event)
-        for (const span of spans) {
-            entries.push({
-                traceId: span.traceId,
-                timestamp: new Date(span.startTime).toISOString(),
-                function: span.name,
-                action: 'enter',
-                params: this.attributesToParams(span.attributes),
-                spanId: span.spanId,
-                parentSpanId: span.parentSpanId,
-            });
-            if (span.endTime) {
-                entries.push({
-                    traceId: span.traceId,
-                    timestamp: new Date(span.endTime).toISOString(),
-                    function: span.name,
-                    action: 'quit',
-                    result: span.result,
-                    error: span.error,
-                    durationMs: span.endTime - span.startTime,
-                    spanId: span.spanId,
-                    parentSpanId: span.parentSpanId,
-                });
-            }
-        }
-        // Sort by timestamp
-        entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-        return entries;
-    }
-    /**
-     * Convert span attributes to params format
-     */
-    attributesToParams(attributes) {
-        if (!attributes)
-            return [];
-        return Object.entries(attributes).map(([key, value]) => ({
-            key,
-            value,
-        }));
-    }
-    /**
-     * Get the underlying storage
-     */
-    getStorage() {
-        return this.storage;
-    }
-    /**
-     * Close the reader and cleanup resources
-     */
-    close() {
-        if (this.storage) {
-            this.storage.close();
-            this.storage = null;
-        }
-        if (this.sqliteDb) {
-            this.sqliteDb.close();
-            this.sqliteDb = null;
-        }
-    }
-}
-// ============================================================================
-// Utility Functions
-// ============================================================================
-/**
- * Create a SpanDbReader from a database path
- */
-export async function createSpanDbReader(dbPath) {
-    const reader = new SpanDbReader({ dbPath });
-    await reader.initialize();
-    return reader;
-}
-/**
- * Create a SpanDbReader from an existing storage instance
- */
-export function createSpanDbReaderFromStorage(storage) {
-    return new SpanDbReader({ storage });
-}
-//# sourceMappingURL=span-db-reader.js.map

package/dist/core/src/env/debug/reader/span-db-reader.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * @fileoverview SpanDbReader Test
- */
-export {};
-//# sourceMappingURL=span-db-reader.test.d.ts.map

package/dist/core/src/env/debug/reader/span-db-reader.test.js

@@ -1,96 +0,0 @@
-/**
- * @fileoverview SpanDbReader Test
- */
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { SpanDbReader } from "./span-db-reader.js";
-import { SQLiteSpanStorage } from "../../log-trace/span-storage.js";
-import { SpanKind, SpanStatus } from "../../log-trace/types.js";
-import * as fs from 'fs';
-// Test data
-const testSpan1 = {
-    traceId: 'trace_test_001',
-    spanId: 'span_1',
-    name: 'testFunction',
-    kind: SpanKind.INTERNAL,
-    status: SpanStatus.OK,
-    startTime: Date.now() - 1000,
-    endTime: Date.now(),
-    attributes: { arg1: 'value1', arg2: 123 },
-    children: [],
-};
-const testSpan2 = {
-    traceId: 'trace_test_002',
-    spanId: 'span_2',
-    name: 'anotherFunction',
-    kind: SpanKind.INTERNAL,
-    status: SpanStatus.OK,
-    startTime: Date.now() - 500,
-    endTime: Date.now() - 100,
-    attributes: {},
-    children: [],
-};
-describe('SpanDbReader', () => {
-    let storage;
-    let reader;
-    let tempDbPath;
-    beforeAll(async () => {
-        // 清除环境变量中的 trace context，避免继承外部上下文
-        delete process.env['TRACEPARENT'];
-        delete process.env['TRACE_ID'];
-        delete process.env['LOG_TRACE_REQUEST_ID'];
-        // Create temporary database file
-        tempDbPath = `/tmp/test_span_db_${Date.now()}.sqlite`;
-        storage = new SQLiteSpanStorage(tempDbPath);
-        await storage.initialize();
-        // Insert test data
-        storage.save(testSpan1);
-        storage.save(testSpan2);
-        // Create reader with storage
-        reader = new SpanDbReader({ storage });
-    });
-    afterAll(() => {
-        reader.close();
-        storage.close();
-        // Cleanup temp file
-        if (fs.existsSync(tempDbPath)) {
-            fs.unlinkSync(tempDbPath);
-        }
-    });
-    test('should list trace IDs', async () => {
-        const summary = await reader.listTraceIds(10);
-        expect(summary.count).toBeGreaterThanOrEqual(2);
-        expect(summary.traceIds.length).toBeGreaterThanOrEqual(2);
-        const traceIds = summary.traceIds.map(t => t.traceId);
-        expect(traceIds).toContain('trace_test_001');
-        expect(traceIds).toContain('trace_test_002');
-    });
-    test('should get trace entries by traceId', async () => {
-        const entries = await reader.getTraceEntries('trace_test_001');
-        expect(entries.length).toBeGreaterThanOrEqual(2); // enter and quit
-        expect(entries[0].traceId).toBe('trace_test_001');
-        expect(entries[0].function).toBe('testFunction');
-        expect(entries[0].action).toBe('enter');
-    });
-    test('should return empty array for non-existent trace', async () => {
-        const entries = await reader.getTraceEntries('non_existent_trace');
-        expect(entries).toHaveLength(0);
-    });
-    test('should limit trace list', async () => {
-        const summary = await reader.listTraceIds(1);
-        expect(summary.traceIds.length).toBeLessThanOrEqual(1);
-    });
-});
-describe('SpanDbReader with dbPath', () => {
-    test('should initialize from dbPath', async () => {
-        const tempPath = `/tmp/test_span_db_${Date.now()}.sqlite`;
-        const reader = new SpanDbReader({ dbPath: tempPath });
-        await reader.initialize();
-        expect(reader.getStorage()).toBeTruthy();
-        reader.close();
-        // Cleanup
-        if (fs.existsSync(tempPath)) {
-            fs.unlinkSync(tempPath);
-        }
-    });
-});
-//# sourceMappingURL=span-db-reader.test.js.map