gitarsenal-cli 1.9.12 → 1.9.14

package/scripts/postinstall.js

@@ -90,7 +90,7 @@ async function checkAndInstallUv() {
 
 // Function to create and activate virtual environment using uv
 async function createVirtualEnvironment() {
-  const packages = ['modal', 'gitingest', 'requests'];
+  const packages = ['modal', 'gitingest', 'requests', 'anthropic'];
   const packageDir = path.join(__dirname, '..');
   
   console.log(chalk.yellow(`📦 Creating virtual environment with uv and installing packages: ${packages.join(', ')}`));
@@ -138,18 +138,30 @@ async function createVirtualEnvironment() {
     
     console.log(chalk.gray(`🔄 Installing packages in virtual environment with uv...`));
     
-    // Install packages using uv pip
-    await execAsync(`uv pip install ${packages.join(' ')}`, {
-      cwd: packageDir,
-      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
-      stdio: 'inherit'
-    });
+    // Install packages using uv pip from requirements.txt
+    const requirementsPath = path.join(packageDir, 'python', 'requirements.txt');
+    if (await fs.pathExists(requirementsPath)) {
+      console.log(chalk.gray(`📦 Installing packages from requirements.txt...`));
+      await execAsync(`uv pip install -r ${requirementsPath}`, {
+        cwd: packageDir,
+        env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
+        stdio: 'inherit'
+      });
+    } else {
+      console.log(chalk.gray(`📦 Installing packages: ${packages.join(', ')}`));
+      await execAsync(`uv pip install ${packages.join(' ')}`, {
+        cwd: packageDir,
+        env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
+        stdio: 'inherit'
+      });
+    }
     
     console.log(chalk.green('✅ Python packages installed successfully in virtual environment!'));
     
     // Verify packages are installed
     const pythonPath = path.join(venvPath, 'bin', 'python');
-    for (const pkg of packages) {
+    const packagesToVerify = [...packages, 'anthropic']; // Ensure anthropic is checked
+    for (const pkg of packagesToVerify) {
       try {
         await execAsync(`${pythonPath} -c "import ${pkg}; print('${pkg} imported successfully')"`);
         console.log(chalk.green(`✅ ${pkg} verified`));
@@ -196,7 +208,7 @@ exec "$@"`;
     console.log(chalk.yellow('💡 Please run manually:'));
     console.log(chalk.yellow('   cd /root/.nvm/versions/node/v22.18.0/lib/node_modules/gitarsenal-cli'));
     console.log(chalk.yellow('   uv venv'));
-    console.log(chalk.yellow('   uv pip install modal gitingest requests'));
+    console.log(chalk.yellow('   uv pip install -r python/requirements.txt'));
     return false;
   }
 }
@@ -382,6 +394,7 @@ if __name__ == "__main__":
      - Modal
      - GitIngest  
      - Requests
+     - Anthropic (for Claude fallback)
 
 💡 Next steps:
    • Run: gitarsenal --help
@@ -393,6 +406,10 @@ if __name__ == "__main__":
    • Windows: .venv\\Scripts\\activate.bat
    • Or use: ./activate_venv.sh (Unix/macOS) or activate_venv.bat (Windows)
 
+💡 Claude Fallback:
+   • Set ANTHROPIC_API_KEY for Claude fallback functionality
+   • Run: python test_claude_fallback.py to test
+
  Having issues? Run: gitarsenal --debug
     `));
     

package/test_modalSandboxScript.py

@@ -15,7 +15,7 @@ import uuid
 import signal
 from pathlib import Path
 import modal
-
+import anthropic
 # Import authentication manager
 try:
     from auth_manager import AuthManager
@@ -516,21 +516,57 @@ class PersistentShell:
             REMOVE_COMMAND: <reason>
             """
             
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
-            
-            response = client.chat.completions.create(
-                model="gpt-4.1",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that suggests alternative commands that don't require user input."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=150,
-                temperature=0.7
-            )
-            
-            response_text = response.choices[0].message.content.strip()
+            # Try OpenAI API first
+            try:
+                import openai
+                client = openai.OpenAI(api_key=api_key)
+                
+                response = client.chat.completions.create(
+                    model="gpt-4.1",
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant that suggests alternative commands that don't require user input."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=150,
+                    temperature=0.7
+                )
+                
+                response_text = response.choices[0].message.content.strip()
+                
+            except Exception as e:
+                print(f"⚠️ OpenAI API call failed: {e}")
+                
+                # Try Claude as fallback if available
+                if anthropic is not None:
+                    print("🔄 Trying Claude-4-Sonnet as fallback for alternative command suggestion...")
+                    try:
+                        # Get Anthropic API key
+                        anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                        if not anthropic_api_key:
+                            print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                            return None
+                        
+                        # Create Anthropic client
+                        client = anthropic.Anthropic(api_key=anthropic_api_key)
+                        
+                        print("🤖 Calling Claude-4-Sonnet for alternative command suggestion...")
+                        message = client.messages.create(
+                            model="claude-3-5-sonnet-20241022",
+                            max_tokens=150,
+                            messages=[
+                                {"role": "user", "content": prompt}
+                            ]
+                        )
+                        
+                        response_text = message.content[0].text.strip()
+                        print("✅ Claude alternative command suggestion completed")
+                        
+                    except Exception as claude_error:
+                        print(f"❌ Claude API call failed: {claude_error}")
+                        return None
+                else:
+                    print("⚠️ Claude fallback not available (anthropic library not installed)")
+                    return None
             
             # Check if the response suggests removing the command
             if response_text.startswith("REMOVE_COMMAND:"):
@@ -967,23 +1003,59 @@ class CommandListManager:
             RUN: <reason>
             """
             
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing if original command should be skipped...")
-            
-            response = client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes command execution."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=100,
-                temperature=0.3
-            )
-            
-            response_text = response.choices[0].message.content.strip()
+            # Try OpenAI API first
+            try:
+                import openai
+                client = openai.OpenAI(api_key=api_key)
+                
+                print("🔍 Analyzing if original command should be skipped...")
+                
+                response = client.chat.completions.create(
+                    model="gpt-3.5-turbo",
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant that analyzes command execution."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=100,
+                    temperature=0.3
+                )
+                
+                response_text = response.choices[0].message.content.strip()
+                
+            except Exception as e:
+                print(f"⚠️ OpenAI API call failed: {e}")
+                
+                # Try Claude as fallback if available
+                if anthropic is not None:
+                    print("🔄 Trying Claude-4-Sonnet as fallback for command skip analysis...")
+                    try:
+                        # Get Anthropic API key
+                        anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                        if not anthropic_api_key:
+                            print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                            return False, "No API key available"
+                        
+                        # Create Anthropic client
+                        client = anthropic.Anthropic(api_key=anthropic_api_key)
+                        
+                        print("🤖 Calling Claude-4-Sonnet for command skip analysis...")
+                        message = client.messages.create(
+                            model="claude-3-5-sonnet-20241022",
+                            max_tokens=100,
+                            messages=[
+                                {"role": "user", "content": prompt}
+                            ]
+                        )
+                        
+                        response_text = message.content[0].text.strip()
+                        print("✅ Claude command skip analysis completed")
+                        
+                    except Exception as claude_error:
+                        print(f"❌ Claude API call failed: {claude_error}")
+                        return False, f"Error: {claude_error}"
+                else:
+                    print("⚠️ Claude fallback not available (anthropic library not installed)")
+                    return False, "No API key available"
             
             # Parse the response
             if response_text.startswith("SKIP:"):
@@ -1111,24 +1183,60 @@ class CommandListManager:
             Only include commands that need changes (SKIP, MODIFY, ADD_AFTER), not KEEP actions.
             """
             
-            # Call OpenAI API
-            import openai
-            import json
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing command list for optimizations...")
-            
-            response = client.chat.completions.create(
-                model="gpt-4.1",  # Use a more capable model for this complex task
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes and optimizes command lists."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=1000,
-                temperature=0.2
-            )
-            
-            response_text = response.choices[0].message.content.strip()
+            # Try OpenAI API first
+            try:
+                import openai
+                import json
+                client = openai.OpenAI(api_key=api_key)
+                
+                print("🔍 Analyzing command list for optimizations...")
+                
+                response = client.chat.completions.create(
+                    model="gpt-4.1",  # Use a more capable model for this complex task
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant that analyzes and optimizes command lists."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=1000,
+                    temperature=0.2
+                )
+                
+                response_text = response.choices[0].message.content.strip()
+                
+            except Exception as e:
+                print(f"⚠️ OpenAI API call failed: {e}")
+                
+                # Try Claude as fallback if available
+                if anthropic is not None:
+                    print("🔄 Trying Claude-4-Sonnet as fallback for command list analysis...")
+                    try:
+                        # Get Anthropic API key
+                        anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                        if not anthropic_api_key:
+                            print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                            return False
+                        
+                        # Create Anthropic client
+                        client = anthropic.Anthropic(api_key=anthropic_api_key)
+                        
+                        print("🤖 Calling Claude-4-Sonnet for command list analysis...")
+                        message = client.messages.create(
+                            model="claude-3-5-sonnet-20241022",
+                            max_tokens=1000,
+                            messages=[
+                                {"role": "user", "content": prompt}
+                            ]
+                        )
+                        
+                        response_text = message.content[0].text.strip()
+                        print("✅ Claude command list analysis completed")
+                        
+                    except Exception as claude_error:
+                        print(f"❌ Claude API call failed: {claude_error}")
+                        return False
+                else:
+                    print("⚠️ Claude fallback not available (anthropic library not installed)")
+                    return False
             
             # Extract JSON from the response
             try:
@@ -1780,8 +1888,186 @@ Do not provide any explanations, just the exact command to run.
             last_error = error
     
     if not result:
-        print(f"❌ All model attempts failed. Last error: {last_error}")
-        return None
+        print(f"❌ All OpenAI model attempts failed. Last error: {last_error}")
+        
+        # Try Claude as fallback if available
+        if anthropic is not None:
+            print("🔄 Trying Claude-4-Sonnet as fallback...")
+            try:
+                # Get Anthropic API key
+                anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                if not anthropic_api_key:
+                    print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                    return None
+                
+                # Create Anthropic client
+                client = anthropic.Anthropic(api_key=anthropic_api_key)
+                
+                # Prepare the same prompt for Claude
+                claude_prompt = f"""
+I'm trying to run the following command in a Linux environment:
+
+```
+{command}
+```
+
+But it failed with this error:
+
+```
+{error_output}
+```
+{system_info}
+{directory_context}
+{file_context}
+
+AVAILABLE CREDENTIALS:
+{auth_context}
+
+Please analyze the error and provide ONLY a single terminal command that would fix the issue.
+Consider the current directory, system information, directory contents, and available credentials carefully before suggesting a solution.
+
+IMPORTANT GUIDELINES:
+1. For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
+   - For apt/apt-get: use -y or --yes
+   - For rm: use -f or --force
+
+2. If the error indicates a file is not found:
+   - FIRST try to search for the file using: find . -name "filename" -type f 2>/dev/null
+   - If found, navigate to that directory using: cd /path/to/directory
+   - If not found, then consider creating the file or installing missing packages
+
+3. For missing packages or dependencies:
+   - Use pip install for Python packages
+   - Use apt-get install -y for system packages
+   - Use npm install for Node.js packages
+
+4. For authentication issues:
+   - Analyze the error to determine what type of authentication is needed
+   - ALWAYS use the actual credential values from the AVAILABLE CREDENTIALS section above (NOT placeholders)
+   - Look for the specific API key or token needed in the auth_context and use its exact value
+   - Common patterns:
+     * wandb errors: use wandb login with the actual WANDB_API_KEY value from auth_context
+     * huggingface errors: use huggingface-cli login with the actual HF_TOKEN or HUGGINGFACE_TOKEN value from auth_context
+     * github errors: configure git credentials with the actual GITHUB_TOKEN value from auth_context
+     * kaggle errors: create ~/.kaggle/kaggle.json with the actual KAGGLE_USERNAME and KAGGLE_KEY values from auth_context
+     * API errors: export the appropriate API key as environment variable using the actual value from auth_context
+
+5. Environment variable exports:
+   - Use export commands for API keys that need to be in environment
+   - ALWAYS use the actual credential values from auth_context, never use placeholders like "YOUR_API_KEY"
+   - Example: export OPENAI_API_KEY="sk-..." (using the actual key from auth_context)
+
+6. CRITICAL: When using any API key, token, or credential:
+   - Find the exact value in the AVAILABLE CREDENTIALS section
+   - Use that exact value in your command
+   - Do not use generic placeholders or dummy values
+   - The auth_context contains real, usable credentials
+
+7. For Git SSH authentication failures:
+   - If the error contains "Host key verification failed" or "Could not read from remote repository"
+   - ALWAYS convert SSH URLs to HTTPS URLs for public repositories
+   - Replace git@github.com:username/repo.git with https://github.com/username/repo.git
+   - This works for public repositories without authentication
+   - Example: git clone https://github.com/xg-chu/ARTalk.git
+
+Do not provide any explanations, just the exact command to run.
+"""
+                
+                print("🤖 Calling Claude-4-Sonnet to debug the failed command...")
+                message = client.messages.create(
+                    model="claude-3-5-sonnet-20241022",
+                    max_tokens=300,
+                    messages=[
+                        {"role": "user", "content": claude_prompt}
+                    ]
+                )
+                
+                fix_command = message.content[0].text.strip()
+                print(f"🔍 DEBUG: Raw Claude response content: {fix_command}")
+                
+                # Process the response similar to OpenAI
+                original_response = fix_command
+                
+                # Extract just the command if it's wrapped in backticks or explanation
+                if "```" in fix_command:
+                    # Extract content between backticks
+                    import re
+                    code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
+                    if code_blocks:
+                        fix_command = code_blocks[0].strip()
+                        print(f"✅ Extracted command from code block: {fix_command}")
+                
+                # If the response still has explanatory text, try to extract just the command
+                if len(fix_command.split('\n')) > 1:
+                    # First try to find lines that look like commands (start with common command prefixes)
+                    command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
+                                      'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
+                                      'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
+                                      'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
+                    
+                    # Check for lines that start with common command prefixes
+                    command_lines = [line.strip() for line in fix_command.split('\n') 
+                                   if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
+                    
+                    if command_lines:
+                        # Use the first command line found
+                        fix_command = command_lines[0]
+                        print(f"✅ Identified command by prefix: {fix_command}")
+                    else:
+                        # Try to find lines that look like commands (contain common shell patterns)
+                        shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
+                        command_lines = [line.strip() for line in fix_command.split('\n') 
+                                      if any(pattern in line for pattern in shell_patterns)]
+                        
+                        if command_lines:
+                            # Use the first command line found
+                            fix_command = command_lines[0]
+                            print(f"✅ Identified command by shell pattern: {fix_command}")
+                        else:
+                            # Fall back to the shortest non-empty line as it's likely the command
+                            lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
+                            if lines:
+                                # Exclude very short lines that are likely not commands
+                                valid_lines = [line for line in lines if len(line) > 5]
+                                if valid_lines:
+                                    fix_command = min(valid_lines, key=len)
+                                else:
+                                    fix_command = min(lines, key=len)
+                                print(f"✅ Selected shortest line as command: {fix_command}")
+                
+                # Clean up the command - remove any trailing periods or quotes
+                fix_command = fix_command.rstrip('.;"\'')
+                
+                # Remove common prefixes that LLMs sometimes add
+                prefixes_to_remove = [
+                    "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
+                    "You should run: ", "You can run: ", "You need to run: "
+                ]
+                for prefix in prefixes_to_remove:
+                    if fix_command.startswith(prefix):
+                        fix_command = fix_command[len(prefix):].strip()
+                        print(f"✅ Removed prefix: {prefix}")
+                        break
+                
+                # If the command is still multi-line or very long, it might not be a valid command
+                if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
+                    print("⚠️ Extracted command appears invalid (multi-line or too long)")
+                    print("🔍 Original response from Claude:")
+                    print("-" * 60)
+                    print(original_response)
+                    print("-" * 60)
+                    print("⚠️ Using best guess for command")
+                
+                print(f"🔧 Claude suggested fix: {fix_command}")
+                print(f"🔍 DEBUG: Returning Claude fix command: {fix_command}")
+                return fix_command
+                
+            except Exception as e:
+                print(f"❌ Claude API call failed: {e}")
+                return None
+        else:
+            print("⚠️ Claude fallback not available (anthropic library not installed)")
+            return None
     
     # Process the response
     try:
@@ -1988,7 +2274,65 @@ Provide fixes for all {len(failed_commands)} failed commands:"""
             return fixes
         else:
             print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
-            return []
+            
+            # Try Claude as fallback if available
+            if anthropic is not None:
+                print("🔄 Trying Claude-4-Sonnet as fallback for batch debugging...")
+                try:
+                    # Get Anthropic API key
+                    anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                    if not anthropic_api_key:
+                        print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                        return []
+                    
+                    # Create Anthropic client
+                    client = anthropic.Anthropic(api_key=anthropic_api_key)
+                    
+                    print("🤖 Calling Claude-4-Sonnet for batch debugging...")
+                    message = client.messages.create(
+                        model="claude-3-5-sonnet-20241022",
+                        max_tokens=1000,
+                        messages=[
+                            {"role": "user", "content": prompt}
+                        ]
+                    )
+                    
+                    content = message.content[0].text
+                    print(f"✅ Claude batch analysis completed")
+                    
+                    # Parse the response to extract fix commands
+                    fixes = []
+                    for i in range(1, len(failed_commands) + 1):
+                        fix_pattern = f"FIX_COMMAND_{i}: (.+)"
+                        reason_pattern = f"REASON_{i}: (.+)"
+                        
+                        fix_match = re.search(fix_pattern, content, re.MULTILINE)
+                        reason_match = re.search(reason_pattern, content, re.MULTILINE)
+                        
+                        if fix_match:
+                            fix_command = fix_match.group(1).strip()
+                            reason = reason_match.group(1).strip() if reason_match else "Claude suggested fix"
+                            
+                            # Clean up the fix command
+                            if fix_command.startswith('`') and fix_command.endswith('`'):
+                                fix_command = fix_command[1:-1]
+                            
+                            fixes.append({
+                                'original_command': failed_commands[i-1]['command'],
+                                'fix_command': fix_command,
+                                'reason': reason,
+                                'command_index': i-1
+                            })
+                    
+                    print(f"🔧 Generated {len(fixes)} fix commands from Claude batch analysis")
+                    return fixes
+                    
+                except Exception as e:
+                    print(f"❌ Claude API call failed: {e}")
+                    return []
+            else:
+                print("⚠️ Claude fallback not available (anthropic library not installed)")
+                return []
             
     except Exception as e:
         print(f"❌ Error during batch debugging: {e}")
@@ -3565,21 +3909,57 @@ Return only the JSON array, no other text.
             print("⚠️ No OpenAI API key available for command preprocessing")
             return setup_commands
         
-        # Call OpenAI API
-        import openai
-        client = openai.OpenAI(api_key=api_key)
-        
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.1,
-            max_tokens=2000
-        )
-        
-        result = response.choices[0].message.content.strip()
+        # Try OpenAI API first
+        try:
+            import openai
+            client = openai.OpenAI(api_key=api_key)
+            
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.1,
+                max_tokens=2000
+            )
+            
+            result = response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            print(f"⚠️ OpenAI API call failed: {e}")
+            
+            # Try Claude as fallback if available
+            if anthropic is not None:
+                print("🔄 Trying Claude-4-Sonnet as fallback for command preprocessing...")
+                try:
+                    # Get Anthropic API key
+                    anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY")
+                    if not anthropic_api_key:
+                        print("⚠️ No ANTHROPIC_API_KEY found in environment")
+                        return fallback_preprocess_commands(setup_commands, stored_credentials)
+                    
+                    # Create Anthropic client
+                    client = anthropic.Anthropic(api_key=anthropic_api_key)
+                    
+                    print("🤖 Calling Claude-4-Sonnet for command preprocessing...")
+                    message = client.messages.create(
+                        model="claude-3-5-sonnet-20241022",
+                        max_tokens=2000,
+                        messages=[
+                            {"role": "user", "content": prompt}
+                        ]
+                    )
+                    
+                    result = message.content[0].text.strip()
+                    print("✅ Claude preprocessing completed")
+                    
+                except Exception as claude_error:
+                    print(f"❌ Claude API call failed: {claude_error}")
+                    return fallback_preprocess_commands(setup_commands, stored_credentials)
+            else:
+                print("⚠️ Claude fallback not available (anthropic library not installed)")
+                return fallback_preprocess_commands(setup_commands, stored_credentials)
         
         # Debug: Print the raw response
         print(f"🔍 LLM Response: {result[:200]}...")
@@ -3929,19 +4309,7 @@ if __name__ == "__main__":
         print(f"Setup Commands: {len(args.setup_commands)} custom commands")
     else:
         print("Setup Commands: Auto-detect from repository")
-    
-    # Confirm settings
-    if not args.yes:
-        try:
-            proceed = input("Proceed with these settings? (Y/n): ").strip().lower()
-            if proceed in ('n', 'no'):
-                print("🛑 Operation cancelled by user.")
-                sys.exit(0)
-        except KeyboardInterrupt:
-            print("\n🛑 Operation cancelled by user.")
-            sys.exit(0)
-    else:
-        print("✅ Skipping confirmation prompt (--yes flag used)")
+
     
     # Interactive mode or missing required arguments
     if args.interactive or not args.repo_url or not args.volume_name: