gitarsenal-cli 1.9.77 → 1.9.80

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-17T08:32:36.269Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-18T04:28:55.195Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -15,6 +15,7 @@ const { spawn } = require('child_process');
 const fs = require('fs');
 const https = require('https');
 const http = require('http');
+const { fetchGitIngestData } = require('../gitingest-integration');
 
 // Function to activate virtual environment
 function activateVirtualEnvironment() {
@@ -22,7 +23,7 @@ function activateVirtualEnvironment() {
   const venvPath = path.join(__dirname, '..', '.venv');
   const statusFile = path.join(__dirname, '..', '.venv_status.json');
   
-  // Check if virtual environment exists
+// Check if virtual environment exists
   if (!fs.existsSync(venvPath)) {
     console.log(chalk.red('❌ Virtual environment not found. Please reinstall the package:'));
     console.log(chalk.yellow('   npm uninstall -g gitarsenal-cli'));
@@ -57,13 +58,7 @@ function activateVirtualEnvironment() {
   const traditionalPipPath = isWindows ? 
     path.join(venvPath, 'Scripts', 'pip.exe') : 
     path.join(venvPath, 'bin', 'pip');
-  
-  // Determine which structure exists
-  // console.log(chalk.gray(`🔍 Checking virtual environment structure:`));
-  // console.log(chalk.gray(`  Python: ${uvPythonPath} (exists: ${fs.existsSync(uvPythonPath)})`));
-  // console.log(chalk.gray(`  Pip: ${uvPipPath} (exists: ${fs.existsSync(uvPipPath)})`));
-  
-  // For uv virtual environments, we only need Python to exist
+
   // uv doesn't create a pip executable, it uses 'uv pip' instead
   if (fs.existsSync(uvPythonPath)) {
     pythonPath = uvPythonPath;
@@ -261,9 +256,271 @@ function printGpuTorchCudaSummary(result) {
       if (gpu.notes) console.log(`  - Notes:  ${gpu.notes}`);
       console.log();
     }
+
+    // Print API key requirements if available
+    if (result.requiredApiKeys && Array.isArray(result.requiredApiKeys) && result.requiredApiKeys.length > 0) {
+      // Separate critical and optional API keys
+      const criticalKeys = result.requiredApiKeys.filter(key => key.priority === 'critical' || key.required);
+      const optionalKeys = result.requiredApiKeys.filter(key => key.priority === 'optional' || !key.required);
+      
+      if (criticalKeys.length > 0) {
+        console.log(chalk.bold('🔑 CRITICAL API KEYS'));
+        criticalKeys.forEach(apiKey => {
+          console.log(`  - ${apiKey.name} ${chalk.red('(REQUIRED)')}`);
+          console.log(`    Service: ${apiKey.service}`);
+          console.log(`    Purpose: ${apiKey.description}`);
+          if (apiKey.example) console.log(`    Format: ${apiKey.example}`);
+          if (apiKey.documentation_url) console.log(`    Docs: ${apiKey.documentation_url}`);
+          console.log();
+        });
+      }
+      
+      if (optionalKeys.length > 0) {
+        console.log(chalk.bold('🔧 OPTIONAL API KEYS'));
+        optionalKeys.forEach(apiKey => {
+          console.log(`  - ${apiKey.name} ${chalk.yellow('(OPTIONAL)')}`);
+          console.log(`    Service: ${apiKey.service}`);
+          console.log(`    Purpose: ${apiKey.description}`);
+          if (apiKey.example) console.log(`    Format: ${apiKey.example}`);
+          if (apiKey.documentation_url) console.log(`    Docs: ${apiKey.documentation_url}`);
+          console.log();
+        });
+      }
+    }
   } catch {}
 }
 
+// Function to load stored API keys
+async function loadStoredApiKeys() {
+  try {
+    const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
+    const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
+    
+    return new Promise((resolve) => {
+      const pythonProcess = spawn(pythonExecutable, [
+        scriptPath,
+        'list',
+        '--json'
+      ], { stdio: 'pipe' });
+      
+      let output = '';
+      pythonProcess.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+      
+      pythonProcess.on('close', (code) => {
+        if (code === 0) {
+          try {
+            const keys = JSON.parse(output);
+            resolve(keys);
+          } catch (e) {
+            resolve({});
+          }
+        } else {
+          resolve({});
+        }
+      });
+    });
+  } catch (error) {
+    return {};
+  }
+}
+
+// Function to prompt for missing required API keys
+async function promptForMissingApiKeys(requiredApiKeys, storedKeys) {
+  if (!requiredApiKeys || !Array.isArray(requiredApiKeys) || requiredApiKeys.length === 0) {
+    return {};
+  }
+
+  const missingKeys = {};
+  
+  // Separate critical and optional missing keys
+  const criticalMissingKeys = requiredApiKeys.filter(apiKey => 
+    (apiKey.priority === 'critical' || apiKey.required) && !storedKeys[apiKey.service.toLowerCase()]
+  );
+  
+  const optionalMissingKeys = requiredApiKeys.filter(apiKey => 
+    (apiKey.priority === 'optional' || !apiKey.required) && !storedKeys[apiKey.service.toLowerCase()]
+  );
+
+  // Handle critical keys first
+  if (criticalMissingKeys.length > 0) {
+    console.log(chalk.red('\n🔑 Critical API Keys Required'));
+    console.log(chalk.gray('These API keys are required for core functionality:'));
+
+    for (const apiKey of criticalMissingKeys) {
+    console.log(chalk.bold(`\n📝 ${apiKey.name} (${apiKey.service})`));
+    console.log(chalk.gray(`Purpose: ${apiKey.description}`));
+    if (apiKey.documentation_url) {
+      console.log(chalk.blue(`Documentation: ${apiKey.documentation_url}`));
+    }
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'provideKey',
+        message: `Do you want to provide your ${apiKey.service} API key now?`,
+        default: true
+      }
+    ]);
+
+    if (answers.provideKey) {
+      const keyAnswer = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'key',
+          message: `Enter your ${apiKey.service} API key:`,
+          mask: '*',
+          validate: (input) => {
+            const key = input.trim();
+            if (key === '') return `${apiKey.service} API key is required`;
+            return true;
+          }
+        }
+      ]);
+
+      const storeAnswer = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'store',
+          message: `Store this API key locally for future use?`,
+          default: true
+        }
+      ]);
+
+      missingKeys[apiKey.service.toLowerCase()] = keyAnswer.key;
+
+      if (storeAnswer.store) {
+        // Store the key using the existing key management system
+        try {
+          const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
+          const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
+          
+          await new Promise((resolve, reject) => {
+            const pythonProcess = spawn(pythonExecutable, [
+              scriptPath,
+              'add',
+              '--service', apiKey.service.toLowerCase(),
+              '--key', keyAnswer.key
+            ], { stdio: 'pipe' });
+            
+            pythonProcess.on('close', (code) => {
+              if (code === 0) {
+                console.log(chalk.green(`✅ ${apiKey.service} API key stored successfully`));
+                resolve();
+              } else {
+                console.log(chalk.yellow(`⚠️ Could not store ${apiKey.service} API key locally`));
+                resolve(); // Don't fail the whole process
+              }
+            });
+          });
+        } catch (error) {
+          console.log(chalk.yellow(`⚠️ Could not store ${apiKey.service} API key: ${error.message}`));
+        }
+      }
+    } else {
+      console.log(chalk.yellow(`⚠️ Skipping ${apiKey.service} API key. Repository setup may fail without it.`));
+    }
+  }
+  }
+
+  // Handle optional keys
+  if (optionalMissingKeys.length > 0) {
+    const setupOptional = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'wantOptional',
+        message: `${optionalMissingKeys.length} optional API key(s) available. Set them up for enhanced features?`,
+        default: false
+      }
+    ]);
+
+    if (setupOptional.wantOptional) {
+      console.log(chalk.blue('\n🔧 Optional API Keys Setup'));
+      console.log(chalk.gray('These enhance functionality but are not required:'));
+
+      for (const apiKey of optionalMissingKeys) {
+        console.log(chalk.bold(`\n📝 ${apiKey.name} (${apiKey.service}) - Optional`));
+        console.log(chalk.gray(`Purpose: ${apiKey.description}`));
+        if (apiKey.documentation_url) {
+          console.log(chalk.blue(`Documentation: ${apiKey.documentation_url}`));
+        }
+
+        const answers = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'provideKey',
+            message: `Provide ${apiKey.service} API key for enhanced features?`,
+            default: false
+          }
+        ]);
+
+        if (answers.provideKey) {
+          const keyAnswer = await inquirer.prompt([
+            {
+              type: 'password',
+              name: 'key',
+              message: `Enter your ${apiKey.service} API key:`,
+              mask: '*',
+              validate: (input) => {
+                const key = input.trim();
+                if (key === '') return `${apiKey.service} API key cannot be empty`;
+                return true;
+              }
+            }
+          ]);
+
+          const storeAnswer = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'store',
+              message: `Store this API key locally for future use?`,
+              default: true
+            }
+          ]);
+
+          missingKeys[apiKey.service.toLowerCase()] = keyAnswer.key;
+
+          if (storeAnswer.store) {
+            try {
+              const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
+              const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
+              
+              await new Promise((resolve, reject) => {
+                const pythonProcess = spawn(pythonExecutable, [
+                  scriptPath,
+                  'add',
+                  '--service', apiKey.service.toLowerCase(),
+                  '--key', keyAnswer.key
+                ], { stdio: 'pipe' });
+                
+                pythonProcess.on('close', (code) => {
+                  if (code === 0) {
+                    console.log(chalk.green(`✅ ${apiKey.service} API key stored successfully`));
+                    resolve();
+                  } else {
+                    console.log(chalk.yellow(`⚠️ Could not store ${apiKey.service} API key locally`));
+                    resolve();
+                  }
+                });
+              });
+            } catch (error) {
+              console.log(chalk.yellow(`⚠️ Could not store ${apiKey.service} API key: ${error.message}`));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Check if all critical keys are handled
+  if (criticalMissingKeys.length === 0) {
+    console.log(chalk.green('✅ All critical API keys are available'));
+  }
+
+  return missingKeys;
+}
+
 // Helper to derive a default volume name from the repository URL
 function getDefaultVolumeName(repoUrl) {
   try {
@@ -321,10 +578,96 @@ function getDefaultVolumeName(repoUrl) {
 }
 
 // Full fetch to get both setup commands and recommendations in one request  
-async function fetchFullSetupAndRecs(repoUrl) {
-  // For now, just use the preview function but don't show summary to avoid duplicates
-  // The Python implementation will handle setup commands
-  return await previewRecommendations(repoUrl, { showSummary: false, hideSpinner: true });
+async function fetchFullSetupAndRecs(repoUrl, storedCredentials = null) {
+  const spinner = ora('Analyzing repository with GitIngest...').start();
+  
+  try {
+    // Try to use local GitIngest CLI first
+    spinner.text = 'Running GitIngest analysis...';
+    const gitingestData = await fetchGitIngestData(repoUrl);
+    
+    let finalGitingestData;
+    if (!gitingestData) {
+      spinner.warn('GitIngest CLI not available, using basic analysis');
+      // Fallback to basic data
+      finalGitingestData = {
+        system_info: {
+          platform: process.platform,
+          python_version: process.version,
+          detected_language: 'Unknown',
+          detected_technologies: [],
+          file_count: 0,
+          repo_stars: 0,
+          repo_forks: 0,
+          primary_package_manager: 'Unknown',
+          complexity_level: 'Unknown'
+        },
+        repository_analysis: {
+          summary: `Repository: ${repoUrl}`,
+          tree: '',
+          content_preview: ''
+        },
+        success: false
+      };
+    } else {
+      finalGitingestData = gitingestData;
+      spinner.text = 'GitIngest complete, generating AI recommendations...';
+    }
+
+    const envUrl = process.env.GITARSENAL_API_URL;
+    const endpoints = envUrl ? [envUrl] : ['https://www.gitarsenal.dev/api/best_gpu'];
+
+    const payload = {
+      repoUrl,
+      gitingestData: finalGitingestData,
+      storedCredentials,
+      preview: false // This is a full analysis, not preview
+    };
+
+    let data = null;
+    let lastErrorText = '';
+
+    for (const url of endpoints) {
+      try {
+        spinner.text = `Analyzing repository: ${url}`;
+        const res = await fetch(url, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'User-Agent': 'GitArsenal-CLI/1.0' },
+          body: JSON.stringify(payload),
+          redirect: 'follow'
+        });
+        if (!res.ok) {
+          const text = await res.text().catch(() => '');
+          lastErrorText = `${res.status} ${text.slice(0, 300)}`;
+          continue;
+        }
+        data = await res.json().catch(() => null);
+        if (data) {
+          console.log(chalk.gray('🐛 DEBUG: Received response from API:'));
+          console.log(chalk.gray('  - Response has commands:', !!data.commands));
+          console.log(chalk.gray('  - Commands count:', data.commands ? data.commands.length : 0));
+          console.log(chalk.gray('  - Response has API keys:', !!data.requiredApiKeys));
+          console.log(chalk.gray('  - API keys count:', data.requiredApiKeys ? data.requiredApiKeys.length : 0));
+          console.log(chalk.gray('  - Response has GPU rec:', !!data.gpuRecommendation));
+          console.log(chalk.gray('  - Response has CUDA rec:', !!data.cudaRecommendation));
+          console.log(chalk.gray('  - Response has Torch rec:', !!data.torchRecommendation));
+          spinner.succeed('Repository analysis complete');
+          return data;
+        }
+      } catch (err) {
+        lastErrorText = err && err.message ? err.message : 'request failed';
+        continue;
+      }
+    }
+
+    spinner.fail('Failed to analyze repository');
+    if (lastErrorText) console.log(chalk.gray(`Reason: ${lastErrorText}`));
+    return null;
+    
+  } catch (e) {
+    spinner.fail(`Analysis failed: ${e.message}`);
+    return null;
+  }
 }
 
 // Function to send user data to web application
@@ -761,8 +1104,15 @@ async function runContainerCommand(options) {
       repoUrl = answers.repoUrl;
     }
 
-    // Analyze repository for GPU recommendations (repository setup is now handled by Agent)
+    // Analyze repository for GPU recommendations and API key requirements
+    let analysisData = null;
+    let collectedApiKeys = {};
+    
     if (repoUrl) {
+      // Load stored API keys first
+      console.log(chalk.blue('🔍 Loading stored API keys...'));
+      const storedKeys = await loadStoredApiKeys();
+      
       // Start a main spinner that will show overall progress
       const mainSpinner = ora('Analyzing repository...').start();
       
@@ -773,16 +1123,24 @@ async function runContainerCommand(options) {
         mainSpinner.text = 'Analyzing repository for GPU/Torch/CUDA recommendations...';
         const previewPromise = previewRecommendations(repoUrl, { showSummary: false, abortSignal: previewAbort.signal, hideSpinner: true }).catch(() => null);
 
-        // Run full fetch in parallel; prefer its results if available.
-        mainSpinner.text = 'Finding the best machine for your code...';
-        const fullData = await fetchFullSetupAndRecs(repoUrl).catch(() => null);
+        // Run full fetch in parallel with stored credentials; prefer its results if available.
+        mainSpinner.text = 'Finding the best machine for your code and detecting API requirements...';
+        const fullData = await fetchFullSetupAndRecs(repoUrl, storedKeys).catch(() => null);
         
         if (fullData) {
           // Stop preview spinner immediately since we have a response
           previewAbort.abort();
           mainSpinner.succeed('Analysis complete!');
           printGpuTorchCudaSummary(fullData);
-          // Repository setup will be handled by Agent in container
+          analysisData = fullData;
+          
+          // Handle API key requirements
+          if (fullData.requiredApiKeys && Array.isArray(fullData.requiredApiKeys) && fullData.requiredApiKeys.length > 0) {
+            const missingKeys = await promptForMissingApiKeys(fullData.requiredApiKeys, storedKeys);
+            collectedApiKeys = { ...storedKeys, ...missingKeys };
+          } else {
+            collectedApiKeys = storedKeys;
+          }
         } else {
           // Full fetch failed, wait for preview and show its results
           mainSpinner.text = 'Waiting for preview analysis to complete...';
@@ -790,16 +1148,19 @@ async function runContainerCommand(options) {
           if (previewData) {
             mainSpinner.succeed('Preview analysis complete!');
             printGpuTorchCudaSummary(previewData);
+            analysisData = previewData;
           } else {
             mainSpinner.fail('Analysis failed - both preview and full analysis timed out or failed');
             console.log(chalk.yellow('⚠️ Unable to analyze repository automatically.'));
             console.log(chalk.gray('Repository setup will still be handled by Agent in container.'));
           }
+          collectedApiKeys = storedKeys;
         }
       } catch (error) {
         mainSpinner.fail(`Analysis failed: ${error.message}`);
         console.log(chalk.yellow('⚠️ Unable to analyze repository automatically.'));
         console.log(chalk.gray('Repository setup will still be handled by Agent in container.'));
+        collectedApiKeys = await loadStoredApiKeys();
       }
     }
 
@@ -934,7 +1295,9 @@ async function runContainerCommand(options) {
         yes: skipConfirmation,
         userId,
         userName,
-        userEmail
+        userEmail,
+        apiKeys: collectedApiKeys,
+        analysisData
       });
       
     } catch (containerError) {