maiass 5.9.6 → 5.9.7

package/lib/commit.js

@@ -13,6 +13,51 @@ import { logCommit } from './devlog.js';
 import colors from './colors.js';
 import chalk from 'chalk';
 
+/**
+ * Simple spinner for AI API calls
+ */
+class Spinner {
+  constructor(message = 'Working') {
+    this.message = message;
+    this.frames = ['\u280b', '\u2819', '\u2839', '\u2838', '\u283c', '\u2834', '\u2826', '\u2827', '\u2807', '\u280f'];
+    this.frameIndex = 0;
+    this.intervalId = null;
+    this.isSpinning = false;
+  }
+
+  start() {
+    if (this.isSpinning) return;
+    this.isSpinning = true;
+    
+    // Hide cursor
+    process.stderr.write('\x1B[?25l');
+    
+    this.intervalId = setInterval(() => {
+      const frame = this.frames[this.frameIndex];
+      process.stderr.write(`\r${colors.BYellow(frame)} ${this.message}...`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 100);
+  }
+
+  stop(success = true) {
+    if (!this.isSpinning) return;
+    this.isSpinning = false;
+    
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    
+    // Clear line and show cursor
+    process.stderr.write('\r' + ' '.repeat(100) + '\r');
+    process.stderr.write('\x1B[?25h');
+    
+    if (success) {
+      process.stderr.write(`${colors.BGreen('\u2713')} Done\n`);
+    }
+  }
+}
+
 /**
  * Get color for credit display based on remaining credits (matches bashmaiass)
  * @param {number} credits - Remaining credits
@@ -373,111 +418,150 @@ ${gitDiff}`;
       log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Request body: ${JSON.stringify(requestBody, null, 2)}`);
     }
 
-    const response = await fetch(aiEndpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${maiassToken}`,
-        'X-Machine-Fingerprint': generateMachineFingerprint(),
-        'X-Client-Name': getClientName(),
-        'X-Client-Version': getClientVersion(),
-        'X-Subscription-ID': process.env.MAIASS_SUBSCRIPTION_ID || ''
-      },
-      body: JSON.stringify(requestBody)
-    });
+    // Set timeout for API call (default 30 seconds)
+    const timeout = parseInt(process.env.MAIASS_AI_TIMEOUT || '30') * 1000;
     
     if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response status: ${response.status} ${response.statusText}`);
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response headers: ${JSON.stringify(Object.fromEntries(response.headers), null, 2)}`);
+      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] API timeout set to ${timeout/1000} seconds`);
     }
-    
-    if (!response.ok) {
-      const errorText = await response.text();
-      if (debugMode) {
-        log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Response error body: ${errorText}`);
-      }
-      log.error(SYMBOLS.WARNING, `AI API request failed: ${response.status} ${response.statusText}`);
-      return null;
-    }
-    
-    const data = await response.json();
-    
-    if (debugMode) {
-      log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response data: ${JSON.stringify(data, null, 2)}`);
-    }
-    
-    if (data.choices && data.choices.length > 0) {
-      let suggestion = data.choices[0].message.content.trim();
 
-      // Enhanced debug logging: output the suggestion returned by AI
+    // Start spinner (unless in debug mode)
+    const spinner = !debugMode ? new Spinner('Waiting for AI response') : null;
+    if (spinner) spinner.start();
+
+    try {
+      // Fetch with timeout using AbortController
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(aiEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${maiassToken}`,
+          'X-Machine-Fingerprint': generateMachineFingerprint(),
+          'X-Client-Name': getClientName(),
+          'X-Client-Version': getClientVersion(),
+          'X-Subscription-ID': process.env.MAIASS_SUBSCRIPTION_ID || ''
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal
+      });
+      
+      clearTimeout(timeoutId);
+      
+      // Stop spinner on success
+      if (spinner) spinner.stop(true);
+      
       if (debugMode) {
-        log.debug(SYMBOLS.INFO, '[MAIASS DEBUG] --- AI SUGGESTION RETURNED ---');
-        log.debug(SYMBOLS.INFO, suggestion);
+        log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response status: ${response.status} ${response.statusText}`);
+        log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response headers: ${JSON.stringify(Object.fromEntries(response.headers), null, 2)}`);
+      }
+      
+      if (!response.ok) {
+        const errorText = await response.text();
+        if (debugMode) {
+          log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] Response error body: ${errorText}`);
+        }
+        log.error(SYMBOLS.WARNING, `AI API request failed: ${response.status} ${response.statusText}`);
+        return null;
       }
       
-      // Clean up any quotes that might wrap the entire response
-      if ((suggestion.startsWith("'") && suggestion.endsWith("'")) || 
-          (suggestion.startsWith('"') && suggestion.endsWith('"'))) {
-        suggestion = suggestion.slice(1, -1).trim();
+      // Parse JSON response inside the same try block
+      const data = await response.json();
+      
+      if (debugMode) {
+        log.debug(SYMBOLS.INFO, `[MAIASS DEBUG] Response data: ${JSON.stringify(data, null, 2)}`);
       }
       
-      // Extract credit information from billing data
-      let creditsUsed, creditsRemaining;
-      if (data.billing) {
-        creditsUsed = data.billing.credits_used;
-        creditsRemaining = data.billing.credits_remaining;
+      if (data.choices && data.choices.length > 0) {
+        let suggestion = data.choices[0].message.content.trim();
+
+        // Enhanced debug logging: output the suggestion returned by AI
+        if (debugMode) {
+          log.debug(SYMBOLS.INFO, '[MAIASS DEBUG] --- AI SUGGESTION RETURNED ---');
+          log.debug(SYMBOLS.INFO, suggestion);
+        }
         
-        // Show warnings if available
-        if (data.billing.warning) {
-          log.warning(SYMBOLS.WARNING, data.billing.warning);
+        // Clean up any quotes that might wrap the entire response
+        if ((suggestion.startsWith("'") && suggestion.endsWith("'")) || 
+            (suggestion.startsWith('"') && suggestion.endsWith('"'))) {
+          suggestion = suggestion.slice(1, -1).trim();
         }
         
-        // Display proxy messages if available
-        if (data.messages && Array.isArray(data.messages)) {
-          data.messages.forEach(message => {
-            const icon = message.icon || '';
-            const text = message.text || '';
-            
-            switch (message.type) {
-              case 'error':
-                log.error(icon, text);
-                break;
-              case 'warning':
-                log.warning(icon, text);
-                break;
-              case 'info':
-                log.info(icon, text);
-                break;
-              case 'notice':
-                log.blue(icon, text);
-                break;
-              case 'success':
-                log.success(icon, text);
-                break;
-              default:
-                log.plain(`${icon} ${text}`);
-            }
-          });
+        // Extract credit information from billing data
+        let creditsUsed, creditsRemaining;
+        if (data.billing) {
+          creditsUsed = data.billing.credits_used;
+          creditsRemaining = data.billing.credits_remaining;
+          
+          // Show warnings if available
+          if (data.billing.warning) {
+            log.warning(SYMBOLS.WARNING, data.billing.warning);
+          }
+          
+          // Display proxy messages if available
+          if (data.messages && Array.isArray(data.messages)) {
+            data.messages.forEach(message => {
+              const icon = message.icon || '';
+              const text = message.text || '';
+              
+              switch (message.type) {
+                case 'error':
+                  log.error(icon, text);
+                  break;
+                case 'warning':
+                  log.warning(icon, text);
+                  break;
+                case 'info':
+                  log.info(icon, text);
+                  break;
+                case 'notice':
+                  log.blue(icon, text);
+                  break;
+                case 'success':
+                  log.success(icon, text);
+                  break;
+                default:
+                  log.plain(`${icon} ${text}`);
+              }
+            });
+          }
+        } else if (data.usage) {
+          // Fallback to legacy token display
+          const totalTokens = data.usage.total_tokens || 0;
+          const promptTokens = data.usage.prompt_tokens || 0;
+          const completionTokens = data.usage.completion_tokens || 0;
+          log.info(SYMBOLS.INFO, `Total Tokens: ${totalTokens} (${promptTokens} + ${completionTokens})`);
         }
-      } else if (data.usage) {
-        // Fallback to legacy token display
-        const totalTokens = data.usage.total_tokens || 0;
-        const promptTokens = data.usage.prompt_tokens || 0;
-        const completionTokens = data.usage.completion_tokens || 0;
-        log.info(SYMBOLS.INFO, `Total Tokens: ${totalTokens} (${promptTokens} + ${completionTokens})`);
+        
+        return {
+          suggestion,
+          creditsUsed,
+          creditsRemaining
+        };
       }
       
-      return {
-        suggestion,
-        creditsUsed,
-        creditsRemaining
-      };
-    }
-    
-    if (debugMode) {
-      log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] No valid AI response received - no choices in response data');
+      if (debugMode) {
+        log.debug(SYMBOLS.WARNING, '[MAIASS DEBUG] No valid AI response received - no choices in response data');
+      }
+      return null;
+    } catch (error) {
+      // Stop spinner on error
+      if (spinner) spinner.stop(false);
+      
+      if (error.name === 'AbortError') {
+        log.error(SYMBOLS.WARNING, `AI request timed out after ${timeout/1000} seconds`);
+        log.info(SYMBOLS.INFO, 'The AI service might be slow or unresponsive. Try again or increase MAIASS_AI_TIMEOUT.');
+        return null;
+      }
+      
+      if (debugMode) {
+        log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] AI suggestion error details: ${error.stack || error.message}`);
+      }
+      log.error(SYMBOLS.WARNING, `AI suggestion failed: ${error.message}`);
+      return null;
     }
-    return null;
   } catch (error) {
     if (debugMode) {
       log.debug(SYMBOLS.WARNING, `[MAIASS DEBUG] AI suggestion error details: ${error.stack || error.message}`);

package/lib/maiass-variables.js

@@ -18,6 +18,7 @@ export const MAIASS_VARIABLES = {
   'MAIASS_AI_MODEL': { default: 'gpt-3.5-turbo', description: 'AI model to use' },
   'MAIASS_AI_TEMPERATURE': { default: '0.7', description: 'AI temperature setting' },
   'MAIASS_AI_MAX_CHARACTERS': { default: '8000', description: 'Max characters for AI requests' },
+  'MAIASS_AI_TIMEOUT': { default: '30', description: 'AI request timeout in seconds' },
   'MAIASS_AI_COMMIT_MESSAGE_STYLE': { default: 'bullet', description: 'Commit message style' },
 
   // Version file system

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maiass",
   "type": "module",
-  "version": "5.9.6",
+  "version": "5.9.7",
   "description": "MAIASS - Modular AI-Augmented Semantic Scribe - Intelligent Git workflow automation",
   "main": "maiass.mjs",
   "bin": {