@mrxkun/mcfast-mcp 4.0.5 → 4.0.11

package/src/utils/streaming.js

@@ -0,0 +1,180 @@
+/**
+ * Streaming utilities for MCP
+ * Supports real-time streaming of tool results
+ */
+
+import { colors } from './colors.js';
+
+/**
+ * Create a streaming response handler
+ * Allows tools to stream results progressively
+ */
+export class StreamingHandler {
+  constructor(options = {}) {
+    this.onProgress = options.onProgress || (() => {});
+    this.onComplete = options.onComplete || (() => {});
+    this.onError = options.onError || (() => {});
+    this.chunks = [];
+    this.isComplete = false;
+  }
+
+  /**
+   * Stream a chunk of data
+   */
+  stream(chunk, metadata = {}) {
+    if (this.isComplete) {
+      console.error(`${colors.yellow}[Stream]${colors.reset} Warning: Streaming after completion`);
+      return;
+    }
+    
+    this.chunks.push({ content: chunk, metadata, timestamp: Date.now() });
+    this.onProgress(chunk, metadata);
+    
+    // Log progress for debugging
+    if (process.env.MCFAST_VERBOSE === 'true') {
+      console.error(`${colors.dim}[Stream]${colors.reset} Chunk #${this.chunks.length}: ${chunk.length} chars`);
+    }
+  }
+
+  /**
+   * Complete the stream
+   */
+  complete(finalData = null) {
+    this.isComplete = true;
+    
+    // Combine all chunks
+    const fullContent = this.chunks.map(c => c.content).join('');
+    
+    this.onComplete({
+      content: fullContent,
+      chunks: this.chunks,
+      finalData
+    });
+    
+    return fullContent;
+  }
+
+  /**
+   * Error occurred during streaming
+   */
+  error(error) {
+    this.isComplete = true;
+    this.onError(error);
+  }
+
+  /**
+   * Get current progress
+   */
+  getProgress() {
+    return {
+      chunks: this.chunks.length,
+      totalChars: this.chunks.reduce((sum, c) => sum + c.content.length, 0),
+      isComplete: this.isComplete
+    };
+  }
+}
+
+/**
+ * Stream file reading for large files
+ * Reads file in chunks and streams progressively
+ */
+export async function streamFileRead(filePath, options = {}) {
+  const { chunkSize = 1000, onChunk } = options;
+  const handler = new StreamingHandler({ onProgress: onChunk });
+  
+  try {
+    const fs = await import('fs/promises');
+    const handle = await fs.open(filePath, 'r');
+    
+    let position = 0;
+    const buffer = Buffer.alloc(chunkSize);
+    
+    while (true) {
+      const { bytesRead } = await handle.read(buffer, 0, chunkSize, position);
+      if (bytesRead === 0) break;
+      
+      const chunk = buffer.toString('utf8', 0, bytesRead);
+      handler.stream(chunk, { position, bytesRead });
+      position += bytesRead;
+    }
+    
+    await handle.close();
+    return handler.complete({ filePath, totalBytes: position });
+    
+  } catch (error) {
+    handler.error(error);
+    throw error;
+  }
+}
+
+/**
+ * Stream search results as they're found
+ */
+export async function streamSearchResults(searchFn, query, options = {}) {
+  const { onResult, onComplete } = options;
+  const results = [];
+  
+  try {
+    // For streaming, we simulate progressive results
+    // In real implementation, search would yield results as found
+    const allResults = await searchFn(query);
+    
+    for (let i = 0; i < allResults.length; i++) {
+      const result = allResults[i];
+      results.push(result);
+      
+      if (onResult) {
+        onResult(result, {
+          index: i,
+          total: allResults.length,
+          progress: ((i + 1) / allResults.length * 100).toFixed(1)
+        });
+      }
+      
+      // Small delay to simulate streaming
+      if (i < allResults.length - 1) {
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+    }
+    
+    if (onComplete) {
+      onComplete(results);
+    }
+    
+    return results;
+    
+  } catch (error) {
+    console.error(`${colors.red}[Stream]${colors.reset} Search error:`, error.message);
+    throw error;
+  }
+}
+
+/**
+ * Stream edit progress
+ */
+export function createEditStream(options = {}) {
+  const handler = new StreamingHandler(options);
+  
+  return {
+    // Report parsing phase
+    parsing: () => handler.stream('Parsing code...\n', { phase: 'parsing' }),
+    
+    // Report analysis phase  
+    analyzing: () => handler.stream('Analyzing impact...\n', { phase: 'analysis' }),
+    
+    // Report applying phase
+    applying: (file) => handler.stream(`Applying changes to ${file}...\n`, { phase: 'applying', file }),
+    
+    // Report validation phase
+    validating: () => handler.stream('Validating changes...\n', { phase: 'validation' }),
+    
+    // Report completion
+    complete: (result) => handler.complete(result),
+    
+    // Report error
+    error: (err) => handler.error(err),
+    
+    // Get current state
+    getProgress: () => handler.getProgress()
+  };
+}