gitarsenal-cli 1.9.95 → 1.9.97

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-09-03T03:52:07.558Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-09-13T16:50:38.652Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/README.md

@@ -25,6 +25,9 @@ gitarsenal --gpu A10G --repo https://github.com/username/awesome-project.git
 
 # With custom setup commands
 gitarsenal --gpu A100 --repo https://github.com/username/awesome-project.git --setup-commands "pip install -r requirements.txt" "python setup.py install"
+
+# Using E2B sandbox provider (faster startup, no GPU)
+gitarsenal --sandbox-provider e2b --repo https://github.com/username/awesome-project.git
 ```
 
 ### Examples
@@ -65,6 +68,32 @@ gitarsenal keys delete --service openai
 
 ## Features
 
+### Sandbox Providers
+
+GitArsenal supports multiple sandbox providers to fit your needs:
+
+#### Modal Sandbox (Default)
+- Full GPU support (A10G, A100, H100, etc.)
+- Persistent storage with volumes
+- SSH access
+- Longer startup time
+
+```bash
+# Explicitly use Modal sandbox
+gitarsenal --sandbox-provider modal --repo https://github.com/username/project.git
+```
+
+#### E2B Sandbox
+- Faster startup time
+- Lightweight environment
+- No GPU support
+- Ideal for quick testing and development
+
+```bash
+# Use E2B sandbox for faster startup
+gitarsenal --sandbox-provider e2b --repo https://github.com/username/project.git
+```
+
 ### Automatic Environment Setup
 The CLI automatically:
 - Clones your repository

package/bin/gitarsenal.js

@@ -6,7 +6,7 @@ const inquirer = require('inquirer');
 const ora = require('ora');
 const path = require('path');
 const { version } = require('../package.json');
-const { checkDependencies } = require('../lib/dependencies');
+const { checkDependencies, checkDependenciesExceptE2B } = require('../lib/dependencies');
 const { runContainer } = require('../lib/sandbox');
 const updateNotifier = require('update-notifier');
 const pkg = require('../package.json');
@@ -16,6 +16,7 @@ const fs = require('fs');
 const https = require('https');
 const http = require('http');
 const { fetchGitIngestData } = require('../gitingest-integration');
+const { execAsync } = require('../lib/execAsync');
 
 // Function to activate virtual environment
 function activateVirtualEnvironment() {
@@ -1042,7 +1043,27 @@ program
   .version(version)
   .description('GitArsenal CLI - Create GPU-accelerated development environments');
 
-
+// Add E2B setup command
+program
+  .command('setup-e2b')
+  .description('Set up E2B sandbox provider')
+  .action(async () => {
+    const setupPath = path.join(__dirname, '..', 'scripts', 'setup_e2b.js');
+    if (fs.existsSync(setupPath)) {
+      const child = spawn('node', [setupPath], {
+        stdio: 'inherit'
+      });
+      child.on('exit', (code) => {
+        if (code !== 0) {
+          console.log(chalk.red('E2B setup failed.'));
+          process.exit(code);
+        }
+      });
+    } else {
+      console.log(chalk.red(`Setup script not found at ${setupPath}`));
+      process.exit(1);
+    }
+  });
 
 // Keys management command
 const keysCmd = program
@@ -1096,6 +1117,7 @@ program
   .option('--show-examples', 'Show usage examples')
   .option('--user-id <id>', 'User ID for tracking')
   .option('--user-name <name>', 'User name for tracking')
+  .option('--sandbox-provider <provider>', 'Sandbox provider (modal or e2b)', 'modal')
   .action(async (options) => {
     // If options are provided directly, run the container command
     if (options.repo || options.showExamples || process.argv.length <= 3) {
@@ -1125,15 +1147,37 @@ async function runContainerCommand(options) {
     // Send user data immediately so the dashboard records users
     await sendUserData(userId, userName, userEmail);
 
-    // Check for required dependencies
-    const spinner = ora('Checking dependencies...').start();
-    const dependenciesOk = await checkDependencies();
-    
-    if (!dependenciesOk) {
-      spinner.fail('Missing dependencies. Please install them and try again.');
+    // Initialize sandbox provider from options or default to modal
+    let sandboxProvider = options.sandboxProvider || 'modal';
+
+    // Prompt for sandbox provider if not specified
+    if (!options.sandboxProvider) {
+      const providerAnswers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'sandboxProvider',
+          message: 'Select sandbox provider:',
+          choices: [
+            { name: 'Modal (GPU support, persistent volumes)', value: 'modal' },
+            { name: 'E2B (Faster startup, no GPU)', value: 'e2b' }
+          ],
+          default: 'modal'
+        }
+      ]);
+      sandboxProvider = providerAnswers.sandboxProvider;
+    }
+
+    // Check dependencies based on selected sandbox provider
+    console.log(chalk.blue('⠋ Checking dependencies...'));
+    const dependenciesMet = sandboxProvider === 'e2b' 
+      ? await checkDependenciesExceptE2B() 
+      : await checkDependencies();
+
+    if (!dependenciesMet) {
+      console.log(chalk.red('✖ Missing dependencies. Please install them and try again.'));
       process.exit(1);
     }
-    spinner.succeed('Dependencies checked');
+    console.log(chalk.green('✔ Dependencies checked'));
 
     // If repo URL not provided, prompt for it
     let repoUrl = options.repoUrl || options.repo;
@@ -1142,6 +1186,14 @@ async function runContainerCommand(options) {
     let volumeName = options.volumeName || options.volume;
     let skipConfirmation = options.yes;
     let setupCommands = options.setupCommands || [];
+    let analysisData = null;
+    let collectedApiKeys = {};
+
+    // Validate sandbox provider
+    if (sandboxProvider !== 'modal' && sandboxProvider !== 'e2b') {
+      console.log(chalk.yellow(`⚠️ Invalid sandbox provider: ${sandboxProvider}. Using 'modal' as default.`));
+      sandboxProvider = 'modal';
+    }
 
     if (!repoUrl) {
       const answers = await inquirer.prompt([
@@ -1155,135 +1207,149 @@ async function runContainerCommand(options) {
       repoUrl = answers.repoUrl;
     }
 
-    // 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();
-      
-      try {
-        // Start preview immediately so we get early feedback; suppress summary here to avoid duplicates.
-        // Provide an AbortController so we can stop the preview spinner as soon as full fetch returns.
-        const previewAbort = new AbortController();
-        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 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);
+    // Always prompt for sandbox provider, even if specified via command line
+    const providerAnswers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'sandboxProvider',
+        message: 'Select sandbox provider:',
+        choices: [
+          { name: 'Modal (GPU support, persistent volumes)', value: 'modal' },
+          { name: 'E2B (Faster startup, no GPU)', value: 'e2b' }
+        ],
+        default: sandboxProvider // Use command line value as default if provided
+      }
+    ]);
+    sandboxProvider = providerAnswers.sandboxProvider;
+
+    // Load stored API keys for both providers
+    console.log(chalk.blue('🔍 Loading stored API keys...'));
+    const storedKeys = await loadStoredApiKeys();
+    collectedApiKeys = storedKeys;
+
+    // Only perform repository analysis and GPU selection for Modal provider
+    if (sandboxProvider === 'modal') {
+      // Analyze repository for GPU recommendations and API key requirements
+      if (repoUrl) {
+        // Start a main spinner that will show overall progress
+        const mainSpinner = ora('Analyzing repository...').start();
         
-        if (fullData) {
-          // Stop preview spinner immediately since we have a response
-          previewAbort.abort();
-          mainSpinner.succeed('Analysis complete!');
-          printGpuTorchCudaSummary(fullData);
-          analysisData = fullData;
+        try {
+          // Start preview immediately so we get early feedback; suppress summary here to avoid duplicates.
+          // Provide an AbortController so we can stop the preview spinner as soon as full fetch returns.
+          const previewAbort = new AbortController();
+          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 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);
           
-          // 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...';
-          const previewData = await previewPromise;
-          if (previewData) {
-            mainSpinner.succeed('Preview analysis complete!');
-            printGpuTorchCudaSummary(previewData);
-            analysisData = previewData;
+          if (fullData) {
+            // Stop preview spinner immediately since we have a response
+            previewAbort.abort();
+            mainSpinner.succeed('Analysis complete!');
+            printGpuTorchCudaSummary(fullData);
+            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 {
-            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.'));
+            // Full fetch failed, wait for preview and show its results
+            mainSpinner.text = 'Waiting for preview analysis to complete...';
+            const previewData = await previewPromise;
+            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.'));
         }
-      } 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();
       }
-    }
 
-    // Prompt for GPU type if not specified
-    if (!gpuType) {
-      const gpuAnswers = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'gpuType',
-          message: 'Select GPU type:',
-          choices: [
-            { name: 'T4 (16GB VRAM)', value: 'T4' },
-            { name: 'L4 (24GB VRAM)', value: 'L4' },
-            { name: 'A10G (24GB VRAM)', value: 'A10G' },
-            { name: 'A100-40 (40GB VRAM)', value: 'A100-40GB' },
-            { name: 'A100-80 (80GB VRAM)', value: 'A100-80GB' },
-            { name: 'L40S (48GB VRAM)', value: 'L40S' },
-            { name: 'H100 (80GB VRAM)', value: 'H100' },
-            { name: 'H200 (141GB VRAM)', value: 'H200' },
-            { name: 'B200 (141GB VRAM)', value: 'B200' }
-          ],
-          default: 'A10G'
-        }
-      ]);
-      gpuType = gpuAnswers.gpuType;
-    }
+      // Prompt for GPU type if not specified
+      if (!gpuType) {
+        const gpuAnswers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'gpuType',
+            message: 'Select GPU type:',
+            choices: [
+              { name: 'T4 (16GB VRAM)', value: 'T4' },
+              { name: 'L4 (24GB VRAM)', value: 'L4' },
+              { name: 'A10G (24GB VRAM)', value: 'A10G' },
+              { name: 'A100-40 (40GB VRAM)', value: 'A100-40GB' },
+              { name: 'A100-80 (80GB VRAM)', value: 'A100-80GB' },
+              { name: 'L40S (48GB VRAM)', value: 'L40S' },
+              { name: 'H100 (80GB VRAM)', value: 'H100' },
+              { name: 'H200 (141GB VRAM)', value: 'H200' },
+              { name: 'B200 (141GB VRAM)', value: 'B200' }
+            ],
+            default: 'A10G'
+          }
+        ]);
+        gpuType = gpuAnswers.gpuType;
+      }
 
-    // Prompt for GPU count if not already specified via CLI
-    if (!options.gpuCount) {
-      const gpuCountAnswers = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'gpuCount',
-          message: 'How many GPUs do you need?',
-          choices: [
-            { name: '1 GPU', value: 1 },
-            { name: '2 GPUs', value: 2 },
-            { name: '3 GPUs', value: 3 },
-            { name: '4 GPUs', value: 4 },
-            { name: '6 GPUs', value: 6 },
-            { name: '8 GPUs', value: 8 }
-          ],
-          default: gpuCount
-        }
-      ]);
-      gpuCount = gpuCountAnswers.gpuCount;
-    }
+      // Prompt for GPU count if not already specified via CLI
+      if (!options.gpuCount) {
+        const gpuCountAnswers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'gpuCount',
+            message: 'How many GPUs do you need?',
+            choices: [
+              { name: '1 GPU', value: 1 },
+              { name: '2 GPUs', value: 2 },
+              { name: '3 GPUs', value: 3 },
+              { name: '4 GPUs', value: 4 },
+              { name: '6 GPUs', value: 6 },
+              { name: '8 GPUs', value: 8 }
+            ],
+            default: gpuCount
+          }
+        ]);
+        gpuCount = gpuCountAnswers.gpuCount;
+      }
 
-    // Prompt for persistent volume
-    if (!volumeName && !skipConfirmation) {
-      const volumeAnswers = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'useVolume',
-          message: 'Use persistent volume for faster installs?',
-          default: true
-        },
-        {
-          type: 'input',
-          name: 'volumeName',
-          message: 'Enter volume name:',
-          default: getDefaultVolumeName(repoUrl),
-          when: (answers) => answers.useVolume
+      // Prompt for persistent volume
+      if (!volumeName && !skipConfirmation) {
+        const volumeAnswers = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'useVolume',
+            message: 'Use persistent volume for faster installs?',
+            default: true
+          },
+          {
+            type: 'input',
+            name: 'volumeName',
+            message: 'Enter volume name:',
+            default: getDefaultVolumeName(repoUrl),
+            when: (answers) => answers.useVolume
+          }
+        ]);
+        
+        if (volumeAnswers.useVolume) {
+          volumeName = volumeAnswers.volumeName || getDefaultVolumeName(repoUrl);
         }
-      ]);
-      
-      if (volumeAnswers.useVolume) {
+      } else if (!volumeName && skipConfirmation) {
+        // If --yes flag is used and no volume specified, use default
         volumeName = getDefaultVolumeName(repoUrl);
       }
-    } else if (!volumeName && skipConfirmation) {
-      // If --yes flag is used and no volume specified, use default
-      volumeName = getDefaultVolumeName(repoUrl);
     }
 
     // Prompt for custom setup commands only if no repo URL provided and no commands specified
@@ -1317,6 +1383,32 @@ async function runContainerCommand(options) {
 
     // Confirm settings (configuration will be shown by Python script after GPU selection)
     if (!skipConfirmation) {
+      // Display configuration summary
+      console.log(chalk.cyan('\n📋 Configuration Summary:'));
+      console.log(chalk.dim('─────────────────────────────────────'));
+      console.log(`${chalk.dim('Repository URL:')} ${chalk.white(repoUrl || 'Not specified')}`);
+      console.log(`${chalk.dim('Sandbox Provider:')} ${chalk.white(sandboxProvider)}`);
+      
+      if (sandboxProvider === 'modal') {
+        if (gpuCount > 1) {
+          console.log(`${chalk.dim('GPU Type:')} ${chalk.white(`${gpuCount}x ${gpuType}`)}`);
+        } else {
+          console.log(`${chalk.dim('GPU Type:')} ${chalk.white(gpuType)}`);
+        }
+        console.log(`${chalk.dim('Volume:')} ${chalk.white(volumeName || 'None')}`);
+      } else {
+        console.log(`${chalk.dim('Note:')} ${chalk.yellow('E2B sandboxes do not support GPU selection or volumes')}`);
+      }
+      
+      if (setupCommands.length > 0) {
+        console.log(`${chalk.dim('Setup Commands:')} ${chalk.white(setupCommands.length)} custom commands`);
+      } else if (repoUrl) {
+        console.log(`${chalk.dim('Setup:')} ${chalk.white('Intelligent repository setup')}`);
+      } else {
+        console.log(`${chalk.dim('Setup Commands:')} ${chalk.white('None')}`);
+      }
+      console.log(chalk.dim('─────────────────────────────────────'));
+
       const confirmAnswers = await inquirer.prompt([
         {
           type: 'confirm',
@@ -1348,7 +1440,8 @@ async function runContainerCommand(options) {
         userName,
         userEmail,
         apiKeys: collectedApiKeys,
-        analysisData
+        analysisData,
+        sandboxProvider
       });
       
     } catch (containerError) {

package/kill_claude/requirements.txt

@@ -1,3 +1,3 @@
 anthropic>=0.25.0
 typer>=0.12.0
-rich>=13.0.0
+rich>=13.0.0

package/lib/dependencies.js

@@ -2,9 +2,43 @@ const { promisify } = require('util');
 const { exec } = require('child_process');
 const which = require('which');
 const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
 
 const execAsync = promisify(exec);
 
+/**
+ * Get the Python executable path from the virtual environment
+ * @returns {string} - Path to Python executable or 'python3'
+ */
+function getPythonExecutable() {
+  // Check if PYTHON_EXECUTABLE is set by the virtual environment activation
+  if (process.env.PYTHON_EXECUTABLE && fs.existsSync(process.env.PYTHON_EXECUTABLE)) {
+    return process.env.PYTHON_EXECUTABLE;
+  }
+  
+  // Try to find the virtual environment Python
+  const venvPath = path.join(__dirname, '..', '.venv');
+  const isWindows = process.platform === 'win32';
+  
+  // Check for uv-style virtual environment first
+  const uvPythonPath = path.join(venvPath, 'bin', 'python');
+  
+  // Check for traditional venv structure
+  const traditionalPythonPath = isWindows ? 
+    path.join(venvPath, 'Scripts', 'python.exe') : 
+    path.join(venvPath, 'bin', 'python');
+  
+  if (fs.existsSync(uvPythonPath)) {
+    return uvPythonPath;
+  } else if (fs.existsSync(traditionalPythonPath)) {
+    return traditionalPythonPath;
+  }
+  
+  // Fall back to system Python
+  return isWindows ? 'python' : 'python3';
+}
+
 /**
  * Check if a command is available in the system
  * @param {string} command - Command to check
@@ -24,8 +58,10 @@ async function commandExists(command) {
  * @returns {Promise<{exists: boolean, version: string|null}>}
  */
 async function checkPython() {
+  const pythonExecutable = getPythonExecutable();
+  
   try {
-    const { stdout } = await execAsync('python --version');
+    const { stdout } = await execAsync(`${pythonExecutable} --version`);
     const version = stdout.trim().split(' ')[1];
     return { exists: true, version };
   } catch (error) {
@@ -44,9 +80,34 @@ async function checkPython() {
  * @returns {Promise<boolean>}
  */
 async function checkModal() {
+  const pythonExecutable = getPythonExecutable();
+  
   try {
-    await execAsync('modal --version');
+    // Check if modal is importable in the Python environment
+    await execAsync(`${pythonExecutable} -c "import modal"`);
     return true;
+  } catch (error) {
+    try {
+      // Fall back to checking the modal command
+      await execAsync('modal --version');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+/**
+ * Check if E2B code interpreter is installed
+ * @returns {Promise<boolean>}
+ */
+async function checkE2B() {
+  const pythonExecutable = getPythonExecutable();
+  
+  try {
+    // Use a more reliable method to check if the module is importable
+    const { stdout } = await execAsync(`${pythonExecutable} -c "import importlib.util; print(importlib.util.find_spec('e2b_code_interpreter') is not None)"`);
+    return stdout.trim() === 'True';
   } catch (error) {
     return false;
   }
@@ -66,11 +127,20 @@ async function checkGit() {
 }
 
 async function checkGitingest() {
+  const pythonExecutable = getPythonExecutable();
+  
   try {
-    await execAsync('gitingest --help');
+    // Check if gitingest is importable in the Python environment
+    await execAsync(`${pythonExecutable} -c "import gitingest"`);
     return true;
   } catch (error) {
-    return false;
+    try {
+      // Fall back to checking the gitingest command
+      await execAsync('gitingest --help');
+      return true;
+    } catch (error) {
+      return false;
+    }
   }
 }
 
@@ -81,6 +151,7 @@ async function checkGitingest() {
 async function checkDependencies() {
   const pythonCheck = await checkPython();
   const modalExists = await checkModal();
+  const e2bExists = await checkE2B();
   const gitExists = await checkGit();
   const gitingestExists = await checkGitingest();
   
@@ -102,6 +173,59 @@ async function checkDependencies() {
     allDependenciesMet = false;
   }
 
+  if (e2bExists) {
+    console.log(`${chalk.green('✓')} E2B Code Interpreter found`);
+  } else {
+    console.log(`${chalk.red('✗')} E2B Code Interpreter not found. Please install it with: pip install e2b-code-interpreter`);
+    allDependenciesMet = false;
+  }
+
+  if (gitingestExists) {
+    console.log(`${chalk.green('✓')} Gitingest CLI found`);
+  } else {
+    console.log(`${chalk.red('✗')} Gitingest CLI not found. Please install it with: pip install gitingest`);
+    allDependenciesMet = false;
+  }
+  
+  if (gitExists) {
+    console.log(`${chalk.green('✓')} Git found`);
+  } else {
+    console.log(`${chalk.red('✗')} Git not found. Please install Git.`);
+    allDependenciesMet = false;
+  }
+  
+  console.log('------------------------\n');
+  
+  return allDependenciesMet;
+}
+
+/**
+ * Check all required dependencies except E2B
+ * @returns {Promise<boolean>} - True if all dependencies are met
+ */
+async function checkDependenciesExceptE2B() {
+  const pythonCheck = await checkPython();
+  const modalExists = await checkModal();
+  const gitExists = await checkGit();
+  const gitingestExists = await checkGitingest();
+  
+  let allDependenciesMet = true;
+  
+  console.log('\n--- Dependency Check ---');
+  
+  if (pythonCheck.exists) {
+    console.log(`${chalk.green('✓')} Python ${pythonCheck.version} found`);
+  } else {
+    console.log(`${chalk.red('✗')} Python not found. Please install Python 3.8 or newer.`);
+    allDependenciesMet = false;
+  }
+  
+  if (modalExists) {
+    console.log(`${chalk.green('✓')} Modal CLI found`);
+  } else {
+    console.log(`${chalk.yellow('!')} Modal CLI not found. Not required for E2B sandbox.`);
+  }
+
   if (gitingestExists) {
     console.log(`${chalk.green('✓')} Gitingest CLI found`);
   } else {
@@ -123,8 +247,10 @@ async function checkDependencies() {
 
 module.exports = {
   checkDependencies,
+  checkDependenciesExceptE2B,
   commandExists,
   checkPython,
   checkModal,
+  checkE2B,
   checkGit
 };