@mrxkun/mcfast-mcp 4.0.6 → 4.0.12

package/src/utils/streaming-api.js

@@ -0,0 +1,168 @@
+/**
+ * Streaming API Client
+ * Handles Server-Sent Events (SSE) for real-time updates
+ */
+
+import { colors } from './colors.js';
+
+export class StreamingAPIClient {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || 'https://mcfast.vercel.app/api/v1';
+    this.token = options.token || process.env.MCFAST_TOKEN;
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Stream edit with real-time progress
+   */
+  async *streamEdit({ instruction, files, onProgress }) {
+    const url = `${this.baseUrl}/edit/stream`;
+    
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.token}`
+        },
+        body: JSON.stringify({
+          instruction,
+          files,
+          stream: true
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim()) {
+            const event = this.parseSSE(line);
+            if (event) {
+              if (onProgress) onProgress(event);
+              yield event;
+            }
+          }
+        }
+      }
+
+    } catch (error) {
+      console.error(`${colors.red}[Streaming]${colors.reset} Error:`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Batch audit with streaming acknowledgments
+   */
+  async *streamBatchAudit(logs, onAck) {
+    const url = `${this.baseUrl}/logs/batch`;
+    
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.token}`
+        },
+        body: JSON.stringify({ logs, stream: true })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      const acks = [];
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim()) {
+            const event = this.parseSSE(line);
+            if (event) {
+              if (event.event === 'ack' && onAck) {
+                onAck(event.data);
+              }
+              acks.push(event.data);
+              yield event;
+            }
+          }
+        }
+      }
+
+      return acks;
+
+    } catch (error) {
+      console.error(`${colors.red}[Streaming]${colors.reset} Batch audit error:`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Parse SSE format
+   */
+  parseSSE(raw) {
+    const lines = raw.split('\n');
+    const event = {};
+
+    for (const line of lines) {
+      if (line.startsWith('event: ')) {
+        event.event = line.substring(7);
+      } else if (line.startsWith('data: ')) {
+        try {
+          event.data = JSON.parse(line.substring(6));
+        } catch {
+          event.data = line.substring(6);
+        }
+      } else if (line.startsWith('id: ')) {
+        event.id = line.substring(4);
+      }
+    }
+
+    return event.event ? event : null;
+  }
+
+  /**
+   * Non-streaming batch audit (fallback)
+   */
+  async batchAudit(logs) {
+    const url = `${this.baseUrl}/logs/batch`;
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.token}`
+      },
+      body: JSON.stringify({ logs, stream: false })
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    }
+
+    return response.json();
+  }
+}

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()
+  };
+}