gitarsenal-cli 1.0.0

package/README.md

@@ -0,0 +1,105 @@
+# GitArsenal CLI
+
+A command-line tool for easily creating Modal sandboxes with GitHub repositories.
+
+## Features
+
+- Interactive prompts to configure your sandbox
+- Support for custom GPU types (A10G, A100, H100, T4, V100)
+- Persistent volume support for faster installations
+- Custom setup commands
+- Automatic repository cloning
+
+## Installation
+
+### Prerequisites
+
+- Node.js 14 or higher
+- Python 3.8 or higher
+- Modal CLI (`pip install modal`)
+- Git
+
+### Global Installation
+
+```bash
+npm install -g gitarsenal-cli
+```
+
+### Local Installation
+
+```bash
+npm install gitarsenal-cli
+```
+
+## Usage
+
+### Command Line Interface
+
+Simply run the command:
+
+```bash
+gitarsenal
+```
+
+The CLI will guide you through the process with interactive prompts:
+
+1. Enter the GitHub repository URL
+2. Select a GPU type
+3. Choose whether to use a persistent volume
+4. Optionally provide custom setup commands
+5. Confirm your settings
+
+### Command Line Options
+
+```
+Usage: gitarsenal [options]
+
+Options:
+  -V, --version        output the version number
+  -r, --repo <url>     GitHub repository URL
+  -g, --gpu <type>     GPU type (A10G, A100, H100, T4, V100) (default: "A10G")
+  -v, --volume <name>  Name of persistent volume
+  -y, --yes            Skip confirmation prompts
+  -h, --help           display help for command
+```
+
+### Example
+
+```bash
+gitarsenal --repo https://github.com/username/repo-name --gpu A10G --volume my-volume
+```
+
+## Programmatic Usage
+
+You can also use GitArsenal programmatically in your Node.js applications:
+
+```javascript
+const { runModalSandbox } = require('gitarsenal-cli');
+
+async function main() {
+  await runModalSandbox({
+    repoUrl: 'https://github.com/username/repo-name',
+    gpuType: 'A10G',
+    volumeName: 'my-volume',
+    setupCommands: [
+      'pip install -r requirements.txt',
+      'python setup.py install'
+    ]
+  });
+}
+
+main().catch(console.error);
+```
+
+## How It Works
+
+GitArsenal CLI is a Node.js wrapper around a Python script that creates Modal sandboxes. The CLI:
+
+1. Checks for required dependencies (Python, Modal, Git)
+2. Prompts for configuration options
+3. Executes the Python script with the provided options
+4. Handles errors and provides feedback
+
+## License
+
+MIT 

package/bin/gitarsenal.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const path = require('path');
+const { version } = require('../package.json');
+const { checkDependencies } = require('../lib/dependencies');
+const { runModalSandbox } = require('../lib/sandbox');
+const updateNotifier = require('update-notifier');
+const pkg = require('../package.json');
+const boxen = require('boxen');
+
+// Check for updates
+updateNotifier({ pkg }).notify();
+
+// Display banner
+console.log(boxen(chalk.bold.green('GitArsenal CLI') + '\n' + chalk.blue('Create Modal sandboxes with GitHub repositories'), {
+  padding: 1,
+  margin: 1,
+  borderStyle: 'round',
+  borderColor: 'green'
+}));
+
+// Set up CLI options
+program
+  .version(version)
+  .description('Create Modal sandboxes with GitHub repositories')
+  .option('-r, --repo <url>', 'GitHub repository URL')
+  .option('-g, --gpu <type>', 'GPU type (A10G, A100, H100, T4, V100)', 'A10G')
+  .option('-v, --volume <name>', 'Name of persistent volume')
+  .option('-y, --yes', 'Skip confirmation prompts')
+  .parse(process.argv);
+
+const options = program.opts();
+
+async function main() {
+  try {
+    // 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.');
+      process.exit(1);
+    }
+    spinner.succeed('Dependencies checked');
+
+    // If repo URL not provided, prompt for it
+    let repoUrl = options.repo;
+    let gpuType = options.gpu;
+    let volumeName = options.volume;
+    let skipConfirmation = options.yes;
+
+    if (!repoUrl) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'repoUrl',
+          message: 'Enter GitHub repository URL:',
+          validate: (input) => input.trim() !== '' ? true : 'Repository URL is required'
+        }
+      ]);
+      repoUrl = answers.repoUrl;
+    }
+
+    // Prompt for GPU type if not specified
+    if (!options.gpu) {
+      const gpuAnswers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'gpuType',
+          message: 'Select GPU type:',
+          choices: [
+            { name: 'A10G (24GB VRAM)', value: 'A10G' },
+            { name: 'A100 (40GB VRAM)', value: 'A100' },
+            { name: 'H100 (80GB VRAM)', value: 'H100' },
+            { name: 'T4 (16GB VRAM)', value: 'T4' },
+            { name: 'V100 (16GB VRAM)', value: 'V100' }
+          ],
+          default: 'A10G'
+        }
+      ]);
+      gpuType = gpuAnswers.gpuType;
+    }
+
+    // Prompt for persistent volume
+    if (!volumeName) {
+      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: 'gitarsenal-volume',
+          when: (answers) => answers.useVolume
+        }
+      ]);
+      
+      if (volumeAnswers.useVolume) {
+        volumeName = volumeAnswers.volumeName;
+      }
+    }
+
+    // Prompt for custom setup commands
+    const setupAnswers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'useCustomCommands',
+        message: 'Provide custom setup commands?',
+        default: false
+      }
+    ]);
+
+    let setupCommands = [];
+    if (setupAnswers.useCustomCommands) {
+      console.log(chalk.yellow('Enter setup commands (one per line). Type "done" on a new line when finished:'));
+      
+      const commandsInput = await inquirer.prompt([
+        {
+          type: 'editor',
+          name: 'commands',
+          message: 'Enter setup commands:',
+          default: '# Enter one command per line\n# Example: pip install -r requirements.txt\n'
+        }
+      ]);
+      
+      setupCommands = commandsInput.commands
+        .split('\n')
+        .filter(line => line.trim() !== '' && !line.trim().startsWith('#'));
+    }
+
+    // Show configuration summary
+    console.log(chalk.bold('\n📋 Sandbox Configuration:'));
+    console.log(chalk.cyan('Repository URL: ') + repoUrl);
+    console.log(chalk.cyan('GPU Type: ') + gpuType);
+    console.log(chalk.cyan('Volume: ') + (volumeName || 'None'));
+    
+    if (setupCommands.length > 0) {
+      console.log(chalk.cyan('Setup Commands:'));
+      setupCommands.forEach((cmd, i) => {
+        console.log(`  ${i + 1}. ${cmd}`);
+      });
+    } else {
+      console.log(chalk.cyan('Setup Commands: ') + 'None (will use defaults)');
+    }
+
+    // Confirm settings
+    if (!skipConfirmation) {
+      const confirmAnswers = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'proceed',
+          message: 'Proceed with these settings?',
+          default: true
+        }
+      ]);
+      
+      if (!confirmAnswers.proceed) {
+        console.log(chalk.yellow('Operation cancelled by user.'));
+        process.exit(0);
+      }
+    }
+
+    // Run the sandbox
+    await runModalSandbox({
+      repoUrl,
+      gpuType,
+      volumeName,
+      setupCommands
+    });
+
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+main(); 

package/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+// This file is the main entry point for the package
+// It simply re-exports the main functionality
+
+const { runModalSandbox } = require('./lib/sandbox');
+const { checkDependencies } = require('./lib/dependencies');
+
+module.exports = {
+  runModalSandbox,
+  checkDependencies
+}; 

package/install.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# GitArsenal CLI Installation Script
+
+echo "🚀 Installing GitArsenal CLI..."
+
+# Check if npm is installed
+if ! command -v npm &> /dev/null; then
+    echo "❌ npm is not installed. Please install Node.js and npm first."
+    exit 1
+fi
+
+# Check if Python is installed
+if ! command -v python &> /dev/null && ! command -v python3 &> /dev/null; then
+    echo "❌ Python is not installed. Please install Python 3.8 or higher."
+    exit 1
+fi
+
+# Check if Modal is installed
+if ! command -v modal &> /dev/null; then
+    echo "⚠️ Modal CLI not found. Installing modal-client..."
+    pip install modal || python3 -m pip install modal
+fi
+
+# Install the package globally
+echo "📦 Installing GitArsenal CLI globally..."
+npm install -g .
+
+echo "✅ Installation complete!"
+echo "You can now run the CLI tool with: gitarsenal" 

package/lib/dependencies.js

@@ -0,0 +1,113 @@
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const which = require('which');
+const chalk = require('chalk');
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a command is available in the system
+ * @param {string} command - Command to check
+ * @returns {Promise<boolean>} - True if command exists
+ */
+async function commandExists(command) {
+  try {
+    await which(command);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check Python version
+ * @returns {Promise<{exists: boolean, version: string|null}>}
+ */
+async function checkPython() {
+  try {
+    const { stdout } = await execAsync('python --version');
+    const version = stdout.trim().split(' ')[1];
+    return { exists: true, version };
+  } catch (error) {
+    try {
+      const { stdout } = await execAsync('python3 --version');
+      const version = stdout.trim().split(' ')[1];
+      return { exists: true, version };
+    } catch (error) {
+      return { exists: false, version: null };
+    }
+  }
+}
+
+/**
+ * Check if Modal is installed
+ * @returns {Promise<boolean>}
+ */
+async function checkModal() {
+  try {
+    await execAsync('modal --version');
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if Git is installed
+ * @returns {Promise<boolean>}
+ */
+async function checkGit() {
+  try {
+    await execAsync('git --version');
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check all required dependencies
+ * @returns {Promise<boolean>} - True if all dependencies are met
+ */
+async function checkDependencies() {
+  const pythonCheck = await checkPython();
+  const modalExists = await checkModal();
+  const gitExists = await checkGit();
+  
+  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.red('✗')} Modal CLI not found. Please install it with: pip install modal`);
+    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;
+}
+
+module.exports = {
+  checkDependencies,
+  commandExists,
+  checkPython,
+  checkModal,
+  checkGit
+}; 

package/lib/sandbox.js

@@ -0,0 +1,106 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const os = require('os');
+
+const execAsync = promisify(exec);
+
+/**
+ * Get the path to the Python script
+ * @returns {string} - Path to the Python script
+ */
+function getPythonScriptPath() {
+  // First check if the script exists in the package directory
+  const packageScriptPath = path.join(__dirname, '..', 'python', 'test_modalSandboxScript.py');
+  
+  if (fs.existsSync(packageScriptPath)) {
+    return packageScriptPath;
+  }
+  
+  // If not found, return the path where it will be copied during installation
+  return packageScriptPath;
+}
+
+/**
+ * Run the Modal sandbox with the given options
+ * @param {Object} options - Sandbox options
+ * @param {string} options.repoUrl - GitHub repository URL
+ * @param {string} options.gpuType - GPU type
+ * @param {string} options.volumeName - Volume name
+ * @param {Array<string>} options.setupCommands - Setup commands
+ * @returns {Promise<void>}
+ */
+async function runModalSandbox(options) {
+  const { repoUrl, gpuType, volumeName, setupCommands = [] } = options;
+  
+  // Get the path to the Python script
+  const scriptPath = getPythonScriptPath();
+  
+  // Check if the script exists
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(`Python script not found at ${scriptPath}. Please reinstall the package.`);
+  }
+  
+  // Prepare command arguments
+  const args = [
+    scriptPath,
+    '--gpu', gpuType,
+    '--repo-url', repoUrl
+  ];
+  
+  if (volumeName) {
+    args.push('--volume-name', volumeName);
+  }
+  
+  // Handle setup commands
+  if (setupCommands.length > 0) {
+    // Create a temporary file to store setup commands
+    const tempCommandsFile = path.join(os.tmpdir(), `gitarsenal-commands-${Date.now()}.txt`);
+    fs.writeFileSync(tempCommandsFile, setupCommands.join('\n'));
+    args.push('--commands-file', tempCommandsFile);
+  }
+  
+  // Log the command being executed
+  console.log(chalk.dim(`\nExecuting: python ${args.join(' ')}`));
+  
+  // Start the spinner
+  const spinner = ora('Launching Modal sandbox...').start();
+  
+  try {
+    // Run the Python script
+    const pythonProcess = spawn('python', args, {
+      stdio: 'inherit' // Inherit stdio to show real-time output
+    });
+    
+    // Handle process completion
+    return new Promise((resolve, reject) => {
+      pythonProcess.on('close', (code) => {
+        if (code === 0) {
+          spinner.succeed('Modal sandbox launched successfully');
+          resolve();
+        } else {
+          spinner.fail(`Modal sandbox launch failed with exit code ${code}`);
+          reject(new Error(`Process exited with code ${code}`));
+        }
+      });
+      
+      // Handle process errors
+      pythonProcess.on('error', (error) => {
+        spinner.fail(`Failed to start Python process: ${error.message}`);
+        reject(error);
+      });
+    });
+  } catch (error) {
+    spinner.fail(`Error launching Modal sandbox: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = {
+  runModalSandbox,
+  getPythonScriptPath
+}; 

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "gitarsenal-cli",
+  "version": "1.0.0",
+  "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
+  "main": "index.js",
+  "bin": {
+    "gitarsenal": "./bin/gitarsenal.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "modal",
+    "sandbox",
+    "cli",
+    "gpu",
+    "github",
+    "repository",
+    "setup"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "inquirer": "^8.2.4",
+    "ora": "^5.4.1",
+    "commander": "^9.4.1",
+    "which": "^3.0.0",
+    "fs-extra": "^11.1.0",
+    "execa": "^5.1.1",
+    "boxen": "^5.1.2",
+    "update-notifier": "^5.1.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+} 

package/python/test_modalSandboxScript.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# This is a minimal version of the Modal sandbox script
+# For full functionality, please ensure the original script is available
+
+import os
+import sys
+import argparse
+import subprocess
+
+def main():
+    parser = argparse.ArgumentParser(description='Create a Modal sandbox with GPU')
+    parser.add_argument('--gpu', type=str, default='A10G', help='GPU type (default: A10G)')
+    parser.add_argument('--repo-url', type=str, help='Repository URL to clone')
+    parser.add_argument('--repo-name', type=str, help='Repository name override')
+    parser.add_argument('--volume-name', type=str, help='Name of the Modal volume for persistent storage')
+    parser.add_argument('--commands-file', type=str, help='Path to file containing setup commands (one per line)')
+    
+    args = parser.parse_args()
+    
+    # Check if modal is installed
+    try:
+        subprocess.run(['modal', '--version'], check=True, capture_output=True)
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Modal CLI not found. Please install it with: pip install modal")
+        sys.exit(1)
+    
+    # Build the modal command
+    cmd = [
+        'modal', 'run', '--gpu', args.gpu.lower(),
+        '--command', f'git clone {args.repo_url} && cd $(basename {args.repo_url} .git) && bash'
+    ]
+    
+    # Execute the command
+    print(f"🚀 Launching Modal sandbox with {args.gpu} GPU...")
+    print(f"📥 Cloning repository: {args.repo_url}")
+    
+    try:
+        subprocess.run(cmd)
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/scripts/postinstall.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const chalk = require('chalk');
+
+const execAsync = promisify(exec);
+
+// Path to the Python script in the package
+const pythonScriptDir = path.join(__dirname, '..', 'python');
+const pythonScriptPath = path.join(pythonScriptDir, 'test_modalSandboxScript.py');
+
+// Path to the original Python script
+const originalScriptPath = path.join(__dirname, '..', '..', '..', 'mcp-server', 'src', 'utils', 'test_modalSandboxScript.py');
+
+async function postinstall() {
+  try {
+    console.log(chalk.blue('📦 Running GitArsenal CLI postinstall script...'));
+    
+    // Create the Python directory if it doesn't exist
+    await fs.ensureDir(pythonScriptDir);
+    
+    // Check if the original script exists
+    let scriptFound = false;
+    
+    if (await fs.pathExists(originalScriptPath)) {
+      console.log(chalk.green('✅ Found original Python script in mcp-server'));
+      await fs.copy(originalScriptPath, pythonScriptPath);
+      scriptFound = true;
+    } else {
+      // Try to find the script in common locations
+      console.log(chalk.yellow('⚠️ Original script not found in expected location. Searching for alternatives...'));
+      
+      const possibleLocations = [
+        path.join(process.cwd(), 'test_modalSandboxScript.py'),
+        path.join(process.cwd(), 'mcp-server', 'src', 'utils', 'test_modalSandboxScript.py'),
+        path.join(process.cwd(), 'src', 'utils', 'test_modalSandboxScript.py'),
+        path.join(process.cwd(), 'utils', 'test_modalSandboxScript.py'),
+        path.join(process.cwd(), 'scripts', 'test_modalSandboxScript.py')
+      ];
+      
+      for (const location of possibleLocations) {
+        if (await fs.pathExists(location)) {
+          console.log(chalk.green(`✅ Found Python script at ${location}`));
+          await fs.copy(location, pythonScriptPath);
+          scriptFound = true;
+          break;
+        }
+      }
+    }
+    
+    // If script not found, create it from embedded content
+    if (!scriptFound) {
+      console.log(chalk.yellow('⚠️ Python script not found. Creating from embedded content...'));
+      
+      // Create a minimal version of the script
+      const minimalScript = `#!/usr/bin/env python3
+# This is a minimal version of the Modal sandbox script
+# For full functionality, please ensure the original script is available
+
+import os
+import sys
+import argparse
+import subprocess
+
+def main():
+    parser = argparse.ArgumentParser(description='Create a Modal sandbox with GPU')
+    parser.add_argument('--gpu', type=str, default='A10G', help='GPU type (default: A10G)')
+    parser.add_argument('--repo-url', type=str, help='Repository URL to clone')
+    parser.add_argument('--repo-name', type=str, help='Repository name override')
+    parser.add_argument('--volume-name', type=str, help='Name of the Modal volume for persistent storage')
+    parser.add_argument('--commands-file', type=str, help='Path to file containing setup commands (one per line)')
+    
+    args = parser.parse_args()
+    
+    # Check if modal is installed
+    try:
+        subprocess.run(['modal', '--version'], check=True, capture_output=True)
+    except (subprocess.SubprocessError, FileNotFoundError):
+        print("❌ Modal CLI not found. Please install it with: pip install modal")
+        sys.exit(1)
+    
+    # Build the modal command
+    cmd = [
+        'modal', 'run', '--gpu', args.gpu.lower(),
+        '--command', f'git clone {args.repo_url} && cd $(basename {args.repo_url} .git) && bash'
+    ]
+    
+    # Execute the command
+    print(f"🚀 Launching Modal sandbox with {args.gpu} GPU...")
+    print(f"📥 Cloning repository: {args.repo_url}")
+    
+    try:
+        subprocess.run(cmd)
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()
+`;
+      
+      await fs.writeFile(pythonScriptPath, minimalScript);
+      console.log(chalk.yellow('⚠️ Created minimal Python script. For full functionality, please install the original script.'));
+    }
+    
+    // Make the script executable
+    try {
+      await fs.chmod(pythonScriptPath, 0o755);
+      console.log(chalk.green('✅ Made Python script executable'));
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️ Could not make script executable: ${error.message}`));
+    }
+    
+    // Check Python and Modal installation
+    try {
+      await execAsync('python --version');
+      console.log(chalk.green('✅ Python is installed'));
+    } catch (error) {
+      try {
+        await execAsync('python3 --version');
+        console.log(chalk.green('✅ Python3 is installed'));
+      } catch (error) {
+        console.log(chalk.yellow('⚠️ Python not found. Please install Python 3.8 or newer.'));
+      }
+    }
+    
+    try {
+      await execAsync('modal --version');
+      console.log(chalk.green('✅ Modal CLI is installed'));
+    } catch (error) {
+      console.log(chalk.yellow('⚠️ Modal CLI not found. Please install it with: pip install modal'));
+    }
+    
+    console.log(chalk.blue('📦 GitArsenal CLI installation complete!'));
+    console.log(chalk.blue('🚀 Run "gitarsenal" to start using the CLI.'));
+    
+  } catch (error) {
+    console.error(chalk.red(`❌ Error during postinstall: ${error.message}`));
+    // Don't exit with error to allow npm install to complete
+  }
+}
+
+postinstall(); 

package/test.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// Simple test script to verify the package works
+
+const { checkDependencies } = require('./lib/dependencies');
+const chalk = require('chalk');
+
+async function test() {
+  console.log(chalk.blue('🧪 Testing GitArsenal CLI...'));
+  
+  // Check dependencies
+  console.log(chalk.yellow('Checking dependencies...'));
+  const dependenciesOk = await checkDependencies();
+  
+  if (dependenciesOk) {
+    console.log(chalk.green('✅ All dependencies are installed!'));
+    console.log(chalk.green('✅ GitArsenal CLI is ready to use.'));
+    console.log(chalk.blue('Run "gitarsenal" to start using the CLI.'));
+  } else {
+    console.log(chalk.red('❌ Some dependencies are missing. Please install them before using GitArsenal CLI.'));
+  }
+}
+
+test().catch(error => {
+  console.error(chalk.red(`❌ Test failed: ${error.message}`));
+  process.exit(1);
+});