@compass-ai/nova 1.0.74 → 1.0.75

package/dist/services/system-event-logger.js

@@ -1,790 +0,0 @@
-/**
- * System Event Logger for comprehensive observability.
- *
- * This module provides structured logging for all system events including
- * bash command execution, file operations, tool executions, and errors.
- * Logs are stored in JSONL format (one JSON object per line) in the project's
- * .compass/.logs/ directory with daily rotation (system-DD-MM-YY.jsonl format).
- */
-import fs from 'fs-extra';
-import path from 'path';
-import { formatTimestamp } from '../utils/format.js';
-import { logger } from '../utils/logger.js';
-import { cleanupOldLogs } from '../utils/log-cleanup.js';
-/**
- * Maximum characters for stdout/stderr truncation
- */
-const MAX_OUTPUT_LENGTH = 100;
-/**
- * Truncates a string to the specified maximum length
- */
-function truncate(str, maxLength = MAX_OUTPUT_LENGTH) {
-    if (!str)
-        return undefined;
-    if (str.length <= maxLength)
-        return str;
-    return str.substring(0, maxLength) + '...';
-}
-/**
- * SystemEventLogger class provides comprehensive logging of system events
- * to project-specific JSONL log files.
- */
-class SystemEventLogger {
-    projectRoot;
-    currentLogFile = null;
-    logFileInitialized = false;
-    enabled = true;
-    sessionId = null;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot || process.cwd();
-    }
-    /**
-     * Sets the project root directory for logging
-     */
-    setProjectRoot(projectRoot) {
-        this.projectRoot = projectRoot;
-        this.currentLogFile = null;
-        this.logFileInitialized = false;
-    }
-    /**
-     * Sets the current session ID for correlation
-     */
-    setSessionId(sessionId) {
-        this.sessionId = sessionId;
-    }
-    /**
-     * Gets the current session ID
-     */
-    getSessionId() {
-        return this.sessionId;
-    }
-    /**
-     * Gets the current log file path
-     */
-    getLogFilePath() {
-        return this.currentLogFile;
-    }
-    /**
-     * Enables or disables system event logging
-     */
-    setEnabled(enabled) {
-        this.enabled = enabled;
-    }
-    /**
-     * Formats a date to DD-MM-YY format for log file names
-     */
-    formatDateForFilename(date) {
-        const day = String(date.getDate()).padStart(2, '0');
-        const month = String(date.getMonth() + 1).padStart(2, '0');
-        const year = String(date.getFullYear()).slice(-2);
-        return `${day}-${month}-${year}`;
-    }
-    /**
-     * Ensures the log file exists and returns its path
-     */
-    async ensureLogFile() {
-        if (this.currentLogFile && this.logFileInitialized) {
-            return this.currentLogFile;
-        }
-        const logsDir = path.join(this.projectRoot, '.compass', '.logs');
-        try {
-            await fs.ensureDir(logsDir);
-        }
-        catch (error) {
-            logger.debug('Failed to create .logs directory for system events', error);
-            this.enabled = false;
-            return '';
-        }
-        // Clean up old log files (runs once per directory per session)
-        await cleanupOldLogs(logsDir);
-        const dateStr = this.formatDateForFilename(new Date());
-        this.currentLogFile = path.join(logsDir, `system-${dateStr}.jsonl`);
-        this.logFileInitialized = true;
-        return this.currentLogFile;
-    }
-    /**
-     * Writes an event in JSONL format (one JSON per line)
-     */
-    async writeEvent(event) {
-        if (!this.enabled) {
-            return;
-        }
-        try {
-            const logFile = await this.ensureLogFile();
-            if (!logFile) {
-                return;
-            }
-            // JSONL format: one JSON object per line, no pretty printing
-            const jsonLine = JSON.stringify(event) + '\n';
-            await fs.appendFile(logFile, jsonLine);
-        }
-        catch (error) {
-            logger.debug('Failed to write system event', error);
-        }
-    }
-    /**
-     * Logs a session start event
-     */
-    async logSessionStart(sessionId, projectPath) {
-        this.sessionId = sessionId;
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'session_start',
-            component: 'Session',
-            session_id: sessionId,
-            data: {
-                projectPath,
-            },
-        });
-    }
-    /**
-     * Logs a session end event
-     */
-    async logSessionEnd() {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'session_end',
-            component: 'Session',
-            session_id: this.sessionId || undefined,
-        });
-    }
-    /**
-     * Logs a bash command execution
-     */
-    async logBashExecuted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: data.exitCode === 0 ? 'info' : 'warn',
-            event: 'bash_executed',
-            component: 'ShellExecutor',
-            session_id: this.sessionId || undefined,
-            data: {
-                command: data.command,
-                cwd: data.cwd,
-                exitCode: data.exitCode,
-                duration_ms: data.duration_ms,
-                stdout: truncate(data.stdout),
-                stderr: truncate(data.stderr),
-                timedOut: data.timedOut,
-                killed: data.killed,
-            },
-        });
-    }
-    /**
-     * Logs a file read operation
-     */
-    async logFileRead(filePath, size, success = true, error) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: success ? 'info' : 'error',
-            event: 'file_read',
-            component: 'FileService',
-            session_id: this.sessionId || undefined,
-            data: {
-                path: filePath,
-                size,
-                operation: 'read',
-                success,
-                error,
-            },
-        });
-    }
-    /**
-     * Logs a file write operation
-     */
-    async logFileWrite(filePath, size, success = true, error) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: success ? 'info' : 'error',
-            event: 'file_write',
-            component: 'FileService',
-            session_id: this.sessionId || undefined,
-            data: {
-                path: filePath,
-                size,
-                operation: 'write',
-                success,
-                error,
-            },
-        });
-    }
-    /**
-     * Logs a file delete operation
-     */
-    async logFileDelete(filePath, success = true, error) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: success ? 'info' : 'error',
-            event: 'file_delete',
-            component: 'FileService',
-            session_id: this.sessionId || undefined,
-            data: {
-                path: filePath,
-                operation: 'delete',
-                success,
-                error,
-            },
-        });
-    }
-    /**
-     * Logs a file rename operation
-     */
-    async logFileRename(oldPath, newPath, success = true, error) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: success ? 'info' : 'error',
-            event: 'file_rename',
-            component: 'FileService',
-            session_id: this.sessionId || undefined,
-            data: {
-                path: oldPath,
-                newPath,
-                operation: 'rename',
-                success,
-                error,
-            },
-        });
-    }
-    /**
-     * Logs a tool execution
-     */
-    async logToolExecuted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: data.success ? 'info' : 'error',
-            event: 'tool_executed',
-            component: 'ToolRegistry',
-            session_id: this.sessionId || undefined,
-            data: {
-                name: data.name,
-                executionId: data.executionId,
-                success: data.success,
-                duration_ms: data.duration_ms,
-                input: data.input,
-                output: truncate(data.output),
-                error: data.error,
-            },
-        });
-    }
-    /**
-     * Logs an error event
-     */
-    async logError(component, errorMessage, errorDetails) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'error',
-            event: 'error',
-            component,
-            session_id: this.sessionId || undefined,
-            data: {
-                error: errorMessage,
-                details: errorDetails,
-            },
-        });
-    }
-    /**
-     * Logs a generic event with custom data
-     */
-    async logEvent(level, event, component, data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level,
-            event,
-            component,
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Configuration Events ==========
-    /**
-     * Logs a configuration change
-     */
-    async logConfigChanged(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'config_changed',
-            component: 'ConfigManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a provider change
-     */
-    async logProviderChanged(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'provider_changed',
-            component: 'ProviderManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a model change
-     */
-    async logModelChanged(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'model_changed',
-            component: 'ProviderManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== MCP Events ==========
-    /**
-     * Logs an MCP server connection
-     */
-    async logMcpConnected(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'mcp_connected',
-            component: 'McpManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs an MCP server disconnection
-     */
-    async logMcpDisconnected(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'warn',
-            event: 'mcp_disconnected',
-            component: 'McpManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs an MCP server error
-     */
-    async logMcpError(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'error',
-            event: 'mcp_error',
-            component: 'McpManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Tool Events ==========
-    /**
-     * Logs a tool registration
-     */
-    async logToolRegistered(name, source) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'debug',
-            event: 'tool_registered',
-            component: 'ToolRegistry',
-            session_id: this.sessionId || undefined,
-            data: { name, source },
-        });
-    }
-    /**
-     * Logs a tool failure
-     */
-    async logToolFailed(name, error, executionId) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'error',
-            event: 'tool_failed',
-            component: 'ToolRegistry',
-            session_id: this.sessionId || undefined,
-            data: { name, error, executionId },
-        });
-    }
-    // ========== Workflow Events ==========
-    /**
-     * Logs a workflow start
-     */
-    async logWorkflowStarted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'workflow_started',
-            component: 'WorkflowManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a workflow completion
-     */
-    async logWorkflowCompleted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'workflow_completed',
-            component: 'WorkflowManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a workflow failure
-     */
-    async logWorkflowFailed(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'error',
-            event: 'workflow_failed',
-            component: 'WorkflowManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a step start
-     */
-    async logStepStarted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'step_started',
-            component: 'WorkflowManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a step completion
-     */
-    async logStepCompleted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'step_completed',
-            component: 'WorkflowManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a step failure
-     */
-    async logStepFailed(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'error',
-            event: 'step_failed',
-            component: 'WorkflowManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Approval Events ==========
-    /**
-     * Logs an approval request
-     */
-    async logApprovalRequested(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'approval_requested',
-            component: 'ApprovalManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs an approval grant
-     */
-    async logApprovalGranted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'approval_granted',
-            component: 'ApprovalManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs an approval denial
-     */
-    async logApprovalDenied(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'warn',
-            event: 'approval_denied',
-            component: 'ApprovalManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs an approval timeout
-     */
-    async logApprovalTimeout(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'warn',
-            event: 'approval_timeout',
-            component: 'ApprovalManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Context Events ==========
-    /**
-     * Logs a context load
-     */
-    async logContextLoaded(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'context_loaded',
-            component: 'ContextManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a context save
-     */
-    async logContextSaved(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'context_saved',
-            component: 'ContextManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a context compaction
-     */
-    async logContextCompacted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'context_compacted',
-            component: 'ContextManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Reliability Events ==========
-    /**
-     * Logs a rate limit event
-     */
-    async logRateLimited(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'warn',
-            event: 'rate_limited',
-            component: 'ApiClient',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a retry attempt
-     */
-    async logRetryAttempted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'warn',
-            event: 'retry_attempted',
-            component: 'ApiClient',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs an API error
-     */
-    async logApiError(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'error',
-            event: 'api_error',
-            component: 'ApiClient',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Cache Events ==========
-    /**
-     * Logs a cache hit
-     */
-    async logCacheHit(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'debug',
-            event: 'cache_hit',
-            component: 'CacheManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a cache miss
-     */
-    async logCacheMiss(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'debug',
-            event: 'cache_miss',
-            component: 'CacheManager',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Indexing Events ==========
-    /**
-     * Logs an index start
-     */
-    async logIndexStarted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'index_started',
-            component: 'CodebaseIndexer',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs an index completion
-     */
-    async logIndexCompleted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'index_completed',
-            component: 'CodebaseIndexer',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Complexity Analysis Events ==========
-    /**
-     * Logs a complexity analysis result
-     */
-    async logComplexityAnalyzed(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'complexity_analyzed',
-            component: 'ComplexityClassifier',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Git Events ==========
-    /**
-     * Logs a git operation
-     */
-    async logGitOperation(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: data.success ? 'info' : 'warn',
-            event: 'git_operation',
-            component: 'GitService',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Clarification Events ==========
-    /**
-     * Logs a clarification request
-     */
-    async logClarificationRequested(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'clarification_requested',
-            component: 'InteractiveClarifier',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a clarification completion
-     */
-    async logClarificationCompleted(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'clarification_completed',
-            component: 'InteractiveClarifier',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    // ========== Plan Generation Events ==========
-    /**
-     * Logs a plan generation
-     */
-    async logPlanGenerated(data) {
-        await this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'plan_generated',
-            component: 'PlanGenerator',
-            session_id: this.sessionId || undefined,
-            data,
-        });
-    }
-    /**
-     * Logs a plan approval request
-     */
-    logPlanApprovalRequested(planId) {
-        this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'plan_approval_requested',
-            component: 'ApprovalManager',
-            session_id: this.sessionId || undefined,
-            data: { planId },
-        });
-    }
-    /**
-     * Logs a plan approval resolution
-     */
-    logPlanApprovalResolved(planId, choice) {
-        this.writeEvent({
-            ts: formatTimestamp(),
-            level: 'info',
-            event: 'plan_approval_resolved',
-            component: 'ApprovalManager',
-            session_id: this.sessionId || undefined,
-            data: { planId, choice },
-        });
-    }
-}
-// Singleton instance
-let systemEventLoggerInstance = null;
-/**
- * Gets the singleton SystemEventLogger instance
- */
-export function getSystemEventLogger(projectRoot) {
-    if (!systemEventLoggerInstance) {
-        systemEventLoggerInstance = new SystemEventLogger(projectRoot);
-    }
-    else if (projectRoot) {
-        systemEventLoggerInstance.setProjectRoot(projectRoot);
-    }
-    return systemEventLoggerInstance;
-}
-/**
- * Creates a new SystemEventLogger instance (non-singleton)
- */
-export function createSystemEventLogger(projectRoot) {
-    return new SystemEventLogger(projectRoot);
-}
-export { SystemEventLogger };
-//# sourceMappingURL=system-event-logger.js.map