@zoebuildsai/trace 1.5.0

package/src/performance-monitoring.ts

@@ -0,0 +1,236 @@
+/**
+ * Performance Monitoring for Trace
+ * Track operation times and identify bottlenecks
+ */
+
+export interface PerformanceMetric {
+  operation: string;
+  duration: number; // milliseconds
+  timestamp: number;
+  metadata?: Record<string, unknown>;
+  status: 'success' | 'failure';
+}
+
+export interface PerformanceStats {
+  operation: string;
+  count: number;
+  avgDuration: number;
+  minDuration: number;
+  maxDuration: number;
+  p95Duration: number;
+  p99Duration: number;
+  failureRate: number;
+}
+
+export interface PerformanceReport {
+  timestamp: number;
+  totalOperations: number;
+  averageLatency: number;
+  bottlenecks: PerformanceStats[];
+  recommendations: string[];
+}
+
+export class PerformanceMonitoring {
+  private metrics: PerformanceMetric[] = [];
+  private operationTimers: Map<string, number> = new Map();
+
+  /**
+   * Start tracking operation
+   */
+  startOperation(operationId: string): void {
+    this.operationTimers.set(operationId, Date.now());
+  }
+
+  /**
+   * End tracking operation
+   */
+  endOperation(
+    operationId: string,
+    operation: string,
+    status: 'success' | 'failure' = 'success',
+    metadata?: Record<string, unknown>
+  ): PerformanceMetric {
+    const startTime = this.operationTimers.get(operationId);
+    if (!startTime) {
+      throw new Error(`No timer found for operation ${operationId}`);
+    }
+
+    const duration = Date.now() - startTime;
+    const metric: PerformanceMetric = {
+      operation,
+      duration,
+      timestamp: Date.now(),
+      metadata,
+      status,
+    };
+
+    this.metrics.push(metric);
+    this.operationTimers.delete(operationId);
+
+    return metric;
+  }
+
+  /**
+   * Get statistics for operation
+   */
+  getStats(operation: string): PerformanceStats {
+    const filtered = this.metrics.filter(m => m.operation === operation);
+
+    if (filtered.length === 0) {
+      return {
+        operation,
+        count: 0,
+        avgDuration: 0,
+        minDuration: 0,
+        maxDuration: 0,
+        p95Duration: 0,
+        p99Duration: 0,
+        failureRate: 0,
+      };
+    }
+
+    const durations = filtered.map(m => m.duration).sort((a, b) => a - b);
+    const failures = filtered.filter(m => m.status === 'failure').length;
+
+    return {
+      operation,
+      count: filtered.length,
+      avgDuration: durations.reduce((a, b) => a + b, 0) / durations.length,
+      minDuration: durations[0],
+      maxDuration: durations[durations.length - 1],
+      p95Duration: durations[Math.floor(durations.length * 0.95)],
+      p99Duration: durations[Math.floor(durations.length * 0.99)],
+      failureRate: failures / filtered.length,
+    };
+  }
+
+  /**
+   * Get all operation stats
+   */
+  getAllStats(): PerformanceStats[] {
+    const operations = new Set(this.metrics.map(m => m.operation));
+    return Array.from(operations).map(op => this.getStats(op));
+  }
+
+  /**
+   * Find bottlenecks (operations slower than baseline)
+   */
+  findBottlenecks(baselineMs: number = 100): PerformanceStats[] {
+    return this.getAllStats().filter(stats => stats.avgDuration > baselineMs);
+  }
+
+  /**
+   * Generate performance report
+   */
+  generateReport(): PerformanceReport {
+    const allStats = this.getAllStats();
+    const bottlenecks = this.findBottlenecks();
+    const recommendations: string[] = [];
+
+    // Calculate average latency
+    const avgLatency = allStats.length > 0
+      ? allStats.reduce((sum, s) => sum + s.avgDuration, 0) / allStats.length
+      : 0;
+
+    // Generate recommendations
+    for (const bottleneck of bottlenecks) {
+      if (bottleneck.p99Duration > 500) {
+        recommendations.push(
+          `${bottleneck.operation}: P99 latency ${bottleneck.p99Duration}ms. Consider caching or optimization.`
+        );
+      }
+
+      if (bottleneck.failureRate > 0.1) {
+        recommendations.push(
+          `${bottleneck.operation}: ${(bottleneck.failureRate * 100).toFixed(1)}% failure rate. Investigate error handling.`
+        );
+      }
+
+      if (bottleneck.maxDuration > bottleneck.avgDuration * 3) {
+        recommendations.push(
+          `${bottleneck.operation}: High variance (${bottleneck.maxDuration}ms max). Check for edge cases.`
+        );
+      }
+    }
+
+    return {
+      timestamp: Date.now(),
+      totalOperations: this.metrics.length,
+      averageLatency: avgLatency,
+      bottlenecks: bottlenecks.sort((a, b) => b.avgDuration - a.avgDuration),
+      recommendations,
+    };
+  }
+
+  /**
+   * Format report for display
+   */
+  static formatReport(report: PerformanceReport): string {
+    let output = `\n📊 PERFORMANCE REPORT\n`;
+    output += `Generated: ${new Date(report.timestamp).toISOString()}\n`;
+    output += `Total Operations: ${report.totalOperations}\n`;
+    output += `Average Latency: ${report.averageLatency.toFixed(2)}ms\n\n`;
+
+    if (report.bottlenecks.length === 0) {
+      output += `✅ All operations performing within baseline. No bottlenecks detected.\n`;
+      return output;
+    }
+
+    output += `⚠️  ${report.bottlenecks.length} BOTTLENECK(S) DETECTED:\n\n`;
+
+    for (let i = 0; i < report.bottlenecks.length; i++) {
+      const b = report.bottlenecks[i];
+      output += `${i + 1}. ${b.operation}\n`;
+      output += `   Avg: ${b.avgDuration.toFixed(2)}ms | Min: ${b.minDuration.toFixed(2)}ms | Max: ${b.maxDuration.toFixed(2)}ms\n`;
+      output += `   P95: ${b.p95Duration.toFixed(2)}ms | P99: ${b.p99Duration.toFixed(2)}ms\n`;
+      output += `   Failure Rate: ${(b.failureRate * 100).toFixed(1)}%\n`;
+      output += `   Operations: ${b.count}\n\n`;
+    }
+
+    if (report.recommendations.length > 0) {
+      output += `💡 RECOMMENDATIONS:\n`;
+      for (const rec of report.recommendations) {
+        output += `- ${rec}\n`;
+      }
+    }
+
+    return output;
+  }
+
+  /**
+   * Clear metrics (for testing or resetting)
+   */
+  clearMetrics(): void {
+    this.metrics = [];
+    this.operationTimers.clear();
+  }
+
+  /**
+   * Get metrics summary
+   */
+  getSummary(): {
+    totalMetrics: number;
+    uniqueOperations: number;
+    timeRange: { start: number; end: number };
+  } {
+    if (this.metrics.length === 0) {
+      return {
+        totalMetrics: 0,
+        uniqueOperations: 0,
+        timeRange: { start: 0, end: 0 },
+      };
+    }
+
+    const timestamps = this.metrics.map(m => m.timestamp);
+    return {
+      totalMetrics: this.metrics.length,
+      uniqueOperations: new Set(this.metrics.map(m => m.operation)).size,
+      timeRange: {
+        start: Math.min(...timestamps),
+        end: Math.max(...timestamps),
+      },
+    };
+  }
+}
+
+export default PerformanceMonitoring;

package/src/rebase.ts

@@ -0,0 +1,327 @@
+/**
+ * Rebase for Trace
+ * Atomic history rewriting for clean linear history
+ */
+
+export interface RebaseOperation {
+  fromCommit: string;
+  toCommit: string;
+  newParent: string;
+  operationTime: number;
+  conflicts: boolean;
+}
+
+export interface RebaseConflict {
+  commitHash: string;
+  message: string;
+  conflictingFiles: string[];
+}
+
+export class Rebase {
+  private operations: RebaseOperation[] = [];
+  private conflictLog: RebaseConflict[] = [];
+
+  /**
+   * Rebase branch onto new parent (interactive rebase)
+   */
+  rebase(
+    commits: Map<string, any>, // hash -> commit object
+    fromHash: string,
+    toHash: string,
+    newParentHash: string
+  ): { success: boolean; newHashes: Map<string, string>; conflicts: RebaseConflict[] } {
+    const newHashes = new Map<string, string>();
+    const conflicts: RebaseConflict[] = [];
+
+    // Get list of commits to rebase
+    const commitsToRebase = this.getCommitsInRange(commits, fromHash, toHash);
+
+    if (commitsToRebase.length === 0) {
+      return { success: true, newHashes, conflicts };
+    }
+
+    // Rebase each commit
+    let currentParent = newParentHash;
+
+    for (const commit of commitsToRebase) {
+      // In real implementation, would:
+      // 1. Apply commit changes
+      // 2. Check for merge conflicts
+      // 3. Create new commit with new parent
+      // 4. Update author/timestamp
+
+      // Simulate conflict detection
+      const hasConflict = Math.random() < 0.1; // 10% conflict rate for testing
+
+      if (hasConflict) {
+        conflicts.push({
+          commitHash: commit.hash,
+          message: commit.message,
+          conflictingFiles: ['src/file.ts'], // Would detect actual conflicts
+        });
+      }
+
+      // Generate new hash for rebased commit
+      const newHash = this.generateNewHash(commit, currentParent);
+      newHashes.set(commit.hash, newHash);
+      currentParent = newHash;
+    }
+
+    const operation: RebaseOperation = {
+      fromCommit: fromHash,
+      toCommit: toHash,
+      newParent: newParentHash,
+      operationTime: Date.now(),
+      conflicts: conflicts.length > 0,
+    };
+
+    this.operations.push(operation);
+    this.conflictLog.push(...conflicts);
+
+    return {
+      success: conflicts.length === 0,
+      newHashes,
+      conflicts,
+    };
+  }
+
+  /**
+   * Squash commits into one
+   */
+  squash(
+    commits: Map<string, any>,
+    fromHash: string,
+    toHash: string,
+    newMessage: string
+  ): {
+    success: boolean;
+    newHash: string;
+    squashedCount: number;
+  } {
+    const toSquash = this.getCommitsInRange(commits, fromHash, toHash);
+
+    if (toSquash.length === 0) {
+      return { success: false, newHash: '', squashedCount: 0 };
+    }
+
+    // Combine all files from commits
+    const combinedFiles = new Map<string, string>();
+    const baseCommit = commits.get(fromHash);
+
+    for (const commit of toSquash) {
+      const commitData = commits.get(commit.hash);
+      if (commitData?.files) {
+        for (const [path, content] of commitData.files) {
+          combinedFiles.set(path, content);
+        }
+      }
+    }
+
+    // Create new squashed commit
+    const newHash = this.generateSquashedHash(newMessage, combinedFiles);
+
+    const operation: RebaseOperation = {
+      fromCommit: fromHash,
+      toCommit: toHash,
+      newParent: baseCommit?.parent || '',
+      operationTime: Date.now(),
+      conflicts: false,
+    };
+
+    this.operations.push(operation);
+
+    return {
+      success: true,
+      newHash,
+      squashedCount: toSquash.length,
+    };
+  }
+
+  /**
+   * Autosquash (combine fixup! commits)
+   */
+  autosquash(commits: Map<string, any>): {
+    success: boolean;
+    squashedGroups: number;
+  } {
+    const commitList = Array.from(commits.values());
+    let squashedGroups = 0;
+
+    // Find fixup! and squash! commits
+    const fixups = new Map<string, string[]>(); // target -> [fixup hashes]
+
+    for (const commit of commitList) {
+      if (commit.message.startsWith('fixup!')) {
+        const targetMsg = commit.message.replace('fixup! ', '');
+        const target = commitList.find(c => c.message.startsWith(targetMsg));
+        
+        if (target) {
+          if (!fixups.has(target.hash)) {
+            fixups.set(target.hash, []);
+          }
+          fixups.get(target.hash)!.push(commit.hash);
+        }
+      }
+    }
+
+    // Apply autosquash
+    for (const [targetHash, fixupHashes] of fixups) {
+      if (fixupHashes.length > 0) {
+        this.squash(commits, targetHash, fixupHashes[fixupHashes.length - 1], '');
+        squashedGroups += fixupHashes.length;
+      }
+    }
+
+    return { success: true, squashedGroups };
+  }
+
+  /**
+   * Reorder commits (interactive)
+   */
+  reorder(
+    commits: Map<string, any>,
+    fromHash: string,
+    order: string[] // ordered commit hashes
+  ): boolean {
+    if (order.length === 0) {
+      return false;
+    }
+
+    // Validate all commits exist
+    for (const hash of order) {
+      if (!commits.has(hash)) {
+        return false;
+      }
+    }
+
+    // In real implementation, would reorder and rebase
+    const operation: RebaseOperation = {
+      fromCommit: fromHash,
+      toCommit: order[order.length - 1],
+      newParent: commits.get(fromHash)?.parent || '',
+      operationTime: Date.now(),
+      conflicts: false,
+    };
+
+    this.operations.push(operation);
+    return true;
+  }
+
+  /**
+   * Get commits in range (from ancestor to descendant)
+   */
+  private getCommitsInRange(
+    commits: Map<string, any>,
+    fromHash: string,
+    toHash: string
+  ): any[] {
+    const result: any[] = [];
+    let current = commits.get(toHash);
+
+    while (current && current.hash !== fromHash) {
+      result.push(current);
+      current = current.parent ? commits.get(current.parent) : null;
+    }
+
+    if (current && current.hash === fromHash) {
+      result.push(current);
+    }
+
+    return result.reverse();
+  }
+
+  /**
+   * Generate new hash for rebased commit
+   */
+  private generateNewHash(commit: any, newParent: string): string {
+    const content = [commit.message, newParent, JSON.stringify(commit.files)].join('|');
+    const hash = require('crypto')
+      .createHash('sha256')
+      .update(content)
+      .digest('hex')
+      .substring(0, 16);
+    return hash;
+  }
+
+  /**
+   * Generate hash for squashed commit
+   */
+  private generateSquashedHash(message: string, files: Map<string, string>): string {
+    const fileStr = Array.from(files.entries())
+      .map(([path, content]) => `${path}:${content}`)
+      .join('|');
+    const content = [message, fileStr].join('|');
+    const hash = require('crypto')
+      .createHash('sha256')
+      .update(content)
+      .digest('hex')
+      .substring(0, 16);
+    return hash;
+  }
+
+  /**
+   * Get rebase operations history
+   */
+  getOperations(): RebaseOperation[] {
+    return [...this.operations];
+  }
+
+  /**
+   * Get conflict log
+   */
+  getConflictLog(): RebaseConflict[] {
+    return [...this.conflictLog];
+  }
+
+  /**
+   * Abort rebase (rollback)
+   */
+  abort(): boolean {
+    if (this.operations.length === 0) {
+      return false;
+    }
+
+    // Remove last operation
+    this.operations.pop();
+    return true;
+  }
+
+  /**
+   * Continue after conflict resolution
+   */
+  continueAfterResolution(): boolean {
+    // In real implementation, would resume rebase after conflicts are fixed
+    return true;
+  }
+
+  /**
+   * Get stats
+   */
+  getStats(): {
+    totalRebases: number;
+    totalConflicts: number;
+    averageCommitsPerRebase: number;
+  } {
+    return {
+      totalRebases: this.operations.length,
+      totalConflicts: this.conflictLog.length,
+      averageCommitsPerRebase:
+        this.operations.length > 0
+          ? Math.round(
+              this.operations.reduce((sum, op) => sum + (op.conflicts ? 1 : 0), 0) /
+                this.operations.length
+            )
+          : 0,
+    };
+  }
+
+  /**
+   * Clear history (for testing)
+   */
+  clearHistory(): void {
+    this.operations = [];
+    this.conflictLog = [];
+  }
+}
+
+export default Rebase;