hanseol-dev 4.0.12

package/dist/utils/logger.js

@@ -0,0 +1,1672 @@
+import chalk from 'chalk';
+import { getJsonStreamLogger } from './json-stream-logger.js';
+import * as path from 'path';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["VERBOSE"] = 4] = "VERBOSE";
+})(LogLevel || (LogLevel = {}));
+let llmLogEnabled = false;
+export function enableLLMLog() {
+    llmLogEnabled = true;
+}
+export function disableLLMLog() {
+    llmLogEnabled = false;
+}
+export function isLLMLogEnabled() {
+    return llmLogEnabled;
+}
+export class Logger {
+    level;
+    prefix;
+    showTimestamp;
+    showLocation;
+    showPid;
+    traceId = null;
+    timers = new Map();
+    constructor(options = {}) {
+        this.level = options.level ?? LogLevel.INFO;
+        this.prefix = options.prefix ?? '';
+        this.showTimestamp = options.timestamp ?? true;
+        this.showLocation = options.showLocation ?? true;
+        this.showPid = options.showPid ?? false;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    setTraceId(traceId) {
+        this.traceId = traceId;
+    }
+    clearTraceId() {
+        this.traceId = null;
+    }
+    getTraceId() {
+        return this.traceId;
+    }
+    getCallLocation(depth = 3) {
+        try {
+            const stack = new Error().stack;
+            if (!stack)
+                return null;
+            const lines = stack.split('\n');
+            if (lines.length <= depth)
+                return null;
+            const line = lines[depth];
+            if (!line)
+                return null;
+            const match = line.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+            if (!match)
+                return null;
+            const [, functionName, file, lineNum, column] = match;
+            if (!file || !lineNum || !column)
+                return null;
+            return {
+                file: path.basename(file),
+                line: parseInt(lineNum),
+                column: parseInt(column),
+                function: functionName?.trim() || '<anonymous>',
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    getTimestamp() {
+        if (!this.showTimestamp)
+            return '';
+        const now = new Date();
+        return chalk.gray(`[${now.toISOString()}]`);
+    }
+    getPrefix() {
+        if (!this.prefix)
+            return '';
+        return chalk.cyan(`[${this.prefix}]`);
+    }
+    getPid() {
+        if (!this.showPid)
+            return '';
+        return chalk.dim(`[PID:${process.pid}]`);
+    }
+    getTraceIdStr() {
+        if (!this.traceId)
+            return '';
+        return chalk.magenta(`[Trace:${this.traceId.slice(0, 8)}]`);
+    }
+    getLocation(location) {
+        if (!this.showLocation || !location)
+            return '';
+        return chalk.dim(`[${location.file}:${location.line}:${location.function}]`);
+    }
+    formatVariable(variable) {
+        const type = variable.type || typeof variable.value;
+        const valueStr = this.formatValue(variable.value);
+        return chalk.yellow(variable.name) + chalk.gray('=') + chalk.white(valueStr) + chalk.dim(` (${type})`);
+    }
+    formatValue(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 (typeof value === 'function')
+            return '[Function]';
+        if (Array.isArray(value))
+            return `Array(${value.length})`;
+        if (value instanceof Error)
+            return `Error: ${value.message}`;
+        try {
+            const json = JSON.stringify(value);
+            return json.length > 100 ? json.slice(0, 100) + '...' : json;
+        }
+        catch {
+            return '[Object]';
+        }
+    }
+    error(message, error) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logError(error || new Error(message), this.prefix || 'logger');
+        }
+        if (this.level < LogLevel.ERROR)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.error(timestamp, prefix, pid, traceId, loc, chalk.red('❌ ERROR:'), message);
+        if (error) {
+            if (error instanceof Error) {
+                console.error(chalk.red('  Message:'), error.message);
+                if (error.stack) {
+                    console.error(chalk.gray('  Stack:'));
+                    console.error(chalk.gray(error.stack));
+                }
+                if (error.cause) {
+                    console.error(chalk.red('  Cause:'), error.cause);
+                }
+                if (error.details) {
+                    console.error(chalk.yellow('  Details:'), JSON.stringify(error.details, null, 2));
+                }
+            }
+            else {
+                console.error(chalk.red('  Error:'), error);
+            }
+        }
+    }
+    warn(message, data) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo(`[WARN] ${message}`, data);
+        }
+        if (this.level < LogLevel.WARN)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.warn(timestamp, prefix, pid, traceId, loc, chalk.yellow('⚠️  WARN:'), message);
+        if (data) {
+            console.warn(chalk.yellow('  Data:'), JSON.stringify(data, null, 2));
+        }
+    }
+    info(message, data) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo(message, data);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.blue('ℹ️  INFO:'), message);
+        if (data) {
+            console.log(chalk.blue('  Data:'), JSON.stringify(data, null, 2));
+        }
+    }
+    debug(message, data) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(message, data);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.magenta('🐛 DEBUG:'), message);
+        if (data) {
+            console.log(chalk.magenta('  Data:'), JSON.stringify(data, null, 2));
+        }
+    }
+    verbose(message, data) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[VERBOSE] ${message}`, data);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.gray('🔍 VERBOSE:'), message);
+        if (data) {
+            console.log(chalk.gray('  Data:'), JSON.stringify(data, null, 2));
+        }
+    }
+    flow(message, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[FLOW] ${message}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.green('➜ FLOW:'), message);
+        if (context) {
+            console.log(chalk.green('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    vars(...variables) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            const varsData = variables.reduce((acc, v) => {
+                acc[v.name] = v.value;
+                return acc;
+            }, {});
+            jsonLogger.logDebug('[VARS]', varsData);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.cyan('📦 VARS:'));
+        variables.forEach(variable => {
+            console.log('  ', this.formatVariable(variable));
+        });
+    }
+    enter(functionName, args) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[ENTER] ${functionName}`, args);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.green('↓ ENTER:'), chalk.bold(functionName));
+        if (args) {
+            console.log(chalk.green('  Args:'), JSON.stringify(args, null, 2));
+        }
+    }
+    exit(functionName, result) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[EXIT] ${functionName}`, { result });
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.green('↑ EXIT:'), chalk.bold(functionName));
+        if (result !== undefined) {
+            console.log(chalk.green('  Result:'), this.formatValue(result));
+        }
+    }
+    state(description, before, after) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[STATE] ${description}`, { before, after });
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.yellow('🔄 STATE:'), description);
+        console.log(chalk.red('  Before:'), this.formatValue(before));
+        console.log(chalk.green('  After:'), this.formatValue(after));
+    }
+    startTimer(label) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[TIMER] Start: ${label}`);
+        }
+        this.timers.set(label, Date.now());
+        if (this.level >= LogLevel.DEBUG) {
+            const location = this.getCallLocation();
+            const timestamp = this.getTimestamp();
+            const prefix = this.getPrefix();
+            const pid = this.getPid();
+            const traceId = this.getTraceIdStr();
+            const loc = this.getLocation(location);
+            console.log(timestamp, prefix, pid, traceId, loc, chalk.blue('⏱️  TIMER START:'), label);
+        }
+    }
+    endTimer(label) {
+        const startTime = this.timers.get(label);
+        if (!startTime) {
+            this.warn(`Timer "${label}" was not started`);
+            return 0;
+        }
+        const elapsed = Date.now() - startTime;
+        this.timers.delete(label);
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[TIMER] End: ${label}`, { elapsed });
+        }
+        if (this.level >= LogLevel.DEBUG) {
+            const location = this.getCallLocation();
+            const timestamp = this.getTimestamp();
+            const prefix = this.getPrefix();
+            const pid = this.getPid();
+            const traceId = this.getTraceIdStr();
+            const loc = this.getLocation(location);
+            console.log(timestamp, prefix, pid, traceId, loc, chalk.blue('⏱️  TIMER END:'), label, chalk.bold(`${elapsed}ms`));
+        }
+        return elapsed;
+    }
+    httpRequest(method, url, body) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`HTTP ${method} ${url}`, { body });
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.cyan('→ HTTP REQUEST:'), chalk.bold(method), url);
+        if (body) {
+            console.log(chalk.cyan('  Body:'), JSON.stringify(body, null, 2));
+        }
+    }
+    httpResponse(status, statusText, data) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`HTTP Response ${status} ${statusText}`, { status, statusText, data });
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        const statusColor = status >= 400 ? chalk.red : status >= 300 ? chalk.yellow : chalk.green;
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.cyan('← HTTP RESPONSE:'), statusColor(`${status} ${statusText}`));
+        if (data && this.level >= LogLevel.VERBOSE) {
+            console.log(chalk.cyan('  Data:'), JSON.stringify(data, null, 2));
+        }
+    }
+    toolExecution(toolName, args, result, error) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logToolCall(toolName, args, result, error);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        if (error) {
+            console.log(timestamp, prefix, pid, traceId, loc, chalk.red('🔧 TOOL FAILED:'), chalk.bold(toolName));
+            console.log(chalk.red('  Args:'), JSON.stringify(args, null, 2));
+            console.log(chalk.red('  Error:'), error.message);
+        }
+        else {
+            console.log(timestamp, prefix, pid, traceId, loc, chalk.green('🔧 TOOL SUCCESS:'), chalk.bold(toolName));
+            console.log(chalk.green('  Args:'), JSON.stringify(args, null, 2));
+            if (result && this.level >= LogLevel.VERBOSE) {
+                console.log(chalk.green('  Result:'), JSON.stringify(result, null, 2));
+            }
+        }
+    }
+    bashExecution(formattedDisplay) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug('[BASH] Execution', { output: formattedDisplay });
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const lines = formattedDisplay.split('\n');
+        lines.forEach((line) => {
+            if (line.startsWith('●')) {
+                console.log(chalk.cyan(line));
+            }
+            else if (line.includes('Error:')) {
+                console.log(chalk.red(line));
+            }
+            else {
+                console.log(line);
+            }
+        });
+        console.log();
+    }
+    llmRequest(messages, model, tools) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug('[LLM] Request', { model, messageCount: messages?.length, toolCount: tools?.length });
+        }
+        if (!llmLogEnabled)
+            return;
+        const timestamp = this.getTimestamp();
+        console.log();
+        console.log(chalk.cyan('─'.repeat(80)));
+        console.log(chalk.cyan.bold(`[${timestamp}] 📤 LLM REQUEST`));
+        console.log(chalk.gray(`Model: ${model}`));
+        if (tools && Array.isArray(tools) && tools.length > 0) {
+            console.log(chalk.gray(`Tools: ${tools.length} available`));
+        }
+        console.log(chalk.cyan('─'.repeat(40)));
+        if (Array.isArray(messages)) {
+            messages.forEach((msg, idx) => {
+                const role = msg.role || 'unknown';
+                const content = msg.content || '';
+                const roleColor = role === 'user' ? chalk.green : role === 'assistant' ? chalk.blue : chalk.yellow;
+                console.log(roleColor.bold(`[${role.toUpperCase()}]`));
+                if (content) {
+                    const displayContent = content.length > 2000
+                        ? content.substring(0, 2000) + chalk.gray(`\n... (${content.length - 2000} more chars)`)
+                        : content;
+                    console.log(displayContent);
+                }
+                if (msg.tool_calls && msg.tool_calls.length > 0) {
+                    console.log(chalk.yellow(`  Tool calls: ${msg.tool_calls.map((tc) => tc.function?.name).join(', ')}`));
+                }
+                if (idx < messages.length - 1)
+                    console.log();
+            });
+        }
+        console.log(chalk.cyan('─'.repeat(80)));
+    }
+    llmResponse(response, toolCalls) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug('[LLM] Response', { responseLength: response?.length, toolCallCount: toolCalls?.length });
+        }
+        if (!llmLogEnabled)
+            return;
+        const timestamp = this.getTimestamp();
+        console.log();
+        console.log(chalk.green('─'.repeat(80)));
+        console.log(chalk.green.bold(`[${timestamp}] 📥 LLM RESPONSE`));
+        console.log(chalk.green('─'.repeat(40)));
+        const displayResponse = response.length > 3000
+            ? response.substring(0, 3000) + chalk.gray(`\n... (${response.length - 3000} more chars)`)
+            : response;
+        console.log(displayResponse);
+        if (toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
+            console.log();
+            console.log(chalk.yellow.bold('Tool Calls:'));
+            toolCalls.forEach((tc) => {
+                console.log(chalk.yellow(`  - ${tc.function?.name}:`));
+                try {
+                    const args = JSON.parse(tc.function?.arguments || '{}');
+                    console.log(chalk.gray(JSON.stringify(args, null, 2)));
+                }
+                catch {
+                    console.log(chalk.gray(tc.function?.arguments || '(no arguments)'));
+                }
+            });
+        }
+        console.log(chalk.green('─'.repeat(80)));
+    }
+    llmToolResult(toolName, result, success) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[LLM] Tool Result: ${toolName}`, { success, resultLength: result?.length });
+        }
+        if (!llmLogEnabled)
+            return;
+        const timestamp = this.getTimestamp();
+        const color = success ? chalk.cyan : chalk.red;
+        console.log();
+        console.log(color('─'.repeat(80)));
+        console.log(color.bold(`[${timestamp}] 🔧 TOOL: ${toolName} ${success ? '✓' : '✗'}`));
+        console.log(color('─'.repeat(40)));
+        const displayResult = result.length > 1000
+            ? result.substring(0, 1000) + chalk.gray(`\n... (${result.length - 1000} more chars)`)
+            : result;
+        console.log(displayResult);
+        console.log(color('─'.repeat(80)));
+    }
+    httpError(url, error) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logError(error instanceof Error ? error : new Error(String(error)), `HTTP ${url}`);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.red('✗ HTTP ERROR:'), url);
+        if (error instanceof Error) {
+            console.log(chalk.red('  Message:'), error.message);
+        }
+        else {
+            console.log(chalk.red('  Error:'), error);
+        }
+    }
+    httpStreamStart(method, url) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`HTTP Stream Start: ${method} ${url}`);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.cyan('⇢ HTTP STREAM START:'), chalk.bold(method), url);
+    }
+    httpStreamChunk(data) {
+        const chunkSize = typeof data === 'string' ? data.length : JSON.stringify(data).length;
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug('[HTTP] Stream Chunk', { bytes: chunkSize });
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.gray('⇨ HTTP STREAM CHUNK:'), `${chunkSize} bytes`);
+    }
+    httpStreamEnd(totalBytes, duration) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`HTTP Stream End`, { totalBytes, duration });
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.cyan('⇠ HTTP STREAM END:'), `${totalBytes} bytes in ${duration}ms`);
+    }
+    toolStart(name, args, reason) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logToolStart(name, args, reason);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.blue('🔧 TOOL START:'), chalk.bold(name));
+        if (reason) {
+            console.log(chalk.blue('  Reason:'), reason);
+        }
+        if (args && this.level >= LogLevel.VERBOSE) {
+            console.log(chalk.blue('  Args:'), JSON.stringify(args, null, 2));
+        }
+    }
+    toolSuccess(name, _args, result, duration) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logToolEnd(name, true, result, undefined, duration);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.green('✓ TOOL SUCCESS:'), chalk.bold(name), chalk.dim(`(${duration}ms)`));
+        if (result && this.level >= LogLevel.VERBOSE) {
+            console.log(chalk.green('  Result:'), this.formatValue(result));
+        }
+    }
+    toolError(name, args, error, duration) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logToolEnd(name, false, undefined, error.message, duration);
+        }
+        if (this.level < LogLevel.ERROR)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const pid = this.getPid();
+        const traceId = this.getTraceIdStr();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, pid, traceId, loc, chalk.red('✗ TOOL ERROR:'), chalk.bold(name), chalk.dim(`(${duration}ms)`));
+        console.log(chalk.red('  Error:'), error.message);
+        if (args) {
+            console.log(chalk.red('  Args:'), JSON.stringify(args, null, 2));
+        }
+    }
+    userClick(element, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] User Click: ${element}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('👆 USER CLICK:'), element);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    userKeyboard(type, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] User Keyboard: ${type}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('⌨️  USER KEYBOARD:'), type);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    userScroll(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug('[UI] User Scroll', context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('📜 USER SCROLL'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    userDragStart(element, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] User Drag Start: ${element}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('🖱️  USER DRAG START:'), element);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    userDragEnd(element, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] User Drag End: ${element}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('🖱️  USER DRAG END:'), element);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    componentMount(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[COMPONENT] Mount: ${name}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('📦 COMPONENT MOUNT:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    componentUnmount(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[COMPONENT] Unmount: ${name}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('📦 COMPONENT UNMOUNT:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    componentRender(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[COMPONENT] Render: ${name}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('📦 COMPONENT RENDER:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    componentRenderComplete(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[COMPONENT] Render Complete: ${name}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('✓ COMPONENT RENDER COMPLETE:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    componentStateChange(name, field, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[COMPONENT] State Change: ${name}.${field}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('🔄 COMPONENT STATE:'), `${name}.${field}`);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    screenChange(to, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[SCREEN] Change: ${to}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.magenta('📱 SCREEN CHANGE:'), to);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.magenta('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    tabChange(container, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[TAB] Change: ${container}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.magenta('🗂️  TAB CHANGE:'), container);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.magenta('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    routeChange(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[ROUTE] Change`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.magenta('🛤️  ROUTE CHANGE'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.magenta('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    formStart(formId, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[FORM] Start: ${formId}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('📝 FORM START:'), formId);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    formSubmit(formId, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[FORM] Submit: ${formId}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('📤 FORM SUBMIT:'), formId);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    formResult(formId, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[FORM] Result: ${formId}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('✓ FORM RESULT:'), formId);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    formError(formId, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[FORM] Error: ${formId}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('✗ FORM ERROR:'), formId);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    fieldChange(formId, field, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[FORM] Field Change: ${formId}.${field}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('📝 FIELD CHANGE:'), `${formId}.${field}`);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    fieldValidation(formId, field, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[FORM] Field Validation: ${formId}.${field}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('✓ FIELD VALIDATION:'), `${formId}.${field}`);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    modalOpen(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[MODAL] Open: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('📭 MODAL OPEN:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.cyan('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    modalClose(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[MODAL] Close: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('📪 MODAL CLOSE:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.cyan('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    dialogShow(type, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[DIALOG] Show: ${type}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('💬 DIALOG SHOW:'), type);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.cyan('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    dialogResult(type, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[DIALOG] Result: ${type}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('💬 DIALOG RESULT:'), type);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.cyan('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    toastShow(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[TOAST] Show`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('🔔 TOAST SHOW'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    toastDismiss(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[TOAST] Dismiss`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('🔕 TOAST DISMISS'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    loadingStart(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[LOADING] Start: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('⏳ LOADING START:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    loadingEnd(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[LOADING] End: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('✓ LOADING END:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    loadingError(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[LOADING] Error: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('✗ LOADING ERROR:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    skeletonShow(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Skeleton Show: ${id}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('💀 SKELETON SHOW:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    skeletonHide(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Skeleton Hide: ${id}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('💀 SKELETON HIDE:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    progressStart(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[PROGRESS] Start: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('📊 PROGRESS START:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    progressUpdate(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[PROGRESS] Update: ${id}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('📊 PROGRESS UPDATE:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    progressComplete(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[PROGRESS] Complete: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('✓ PROGRESS COMPLETE:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    progressError(id, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[PROGRESS] Error: ${id}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('✗ PROGRESS ERROR:'), id);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    animationStart(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Animation Start: ${name}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.magenta('🎬 ANIMATION START:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.magenta('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    animationEnd(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Animation End: ${name}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.magenta('🎬 ANIMATION END:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.magenta('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    transitionStart(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Transition Start: ${name}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.magenta('🔀 TRANSITION START:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.magenta('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    transitionEnd(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Transition End: ${name}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.magenta('🔀 TRANSITION END:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.magenta('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    hoverEnter(element, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Hover Enter: ${element}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('🖱️  HOVER ENTER:'), element);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    hoverLeave(element, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[UI] Hover Leave: ${element}`, context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('🖱️  HOVER LEAVE:'), element);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    viewportResize(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[LAYOUT] Viewport Resize`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('📐 VIEWPORT RESIZE'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    breakpointChange(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[LAYOUT] Breakpoint Change`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.blue('📐 BREAKPOINT CHANGE'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.blue('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    layoutShift(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`[LAYOUT] Shift`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('📐 LAYOUT SHIFT'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    scrollPosition(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug('[UI] Scroll Position', context);
+        }
+        if (this.level < LogLevel.VERBOSE)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.gray('📜 SCROLL POSITION'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.gray('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    errorBoundary(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logError(new Error('Error Boundary'), 'errorBoundary');
+        }
+        if (this.level < LogLevel.ERROR)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('🛡️  ERROR BOUNDARY'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    unhandledRejection(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logError(new Error('Unhandled Rejection'), 'unhandledRejection');
+        }
+        if (this.level < LogLevel.ERROR)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('⚠️  UNHANDLED REJECTION'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    globalError(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logError(new Error('Global Error'), 'globalError');
+        }
+        if (this.level < LogLevel.ERROR)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('💥 GLOBAL ERROR'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    sessionStart(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo(`Session Start`, context);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('🚀 SESSION START'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    sessionEnd(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo(`Session End`, context);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('🏁 SESSION END'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    userMilestone(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo(`User Milestone: ${name}`, context);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('🏆 USER MILESTONE:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.yellow('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    featureUsage(name, context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug(`Feature Usage: ${name}`, context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('📊 FEATURE USAGE:'), name);
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.cyan('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    updateCheckStart() {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo('Update Check Start', {});
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('🔄 UPDATE CHECK START'));
+    }
+    updateAvailable(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo('Update Available', context);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('✨ UPDATE AVAILABLE'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Version:'), context['version']);
+        }
+    }
+    updateDownloadStart(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo('Update Download Start', context);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('⬇️  UPDATE DOWNLOAD START'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.cyan('  Context:'), JSON.stringify(context, null, 2));
+        }
+    }
+    updateDownloadProgress(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logDebug('Update Download Progress', context);
+        }
+        if (this.level < LogLevel.DEBUG)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.cyan('⬇️  DOWNLOAD PROGRESS:'), `${context['percent']}%`);
+    }
+    updateDownloadComplete(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo('Update Download Complete', context);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('✅ UPDATE DOWNLOAD COMPLETE'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Version:'), context['version']);
+        }
+    }
+    updateInstalling() {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo('Update Installing', {});
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.yellow('🔧 UPDATE INSTALLING'));
+    }
+    updateInstalled(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logInfo('Update Installed', context);
+        }
+        if (this.level < LogLevel.INFO)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.green('🎉 UPDATE INSTALLED'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.green('  Version:'), context['version']);
+        }
+    }
+    updateError(context) {
+        const jsonLogger = getJsonStreamLogger();
+        if (jsonLogger?.isActive()) {
+            jsonLogger.logError(new Error(String(context['error'] || 'Unknown error')), 'updateError');
+        }
+        if (this.level < LogLevel.ERROR)
+            return;
+        const location = this.getCallLocation();
+        const timestamp = this.getTimestamp();
+        const prefix = this.getPrefix();
+        const loc = this.getLocation(location);
+        console.log(timestamp, prefix, loc, chalk.red('❌ UPDATE ERROR'));
+        if (Object.keys(context).length > 0) {
+            console.log(chalk.red('  Error:'), context['error']);
+        }
+    }
+}
+export const logger = new Logger({
+    level: LogLevel.ERROR,
+    prefix: '한설',
+    timestamp: true,
+    showLocation: false,
+    showPid: false,
+});
+export function setLogLevel(level) {
+    logger.setLevel(level);
+    if (level >= LogLevel.DEBUG) {
+        logger['showLocation'] = true;
+    }
+}
+export function enableVerbose() {
+    logger.setLevel(LogLevel.VERBOSE);
+}
+export function disableVerbose() {
+    logger.setLevel(LogLevel.INFO);
+}
+export function enableDebug() {
+    logger.setLevel(LogLevel.DEBUG);
+}
+export function createLogger(prefix, options) {
+    return new Logger({
+        level: logger['level'],
+        prefix,
+        timestamp: true,
+        showLocation: logger['showLocation'],
+        showPid: logger['showPid'],
+        ...options,
+    });
+}
+export function generateTraceId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+export async function setupLogging(options) {
+    const { initializeJsonStreamLogger, closeJsonStreamLogger } = await import('./json-stream-logger.js');
+    const { sessionManager } = await import('../core/session/session-manager.js');
+    const isVerboseMode = options.verbose || options.debug;
+    const sessionId = options.sessionId || sessionManager.getCurrentSessionId();
+    const jsonLogger = await initializeJsonStreamLogger(sessionId, false, isVerboseMode);
+    if (options.llmLog) {
+        enableLLMLog();
+    }
+    if (options.debug) {
+        setLogLevel(LogLevel.VERBOSE);
+        logger.debug('🔍 Debug mode enabled - maximum logging with location tracking');
+    }
+    else if (options.verbose) {
+        setLogLevel(LogLevel.DEBUG);
+        logger.debug('📝 Verbose mode enabled - detailed logging');
+    }
+    else if (options.llmLog) {
+        console.log(chalk.cyan('📡 LLM Log mode enabled - showing LLM requests/responses only'));
+    }
+    let cleanupCalled = false;
+    const cleanup = async () => {
+        if (cleanupCalled) {
+            return;
+        }
+        cleanupCalled = true;
+        await closeJsonStreamLogger();
+    };
+    const exitHandler = async (signal) => {
+        logger.debug(`Received ${signal}, cleaning up...`);
+        await cleanup();
+        process.exit(0);
+    };
+    process.once('SIGTERM', () => exitHandler('SIGTERM'));
+    return { cleanup, jsonLogger };
+}
+//# sourceMappingURL=logger.js.map