drtrace 0.3.0 → 0.5.0

package/dist/cli/grep.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Grep command implementation for searching logs with POSIX regex.
+ * Matches Python implementation in packages/python/src/drtrace_service/cli/grep.py
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grep = grep;
+exports.runGrep = runGrep;
+/**
+ * Check if daemon is available with timeout
+ */
+async function checkDaemonAlive(host, port, timeoutMs = 500) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(`http://${host}:${port}/status`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        return response.ok;
+    }
+    catch (error) {
+        clearTimeout(timeout);
+        return false;
+    }
+}
+/**
+ * Format timestamp for display
+ */
+function formatTimestamp(ts) {
+    const date = new Date(ts * 1000);
+    return date.toISOString().replace('T', ' ').substring(0, 19);
+}
+/**
+ * Apply color to text based on log level
+ */
+function colorize(text, level, colorMode) {
+    const shouldColor = colorMode === 'always' || (colorMode === 'auto' && process.stdout.isTTY);
+    if (!shouldColor) {
+        return text;
+    }
+    const colors = {
+        ERROR: '\x1b[31m', // Red
+        CRITICAL: '\x1b[31m', // Red
+        WARNING: '\x1b[33m', // Yellow
+        WARN: '\x1b[33m', // Yellow
+        INFO: '\x1b[0m', // Default
+        DEBUG: '\x1b[90m', // Gray
+    };
+    const reset = '\x1b[0m';
+    const color = colors[level] || colors.INFO;
+    return `${color}${text}${reset}`;
+}
+/**
+ * Main grep implementation
+ */
+async function grep(options) {
+    const { pattern, ignoreCase = false, count = false, invertMatch = false, lineNumber = false, extendedRegex = false, since = '5m', applicationId, daemonHost = process.env.DRTRACE_DAEMON_HOST || 'localhost', daemonPort = parseInt(process.env.DRTRACE_DAEMON_PORT || '8001'), json = false, color = 'auto', } = options;
+    // Check if daemon is available
+    const daemonAvailable = await checkDaemonAlive(daemonHost, daemonPort, 500);
+    if (!daemonAvailable) {
+        console.error('Error: DrTrace daemon is not running.');
+        console.error('');
+        console.error('Start the daemon with:');
+        console.error('  drtrace daemon start');
+        return 2;
+    }
+    // Build query parameters (Story 11-2: wire -E flag to message_regex)
+    const params = new URLSearchParams({
+        since: since,
+    });
+    // Use message_regex if -E flag provided, else message_contains (Epic 11.1, 11.2)
+    if (extendedRegex) {
+        params.append('message_regex', pattern);
+    }
+    else {
+        params.append('message_contains', pattern);
+    }
+    if (applicationId) {
+        params.append('application_id', applicationId);
+    }
+    // Query daemon using fetch
+    try {
+        const daemonUrl = `http://${daemonHost}:${daemonPort}/logs/query`;
+        const response = await fetch(`${daemonUrl}?${params.toString()}`);
+        if (!response.ok) {
+            const error = await response.json();
+            const errorMsg = typeof error.detail === 'object' ? error.detail?.message : error.detail;
+            console.error(`Error: ${errorMsg || 'Query failed'}`);
+            return 2;
+        }
+        const data = await response.json();
+        const results = data.results || [];
+        // Apply additional filters that weren't sent to API (invert_match)
+        let filteredResults = results;
+        if (invertMatch) {
+            if (extendedRegex) {
+                const flags = ignoreCase ? 'i' : '';
+                const regex = new RegExp(pattern, flags);
+                filteredResults = results.filter(record => !regex.test(record.message));
+            }
+            else {
+                const searchPattern = ignoreCase ? pattern.toLowerCase() : pattern;
+                filteredResults = results.filter(record => {
+                    const message = ignoreCase ? record.message.toLowerCase() : record.message;
+                    return !message.includes(searchPattern);
+                });
+            }
+        }
+        // Output results
+        if (count) {
+            console.log(filteredResults.length);
+            return 0;
+        }
+        if (json) {
+            console.log(JSON.stringify(filteredResults, null, 2));
+            return 0;
+        }
+        if (filteredResults.length === 0) {
+            return 1;
+        }
+        // Format and print results
+        for (const record of filteredResults) {
+            const tsStr = formatTimestamp(record.ts);
+            const serviceStr = record.service_name ? `[${record.service_name}]` : '';
+            let msg = `[${tsStr}] ${serviceStr} [${record.level}] ${record.message}`;
+            msg = colorize(msg, record.level, color);
+            if (lineNumber) {
+                // Use timestamp as pseudo line number for daemon results
+                msg = `${Math.floor(record.ts)}:${msg}`;
+            }
+            console.log(msg);
+        }
+        return 0;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error: Failed to query daemon: ${errorMessage}`);
+        return 2;
+    }
+}
+/**
+ * Parse CLI arguments and run grep command
+ */
+async function runGrep(args) {
+    // Simple argument parser matching Python argparse behavior
+    const options = {
+        pattern: '',
+        ignoreCase: false,
+        count: false,
+        invertMatch: false,
+        lineNumber: false,
+        extendedRegex: false,
+        since: '5m',
+        color: 'auto',
+    };
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '-i' || arg === '--ignore-case') {
+            options.ignoreCase = true;
+        }
+        else if (arg === '-c' || arg === '--count') {
+            options.count = true;
+        }
+        else if (arg === '-v' || arg === '--invert-match') {
+            options.invertMatch = true;
+        }
+        else if (arg === '-n' || arg === '--line-number') {
+            options.lineNumber = true;
+        }
+        else if (arg === '-E' || arg === '--extended-regex') {
+            options.extendedRegex = true;
+        }
+        else if (arg === '--since') {
+            options.since = args[++i];
+        }
+        else if (arg === '--application-id') {
+            options.applicationId = args[++i];
+        }
+        else if (arg === '--daemon-host') {
+            options.daemonHost = args[++i];
+        }
+        else if (arg === '--daemon-port') {
+            options.daemonPort = parseInt(args[++i]);
+        }
+        else if (arg === '--json') {
+            options.json = true;
+        }
+        else if (arg === '--color') {
+            const colorValue = args[++i];
+            if (colorValue !== 'auto' && colorValue !== 'always' && colorValue !== 'never') {
+                console.error(`Error: Invalid color value '${colorValue}'. Use: auto, always, never`);
+                return 2;
+            }
+            options.color = colorValue;
+        }
+        else if (arg === '-h' || arg === '--help') {
+            printHelp();
+            return 0;
+        }
+        else if (!arg.startsWith('-')) {
+            // Positional argument - pattern
+            options.pattern = arg;
+        }
+        else {
+            console.error(`Error: Unknown option '${arg}'`);
+            return 2;
+        }
+        i++;
+    }
+    if (!options.pattern) {
+        console.error('Error: Pattern is required');
+        printHelp();
+        return 2;
+    }
+    return grep(options);
+}
+function printHelp() {
+    console.log(`Usage: drtrace grep [OPTIONS] PATTERN
+
+Search log messages with pattern matching.
+
+Options:
+  -i, --ignore-case       Ignore case in pattern matching
+  -c, --count             Output count of matches instead of matches
+  -v, --invert-match      Invert match (show non-matching lines)
+  -n, --line-number       Output line numbers with matches
+  -E, --extended-regex    Use POSIX extended regex (sends message_regex to API)
+  --since <time>          Time range: 30m/1h/2d/7d (default: 5m)
+  --application-id <id>   Filter by application ID
+  --daemon-host <host>    Daemon host (default: localhost)
+  --daemon-port <port>    Daemon port (default: 8001)
+  --json                  Output in JSON format
+  --color <mode>          Color control: auto, always, never (default: auto)
+  -h, --help              Show this help message
+
+Examples:
+  # Simple substring search
+  drtrace grep "timeout"
+
+  # Regex search with -E flag
+  drtrace grep -E "error|warning"
+
+  # Search with application filter
+  drtrace grep --application-id myapp "error"
+
+  # Count matches
+  drtrace grep -c "error"
+`);
+}

package/dist/cli/status.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Status command implementation - check daemon health
+ */
+/**
+ * Check daemon status and display information
+ */
+export declare function status(daemonHost?: string, daemonPort?: number): Promise<number>;
+/**
+ * Parse CLI arguments and run status command
+ */
+export declare function runStatus(args: string[]): Promise<number>;

package/dist/cli/status.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Status command implementation - check daemon health
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+exports.runStatus = runStatus;
+/**
+ * Check daemon status and display information
+ */
+async function status(daemonHost = process.env.DRTRACE_DAEMON_HOST || 'localhost', daemonPort = parseInt(process.env.DRTRACE_DAEMON_PORT || '8001')) {
+    try {
+        const response = await fetch(`http://${daemonHost}:${daemonPort}/status`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            console.error(`DrTrace daemon status: UNHEALTHY (HTTP ${response.status})`);
+            console.error(`URL: http://${daemonHost}:${daemonPort}/status`);
+            return 2;
+        }
+        const data = await response.json();
+        console.log('DrTrace daemon status: HEALTHY');
+        console.log(`Service: ${data.service_name} v${data.version}`);
+        console.log(`Listening on: ${data.host}:${data.port}`);
+        if (data.retention_days) {
+            console.log(`Retention: ${data.retention_days} days`);
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(`DrTrace daemon status: UNREACHABLE`);
+        console.error(`URL: http://${daemonHost}:${daemonPort}/status`);
+        console.error('');
+        console.error('Make sure the daemon is running:');
+        console.error('  python -m drtrace_service daemon start');
+        return 2;
+    }
+}
+/**
+ * Parse CLI arguments and run status command
+ */
+async function runStatus(args) {
+    let daemonHost = process.env.DRTRACE_DAEMON_HOST || 'localhost';
+    let daemonPort = parseInt(process.env.DRTRACE_DAEMON_PORT || '8001');
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--daemon-host') {
+            daemonHost = args[++i];
+        }
+        else if (arg === '--daemon-port') {
+            daemonPort = parseInt(args[++i]);
+        }
+        else if (arg === '-h' || arg === '--help') {
+            printHelp();
+            return 0;
+        }
+        else {
+            console.error(`Error: Unknown option '${arg}'`);
+            return 2;
+        }
+    }
+    return status(daemonHost, daemonPort);
+}
+function printHelp() {
+    console.log(`Usage: drtrace status [OPTIONS]
+
+Check daemon health and configuration.
+
+Options:
+  --daemon-host <host>    Daemon host (default: localhost)
+  --daemon-port <port>    Daemon port (default: 8001)
+  -h, --help              Show this help message
+
+Environment Variables:
+  DRTRACE_DAEMON_HOST     Daemon host (default: localhost)
+  DRTRACE_DAEMON_PORT     Daemon port (default: 8001)
+`);
+}

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { DrTrace } from './client';
+export { DrTrace } from './node';
 export { loadConfig } from './config';
 export * from './types';

package/dist/index.js

@@ -15,8 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfig = exports.DrTrace = void 0;
-var client_1 = require("./client");
-Object.defineProperty(exports, "DrTrace", { enumerable: true, get: function () { return client_1.DrTrace; } });
+var node_1 = require("./node");
+Object.defineProperty(exports, "DrTrace", { enumerable: true, get: function () { return node_1.DrTrace; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
 __exportStar(require("./types"), exports);

package/dist/init.d.ts

@@ -12,6 +12,7 @@ export declare class ProjectInitializer {
     private projectRoot;
     private drtraceDir;
     private configPath;
+    private copiedAgentFiles;
     constructor(projectRoot?: string);
     /**
      * Run the interactive initialization workflow
@@ -57,6 +58,7 @@ export declare class ProjectInitializer {
     private copyAgentSpec;
     /**
      * Recursively copy all files from sourceDir to targetDir
+     * Returns list of relative file paths copied (for summary display)
      */
     private copyAgentsRecursive;
     /**

package/dist/init.js

@@ -49,6 +49,8 @@ const prompts_1 = __importDefault(require("prompts"));
 const config_schema_1 = require("./config-schema");
 class ProjectInitializer {
     constructor(projectRoot = process.cwd()) {
+        // Track copied agent files for summary display
+        this.copiedAgentFiles = [];
         this.projectRoot = projectRoot;
         this.drtraceDir = path.join(projectRoot, "_drtrace");
         this.configPath = path.join(this.drtraceDir, "config.json");
@@ -260,8 +262,9 @@ class ProjectInitializer {
                 console.warn("⚠️  Could not find agents directory");
                 return;
             }
-            // Copy all files recursively
-            this.copyAgentsRecursive(agentsDir, path.join(this.drtraceDir, "agents"));
+            // Copy all files recursively and track copied files
+            const copiedFiles = this.copyAgentsRecursive(agentsDir, path.join(this.drtraceDir, "agents"));
+            this.copiedAgentFiles.push(...copiedFiles);
         }
         catch (error) {
             console.warn(`⚠️  Could not copy agent files: ${error}`);
@@ -269,34 +272,35 @@ class ProjectInitializer {
     }
     /**
      * Recursively copy all files from sourceDir to targetDir
+     * Returns list of relative file paths copied (for summary display)
      */
-    copyAgentsRecursive(sourceDir, targetDir) {
+    copyAgentsRecursive(sourceDir, targetDir, basePath = "") {
         if (!fs.existsSync(targetDir)) {
             fs.mkdirSync(targetDir, { recursive: true });
         }
         const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
-        let copiedCount = 0;
+        const copiedFiles = [];
         for (const entry of entries) {
             const srcPath = path.join(sourceDir, entry.name);
             const destPath = path.join(targetDir, entry.name);
+            const relativePath = basePath ? path.join(basePath, entry.name) : entry.name;
             if (entry.isDirectory()) {
                 // Recursively copy directories
-                this.copyAgentsRecursive(srcPath, destPath);
+                const subCopied = this.copyAgentsRecursive(srcPath, destPath, relativePath);
+                copiedFiles.push(...subCopied);
             }
             else {
                 // Copy file (no renaming needed - files are already named correctly)
                 fs.copyFileSync(srcPath, destPath);
-                copiedCount++;
-                console.log(`✓ Copied ${entry.name}`);
+                copiedFiles.push(relativePath);
+                console.log(`✓ Copied ${relativePath}`);
             }
         }
-        if (copiedCount > 0 && !fs.existsSync(path.join(targetDir, "..", ".."))) {
-            // Only print summary if we're at the top level
-            const relativeSource = path.relative(process.cwd(), sourceDir);
-            if (!relativeSource.includes("..")) {
-                console.log(`✓ Successfully copied ${copiedCount} file(s) from agents/`);
-            }
+        // Print summary only at top level
+        if (!basePath && copiedFiles.length > 0) {
+            console.log(`✓ Successfully copied ${copiedFiles.length} file(s) from agents/`);
         }
+        return copiedFiles;
     }
     /**
      * Copy framework-specific integration guides to _drtrace/agents/integration-guides/
@@ -781,11 +785,12 @@ python -m drtrace_service status
         }
         console.log(`   • ${path.join(this.drtraceDir, ".env.example")}`);
         console.log(`   • ${path.join(this.drtraceDir, "README.md")}`);
-        if (config.agent?.enabled) {
-            console.log(`   • ${path.join(this.drtraceDir, "agents", "log-analysis.md")}`);
-            console.log(`   • ${path.join(this.drtraceDir, "agents", "log-it.md")}`);
-            console.log(`   • ${path.join(this.drtraceDir, "agents", "log-init.md")}`);
-            console.log(`   • ${path.join(this.drtraceDir, "agents", "log-help.md")}`);
+        // List all copied agent files (includes integration-guides/)
+        if (this.copiedAgentFiles.length > 0) {
+            console.log("\n📋 Agent Files:");
+            for (const agentFile of this.copiedAgentFiles.sort()) {
+                console.log(`   • ${path.join(this.drtraceDir, "agents", agentFile)}`);
+            }
         }
         console.log("\n📖 Next Steps:");
         console.log(`   1. Review ${this.configPath}`);

package/dist/logger.d.ts

@@ -3,13 +3,20 @@ import { LogQueue } from './queue';
 export declare class DrTraceLogger {
     private queue;
     private applicationId;
+    private moduleName;
     private logLevel;
     private originalConsole?;
     constructor(opts: {
         queue: LogQueue;
         applicationId: string;
+        moduleName?: string;
         logLevel: LogLevel;
     });
+    /**
+     * Serialize a value to a string suitable for logging.
+     * Handles objects, arrays, errors, and primitives correctly.
+     */
+    private serialize;
     attachToConsole(): void;
     detachFromConsole(): void;
     log(level: LogLevel, message: string, context?: Record<string, unknown>): void;

package/dist/logger.js

@@ -5,15 +5,40 @@ class DrTraceLogger {
     constructor(opts) {
         this.queue = opts.queue;
         this.applicationId = opts.applicationId;
+        this.moduleName = opts.moduleName || 'default';
         this.logLevel = opts.logLevel || 'info';
     }
+    /**
+     * Serialize a value to a string suitable for logging.
+     * Handles objects, arrays, errors, and primitives correctly.
+     */
+    serialize(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string')
+            return value;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (value instanceof Error) {
+            return value.stack || `${value.name}: ${value.message}`;
+        }
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            // Handle circular references gracefully
+            return String(value);
+        }
+    }
     attachToConsole() {
         if (this.originalConsole)
             return;
         this.originalConsole = { log: console.log, error: console.error };
         console.log = (...args) => {
             try {
-                this.log('info', args.map(String).join(' '));
+                this.log('info', args.map((arg) => this.serialize(arg)).join(' '));
             }
             catch {
                 // Silently ignore logging errors
@@ -22,7 +47,7 @@ class DrTraceLogger {
         };
         console.error = (...args) => {
             try {
-                this.log('error', args.map(String).join(' '));
+                this.log('error', args.map((arg) => this.serialize(arg)).join(' '));
             }
             catch {
                 // Silently ignore logging errors
@@ -39,8 +64,9 @@ class DrTraceLogger {
     }
     log(level, message, context) {
         const event = {
-            timestamp: new Date().toISOString(),
-            applicationId: this.applicationId,
+            ts: Date.now() / 1000, // Unix timestamp as float (seconds.milliseconds)
+            application_id: this.applicationId,
+            module_name: this.moduleName,
             level,
             message,
             context,

package/dist/node.d.ts

@@ -0,0 +1,13 @@
+import type { ClientOptions, LogLevel } from './types';
+export declare class DrTrace {
+    private queue;
+    private logger;
+    private enabled;
+    private constructor();
+    static init(opts?: Partial<ClientOptions>): DrTrace;
+    attachToConsole(): void;
+    detachFromConsole(): void;
+    log(message: string, level?: LogLevel, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    shutdown(): Promise<void>;
+}

package/dist/node.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrTrace = void 0;
+const config_1 = require("./config");
+const transport_1 = require("./transport");
+const queue_1 = require("./queue");
+const logger_1 = require("./logger");
+class DrTrace {
+    constructor(opts) {
+        const transport = new transport_1.Transport({
+            daemonUrl: opts.daemonUrl,
+            maxRetries: opts.maxRetries ?? 3,
+            timeoutMs: 5000,
+        });
+        this.queue = new queue_1.LogQueue({
+            transport,
+            batchSize: opts.batchSize ?? 50,
+            flushIntervalMs: opts.flushIntervalMs ?? 1000,
+            maxQueueSize: opts.maxQueueSize ?? 10000,
+        });
+        this.queue.start();
+        this.enabled = opts.enabled ?? true;
+        this.logger = new logger_1.DrTraceLogger({
+            queue: this.queue,
+            applicationId: opts.applicationId,
+            moduleName: opts.moduleName,
+            logLevel: (opts.logLevel ?? 'info'),
+        });
+    }
+    static init(opts) {
+        const cfg = (0, config_1.loadConfig)({ projectRoot: '.', environment: process.env.NODE_ENV });
+        const merged = {
+            applicationId: cfg.drtrace.applicationId,
+            daemonUrl: cfg.drtrace.daemonUrl || 'http://localhost:8001',
+            enabled: cfg.drtrace.enabled ?? true,
+            logLevel: (cfg.drtrace.logLevel ?? 'info'),
+            batchSize: cfg.drtrace.batchSize ?? 50,
+            flushIntervalMs: cfg.drtrace.flushIntervalMs ?? 1000,
+            ...opts,
+        };
+        return new DrTrace(merged);
+    }
+    attachToConsole() {
+        if (!this.enabled)
+            return;
+        this.logger.attachToConsole();
+    }
+    detachFromConsole() {
+        this.logger.detachFromConsole();
+    }
+    log(message, level = 'info', context) {
+        if (!this.enabled)
+            return;
+        this.logger.log(level, message, context);
+    }
+    error(message, context) {
+        if (!this.enabled)
+            return;
+        this.logger.log('error', message, context);
+    }
+    async shutdown() {
+        await this.queue.flush();
+        this.queue.stop();
+        this.detachFromConsole();
+    }
+}
+exports.DrTrace = DrTrace;