hanseol-dev 4.0.12

package/dist/utils/json-stream-logger.js

@@ -0,0 +1,808 @@
+import { createWriteStream } from 'fs';
+import { mkdir, access, readFile, writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+import { PROJECTS_DIR } from '../constants.js';
+const FLUSH_INTERVAL_MS = 1000;
+function getLogCategory(type) {
+    switch (type) {
+        case 'user_input':
+        case 'assistant_response':
+            return 'chat';
+        case 'tool_call':
+        case 'tool_start':
+        case 'tool_end':
+        case 'todo_update':
+        case 'planning_start':
+        case 'planning_end':
+            return 'tool';
+        case 'server_request':
+        case 'server_response':
+        case 'http_event':
+            return 'http';
+        case 'ui_interaction':
+        case 'component_lifecycle':
+        case 'screen_change':
+        case 'form_event':
+        case 'modal_event':
+        case 'loading_event':
+        case 'animation_event':
+        case 'layout_event':
+            return 'ui';
+        case 'system_message':
+        case 'ipc_event':
+        case 'window_event':
+        case 'system_event':
+        case 'update_event':
+        case 'session_event':
+        case 'error':
+            return 'system';
+        case 'debug':
+        case 'info':
+            return 'debug';
+        default:
+            return 'system';
+    }
+}
+function refineCategoryFromContent(category, content) {
+    const msg = content.toLowerCase();
+    if (msg.includes('[llm]') || msg.includes('llm request') || msg.includes('llm response') ||
+        msg.includes('llm tool') || msg.includes('completion') || msg.includes('tokens')) {
+        return 'llm';
+    }
+    if (msg.includes('[http]') || msg.includes('stream start') || msg.includes('stream end') ||
+        msg.includes('stream chunk') || msg.includes('http request') || msg.includes('http response')) {
+        return 'http';
+    }
+    if (msg.includes('[tool]') || msg.includes('[bash]') || msg.includes('[read]') ||
+        msg.includes('[write]') || msg.includes('[edit]') || msg.includes('tool execution') ||
+        msg.includes('tool result')) {
+        return 'tool';
+    }
+    if (msg.includes('[ui]') || msg.includes('[component]') || msg.includes('[render]') ||
+        msg.includes('[modal]') || msg.includes('[form]') || msg.includes('[loading]')) {
+        return 'ui';
+    }
+    if (msg.includes('[system]') || msg.includes('[session]') || msg.includes('[config]') ||
+        msg.includes('[update]') || msg.includes('[window]') || msg.includes('[ipc]')) {
+        return 'system';
+    }
+    return category;
+}
+export class JsonStreamLogger {
+    writeStream = null;
+    errorWriteStream = null;
+    filePath;
+    errorFilePath;
+    isFirstEntry = true;
+    isFirstErrorEntry = true;
+    buffer = [];
+    errorBuffer = [];
+    flushInterval = null;
+    isEnabled = false;
+    errorStreamInitialized = false;
+    appendMode = false;
+    verbose = false;
+    categoryStreams = new Map();
+    enableCategorySplit = true;
+    pendingStreamInits = new Set();
+    constructor(filePath, errorFilePath) {
+        this.filePath = filePath;
+        this.errorFilePath = errorFilePath;
+    }
+    async initialize(append = false, verbose = false) {
+        this.verbose = verbose;
+        try {
+            this.appendMode = append;
+            await mkdir(dirname(this.filePath), { recursive: true });
+            let fileExists = false;
+            try {
+                await access(this.filePath);
+                fileExists = true;
+            }
+            catch {
+                fileExists = false;
+            }
+            if (append && fileExists) {
+                await this.prepareFileForAppend(this.filePath);
+                this.writeStream = createWriteStream(this.filePath, { flags: 'a' });
+                this.isFirstEntry = false;
+                if (this.verbose) {
+                    console.log(chalk.dim(`📝 JSON stream logging resumed (append mode)`));
+                }
+            }
+            else {
+                this.writeStream = createWriteStream(this.filePath, { flags: 'w' });
+                this.writeStream.write('[\n');
+                this.isFirstEntry = true;
+                if (this.verbose) {
+                    console.log(chalk.dim(`📝 JSON stream logging enabled`));
+                }
+            }
+            this.isEnabled = true;
+            this.flushInterval = setInterval(() => {
+                this.flush();
+                this.flushErrors();
+                this.flushCategories();
+            }, FLUSH_INTERVAL_MS);
+            if (this.verbose) {
+                console.log(chalk.dim(`   Log: ${this.filePath}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Failed to initialize JSON stream logger:'), error);
+            this.isEnabled = false;
+        }
+    }
+    async prepareFileForAppend(filePath) {
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            const trimmed = content.trimEnd();
+            if (trimmed.endsWith(']')) {
+                const withoutClosing = trimmed.slice(0, -1);
+                await writeFile(filePath, withoutClosing, 'utf-8');
+            }
+        }
+        catch (error) {
+            console.error(chalk.yellow('Warning: Could not prepare file for append:'), error);
+        }
+    }
+    async initializeCategoryStream(category) {
+        if (!this.enableCategorySplit) {
+            return;
+        }
+        const existingInfo = this.categoryStreams.get(category);
+        if (existingInfo && existingInfo.stream && !existingInfo.stream.destroyed) {
+            return;
+        }
+        try {
+            const categoryFilePath = existingInfo?.filePath || this.filePath.replace('_log.json', `_${category}.json`);
+            await mkdir(dirname(categoryFilePath), { recursive: true });
+            let fileExists = false;
+            try {
+                await access(categoryFilePath);
+                fileExists = true;
+            }
+            catch {
+                fileExists = false;
+            }
+            let stream;
+            let isFirstEntry = true;
+            if (this.appendMode && fileExists) {
+                await this.prepareFileForAppend(categoryFilePath);
+                stream = createWriteStream(categoryFilePath, { flags: 'a' });
+                isFirstEntry = false;
+            }
+            else {
+                stream = createWriteStream(categoryFilePath, { flags: 'w' });
+                stream.write('[\n');
+                isFirstEntry = true;
+            }
+            if (existingInfo) {
+                existingInfo.stream = stream;
+                existingInfo.isFirstEntry = isFirstEntry;
+            }
+            else {
+                this.categoryStreams.set(category, {
+                    stream,
+                    buffer: [],
+                    isFirstEntry,
+                    filePath: categoryFilePath,
+                });
+            }
+            if (this.verbose) {
+                console.log(chalk.dim(`   Category log: ${categoryFilePath}`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`Failed to initialize category stream (${category}):`), error);
+        }
+    }
+    log(entry) {
+        if (!this.isEnabled || !this.writeStream) {
+            return;
+        }
+        if (!entry.category) {
+            const baseCategory = getLogCategory(entry.type);
+            entry.category = refineCategoryFromContent(baseCategory, entry.content);
+        }
+        this.buffer.push(entry);
+        if (entry.type === 'error') {
+            if (!this.errorStreamInitialized) {
+                this.initializeErrorStream().catch(err => {
+                    console.error(chalk.red('Failed to initialize error stream:'), err);
+                });
+            }
+            this.errorBuffer.push(entry);
+        }
+        if (this.enableCategorySplit && entry.category && entry.category !== 'all') {
+            const category = entry.category;
+            if (!this.categoryStreams.has(category)) {
+                const categoryFilePath = this.filePath.replace('_log.json', `_${category}.json`);
+                this.categoryStreams.set(category, {
+                    stream: null,
+                    buffer: [],
+                    isFirstEntry: true,
+                    filePath: categoryFilePath,
+                });
+                const initPromise = this.initializeCategoryStream(category).catch(err => {
+                    console.error(chalk.red(`Failed to initialize category stream (${category}):`), err);
+                });
+                this.pendingStreamInits.add(initPromise);
+                initPromise.finally(() => this.pendingStreamInits.delete(initPromise));
+            }
+            const streamInfo = this.categoryStreams.get(category);
+            if (streamInfo) {
+                streamInfo.buffer.push(entry);
+            }
+        }
+    }
+    flush() {
+        if (!this.writeStream || this.buffer.length === 0) {
+            return;
+        }
+        try {
+            for (const entry of this.buffer) {
+                if (!this.isFirstEntry) {
+                    this.writeStream.write(',\n');
+                }
+                this.isFirstEntry = false;
+                const json = JSON.stringify(entry, null, 2);
+                const indentedJson = json.split('\n').map(line => '  ' + line).join('\n');
+                this.writeStream.write(indentedJson);
+            }
+            this.buffer = [];
+        }
+        catch (error) {
+            console.error(chalk.red('Failed to write to JSON stream:'), error);
+        }
+    }
+    async initializeErrorStream() {
+        if (this.errorStreamInitialized) {
+            return;
+        }
+        try {
+            await mkdir(dirname(this.errorFilePath), { recursive: true });
+            let fileExists = false;
+            try {
+                await access(this.errorFilePath);
+                fileExists = true;
+            }
+            catch {
+                fileExists = false;
+            }
+            if (this.appendMode && fileExists) {
+                await this.prepareFileForAppend(this.errorFilePath);
+                this.errorWriteStream = createWriteStream(this.errorFilePath, { flags: 'a' });
+                this.isFirstErrorEntry = false;
+            }
+            else {
+                this.errorWriteStream = createWriteStream(this.errorFilePath, { flags: 'w' });
+                this.errorWriteStream.write('[\n');
+                this.isFirstErrorEntry = true;
+            }
+            this.errorStreamInitialized = true;
+            console.log(chalk.dim(`   Error log: ${this.errorFilePath}`));
+        }
+        catch (error) {
+            console.error(chalk.red('Failed to initialize error stream:'), error);
+        }
+    }
+    flushErrors() {
+        if (!this.errorWriteStream || this.errorBuffer.length === 0) {
+            return;
+        }
+        try {
+            for (const entry of this.errorBuffer) {
+                if (!this.isFirstErrorEntry) {
+                    this.errorWriteStream.write(',\n');
+                }
+                this.isFirstErrorEntry = false;
+                const json = JSON.stringify(entry, null, 2);
+                const indentedJson = json.split('\n').map(line => '  ' + line).join('\n');
+                this.errorWriteStream.write(indentedJson);
+            }
+            this.errorBuffer = [];
+        }
+        catch (error) {
+            console.error(chalk.red('Failed to write to error JSON stream:'), error);
+        }
+    }
+    flushCategories() {
+        for (const [_category, streamInfo] of this.categoryStreams) {
+            if (!streamInfo.stream || !streamInfo.stream.writable || streamInfo.buffer.length === 0) {
+                continue;
+            }
+            try {
+                for (const entry of streamInfo.buffer) {
+                    if (!streamInfo.isFirstEntry) {
+                        streamInfo.stream.write(',\n');
+                    }
+                    streamInfo.isFirstEntry = false;
+                    const json = JSON.stringify(entry, null, 2);
+                    const indentedJson = json.split('\n').map(line => '  ' + line).join('\n');
+                    streamInfo.stream.write(indentedJson);
+                }
+                streamInfo.buffer = [];
+            }
+            catch (error) {
+                console.error(chalk.red(`Failed to write to category stream:`), error);
+            }
+        }
+    }
+    logUserInput(input) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'user_input',
+            content: input,
+            metadata: {
+                length: input.length,
+            },
+        });
+    }
+    logAssistantResponse(response, streaming = false) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'assistant_response',
+            content: response,
+            metadata: {
+                length: response.length,
+                streaming,
+            },
+        });
+    }
+    logSystemMessage(message) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'system_message',
+            content: message,
+        });
+    }
+    logError(error, context) {
+        let errorMessage;
+        let errorStack;
+        let errorDetails;
+        if (error instanceof Error) {
+            errorMessage = error.message;
+            errorStack = error.stack;
+            if (error.details) {
+                errorDetails = error.details;
+            }
+        }
+        else if (typeof error === 'object' && error !== null) {
+            try {
+                errorMessage = JSON.stringify(error, null, 2);
+                errorDetails = error;
+            }
+            catch {
+                errorMessage = String(error);
+            }
+        }
+        else {
+            errorMessage = String(error);
+        }
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'error',
+            content: errorMessage,
+            metadata: {
+                context,
+                stack: errorStack,
+                name: error instanceof Error ? error.constructor.name : 'Unknown',
+                ...(errorDetails && { details: errorDetails }),
+            },
+        });
+    }
+    logToolCall(toolName, args, result, error) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'tool_call',
+            content: `Tool: ${toolName}`,
+            metadata: {
+                toolName,
+                args,
+                result: result ? (typeof result === 'string' ? result.substring(0, 500) : result) : undefined,
+                error: error ? error.message : undefined,
+                success: !error,
+            },
+        });
+    }
+    logTodoUpdate(todos) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'todo_update',
+            content: `TODO list updated (${todos.length} items)`,
+            metadata: {
+                todos,
+                count: todos.length,
+            },
+        });
+    }
+    logDebug(message, data) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'debug',
+            content: message,
+            metadata: data ? { data } : undefined,
+        });
+    }
+    logInfo(message, data) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'info',
+            content: message,
+            metadata: data ? { data } : undefined,
+        });
+    }
+    logToolStart(toolName, args, reason) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'tool_start',
+            content: `Tool Start: ${toolName}`,
+            metadata: {
+                toolName,
+                args,
+                reason,
+            },
+        });
+    }
+    logToolEnd(toolName, success, result, error, durationMs) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'tool_end',
+            content: `Tool End: ${toolName} (${success ? 'success' : 'failed'})`,
+            metadata: {
+                toolName,
+                success,
+                result: result ? (typeof result === 'string' ? result.substring(0, 1000) : result) : undefined,
+                error,
+                durationMs,
+            },
+        });
+    }
+    logPlanningStart(userMessage, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'planning_start',
+            content: `Planning Start: ${userMessage.substring(0, 100)}...`,
+            metadata: {
+                userMessage,
+                messageLength: userMessage.length,
+                ...context,
+            },
+        });
+    }
+    logPlanningEnd(todoCount, todos, directResponse, durationMs) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'planning_end',
+            content: directResponse ? 'Planning End: Direct response' : `Planning End: ${todoCount} TODOs created`,
+            metadata: {
+                todoCount,
+                todos,
+                directResponse,
+                durationMs,
+            },
+        });
+    }
+    logServerRequest(serverType, method, endpoint, body) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'server_request',
+            content: `${serverType.toUpperCase()} Server: ${method} ${endpoint}`,
+            metadata: {
+                serverType,
+                method,
+                endpoint,
+                body,
+            },
+        });
+    }
+    logServerResponse(serverType, endpoint, success, response, error, durationMs) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'server_response',
+            content: `${serverType.toUpperCase()} Server Response: ${endpoint} (${success ? 'success' : 'failed'})`,
+            metadata: {
+                serverType,
+                endpoint,
+                success,
+                response: response ? (typeof response === 'string' ? response.substring(0, 500) : response) : undefined,
+                error,
+                durationMs,
+            },
+        });
+    }
+    logUIInteraction(action, element, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'ui_interaction',
+            content: `UI: ${action}${element ? ` - ${element}` : ''}`,
+            metadata: {
+                action,
+                element,
+                ...context,
+            },
+        });
+    }
+    logComponentLifecycle(event, componentName, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'component_lifecycle',
+            content: `Component ${event}: ${componentName}`,
+            metadata: {
+                event,
+                componentName,
+                ...context,
+            },
+        });
+    }
+    logScreenChange(changeType, target, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'screen_change',
+            content: `${changeType.charAt(0).toUpperCase() + changeType.slice(1)} change: ${target}`,
+            metadata: {
+                changeType,
+                target,
+                ...context,
+            },
+        });
+    }
+    logFormEvent(event, formId, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'form_event',
+            content: `Form ${event}: ${formId}`,
+            metadata: {
+                event,
+                formId,
+                ...context,
+            },
+        });
+    }
+    logModalEvent(event, id, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'modal_event',
+            content: `${event}: ${id}`,
+            metadata: {
+                event,
+                id,
+                ...context,
+            },
+        });
+    }
+    logLoadingEvent(event, id, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'loading_event',
+            content: `${event}: ${id}`,
+            metadata: {
+                event,
+                id,
+                ...context,
+            },
+        });
+    }
+    logAnimationEvent(event, name, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'animation_event',
+            content: `${event}: ${name}`,
+            metadata: {
+                event,
+                name,
+                ...context,
+            },
+        });
+    }
+    logLayoutEvent(event, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'layout_event',
+            content: `Layout: ${event}`,
+            metadata: {
+                event,
+                ...context,
+            },
+        });
+    }
+    logIPCEvent(event, channel, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'ipc_event',
+            content: `IPC ${event}: ${channel}`,
+            metadata: {
+                event,
+                channel,
+                ...context,
+            },
+        });
+    }
+    logWindowEvent(event, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'window_event',
+            content: `Window: ${event}`,
+            metadata: {
+                event,
+                ...context,
+            },
+        });
+    }
+    logSystemEvent(event, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'system_event',
+            content: `System: ${event}`,
+            metadata: {
+                event,
+                ...context,
+            },
+        });
+    }
+    logUpdateEvent(event, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'update_event',
+            content: `Update: ${event}`,
+            metadata: {
+                event,
+                ...context,
+            },
+        });
+    }
+    logSessionEvent(event, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'session_event',
+            content: `Session: ${event}`,
+            metadata: {
+                event,
+                ...context,
+            },
+        });
+    }
+    logHTTPEvent(event, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'http_event',
+            content: `HTTP: ${event}`,
+            metadata: {
+                event,
+                ...context,
+            },
+        });
+    }
+    logErrorEvent(event, context) {
+        this.log({
+            timestamp: new Date().toISOString(),
+            type: 'error',
+            content: `Error: ${event}`,
+            metadata: {
+                event,
+                ...context,
+            },
+        });
+    }
+    getLogDirectory() {
+        return dirname(this.filePath);
+    }
+    getLogFilePath() {
+        return this.filePath;
+    }
+    async close() {
+        if (!this.isEnabled || !this.writeStream) {
+            return;
+        }
+        this.isEnabled = false;
+        if (this.flushInterval) {
+            clearInterval(this.flushInterval);
+            this.flushInterval = null;
+        }
+        if (this.pendingStreamInits.size > 0) {
+            await Promise.all(this.pendingStreamInits);
+        }
+        this.flush();
+        if (this.errorStreamInitialized) {
+            this.flushErrors();
+        }
+        this.flushCategories();
+        const promises = [];
+        if (!this.writeStream.destroyed) {
+            if (this.writeStream.writable) {
+                this.writeStream.write('\n]\n');
+            }
+            promises.push(new Promise((resolve, reject) => {
+                this.writeStream.end((error) => {
+                    if (error) {
+                        console.error(chalk.red('Failed to close JSON stream:'), error);
+                        reject(error);
+                    }
+                    else {
+                        if (this.verbose) {
+                            console.log(chalk.dim(`✅ Log saved: ${this.filePath}`));
+                        }
+                        resolve();
+                    }
+                });
+            }));
+        }
+        else if (this.verbose) {
+            console.log(chalk.dim(`⚠️  Log stream already closed: ${this.filePath}`));
+        }
+        if (this.errorStreamInitialized && this.errorWriteStream && !this.errorWriteStream.destroyed) {
+            if (this.errorWriteStream.writable) {
+                this.errorWriteStream.write('\n]\n');
+            }
+            promises.push(new Promise((resolve, reject) => {
+                this.errorWriteStream.end((error) => {
+                    if (error) {
+                        console.error(chalk.red('Failed to close error JSON stream:'), error);
+                        reject(error);
+                    }
+                    else {
+                        console.log(chalk.dim(`✅ Error log saved: ${this.errorFilePath}`));
+                        resolve();
+                    }
+                });
+            }));
+        }
+        for (const [category, streamInfo] of this.categoryStreams) {
+            if (streamInfo.stream && !streamInfo.stream.destroyed) {
+                if (streamInfo.stream.writable) {
+                    streamInfo.stream.write('\n]\n');
+                }
+                promises.push(new Promise((resolve, reject) => {
+                    streamInfo.stream.end((error) => {
+                        if (error) {
+                            console.error(chalk.red(`Failed to close category stream (${category}):`), error);
+                            reject(error);
+                        }
+                        else {
+                            if (this.verbose) {
+                                console.log(chalk.dim(`✅ Category log saved: ${streamInfo.filePath}`));
+                            }
+                            resolve();
+                        }
+                    });
+                }));
+            }
+        }
+        await Promise.all(promises);
+        this.writeStream = null;
+        this.errorWriteStream = null;
+        this.categoryStreams.clear();
+    }
+    isActive() {
+        return this.isEnabled;
+    }
+    getFilePath() {
+        return this.filePath;
+    }
+}
+let globalJsonStreamLogger = null;
+export async function initializeJsonStreamLogger(sessionId, append = false, verbose = false) {
+    if (globalJsonStreamLogger) {
+        await globalJsonStreamLogger.close();
+    }
+    const cwd = process.cwd().replace(/\//g, '-').replace(/^-/, '');
+    const projectLogDir = join(PROJECTS_DIR, cwd);
+    const logFile = join(projectLogDir, `${sessionId}_log.json`);
+    const errorLogFile = join(projectLogDir, `${sessionId}_error.json`);
+    globalJsonStreamLogger = new JsonStreamLogger(logFile, errorLogFile);
+    await globalJsonStreamLogger.initialize(append, verbose);
+    return globalJsonStreamLogger;
+}
+export function getJsonStreamLogger() {
+    return globalJsonStreamLogger;
+}
+export const getStreamLogger = getJsonStreamLogger;
+export async function closeJsonStreamLogger() {
+    if (globalJsonStreamLogger && globalJsonStreamLogger.isActive()) {
+        await globalJsonStreamLogger.close();
+        globalJsonStreamLogger = null;
+    }
+}
+//# sourceMappingURL=json-stream-logger.js.map