gitarsenal-cli 1.9.58 → 1.9.60

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-12T19:09:30.955Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-13T13:05:38.083Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -22,9 +22,6 @@ function activateVirtualEnvironment() {
   const venvPath = path.join(__dirname, '..', '.venv');
   const statusFile = path.join(__dirname, '..', '.venv_status.json');
   
-  // Debug: Log the path we're looking for
-  // console.log(chalk.gray(`🔍 Looking for virtual environment at: ${venvPath}`));
-  
   // Check if virtual environment exists
   if (!fs.existsSync(venvPath)) {
     console.log(chalk.red('❌ Virtual environment not found. Please reinstall the package:'));
@@ -41,7 +38,6 @@ function activateVirtualEnvironment() {
   if (fs.existsSync(statusFile)) {
     try {
       const status = JSON.parse(fs.readFileSync(statusFile, 'utf8'));
-      // console.log(chalk.gray(`📦 Packages: ${status.packages.join(', ')}`));
     } catch (error) {
       console.log(chalk.gray('✅ Virtual environment found'));
     }
@@ -103,6 +99,7 @@ function activateVirtualEnvironment() {
   return true;
 }
 
+
 // Lightweight preview of GPU/Torch/CUDA recommendations prior to GPU selection
 async function previewRecommendations(repoUrl, optsOrShowSummary = true) {
   const showSummary = typeof optsOrShowSummary === 'boolean' ? optsOrShowSummary : (optsOrShowSummary?.showSummary ?? true);
@@ -214,46 +211,6 @@ async function previewRecommendations(repoUrl, optsOrShowSummary = true) {
   }
 }
 
-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📊 RESULT SUMMARY (GPU/Torch/CUDA)'));
@@ -307,66 +264,6 @@ function printGpuTorchCudaSummary(result) {
   } catch {}
 }
 
-// Full fetch to get both setup commands and recommendations in one request
-async function fetchFullSetupAndRecs(repoUrl) {
-  const envUrl = process.env.GITARSENAL_API_URL;
-  const endpoints = envUrl ? [envUrl] : ['https://www.gitarsenal.dev/api/best_gpu'];
-  const payload = {
-    repoUrl,
-    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 timeoutMs = Number(process.env.GITARSENAL_FULL_TIMEOUT_MS || 180000);
-
-  const fetchWithTimeout = async (url, body, timeout) => {
-    const controller = new AbortController();
-    const id = setTimeout(() => controller.abort(), timeout);
-    try {
-      const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'User-Agent': 'GitArsenal-CLI/1.0' },
-        body: JSON.stringify(body),
-        redirect: 'follow',
-        signal: controller.signal
-      });
-      clearTimeout(id);
-      return res;
-    } catch (e) {
-      clearTimeout(id);
-      throw e;
-    }
-  };
-
-  for (const url of endpoints) {
-    try {
-      const res = await fetchWithTimeout(url, payload, timeoutMs);
-      if (!res.ok) continue;
-      const data = await res.json().catch(() => null);
-      if (data) return data;
-    } catch (_e) {
-      continue;
-    }
-  }
-  return null;
-}
-
 // Helper to derive a default volume name from the repository URL
 function getDefaultVolumeName(repoUrl) {
   try {
@@ -423,13 +320,20 @@ function getDefaultVolumeName(repoUrl) {
   }
 }
 
+// Full fetch to get both setup commands and recommendations in one request  
+async function fetchFullSetupAndRecs(repoUrl) {
+  // For now, just use the preview function but don't show summary to avoid duplicates
+  // The Python implementation will handle setup commands
+  return await previewRecommendations(repoUrl, { showSummary: false, hideSpinner: true });
+}
+
 // Function to send user data to web application
 async function sendUserData(userId, userName, userEmail) {
   try {
-    console.log(chalk.blue(`🔗 Attempting to register user: ${userName} (${userEmail})`));
+    console.log(chalk.blue(`🔗 Attempting to register user: ${userName} (${userId})`));
     
     const userData = {
-      email: userEmail,  // Use actual email address
+      email: userEmail,  // Use userId as email (assuming it's an email)
       name: userName,
       username: userId
     };
@@ -453,8 +357,7 @@ async function sendUserData(userId, userName, userEmail) {
     if (process.env.GITARSENAL_WEBHOOK_URL) {
       webhookUrl = process.env.GITARSENAL_WEBHOOK_URL;
     }
-    
-    // console.log(chalk.gray(`📡 Sending to: ${webhookUrl}`));
+  
     console.log(chalk.gray(`📦 Data: ${data}`));
     
     const urlObj = new URL(webhookUrl);
@@ -521,11 +424,10 @@ async function collectUserCredentials(options) {
   let userName = options.userName;
   let userEmail = options.userEmail;
 
-  // Check for user-specific config file first (in user's home directory)
+  // Check for config file first
   const os = require('os');
   const userConfigDir = path.join(os.homedir(), '.gitarsenal');
   const userConfigPath = path.join(userConfigDir, 'user-config.json');
-  
   if (fs.existsSync(userConfigPath)) {
     try {
       const config = JSON.parse(fs.readFileSync(userConfigPath, 'utf8'));
@@ -639,7 +541,7 @@ async function collectUserCredentials(options) {
             if (input !== answers.password) return 'Passwords do not match';
             return true;
           }
-      }
+        }
     ]);
     
     userId = credentials.userId;
@@ -947,7 +849,7 @@ async function runContainerCommand(options) {
       ]);
       
       if (volumeAnswers.useVolume) {
-        volumeName = volumeAnswers.volumeName;
+        volumeName = getDefaultVolumeName(repoUrl);
       }
     } else if (!volumeName && skipConfirmation) {
       // If --yes flag is used and no volume specified, use default
@@ -1001,7 +903,6 @@ async function runContainerCommand(options) {
     }
 
     // Confirm settings (configuration will be shown by Python script after GPU selection)
-    // console.log(chalk.gray(`🔍 Debug: skipConfirmation = ${skipConfirmation}, options.yes = ${options.yes}`));
     if (!skipConfirmation) {
       const confirmAnswers = await inquirer.prompt([
         {
@@ -1023,7 +924,6 @@ async function runContainerCommand(options) {
 
     // Run the container
     try {
-      // console.log(chalk.gray(`🔍 Debug: skipConfirmation = ${skipConfirmation}`));
       await runContainer({
         repoUrl,
         gpuType,
@@ -1287,4 +1187,4 @@ async function handleKeysDelete(options) {
     console.error(chalk.red(`Error: ${error.message}`));
     process.exit(1);
   }
-}
+} 

package/config.json

@@ -0,0 +1,5 @@
+{
+  "userId": "rs545837",
+  "userName": "ROhan Sharma",
+  "webhookUrl": "https://www.gitarsenal.dev/api/users"
+}

package/lib/sandbox.js

@@ -72,8 +72,9 @@ async function runContainer(options) {
     
     // Run the Python script with show examples flag
     const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
-    const pythonProcess = spawn(pythonExecutable, args, {
-      stdio: 'inherit' // Inherit stdio to show real-time output
+    const pythonProcess = spawn(pythonExecutable, ['-u', ...args], {
+      stdio: 'inherit', // Inherit stdio to show real-time output
+      env: { ...process.env, PYTHONUNBUFFERED: '1' } // Force unbuffered output
     });
     
     return new Promise((resolve, reject) => {
@@ -138,8 +139,9 @@ async function runContainer(options) {
   try {
     // Run the Python script
     const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
-    const pythonProcess = spawn(pythonExecutable, args, {
-      stdio: 'inherit' // Inherit stdio to show real-time output
+    const pythonProcess = spawn(pythonExecutable, ['-u', ...args], {
+      stdio: 'inherit', // Inherit stdio to show real-time output
+      env: { ...process.env, PYTHONUNBUFFERED: '1' } // Force unbuffered output
     });
     
     // Handle process completion

package/package.json

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

package/python/llm_debugging.py

@@ -9,15 +9,11 @@ from pathlib import Path
 
 def get_stored_credentials():
     """Load stored credentials from ~/.gitarsenal/credentials.json"""
-    try:
-        credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
-        if credentials_file.exists():
-            with open(credentials_file, 'r') as f:
-                return json.load(f)
-        return {}
-    except Exception as e:
-        print(f"⚠️ Error loading stored credentials: {e}")
-        return {}
+    credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
+    if credentials_file.exists():
+        with open(credentials_file, 'r') as f:
+            return json.load(f)
+    return {}
 
 
 def generate_auth_context(stored_credentials):
@@ -35,7 +31,7 @@ def generate_auth_context(stored_credentials):
 
 def get_current_debug_model():
     """Get the currently configured debugging model preference"""
-    return os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
+    return os.environ.get("GITARSENAL_DEBUG_MODEL", "anthropic")
 
 
 def _to_str(maybe_bytes):
@@ -536,7 +532,7 @@ def make_groq_request(api_key, prompt, retries=2):
 
 def get_provider_rotation_order(preferred=None):
     """Return provider rotation order starting with preferred if valid."""
-    default_order = ["openai", "anthropic", "groq", "openrouter"]
+    default_order = ["anthropic", "openai", "groq", "openrouter"]
     if preferred and preferred in default_order:
         return [preferred] + [p for p in default_order if p != preferred]
     return default_order

package/python/shell.py

@@ -180,7 +180,7 @@ class PersistentShell:
         self.command_counter += 1
         marker = f"CMD_DONE_{self.command_counter}_{uuid.uuid4().hex[:8]}"
         
-        print(f"🔧 Executing: {command}")
+        print(f"🔧 Executing: {command}", flush=True)
         
         # Clear any existing output
         self._clear_lines()
@@ -266,6 +266,8 @@ class PersistentShell:
                     command_stdout.append(line)
                 elif line.strip() and not line.startswith("$"):  # Skip empty lines and prompt lines
                     command_stdout.append(line)
+                    # Print line immediately for real-time streaming
+                    print(line, flush=True)
             
             if found_marker:
                 break
@@ -278,6 +280,8 @@ class PersistentShell:
             for line in current_stderr:
                 if line.strip():  # Skip empty lines
                     command_stderr.append(line)
+                    # Print stderr immediately for real-time streaming
+                    print(f"{line}", flush=True)
             
             # Check if command is waiting for user input
             if not found_marker and time.time() - start_time > 5:  # Wait at least 5 seconds before checking
@@ -313,8 +317,8 @@ class PersistentShell:
             success = exit_code == 0 if exit_code is not None else len(command_stderr) == 0
         
         if success:
-            if stdout_text:
-                print(f"✅ Output: {stdout_text}")
+            # Don't print the summary output since we already streamed it line by line
+            pass
             # Track virtual environment activation
             if command.strip().startswith("source ") and "/bin/activate" in command:
                 venv_path = command.replace("source ", "").replace("/bin/activate", "").strip()

package/python/test_modalSandboxScript.py

@@ -235,23 +235,9 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
     
     # Check if Modal is authenticated
     try:
-        # Print all environment variables for debugging
-        # print("🔍 DEBUG: Checking environment variables")
         modal_token_id = os.environ.get("MODAL_TOKEN_ID")
         modal_token = os.environ.get("MODAL_TOKEN")
         openai_api_key = os.environ.get("OPENAI_API_KEY")
-        # print(f"🔍 token exists: {'Yes' if modal_token_id else 'No'}")
-        # print(f"🔍 token exists: {'Yes' if modal_token else 'No'}")
-        # print(f"🔍 openai_api_key exists: {'Yes' if openai_api_key else 'No'}")
-        if modal_token_id:
-            # print(f"🔍 token length: {len(modal_token_id)}")
-            pass
-        if modal_token:
-            # print(f"🔍 token length: {len(modal_token)}")
-            pass
-        if openai_api_key:
-            # print(f"🔍 openai_api_key length: {len(openai_api_key)}")
-            pass
         # Try to access Modal token to check authentication
         try:
             # Check if token is set in environment
@@ -342,62 +328,54 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
             print("⚠️ Continuing without persistent volume")
             volume = None
     
-    # Print debug info for authentication
-    # print("🔍 Modal authentication debug info:")
     modal_token = os.environ.get("MODAL_TOKEN_ID")
-    # print(f"  - token in env: {'Yes' if modal_token else 'No'}")
-    # print(f"  - Token length: {len(modal_token) if modal_token else 'N/A'}")
 
     # Create SSH-enabled image
-    try:
-        print("📦 Building SSH-enabled image...")
-        
-        # Get the current directory path for mounting local Python sources
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        # print(f"🔍 Current directory for mounting: {current_dir}")
-        
-        # Use a more stable CUDA base image and avoid problematic packages
-        ssh_image = (
-            # modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
-            modal.Image.debian_slim()
-            .apt_install(
-                "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
-                "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
-                "gpg", "ca-certificates", "software-properties-common"
-            )
-            .uv_pip_install("uv", "modal", "gitingest", "requests", "openai", "anthropic", "exa-py")  # Remove problematic CUDA packages
-            .run_commands(
-                # Create SSH directory
-                "mkdir -p /var/run/sshd",
-                "mkdir -p /root/.ssh",
-                "chmod 700 /root/.ssh",
-                
-                # Configure SSH server
-                "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
-                "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
-                "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
-                
-                # SSH keep-alive settings
-                "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
-                "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
-                
-                # Generate SSH host keys
-                "ssh-keygen -A",
-                
-                # Set up a nice bash prompt
-                "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
-            )
-            .add_local_file(os.path.join(current_dir, "shell.py"), "/python/shell.py")  # Mount shell.py
-            .add_local_file(os.path.join(current_dir, "command_manager.py"), "/python/command_manager.py")  # Mount command_manager.py
-            .add_local_file(os.path.join(current_dir, "fetch_modal_tokens.py"), "/python/fetch_modal_tokens.py")  # Mount fetch_modal_token.py
-            .add_local_file(os.path.join(current_dir, "llm_debugging.py"), "/python/llm_debugging.py")  # Mount llm_debugging.py
-            .add_local_file(os.path.join(current_dir, "credentials_manager.py"), "/python/credentials_manager.py")  # Mount credentials_manager.py
-
+    print("📦 Building SSH-enabled image...")
+    
+    # Get the current directory path for mounting local Python sources
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    # print(f"🔍 Current directory for mounting: {current_dir}")
+    
+    # Use a more stable CUDA base image and avoid problematic packages
+    ssh_image = (
+        # modal.Image.from_registry("nvidia/cuda:12.4.0-devel-ubuntu22.04", add_python="3.11")
+        modal.Image.debian_slim()
+        .apt_install(
+            "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
+            "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
+            "gpg", "ca-certificates", "software-properties-common"
         )
-        print("✅ SSH image built successfully")
-    except Exception as e:
-        print(f"❌ Error building SSH image: {e}")
-        return None
+        .uv_pip_install("uv", "modal", "gitingest", "requests", "openai", "anthropic", "exa-py")  # Remove problematic CUDA packages
+        .run_commands(
+            # Create SSH directory
+            "mkdir -p /var/run/sshd",
+            "mkdir -p /root/.ssh",
+            "chmod 700 /root/.ssh",
+            
+            # Configure SSH server
+            "sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config",
+            "sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config",
+            "sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config",
+            
+            # SSH keep-alive settings
+            "echo 'ClientAliveInterval 60' >> /etc/ssh/sshd_config",
+            "echo 'ClientAliveCountMax 3' >> /etc/ssh/sshd_config",
+            
+            # Generate SSH host keys
+            "ssh-keygen -A",
+            
+            # Set up a nice bash prompt
+            "echo 'export PS1=\"\\[\\e[1;32m\\]modal:\\[\\e[1;34m\\]\\w\\[\\e[0m\\]$ \"' >> /root/.bashrc",
+        )
+        .add_local_file(os.path.join(current_dir, "shell.py"), "/python/shell.py")  # Mount shell.py
+        .add_local_file(os.path.join(current_dir, "command_manager.py"), "/python/command_manager.py")  # Mount command_manager.py
+        .add_local_file(os.path.join(current_dir, "fetch_modal_tokens.py"), "/python/fetch_modal_tokens.py")  # Mount fetch_modal_token.py
+        .add_local_file(os.path.join(current_dir, "llm_debugging.py"), "/python/llm_debugging.py")  # Mount llm_debugging.py
+        .add_local_file(os.path.join(current_dir, "credentials_manager.py"), "/python/credentials_manager.py")  # Mount credentials_manager.py
+
+    )
+    print("✅ SSH image built successfully")
         
     # Configure volumes if available
     volumes_config = {}
@@ -498,9 +476,6 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         # Start SSH service
         subprocess.run(["service", "ssh", "start"], check=True)
         
-        # Fetch setup commands from API if repo_url is provided and no commands exist
-        setup_commands = get_setup_commands_from_gitingest(repo_url)
-        
         # Preprocess setup commands using LLM to inject credentials
         if setup_commands:
             print(f"🔧 Preprocessing {len(setup_commands)} setup commands with LLM to inject credentials...")
@@ -839,7 +814,7 @@ def fetch_setup_commands_from_api(repo_url):
     
     # Define API endpoints to try in order - using only online endpoints
     api_endpoints = [
-       "https://www.gitarsenal.dev/api/gitingest-setup-commands"  # Working endpoint with www prefix
+        "https://www.gitarsenal.dev/api/analyze-with-gitingest"  # Working endpoint with www prefix
     ]
     
     print(f"🔍 Fetching setup commands from API for repository: {repo_url}")
@@ -874,6 +849,12 @@ def fetch_setup_commands_from_api(repo_url):
             # Use gitingest CLI tool to analyze the repository directly from URL
             print(f"🔎 Running GitIngest analysis on {repo_url}...")
             
+            # Based on the help output, the correct format is:
+            # gitingest [OPTIONS] [SOURCE]
+            # With options:
+            # -o, --output TEXT           Output file path
+            # --format TEXT               Output format (json)
+            
             # Run gitingest command with proper parameters
             gitingest_run_cmd = [
                 gitingest_cmd_name,
@@ -1103,115 +1084,7 @@ def fetch_setup_commands_from_api(repo_url):
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 def generate_fallback_commands(gitingest_data):
-    """Generate fallback setup commands based on repository analysis"""
-    print("\n" + "="*80)
-    print("📋 GENERATING FALLBACK SETUP COMMANDS")
-    print("="*80)
-    print("Using basic repository analysis to generate setup commands")
-    
-    # Default commands that work for most repositories
-    default_commands = [
-        "apt-get update -y",
-        "apt-get install -y git curl wget",
-        "pip install --upgrade pip setuptools wheel"
-    ]
-    
-    # If we don't have any analysis data, return default commands
-    if not gitingest_data:
-        print("⚠️ No repository analysis data available. Using default commands.")
-        return default_commands
-    
-    # Extract language and technologies information
-    detected_language = gitingest_data.get("system_info", {}).get("detected_language", "Unknown")
-    detected_technologies = gitingest_data.get("system_info", {}).get("detected_technologies", [])
-    primary_package_manager = gitingest_data.get("system_info", {}).get("primary_package_manager", "Unknown")
-    
-    # Add language-specific commands
-    language_commands = []
-    
-    print(f"📋 Detected primary language: {detected_language}")
-    print(f"📋 Detected technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
-    print(f"📋 Detected package manager: {primary_package_manager}")
-    
-    # Python-specific commands
-    if detected_language == "Python" or primary_package_manager == "pip":
-        print("📦 Adding Python-specific setup commands")
-        
-        # Check for requirements.txt
-        requirements_check = [
-            "if [ -f requirements.txt ]; then",
-            "  echo 'Installing from requirements.txt'",
-            "  pip install -r requirements.txt",
-            "elif [ -f setup.py ]; then",
-            "  echo 'Installing from setup.py'",
-            "  pip install -e .",
-            "fi"
-        ]
-        language_commands.extend(requirements_check)
-        
-        # Add common Python packages
-        language_commands.append("pip install pytest numpy pandas matplotlib")
-    
-    # JavaScript/Node.js specific commands
-    elif detected_language in ["JavaScript", "TypeScript"] or primary_package_manager in ["npm", "yarn", "pnpm"]:
-        print("📦 Adding JavaScript/Node.js-specific setup commands")
-        
-        # Install Node.js if not available
-        language_commands.append("apt-get install -y nodejs npm")
-        
-        # Check for package.json
-        package_json_check = [
-            "if [ -f package.json ]; then",
-            "  echo 'Installing from package.json'",
-            "  npm install",
-            "fi"
-        ]
-        language_commands.extend(package_json_check)
-    
-    # Java specific commands
-    elif detected_language == "Java" or primary_package_manager in ["maven", "gradle"]:
-        print("📦 Adding Java-specific setup commands")
-        
-        language_commands.append("apt-get install -y openjdk-11-jdk maven gradle")
-        
-        # Check for Maven or Gradle
-        build_check = [
-            "if [ -f pom.xml ]; then",
-            "  echo 'Building with Maven'",
-            "  mvn clean install -DskipTests",
-            "elif [ -f build.gradle ]; then",
-            "  echo 'Building with Gradle'",
-            "  gradle build --no-daemon",
-            "fi"
-        ]
-        language_commands.extend(build_check)
-    
-    # Go specific commands
-    elif detected_language == "Go" or primary_package_manager == "go":
-        print("📦 Adding Go-specific setup commands")
-        
-        language_commands.append("apt-get install -y golang-go")
-        language_commands.append("go mod tidy")
-    
-    # Rust specific commands
-    elif detected_language == "Rust" or primary_package_manager == "cargo":
-        print("📦 Adding Rust-specific setup commands")
-        
-        language_commands.append("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y")
-        language_commands.append("source $HOME/.cargo/env")
-        language_commands.append("cargo build")
-    
-    # Combine all commands
-    all_commands = default_commands + language_commands
-    
-    # Fix the commands
-    fixed_commands = fix_setup_commands(all_commands)
-    
-    print("\n📋 Generated fallback setup commands:")
-    for i, cmd in enumerate(fixed_commands, 1):
-        print(f"  {i}. {cmd}")
-    
-    return fixed_commands
+    return True
 
 def generate_basic_repo_analysis_from_url(repo_url):
     """Generate basic repository analysis data from a repository URL."""
@@ -1263,120 +1136,7 @@ def generate_basic_repo_analysis_from_url(repo_url):
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 def generate_basic_repo_analysis(repo_dir):
-    """Generate basic repository analysis when GitIngest is not available."""
-    import os
-    import subprocess
-    
-    # Detect language and technologies based on file extensions
-    file_extensions = {}
-    file_count = 0
-    
-    for root, _, files in os.walk(repo_dir):
-        for file in files:
-            file_count += 1
-            ext = os.path.splitext(file)[1].lower()
-            if ext:
-                file_extensions[ext] = file_extensions.get(ext, 0) + 1
-    
-    # Determine primary language
-    language_map = {
-        '.py': 'Python',
-        '.js': 'JavaScript',
-        '.ts': 'TypeScript',
-        '.jsx': 'JavaScript',
-        '.tsx': 'TypeScript',
-        '.java': 'Java',
-        '.cpp': 'C++',
-        '.c': 'C',
-        '.go': 'Go',
-        '.rs': 'Rust',
-        '.rb': 'Ruby',
-        '.php': 'PHP',
-        '.swift': 'Swift',
-        '.kt': 'Kotlin',
-        '.cs': 'C#'
-    }
-    
-    # Count files by language
-    language_counts = {}
-    for ext, count in file_extensions.items():
-        if ext in language_map:
-            lang = language_map[ext]
-            language_counts[lang] = language_counts.get(lang, 0) + count
-    
-    # Determine primary language
-    primary_language = max(language_counts.items(), key=lambda x: x[1])[0] if language_counts else "Unknown"
-    
-    # Detect package managers
-    package_managers = []
-    package_files = {
-        'requirements.txt': 'pip',
-        'setup.py': 'pip',
-        'pyproject.toml': 'pip',
-        'package.json': 'npm',
-        'yarn.lock': 'yarn',
-        'pnpm-lock.yaml': 'pnpm',
-        'Cargo.toml': 'cargo',
-        'go.mod': 'go',
-        'Gemfile': 'bundler',
-        'pom.xml': 'maven',
-        'build.gradle': 'gradle',
-        'composer.json': 'composer'
-    }
-    
-    for file, manager in package_files.items():
-        if os.path.exists(os.path.join(repo_dir, file)):
-            package_managers.append(manager)
-    
-    primary_package_manager = package_managers[0] if package_managers else "Unknown"
-    
-    # Get README content
-    readme_content = ""
-    for readme_name in ['README.md', 'README', 'README.txt', 'readme.md']:
-        readme_path = os.path.join(repo_dir, readme_name)
-        if os.path.exists(readme_path):
-            with open(readme_path, 'r', encoding='utf-8', errors='ignore') as f:
-                readme_content = f.read()
-            break
-    
-    # Try to get repository info
-    repo_info = {}
-    try:
-        # Get remote origin URL
-        cmd = ["git", "config", "--get", "remote.origin.url"]
-        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
-        if result.returncode == 0:
-            repo_info["url"] = result.stdout.strip()
-        
-        # Get commit count as a proxy for activity
-        cmd = ["git", "rev-list", "--count", "HEAD"]
-        result = subprocess.run(cmd, cwd=repo_dir, capture_output=True, text=True)
-        if result.returncode == 0:
-            repo_info["commit_count"] = int(result.stdout.strip())
-    except Exception:
-        pass
-    
-    # Build the analysis data
-    return {
-        "system_info": {
-            "platform": "linux",  # Assuming Linux for container environment
-            "python_version": "3.10",  # Common Python version
-            "detected_language": primary_language,
-            "detected_technologies": list(language_counts.keys()),
-            "file_count": file_count,
-            "repo_stars": repo_info.get("stars", 0),
-            "repo_forks": repo_info.get("forks", 0),
-            "primary_package_manager": primary_package_manager,
-            "complexity_level": "medium"  # Default assumption
-        },
-        "repository_analysis": {
-            "summary": f"Repository analysis for {repo_dir}",
-            "readme_content": readme_content[:5000] if readme_content else "No README found",
-            "package_managers": package_managers,
-            "file_extensions": list(file_extensions.keys())
-        },
-        "success": True
-    }
+    return True
 
 def fix_setup_commands(commands):
     """Fix setup commands by removing placeholders and comments."""
@@ -1556,8 +1316,8 @@ def make_api_request_with_retry(url, payload, max_retries=2, timeout=180):
             if attempt > 0:
                 print(f"🔄 Retry attempt {attempt}/{max_retries}...")
                 
-            print(f"🌐 Making POST request to: {url}")
-            print(f"⏳ Waiting up to {timeout//60} minutes for response...")
+            # print(f"🌐 Making POST request to: {url}")
+            # print(f"⏳ Waiting up to {timeout//60} minutes for response...")
             
             # Set allow_redirects=True to follow redirects automatically
             response = requests.post(
@@ -1617,6 +1377,8 @@ def get_setup_commands_from_gitingest(repo_url):
     api_endpoints = [
         "https://www.gitarsenal.dev/api/gitingest-setup-commands",
         "https://gitarsenal.dev/api/gitingest-setup-commands",
+        "https://www.gitarsenal.dev/api/analyze-with-gitingest",
+        "http://localhost:3000/api/gitingest-setup-commands"
     ]
     
     # Generate basic gitingest data
@@ -1709,7 +1471,7 @@ def get_setup_commands_from_gitingest(repo_url):
     # Try each API endpoint
     for api_url in api_endpoints:
         try:
-            print(f"Trying API endpoint: {api_url}")
+            # print(f"Trying API endpoint: {api_url}")
             
             # Load stored credentials
             stored_credentials = get_stored_credentials()
@@ -1947,7 +1709,7 @@ Return only the JSON array, no other text.
         client = openai.OpenAI(api_key=api_key)
         
         response = client.chat.completions.create(
-            model="gpt-4.1",  # Fixed: using valid OpenAI model
+            model="gpt-4.1",
             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}
@@ -2404,7 +2166,7 @@ if __name__ == "__main__":
         
         # Use gitingest by default unless --no-gitingest is set
         if args.repo_url and (args.use_gitingest and not args.no_gitingest):
-            print("🔄 Using gitingest approach to fetch setup commands (default)")
+            # print("🔄 Using gitingest approach to fetch setup commands (default)")
             api_commands = get_setup_commands_from_gitingest(args.repo_url)
             if api_commands:
                 setup_commands = api_commands