gitarsenal-cli 1.9.31 → 1.9.33

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-10T15:27:06.463Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-10T17:52:52.499Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -104,6 +104,145 @@ 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
+      }
+    };
+
+    const res = await httpPostJson(apiUrl, payload);
+    spinner.stop();
+
+    if (!res) {
+      console.log(chalk.yellow('⚠️ Could not fetch recommendations preview.'));
+      return null;
+    }
+
+    printGpuTorchCudaSummary(res);
+    return res;
+  } 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 +328,7 @@ async function sendUserData(userId, userName) {
         resolve();
       });
 
-      req.write(data);
+      req.write(JSON.stringify(userData));
       req.end();
     });
   } catch (error) {
@@ -406,6 +545,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.31",
+  "version": "1.9.33",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/test_modalSandboxScript.py

@@ -914,6 +914,68 @@ def fetch_setup_commands_from_api(repo_url):
                     print(f"📄 Response size: {len(response.text)} bytes")
                     print(f"📄 Response URL: {response.url}")
                     
+                    # NEW: Print a concise summary of only GPU, Torch, and CUDA recommendations
+                    try:
+                        print("\n📊 API RESULT SUMMARY (GPU/Torch/CUDA)")
+                        print("────────────────────────────────────────────────────────")
+                        
+                        # CUDA Recommendation
+                        cuda = data.get("cudaRecommendation")
+                        if cuda:
+                            print("🎯 CUDA Recommendation")
+                            print("  - CUDA: ", cuda.get("recommendedCudaVersion", "Unknown"))
+                            ct = cuda.get("compatibleTorchVersions") or []
+                            if ct:
+                                print("  - Torch Compatibility: ", ", ".join(ct))
+                            if cuda.get("dockerImage"):
+                                print("  - Docker Image: ", cuda.get("dockerImage"))
+                            install_cmds = cuda.get("installCommands") or []
+                            if install_cmds:
+                                print("  - Install Commands:")
+                                for c in install_cmds:
+                                    print(f"    $ {c}")
+                            if cuda.get("notes"):
+                                print("  - Notes: ", cuda.get("notes"))
+                        
+                        # Torch Recommendation
+                        torch = data.get("torchRecommendation")
+                        if torch:
+                            print("\n🔥 PyTorch Recommendation")
+                            print("  - Torch: ", torch.get("recommendedTorchVersion", "Unknown"))
+                            print("  - CUDA Variant: ", torch.get("cudaVariant", "Unknown"))
+                            if torch.get("pipInstallCommand"):
+                                print("  - Install:")
+                                print(f"    $ {torch.get('pipInstallCommand')}")
+                            extras = torch.get("extraPackages") or []
+                            if extras:
+                                print("  - Extra Packages: ", ", ".join(extras))
+                            if torch.get("notes"):
+                                print("  - Notes: ", torch.get("notes"))
+                        
+                        # GPU Recommendation
+                        gpu = data.get("gpuRecommendation")
+                        if gpu:
+                            print("\n🖥️ GPU Recommendation")
+                            if gpu.get("minimumVramGb") is not None:
+                                print(f"  - Min VRAM: {gpu.get('minimumVramGb')} GB")
+                            if gpu.get("recommendedVramGb") is not None:
+                                print(f"  - Recommended VRAM: {gpu.get('recommendedVramGb')} GB")
+                            if gpu.get("minComputeCapability"):
+                                print(f"  - Min Compute Capability: {gpu.get('minComputeCapability')}")
+                            rec_models = gpu.get("recommendedModels") or []
+                            if rec_models:
+                                print("  - Recommended Models: ", ", ".join(rec_models))
+                            budget = gpu.get("budgetOptions") or []
+                            if budget:
+                                print("  - Budget Options: ", ", ".join(budget))
+                            clouds = gpu.get("cloudInstances") or []
+                            if clouds:
+                                print("  - Cloud Instances: ", ", ".join(clouds))
+                            if gpu.get("notes"):
+                                print("  - Notes: ", gpu.get("notes"))
+                    except Exception as summary_err:
+                        print(f"⚠️ Failed to print API summary: {summary_err}")
+                    
                     # Extract setup commands from the response
                     if "setupInstructions" in data and "commands" in data["setupInstructions"]:
                         commands = data["setupInstructions"]["commands"]
@@ -947,6 +1009,16 @@ def fetch_setup_commands_from_api(repo_url):
                         return fixed_commands
                     else:
                         print("⚠️ API response did not contain setupInstructions.commands field")
+                        # If top-level commands exist (newer API), use them
+                        if "commands" in data and isinstance(data["commands"], list):
+                            commands = data["commands"]
+                            print(f"✅ Found top-level commands array with {len(commands)} entries")
+                            fixed_commands = fix_setup_commands(commands)
+                            print("\n📋 Fixed commands:")
+                            for i, cmd in enumerate(fixed_commands, 1):
+                                print(f"  {i}. {cmd}")
+                            return fixed_commands
+                        
                         print("📋 Available fields in response:")
                         for key in data.keys():
                             print(f"  - {key}")
@@ -1620,6 +1692,68 @@ def get_setup_commands_from_gitingest(repo_url):
             try:
                 result = response.json()
                 
+                # NEW: Print a concise summary of only GPU, Torch, and CUDA recommendations
+                try:
+                    print("\n📊 API RESULT SUMMARY (GPU/Torch/CUDA)")
+                    print("────────────────────────────────────────────────────────")
+                    
+                    # CUDA Recommendation
+                    cuda = result.get("cudaRecommendation")
+                    if cuda:
+                        print("🎯 CUDA Recommendation")
+                        print("  - CUDA: ", cuda.get("recommendedCudaVersion", "Unknown"))
+                        ct = cuda.get("compatibleTorchVersions") or []
+                        if ct:
+                            print("  - Torch Compatibility: ", ", ".join(ct))
+                        if cuda.get("dockerImage"):
+                            print("  - Docker Image: ", cuda.get("dockerImage"))
+                        install_cmds = cuda.get("installCommands") or []
+                        if install_cmds:
+                            print("  - Install Commands:")
+                            for c in install_cmds:
+                                print(f"    $ {c}")
+                        if cuda.get("notes"):
+                            print("  - Notes: ", cuda.get("notes"))
+                    
+                    # Torch Recommendation
+                    torch = result.get("torchRecommendation")
+                    if torch:
+                        print("\n🔥 PyTorch Recommendation")
+                        print("  - Torch: ", torch.get("recommendedTorchVersion", "Unknown"))
+                        print("  - CUDA Variant: ", torch.get("cudaVariant", "Unknown"))
+                        if torch.get("pipInstallCommand"):
+                            print("  - Install:")
+                            print(f"    $ {torch.get('pipInstallCommand')}")
+                        extras = torch.get("extraPackages") or []
+                        if extras:
+                            print("  - Extra Packages: ", ", ".join(extras))
+                        if torch.get("notes"):
+                            print("  - Notes: ", torch.get("notes"))
+                    
+                    # GPU Recommendation
+                    gpu = result.get("gpuRecommendation")
+                    if gpu:
+                        print("\n🖥️ GPU Recommendation")
+                        if gpu.get("minimumVramGb") is not None:
+                            print(f"  - Min VRAM: {gpu.get('minimumVramGb')} GB")
+                        if gpu.get("recommendedVramGb") is not None:
+                            print(f"  - Recommended VRAM: {gpu.get('recommendedVramGb')} GB")
+                        if gpu.get("minComputeCapability"):
+                            print(f"  - Min Compute Capability: {gpu.get('minComputeCapability')}")
+                        rec_models = gpu.get("recommendedModels") or []
+                        if rec_models:
+                            print("  - Recommended Models: ", ", ".join(rec_models))
+                        budget = gpu.get("budgetOptions") or []
+                        if budget:
+                            print("  - Budget Options: ", ", ".join(budget))
+                        clouds = gpu.get("cloudInstances") or []
+                        if clouds:
+                            print("  - Cloud Instances: ", ", ".join(clouds))
+                        if gpu.get("notes"):
+                            print("  - Notes: ", gpu.get("notes"))
+                except Exception as summary_err:
+                    print(f"⚠️ Failed to print API summary: {summary_err}")
+                
                 # Check if we have commands in the response
                 commands = None