adding logs

Author: STetsing

libs/remix-ai-core/src/inferencers/remote/remoteInference.ts

@@ -26,7 +26,7 @@ export class RemoteInferencer implements ICompletions, IGeneration {
     const requestURL = rType === AIRequestType.COMPLETION ? this.completion_url : this.api_url
 
     try {
-      const options = { headers: { 'Content-Type': 'application/json', }, timeout: 2000 }
+      const options = { headers: { 'Content-Type': 'application/json', }, timeout: 3000 }
       const result = await axios.post(requestURL, payload, options)
 
       switch (rType) {

libs/remix-ui/editor/src/lib/inlineCompetionsLibs/AdaptiveRateLimiter.ts

@@ -52,26 +52,44 @@ export class AdaptiveRateLimiter {
   shouldAllowRequest(currentTime: number = Date.now()): boolean {
     const timeSinceLastRequest = currentTime - this.lastRequestTime;
     const timeSinceLastCompletion = currentTime - this.lastCompletionTime;
+    const adaptiveCooldown = this.getAdaptiveCooldown();
+
+    const minIntervalCheck = timeSinceLastRequest < this.minRequestInterval;
+    const adaptiveCooldownCheck = timeSinceLastCompletion < adaptiveCooldown;
+
+    console.log('[AdaptiveRateLimiter] shouldAllowRequest check:', {
+      timeSinceLastRequest,
+      timeSinceLastCompletion,
+      minRequestInterval: this.minRequestInterval,
+      adaptiveCooldown,
+      acceptanceRate: this.acceptanceRate,
+      minIntervalCheck,
+      adaptiveCooldownCheck
+    });
 
     // Check minimum request interval
-    if (timeSinceLastRequest < this.minRequestInterval) {
+    if (minIntervalCheck) {
+      console.log('[AdaptiveRateLimiter] Blocked: minimum request interval not met');
       return false;
     }
 
     // Check adaptive cooldown
-    const adaptiveCooldown = this.getAdaptiveCooldown();
-    if (timeSinceLastCompletion < adaptiveCooldown) {
+    if (adaptiveCooldownCheck) {
+      console.log('[AdaptiveRateLimiter] Blocked: adaptive cooldown active');
       return false;
     }
 
+    console.log('[AdaptiveRateLimiter] Request allowed');
     return true;
   }
 
   recordRequest(currentTime: number = Date.now()): void {
+    console.log('[AdaptiveRateLimiter] Recording request at:', currentTime);
     this.lastRequestTime = currentTime;
   }
 
   recordCompletion(currentTime: number = Date.now()): void {
+    console.log('[AdaptiveRateLimiter] Recording completion at:', currentTime);
     this.lastCompletionTime = currentTime;
   }
 
@@ -81,6 +99,7 @@ export class AdaptiveRateLimiter {
       timestamp: Date.now(),
       accepted: false
     });
+    console.log('[AdaptiveRateLimiter] Completion shown, total:', this.totalCompletions);
   }
 
   trackCompletionAccepted(): void {
@@ -90,10 +109,13 @@ export class AdaptiveRateLimiter {
     if (this.recentCompletionHistory.length > 0) {
       this.recentCompletionHistory[this.recentCompletionHistory.length - 1].accepted = true;
     }
+
+    console.log('[AdaptiveRateLimiter] Completion accepted, total accepted:', this.acceptedCompletions);
   }
 
   trackCompletionRejected(): void {
     this.rejectedCompletions++;
+    console.log('[AdaptiveRateLimiter] Completion rejected, total rejected:', this.rejectedCompletions);
   }
 
   private getAdaptiveCooldown(): number {
@@ -111,6 +133,7 @@ export class AdaptiveRateLimiter {
 
   private updateAcceptanceRate(): void {
     const currentTime = Date.now();
+    const oldHistoryLength = this.recentCompletionHistory.length;
 
     // Remove old entries beyond the history window
     this.recentCompletionHistory = this.recentCompletionHistory.filter(
@@ -126,6 +149,12 @@ export class AdaptiveRateLimiter {
       // do not penalize anyone at startup
       this.acceptanceRate = 0.5;
     }
+
+    console.log('[AdaptiveRateLimiter] Acceptance rate updated:', {
+      oldHistoryLength,
+      newHistoryLength: this.recentCompletionHistory.length,
+      acceptanceRate: this.acceptanceRate
+    });
   }
 
   getStats(): AdaptiveRateLimiterStats {

libs/remix-ui/editor/src/lib/inlineCompetionsLibs/CompletionCache.ts

@@ -51,22 +51,36 @@ export class CompletionCache {
    */
   getCachedResult(cacheKey: string): any | null {
     const cached = this.cache.get(cacheKey);
-    if (cached && Date.now() - cached.timestamp < this.cacheTimeout) {
+    const currentTime = Date.now();
+    const isExpired = cached && currentTime - cached.timestamp >= this.cacheTimeout;
+
+    console.log('[CompletionCache] getCachedResult:', {
+      cacheKey: cacheKey.substring(0, 50) + '...',
+      hasCached: !!cached,
+      isExpired,
+      age: cached ? currentTime - cached.timestamp : 0
+    });
+
+    if (cached && !isExpired) {
+      console.log('[CompletionCache] Cache hit');
       return cached.result;
     }
 
     // Remove expired cache entry
     if (cached) {
+      console.log('[CompletionCache] Removing expired cache entry');
       this.cache.delete(cacheKey);
     }
 
+    console.log('[CompletionCache] Cache miss');
     return null;
   }
 
   /**
    * Cache a completion result
    */
   cacheResult(cacheKey: string, result: any): void {
+    const oldSize = this.cache.size;
     // Clean up old cache entries periodically
     if (this.cache.size >= this.maxCacheSize) {
       this.cleanupExpiredEntries();
@@ -76,6 +90,7 @@ export class CompletionCache {
     if (this.cache.size >= this.maxCacheSize) {
       const oldestKey = this.cache.keys().next().value;
       if (oldestKey) {
+        console.log('[CompletionCache] Removing oldest cache entry due to capacity');
         this.cache.delete(oldestKey);
       }
     }
@@ -84,13 +99,24 @@ export class CompletionCache {
       result: result,
       timestamp: Date.now()
     });
+
+    console.log('[CompletionCache] Cached result:', {
+      cacheKey: cacheKey.substring(0, 50) + '...',
+      oldSize,
+      newSize: this.cache.size
+    });
   }
 
   /**
    * Check if a request is already pending
    */
   isPending(cacheKey: string): boolean {
-    return this.pendingRequests.has(cacheKey);
+    const pending = this.pendingRequests.has(cacheKey);
+    console.log('[CompletionCache] isPending:', {
+      cacheKey: cacheKey.substring(0, 50) + '...',
+      pending
+    });
+    return pending;
   }
 
   /**
@@ -104,13 +130,21 @@ export class CompletionCache {
    * Set a pending request
    */
   setPendingRequest(cacheKey: string, promise: Promise<any>): void {
+    console.log('[CompletionCache] Setting pending request:', {
+      cacheKey: cacheKey.substring(0, 50) + '...',
+      totalPending: this.pendingRequests.size + 1
+    });
     this.pendingRequests.set(cacheKey, promise);
   }
 
   /**
    * Remove a pending request
    */
   removePendingRequest(cacheKey: string): void {
+    console.log('[CompletionCache] Removing pending request:', {
+      cacheKey: cacheKey.substring(0, 50) + '...',
+      totalPending: this.pendingRequests.size - 1
+    });
     this.pendingRequests.delete(cacheKey);
   }
 
@@ -121,26 +155,37 @@ export class CompletionCache {
     cacheKey: string,
     requestFn: () => Promise<T>
   ): Promise<T> {
+    console.log('[CompletionCache] handleRequest started:', {
+      cacheKey: cacheKey.substring(0, 50) + '...'
+    });
+
     // Check cache first
     const cachedResult = this.getCachedResult(cacheKey);
     if (cachedResult) {
+      console.log('[CompletionCache] Returning cached result');
       return cachedResult;
     }
 
     // Check if same request is already pending
     const pendingRequest = this.getPendingRequest(cacheKey);
     if (pendingRequest) {
+      console.log('[CompletionCache] Waiting for pending request');
       return await pendingRequest;
     }
 
     // Create and store pending request
+    console.log('[CompletionCache] Creating new request');
     const promise = requestFn();
     this.setPendingRequest(cacheKey, promise);
 
     try {
       const result = await promise;
+      console.log('[CompletionCache] Request completed successfully');
       this.cacheResult(cacheKey, result);
       return result;
+    } catch (error) {
+      console.error('[CompletionCache] Request failed:', error);
+      throw error;
     } finally {
       this.removePendingRequest(cacheKey);
     }
@@ -156,6 +201,7 @@ export class CompletionCache {
   }
 
   clear(): void {
+    console.log('[CompletionCache] Clearing cache and pending requests');
     this.cache.clear();
     this.pendingRequests.clear();
   }
@@ -169,6 +215,12 @@ export class CompletionCache {
   }
 
   cleanup(): void {
+    const oldSize = this.cache.size;
     this.cleanupExpiredEntries();
+    console.log('[CompletionCache] Cleanup completed:', {
+      oldSize,
+      newSize: this.cache.size,
+      removedEntries: oldSize - this.cache.size
+    });
   }
 }

libs/remix-ui/editor/src/lib/inlineCompetionsLibs/SmartContextDetector.ts

@@ -45,10 +45,32 @@ export class SmartContextDetector {
   ): boolean {
     this.updateTypingSpeed(currentTime);
 
-    if (this.isRapidTyping(currentTime)) return false;
-    if (this.isInStringOrComment(model, position)) return false;
-    if (!this.isAppropriatePosition(model, position)) return false;
+    const rapidTyping = this.isRapidTyping(currentTime);
+    const inStringOrComment = this.isInStringOrComment(model, position);
+    const appropriatePosition = this.isAppropriatePosition(model, position);
+
+    console.log('[SmartContextDetector] shouldShowCompletion check:', {
+      rapidTyping,
+      inStringOrComment,
+      appropriatePosition,
+      typingSpeed: this.typingSpeed,
+      timeSinceLastTyping: currentTime - this.lastTypingTime
+    });
+
+    if (rapidTyping) {
+      console.log('[SmartContextDetector] Blocked: rapid typing detected');
+      return false;
+    }
+    if (inStringOrComment) {
+      console.log('[SmartContextDetector] Blocked: in string or comment');
+      return false;
+    }
+    if (!appropriatePosition) {
+      console.log('[SmartContextDetector] Blocked: inappropriate position');
+      return false;
+    }
 
+    console.log('[SmartContextDetector] Completion allowed');
     return true;
   }
 
@@ -69,6 +91,12 @@ export class SmartContextDetector {
         const avgSpeed = this.typingSpeedWindow.reduce((sum, entry) => sum + entry.speed, 0) / this.typingSpeedWindow.length;
         this.typingSpeed = avgSpeed;
       }
+
+      console.log('[SmartContextDetector] Typing speed updated:', {
+        timeDiff,
+        avgSpeed: this.typingSpeed,
+        windowSize: this.typingSpeedWindow.length
+      });
     }
     this.lastTypingTime = currentTime;
   }
@@ -152,6 +180,7 @@ export class SmartContextDetector {
   }
 
   reset(): void {
+    console.log('[SmartContextDetector] Resetting state');
     this.typingSpeed = 0;
     this.lastTypingTime = 0;
     this.typingSpeedWindow = [];

libs/remix-ui/editor/src/lib/providers/inlineCompletionProvider.ts

@@ -30,7 +30,10 @@ export class RemixInLineCompletionProvider implements monacoTypes.languages.Inli
       item: [],
       task: this.task,
       displayed: false,
-      accepted: false
+      accepted: false,
+      onAccepted: () => {
+        this.rateLimiter.trackCompletionAccepted()
+      }
     }
 
     this.rateLimiter = new AdaptiveRateLimiter();
@@ -101,6 +104,7 @@ export class RemixInLineCompletionProvider implements monacoTypes.languages.Inli
 
     // Create cache key and check cache
     const cacheKey = this.cache.createCacheKey(word, word_after, position, this.task);
+    this.currentCompletion.accepted = false
 
     return await this.cache.handleRequest(cacheKey, async () => {
       return await this.performCompletion(word, word_after, position);

libs/remix-ui/editor/src/lib/remix-ui-editor.tsx

@@ -838,6 +838,8 @@ export const EditorUI = (props: EditorUIProps) => {
         const changes = e.changes;
         // Check if the change matches the current completion
         if (changes.some(change => change.text === inlineCompletionProvider.currentCompletion.item.insertText)) {
+          inlineCompletionProvider.currentCompletion.onAccepted()
+          inlineCompletionProvider.currentCompletion.accepted = true
           _paq.push(['trackEvent', 'ai', 'remixAI', inlineCompletionProvider.currentCompletion.task + '_accepted'])
         }
       }