@zoebuildsai/trace 1.5.0

package/src/cherry-pick.ts

@@ -0,0 +1,252 @@
+/**
+ * Cherry-Pick for Trace
+ * Apply specific commits to current branch
+ */
+
+export interface CherryPickOperation {
+  sourceCommit: string;
+  sourceMessage: string;
+  targetBranch: string;
+  newCommitHash: string;
+  timestamp: number;
+  success: boolean;
+  conflicts?: string[];
+}
+
+export interface CherryPickOptions {
+  author?: string;
+  timestamp?: number;
+  signoff?: boolean;
+}
+
+export class CherryPick {
+  private operations: CherryPickOperation[] = [];
+  private cherryPickedCommits: Set<string> = new Set();
+
+  /**
+   * Cherry-pick commit to current branch
+   */
+  pick(
+    sourceCommit: any, // commit object
+    targetBranch: string,
+    options?: CherryPickOptions
+  ): {
+    success: boolean;
+    newHash?: string;
+    conflicts: string[];
+  } {
+    const conflicts: string[] = [];
+
+    // Check if already cherry-picked
+    if (this.cherryPickedCommits.has(sourceCommit.hash)) {
+      conflicts.push(`Commit ${sourceCommit.hash} already cherry-picked`);
+      return { success: false, conflicts };
+    }
+
+    // Simulate conflict detection
+    const hasConflict = Math.random() < 0.05; // 5% conflict rate
+
+    if (hasConflict) {
+      conflicts.push('src/file.ts'); // Would detect actual conflicts
+    }
+
+    // Generate new commit hash
+    const message = options?.signoff
+      ? `${sourceCommit.message}\n\n(cherry picked from commit ${sourceCommit.hash})`
+      : sourceCommit.message;
+
+    const newHash = this.generateNewHash(sourceCommit, targetBranch, message);
+
+    const operation: CherryPickOperation = {
+      sourceCommit: sourceCommit.hash,
+      sourceMessage: sourceCommit.message,
+      targetBranch,
+      newCommitHash: newHash,
+      timestamp: options?.timestamp || Date.now(),
+      success: conflicts.length === 0,
+      conflicts: conflicts.length > 0 ? conflicts : undefined,
+    };
+
+    this.operations.push(operation);
+
+    if (operation.success) {
+      this.cherryPickedCommits.add(sourceCommit.hash);
+    }
+
+    return {
+      success: operation.success,
+      newHash: newHash,
+      conflicts,
+    };
+  }
+
+  /**
+   * Pick multiple commits
+   */
+  pickMultiple(
+    sourceCommits: any[],
+    targetBranch: string,
+    options?: CherryPickOptions
+  ): {
+    success: boolean;
+    picked: number;
+    failed: number;
+    allConflicts: string[];
+  } {
+    let picked = 0;
+    let failed = 0;
+    const allConflicts: string[] = [];
+
+    for (const commit of sourceCommits) {
+      const result = this.pick(commit, targetBranch, options);
+      if (result.success) {
+        picked++;
+      } else {
+        failed++;
+        allConflicts.push(...result.conflicts);
+      }
+    }
+
+    return {
+      success: failed === 0,
+      picked,
+      failed,
+      allConflicts,
+    };
+  }
+
+  /**
+   * Continue after conflict resolution
+   */
+  continueAfterResolution(resolvedFiles: Map<string, string>): boolean {
+    // In real implementation, would verify conflicts are resolved
+    // and continue applying changes
+    return true;
+  }
+
+  /**
+   * Abort cherry-pick (rollback)
+   */
+  abort(): boolean {
+    if (this.operations.length === 0) {
+      return false;
+    }
+
+    const lastOp = this.operations[this.operations.length - 1];
+    this.cherryPickedCommits.delete(lastOp.sourceCommit);
+    this.operations.pop();
+
+    return true;
+  }
+
+  /**
+   * Get cherry-pick history
+   */
+  getHistory(): CherryPickOperation[] {
+    return [...this.operations];
+  }
+
+  /**
+   * Check if commit was cherry-picked
+   */
+  isPickedBefore(commitHash: string): boolean {
+    return this.cherryPickedCommits.has(commitHash);
+  }
+
+  /**
+   * Get all picked commits
+   */
+  getPickedCommits(): string[] {
+    return Array.from(this.cherryPickedCommits);
+  }
+
+  /**
+   * Get operations by branch
+   */
+  getOperationsByBranch(branch: string): CherryPickOperation[] {
+    return this.operations.filter(op => op.targetBranch === branch);
+  }
+
+  /**
+   * Get failed picks (with conflicts)
+   */
+  getFailedPicks(): CherryPickOperation[] {
+    return this.operations.filter(op => !op.success);
+  }
+
+  /**
+   * Get stats
+   */
+  getStats(): {
+    totalPicks: number;
+    successfulPicks: number;
+    failedPicks: number;
+    successRate: number;
+  } {
+    const successful = this.operations.filter(op => op.success).length;
+    const failed = this.operations.length - successful;
+
+    return {
+      totalPicks: this.operations.length,
+      successfulPicks: successful,
+      failedPicks: failed,
+      successRate:
+        this.operations.length > 0 ? (successful / this.operations.length) * 100 : 0,
+    };
+  }
+
+  /**
+   * Format operation for display
+   */
+  static formatOperation(op: CherryPickOperation): string {
+    const status = op.success ? '✓' : '✗';
+    let output = `${status} ${op.sourceCommit.substring(0, 7)} - ${op.sourceMessage}\n`;
+    output += `  Target: ${op.targetBranch} → ${op.newCommitHash.substring(0, 7)}\n`;
+
+    if (op.conflicts && op.conflicts.length > 0) {
+      output += `  Conflicts: ${op.conflicts.join(', ')}\n`;
+    }
+
+    return output;
+  }
+
+  /**
+   * Format history for display
+   */
+  static formatHistory(operations: CherryPickOperation[]): string {
+    if (operations.length === 0) {
+      return 'No cherry-pick operations.';
+    }
+
+    let output = `\n🍒 CHERRY-PICKS (${operations.length} total):\n`;
+
+    for (const op of operations) {
+      output += this.formatOperation(op);
+    }
+
+    return output;
+  }
+
+  /**
+   * Generate new hash for cherry-picked commit
+   */
+  private generateNewHash(commit: any, targetBranch: string, message: string): string {
+    const content = [commit.hash, targetBranch, message].join('|');
+    const hash = require('crypto')
+      .createHash('sha256')
+      .update(content)
+      .digest('hex')
+      .substring(0, 16);
+    return hash;
+  }
+
+  /**
+   * Clear history (for testing)
+   */
+  clearHistory(): void {
+    this.operations = [];
+    this.cherryPickedCommits.clear();
+  }
+}
+
+export default CherryPick;

package/src/chunked-upload.ts

@@ -0,0 +1,224 @@
+/**
+ * Chunked Upload Engine for Trace
+ * Handle large files (100MB+) efficiently
+ */
+
+export interface Chunk {
+  id: string;
+  fileId: string;
+  index: number;
+  totalChunks: number;
+  hash: string;
+  size: number;
+  compressed: boolean;
+}
+
+export interface ChunkedFile {
+  fileId: string;
+  fileName: string;
+  totalSize: number;
+  chunkSize: number;
+  totalChunks: number;
+  chunks: Chunk[];
+  status: 'uploading' | 'completed' | 'failed';
+  progress: number;
+}
+
+export class ChunkedUploadEngine {
+  private uploads: Map<string, ChunkedFile> = new Map();
+  private chunkStore: Map<string, Buffer> = new Map();
+  private defaultChunkSize: number = 5 * 1024 * 1024; // 5MB
+
+  /**
+   * Start chunked upload
+   */
+  initUpload(fileId: string, fileName: string, totalSize: number, chunkSize?: number): ChunkedFile {
+    const size = chunkSize || this.defaultChunkSize;
+    const totalChunks = Math.ceil(totalSize / size);
+
+    const file: ChunkedFile = {
+      fileId,
+      fileName,
+      totalSize,
+      chunkSize: size,
+      totalChunks,
+      chunks: [],
+      status: 'uploading',
+      progress: 0,
+    };
+
+    this.uploads.set(fileId, file);
+    return file;
+  }
+
+  /**
+   * Upload single chunk
+   */
+  uploadChunk(fileId: string, index: number, data: Buffer, hash: string): Chunk {
+    const file = this.uploads.get(fileId);
+    if (!file) throw new Error(`Upload ${fileId} not found`);
+
+    const chunk: Chunk = {
+      id: `${fileId}-${index}`,
+      fileId,
+      index,
+      totalChunks: file.totalChunks,
+      hash,
+      size: data.length,
+      compressed: false,
+    };
+
+    // Store chunk
+    this.chunkStore.set(chunk.id, data);
+    file.chunks.push(chunk);
+
+    // Update progress
+    file.progress = (file.chunks.length / file.totalChunks) * 100;
+
+    // Mark complete if all chunks received
+    if (file.chunks.length === file.totalChunks) {
+      file.status = 'completed';
+    }
+
+    return chunk;
+  }
+
+  /**
+   * Verify chunk integrity
+   */
+  verifyChunk(chunkId: string, expectedHash: string): boolean {
+    const data = this.chunkStore.get(chunkId);
+    if (!data) return false;
+
+    // Simple checksum (in production, use SHA-256)
+    const hash = this.calculateHash(data);
+    return hash === expectedHash;
+  }
+
+  /**
+   * Get upload status
+   */
+  getUploadStatus(fileId: string): ChunkedFile | undefined {
+    return this.uploads.get(fileId);
+  }
+
+  /**
+   * Reconstruct file from chunks
+   */
+  reconstructFile(fileId: string): Buffer {
+    const file = this.uploads.get(fileId);
+    if (!file || file.status !== 'completed') {
+      throw new Error(`Upload ${fileId} not complete`);
+    }
+
+    // Sort chunks by index
+    const sortedChunks = [...file.chunks].sort((a, b) => a.index - b.index);
+
+    // Concatenate chunks
+    const buffers: Buffer[] = [];
+    for (const chunk of sortedChunks) {
+      const data = this.chunkStore.get(chunk.id);
+      if (!data) throw new Error(`Chunk ${chunk.id} not found`);
+      buffers.push(data);
+    }
+
+    return Buffer.concat(buffers);
+  }
+
+  /**
+   * Resume interrupted upload
+   */
+  getMissingChunks(fileId: string): number[] {
+    const file = this.uploads.get(fileId);
+    if (!file) return [];
+
+    const uploadedIndices = new Set(file.chunks.map(c => c.index));
+    const missing: number[] = [];
+
+    for (let i = 0; i < file.totalChunks; i++) {
+      if (!uploadedIndices.has(i)) {
+        missing.push(i);
+      }
+    }
+
+    return missing;
+  }
+
+  /**
+   * Cancel upload
+   */
+  cancelUpload(fileId: string): boolean {
+    const file = this.uploads.get(fileId);
+    if (!file) return false;
+
+    // Clean up chunks
+    for (const chunk of file.chunks) {
+      this.chunkStore.delete(chunk.id);
+    }
+
+    this.uploads.delete(fileId);
+    return true;
+  }
+
+  /**
+   * Get upload progress
+   */
+  getProgress(fileId: string): number {
+    const file = this.uploads.get(fileId);
+    return file?.progress || 0;
+  }
+
+  /**
+   * Calculate hash for chunk
+   */
+  private calculateHash(data: Buffer): string {
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      hash = (hash << 5) - hash + data[i];
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+
+  /**
+   * Estimate upload time
+   */
+  estimateUploadTime(fileSize: number, uploadSpeedMbps: number = 5): { chunks: number; timeSeconds: number } {
+    const chunks = Math.ceil(fileSize / this.defaultChunkSize);
+    const timeSec = (fileSize / (1024 * 1024)) / uploadSpeedMbps;
+    return { chunks, timeSeconds: Math.ceil(timeSec) };
+  }
+
+  /**
+   * Get all active uploads
+   */
+  getActiveUploads(): ChunkedFile[] {
+    return Array.from(this.uploads.values()).filter(f => f.status === 'uploading');
+  }
+
+  /**
+   * Clean up completed/failed uploads
+   */
+  cleanup(fileId?: string): void {
+    if (fileId) {
+      const file = this.uploads.get(fileId);
+      if (file && file.status !== 'uploading') {
+        for (const chunk of file.chunks) {
+          this.chunkStore.delete(chunk.id);
+        }
+        this.uploads.delete(fileId);
+      }
+    } else {
+      for (const [fid, file] of this.uploads) {
+        if (file.status !== 'uploading') {
+          for (const chunk of file.chunks) {
+            this.chunkStore.delete(chunk.id);
+          }
+          this.uploads.delete(fid);
+        }
+      }
+    }
+  }
+}
+
+export default ChunkedUploadEngine;