@compass-ai/nova 1.0.73 → 1.0.74

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

@@ -0,0 +1,790 @@
+/**
+ * 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