gitarsenal-cli 1.9.32 → 1.9.34

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-10T17:44:29.632Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-10T17:58:47.793Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -104,6 +104,163 @@ function activateVirtualEnvironment() {
   return true;
 }
 
+// Lightweight preview of GPU/Torch/CUDA recommendations prior to GPU selection
+async function previewRecommendations(repoUrl) {
+  const spinner = ora('Analyzing repository for GPU/Torch/CUDA recommendations...').start();
+  try {
+    const apiUrl = process.env.GITARSENAL_API_URL || 'https://www.gitarsenal.dev/api/gitingest-setup-commands';
+    const payload = {
+      repoUrl,
+      // Minimal GitIngest data to allow backend to run LLM analysis
+      gitingestData: {
+        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: true
+      }
+    };
+
+    // Use global fetch (Node 18+) and follow redirects
+    const res = await fetch(apiUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'GitArsenal-CLI/1.0'
+      },
+      body: JSON.stringify(payload),
+      redirect: 'follow'
+    });
+
+    spinner.stop();
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      console.log(chalk.yellow(`⚠️ Preview request failed (${res.status}).`));
+      if (text) console.log(chalk.gray(`Response: ${text.slice(0, 500)}`));
+      return null;
+    }
+
+    const data = await res.json().catch(() => null);
+    if (!data) {
+      console.log(chalk.yellow('⚠️ Could not parse recommendations preview response.'));
+      return null;
+    }
+
+    printGpuTorchCudaSummary(data);
+    return data;
+  } catch (e) {
+    spinner.stop();
+    console.log(chalk.yellow(`⚠️ Preview failed: ${e.message}`));
+    return null;
+  }
+}
+
+function httpPostJson(urlString, body) {
+  return new Promise((resolve) => {
+    try {
+      const urlObj = new URL(urlString);
+      const data = JSON.stringify(body);
+      const options = {
+        hostname: urlObj.hostname,
+        port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+        path: urlObj.pathname,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(data),
+          'User-Agent': 'GitArsenal-CLI/1.0'
+        }
+      };
+      const client = urlObj.protocol === 'https:' ? https : http;
+      const req = client.request(options, (res) => {
+        let responseData = '';
+        res.on('data', (chunk) => {
+          responseData += chunk;
+        });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(responseData);
+            resolve(parsed);
+          } catch (err) {
+            resolve(null);
+          }
+        });
+      });
+      req.on('error', () => resolve(null));
+      req.write(data);
+      req.end();
+    } catch (e) {
+      resolve(null);
+    }
+  });
+}
+
+function printGpuTorchCudaSummary(result) {
+  try {
+    console.log(chalk.bold('\n📊 API RESULT SUMMARY (GPU/Torch/CUDA)'));
+    console.log('────────────────────────────────────────────────────────');
+
+    const cuda = result.cudaRecommendation;
+    if (cuda) {
+      console.log(chalk.bold('🎯 CUDA Recommendation'));
+      if (cuda.recommendedCudaVersion) console.log(`  - CUDA:  ${cuda.recommendedCudaVersion}`);
+      if (Array.isArray(cuda.compatibleTorchVersions) && cuda.compatibleTorchVersions.length)
+        console.log(`  - Torch Compatibility:  ${cuda.compatibleTorchVersions.join(', ')}`);
+      if (cuda.dockerImage) console.log(`  - Docker Image:  ${cuda.dockerImage}`);
+      if (Array.isArray(cuda.installCommands) && cuda.installCommands.length) {
+        console.log('  - Install Commands:');
+        cuda.installCommands.forEach((c) => console.log(`    $ ${c}`));
+      }
+      if (cuda.notes) console.log(`  - Notes:  ${cuda.notes}`);
+      console.log();
+    }
+
+    const torch = result.torchRecommendation;
+    if (torch) {
+      console.log(chalk.bold('🔥 PyTorch Recommendation'));
+      if (torch.recommendedTorchVersion) console.log(`  - Torch:  ${torch.recommendedTorchVersion}`);
+      if (torch.cudaVariant) console.log(`  - CUDA Variant:  ${torch.cudaVariant}`);
+      if (torch.pipInstallCommand) {
+        console.log('  - Install:');
+        console.log(`    $ ${torch.pipInstallCommand}`);
+      }
+      if (Array.isArray(torch.extraPackages) && torch.extraPackages.length)
+        console.log(`  - Extra Packages:  ${torch.extraPackages.join(', ')}`);
+      if (torch.notes) console.log(`  - Notes:  ${torch.notes}`);
+      console.log();
+    }
+
+    const gpu = result.gpuRecommendation;
+    if (gpu) {
+      console.log(chalk.bold('🖥️ GPU Recommendation'));
+      if (gpu.minimumVramGb !== undefined) console.log(`  - Min VRAM: ${gpu.minimumVramGb} GB`);
+      if (gpu.recommendedVramGb !== undefined) console.log(`  - Recommended VRAM: ${gpu.recommendedVramGb} GB`);
+      if (gpu.minComputeCapability) console.log(`  - Min Compute Capability: ${gpu.minComputeCapability}`);
+      if (Array.isArray(gpu.recommendedModels) && gpu.recommendedModels.length)
+        console.log(`  - Recommended Models:  ${gpu.recommendedModels.join(', ')}`);
+      if (Array.isArray(gpu.budgetOptions) && gpu.budgetOptions.length)
+        console.log(`  - Budget Options:  ${gpu.budgetOptions.join(', ')}`);
+      if (Array.isArray(gpu.cloudInstances) && gpu.cloudInstances.length)
+        console.log(`  - Cloud Instances:  ${gpu.cloudInstances.join(', ')}`);
+      if (gpu.notes) console.log(`  - Notes:  ${gpu.notes}`);
+      console.log();
+    }
+  } catch {}
+}
+
 // Function to send user data to web application
 async function sendUserData(userId, userName) {
   try {
@@ -189,7 +346,7 @@ async function sendUserData(userId, userName) {
         resolve();
       });
 
-      req.write(data);
+      req.write(JSON.stringify(userData));
       req.end();
     });
   } catch (error) {
@@ -406,6 +563,11 @@ async function runContainerCommand(options) {
       repoUrl = answers.repoUrl;
     }
 
+    // NEW: Preview CUDA/Torch/GPU recommendations before choosing GPU (only if auto-detect enabled)
+    if (useApi && repoUrl) {
+      await previewRecommendations(repoUrl);
+    }
+
     // Prompt for GPU type if not specified
     if (!gpuType) {
       const gpuAnswers = await inquirer.prompt([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.32",
+  "version": "1.9.34",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {