codex-linux 1.0.0

package/src/main/monitoring/MetricsCollector.ts

@@ -0,0 +1,196 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+
+interface MetricValue {
+  timestamp: number;
+  value: number;
+  tags?: Record<string, string>;
+}
+
+interface Metric {
+  name: string;
+  type: 'counter' | 'gauge' | 'histogram';
+  values: MetricValue[];
+  labels?: string[];
+}
+
+export class MetricsCollector extends EventEmitter {
+  private metrics: Map<string, Metric> = new Map();
+  private retentionMs = 24 * 60 * 60 * 1000; // 24 hours
+  private cleanupInterval: NodeJS.Timeout | undefined;
+
+  constructor() {
+    super();
+    this.cleanupInterval = setInterval(() => this.cleanup(), 60 * 60 * 1000); // Every hour
+  }
+
+  // Counter - cumulative metric
+  increment(name: string, value: number = 1, tags?: Record<string, string>): void {
+    const metric = this.getOrCreateMetric(name, 'counter');
+    metric.values.push({
+      timestamp: Date.now(),
+      value,
+      tags,
+    });
+    
+    this.emit('metric', { name, type: 'counter', value, tags });
+  }
+
+  // Gauge - current value
+  gauge(name: string, value: number, tags?: Record<string, string>): void {
+    const metric = this.getOrCreateMetric(name, 'gauge');
+    metric.values.push({
+      timestamp: Date.now(),
+      value,
+      tags,
+    });
+
+    // Keep only last value for gauges (or last N values)
+    if (metric.values.length > 100) {
+      metric.values = metric.values.slice(-100);
+    }
+
+    this.emit('metric', { name, type: 'gauge', value, tags });
+  }
+
+  // Histogram - distribution of values
+  histogram(name: string, value: number, tags?: Record<string, string>): void {
+    const metric = this.getOrCreateMetric(name, 'histogram');
+    metric.values.push({
+      timestamp: Date.now(),
+      value,
+      tags,
+    });
+
+    // Limit histogram size
+    if (metric.values.length > 1000) {
+      metric.values = metric.values.slice(-1000);
+    }
+
+    this.emit('metric', { name, type: 'histogram', value, tags });
+  }
+
+  // Timer - measure duration
+  timer(name: string, fn: () => void, tags?: Record<string, string>): void {
+    const start = process.hrtime.bigint();
+    
+    try {
+      fn();
+    } finally {
+      const end = process.hrtime.bigint();
+      const durationMs = Number(end - start) / 1_000_000;
+      this.histogram(name, durationMs, tags);
+    }
+  }
+
+  async timerAsync<T>(
+    name: string,
+    fn: () => Promise<T>,
+    tags?: Record<string, string>
+  ): Promise<T> {
+    const start = process.hrtime.bigint();
+    
+    try {
+      return await fn();
+    } finally {
+      const end = process.hrtime.bigint();
+      const durationMs = Number(end - start) / 1_000_000;
+      this.histogram(name, durationMs, tags);
+    }
+  }
+
+  getMetric(name: string): Metric | undefined {
+    return this.metrics.get(name);
+  }
+
+  getAllMetrics(): Metric[] {
+    return Array.from(this.metrics.values());
+  }
+
+  getStats(): Record<string, any> {
+    const stats: Record<string, any> = {
+      totalMetrics: this.metrics.size,
+      byType: {},
+    };
+
+    for (const metric of this.metrics.values()) {
+      stats.byType[metric.type] = (stats.byType[metric.type] || 0) + 1;
+    }
+
+    return stats;
+  }
+
+  exportMetrics(): string {
+    // Prometheus format
+    const lines: string[] = [];
+
+    for (const metric of this.metrics.values()) {
+      lines.push(`# HELP ${metric.name} ${metric.type} metric`);
+      lines.push(`# TYPE ${metric.name} ${metric.type}`);
+
+      for (const value of metric.values) {
+        const tagStr = value.tags
+          ? Object.entries(value.tags)
+              .map(([k, v]) => `${k}="${v}"`)
+              .join(',')
+          : '';
+        lines.push(`${metric.name}${tagStr ? `{${tagStr}}` : ''} ${value.value}`);
+      }
+
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+
+  private getOrCreateMetric(name: string, type: Metric['type']): Metric {
+    if (!this.metrics.has(name)) {
+      this.metrics.set(name, {
+        name,
+        type,
+        values: [],
+      });
+    }
+
+    return this.metrics.get(name)!;
+  }
+
+  private cleanup(): void {
+    const cutoff = Date.now() - this.retentionMs;
+
+    for (const metric of this.metrics.values()) {
+      metric.values = metric.values.filter(v => v.timestamp > cutoff);
+    }
+
+    log.debug('Metrics cleanup completed');
+  }
+
+  public stop(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = undefined;
+    }
+  }
+}
+
+// Global instance
+export const metrics = new MetricsCollector();
+
+// Track system metrics
+export function startSystemMetrics(): void {
+  setInterval(() => {
+    const usage = process.memoryUsage();
+    
+    metrics.gauge('system.memory.heap_used', usage.heapUsed / 1024 / 1024, {
+      unit: 'MB',
+    });
+    
+    metrics.gauge('system.memory.heap_total', usage.heapTotal / 1024 / 1024, {
+      unit: 'MB',
+    });
+
+    metrics.gauge('system.cpu.usage', process.cpuUsage().user / 1000, {
+      unit: 'ms',
+    });
+  }, 30000); // Every 30 seconds
+}

package/src/main/monitoring/TraceGradingSystem.ts

@@ -0,0 +1,196 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+
+interface TraceEntry {
+  timestamp: number;
+  level: 'info' | 'warn' | 'error' | 'debug';
+  component: string;
+  action: string;
+  details: Record<string, any>;
+  duration?: number;
+}
+
+interface ExecutionTrace {
+  id: string;
+  agentId: string;
+  startTime: number;
+  endTime?: number;
+  entries: TraceEntry[];
+  metadata: {
+    model: string;
+    provider: string;
+    totalTokens?: number;
+    cost?: number;
+  };
+}
+
+export class TraceGradingSystem extends EventEmitter {
+  private traces: Map<string, ExecutionTrace> = new Map();
+  private activeTraces: Map<string, ExecutionTrace> = new Map();
+
+  startTrace(agentId: string, metadata: ExecutionTrace['metadata']): string {
+    const traceId = `trace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    const trace: ExecutionTrace = {
+      id: traceId,
+      agentId,
+      startTime: Date.now(),
+      entries: [],
+      metadata
+    };
+
+    this.activeTraces.set(traceId, trace);
+    log.debug(`Trace started: ${traceId}`);
+    
+    return traceId;
+  }
+
+  addEntry(
+    traceId: string,
+    level: TraceEntry['level'],
+    component: string,
+    action: string,
+    details: Record<string, any> = {},
+    duration?: number
+  ): void {
+    const trace = this.activeTraces.get(traceId);
+    if (!trace) return;
+
+    trace.entries.push({
+      timestamp: Date.now(),
+      level,
+      component,
+      action,
+      details,
+      duration
+    });
+  }
+
+  endTrace(traceId: string, metadata?: Partial<ExecutionTrace['metadata']>): ExecutionTrace {
+    const trace = this.activeTraces.get(traceId);
+    if (!trace) throw new Error(`Trace ${traceId} not found`);
+
+    trace.endTime = Date.now();
+    if (metadata) {
+      trace.metadata = { ...trace.metadata, ...metadata };
+    }
+
+    this.activeTraces.delete(traceId);
+    this.traces.set(traceId, trace);
+
+    // Grade the trace
+    const grade = this.gradeTrace(trace);
+    this.emit('trace:graded', { traceId, grade, trace });
+
+    log.debug(`Trace ended: ${traceId}, Grade: ${grade.score}`);
+    return trace;
+  }
+
+  private gradeTrace(trace: ExecutionTrace): { score: number; issues: string[]; highlights: string[] } {
+    const issues: string[] = [];
+    const highlights: string[] = [];
+    let score = 100;
+
+    // Check for errors
+    const errors = trace.entries.filter(e => e.level === 'error');
+    if (errors.length > 0) {
+      score -= errors.length * 10;
+      issues.push(`${errors.length} error(s) occurred during execution`);
+    }
+
+    // Check for warnings
+    const warnings = trace.entries.filter(e => e.level === 'warn');
+    if (warnings.length > 0) {
+      score -= warnings.length * 5;
+      issues.push(`${warnings.length} warning(s) during execution`);
+    }
+
+    // Check execution time
+    const duration = trace.endTime! - trace.startTime;
+    if (duration > 60000) {
+      score -= 5;
+      issues.push('Execution took longer than 60 seconds');
+    } else if (duration < 5000) {
+      highlights.push('Fast execution time');
+    }
+
+    // Check for retries
+    const retries = trace.entries.filter(e => e.action === 'retry');
+    if (retries.length > 0) {
+      score -= retries.length * 3;
+      issues.push(`${retries.length} retry(ies) needed`);
+    }
+
+    // Check for successful tool usage
+    const toolCalls = trace.entries.filter(e => e.component === 'tool');
+    const successfulTools = toolCalls.filter(e => e.level !== 'error');
+    if (toolCalls.length > 0 && successfulTools.length === toolCalls.length) {
+      highlights.push('All tool calls successful');
+    }
+
+    return {
+      score: Math.max(0, score),
+      issues,
+      highlights
+    };
+  }
+
+  getTrace(traceId: string): ExecutionTrace | undefined {
+    return this.traces.get(traceId) || this.activeTraces.get(traceId);
+  }
+
+  getTracesForAgent(agentId: string): ExecutionTrace[] {
+    return Array.from(this.traces.values())
+      .filter(t => t.agentId === agentId)
+      .sort((a, b) => b.startTime - a.startTime);
+  }
+
+  generateReport(traceId: string): string {
+    const trace = this.getTrace(traceId);
+    if (!trace) throw new Error(`Trace ${traceId} not found`);
+
+    const grade = this.gradeTrace(trace);
+    const duration = trace.endTime ? trace.endTime - trace.startTime : 0;
+
+    let report = `# Execution Trace Report\n\n`;
+    report += `**Trace ID:** ${trace.id}\n`;
+    report += `**Agent ID:** ${trace.agentId}\n`;
+    report += `**Duration:** ${(duration / 1000).toFixed(2)}s\n`;
+    report += `**Score:** ${grade.score}/100\n\n`;
+
+    if (grade.issues.length > 0) {
+      report += `## Issues\n`;
+      grade.issues.forEach(issue => report += `- ${issue}\n`);
+      report += '\n';
+    }
+
+    if (grade.highlights.length > 0) {
+      report += `## Highlights\n`;
+      grade.highlights.forEach(h => report += `- ${h}\n`);
+      report += '\n';
+    }
+
+    report += `## Execution Log\n\n`;
+    trace.entries.forEach(entry => {
+      const time = new Date(entry.timestamp).toISOString();
+      report += `[${time}] [${entry.level.toUpperCase()}] ${entry.component}: ${entry.action}\n`;
+      if (entry.duration) {
+        report += `  Duration: ${entry.duration}ms\n`;
+      }
+      if (Object.keys(entry.details).length > 0) {
+        report += `  Details: ${JSON.stringify(entry.details)}\n`;
+      }
+      report += '\n';
+    });
+
+    return report;
+  }
+
+  cleanup(): void {
+    this.activeTraces.clear();
+    this.traces.clear();
+    this.removeAllListeners();
+  }
+}
+
+export default TraceGradingSystem;

package/src/main/notifications/NotificationManager.ts

@@ -0,0 +1,96 @@
+import { Notification } from 'electron';
+import log from 'electron-log';
+
+interface NotificationOptions {
+  title: string;
+  body: string;
+  icon?: string;
+  actions?: Array<{
+    text: string;
+    type: 'button';
+  }>;
+  onClick?: () => void;
+  onClose?: () => void;
+}
+
+export class NotificationManager {
+  private notificationHistory: Array<{
+    id: string;
+    title: string;
+    body: string;
+    timestamp: Date;
+    read: boolean;
+  }> = [];
+
+  show(options: NotificationOptions): void {
+    if (!Notification.isSupported()) {
+      log.warn('Notifications not supported on this platform');
+      return;
+    }
+
+    try {
+      const notification = new Notification({
+        title: options.title,
+        body: options.body,
+        icon: options.icon,
+        actions: options.actions
+      });
+
+      notification.on('click', () => {
+        options.onClick?.();
+      });
+
+      notification.on('close', () => {
+        options.onClose?.();
+      });
+
+      notification.show();
+
+      // Add to history
+      this.notificationHistory.push({
+        id: Math.random().toString(36).substr(2, 9),
+        title: options.title,
+        body: options.body,
+        timestamp: new Date(),
+        read: false
+      });
+
+      // Keep only last 100 notifications
+      if (this.notificationHistory.length > 100) {
+        this.notificationHistory = this.notificationHistory.slice(-100);
+      }
+
+    } catch (error) {
+      log.error('Failed to show notification:', error);
+    }
+  }
+
+  getHistory(): Array<{
+    id: string;
+    title: string;
+    body: string;
+    timestamp: Date;
+    read: boolean;
+  }> {
+    return [...this.notificationHistory].reverse();
+  }
+
+  markAsRead(id: string): void {
+    const notification = this.notificationHistory.find(n => n.id === id);
+    if (notification) {
+      notification.read = true;
+    }
+  }
+
+  markAllAsRead(): void {
+    this.notificationHistory.forEach(n => n.read = true);
+  }
+
+  clearHistory(): void {
+    this.notificationHistory = [];
+  }
+
+  getUnreadCount(): number {
+    return this.notificationHistory.filter(n => !n.read).length;
+  }
+}