gitarsenal-cli 1.9.77 → 1.9.78

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-17T08:32:36.269Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-17T17:20:43.416Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -15,6 +15,7 @@ const { spawn } = require('child_process');
 const fs = require('fs');
 const https = require('https');
 const http = require('http');
+const { fetchGitIngestData } = require('../gitingest-integration');
 
 // Function to activate virtual environment
 function activateVirtualEnvironment() {
@@ -22,7 +23,7 @@ function activateVirtualEnvironment() {
   const venvPath = path.join(__dirname, '..', '.venv');
   const statusFile = path.join(__dirname, '..', '.venv_status.json');
   
-  // Check if virtual environment exists
+// Check if virtual environment exists
   if (!fs.existsSync(venvPath)) {
     console.log(chalk.red('❌ Virtual environment not found. Please reinstall the package:'));
     console.log(chalk.yellow('   npm uninstall -g gitarsenal-cli'));
@@ -57,13 +58,7 @@ function activateVirtualEnvironment() {
   const traditionalPipPath = isWindows ? 
     path.join(venvPath, 'Scripts', 'pip.exe') : 
     path.join(venvPath, 'bin', 'pip');
-  
-  // Determine which structure exists
-  // console.log(chalk.gray(`🔍 Checking virtual environment structure:`));
-  // console.log(chalk.gray(`  Python: ${uvPythonPath} (exists: ${fs.existsSync(uvPythonPath)})`));
-  // console.log(chalk.gray(`  Pip: ${uvPipPath} (exists: ${fs.existsSync(uvPipPath)})`));
-  
-  // For uv virtual environments, we only need Python to exist
+
   // uv doesn't create a pip executable, it uses 'uv pip' instead
   if (fs.existsSync(uvPythonPath)) {
     pythonPath = uvPythonPath;
@@ -261,9 +256,156 @@ function printGpuTorchCudaSummary(result) {
       if (gpu.notes) console.log(`  - Notes:  ${gpu.notes}`);
       console.log();
     }
+
+    // Print API key requirements if available
+    if (result.requiredApiKeys && Array.isArray(result.requiredApiKeys) && result.requiredApiKeys.length > 0) {
+      console.log(chalk.bold('🔑 REQUIRED API KEYS'));
+      result.requiredApiKeys.forEach(apiKey => {
+        const status = apiKey.required ? chalk.red('REQUIRED') : chalk.yellow('OPTIONAL');
+        console.log(`  - ${apiKey.name} (${status})`);
+        console.log(`    Service: ${apiKey.service}`);
+        console.log(`    Purpose: ${apiKey.description}`);
+        if (apiKey.example) console.log(`    Format: ${apiKey.example}`);
+        if (apiKey.documentation_url) console.log(`    Docs: ${apiKey.documentation_url}`);
+        console.log();
+      });
+    }
   } catch {}
 }
 
+// Function to load stored API keys
+async function loadStoredApiKeys() {
+  try {
+    const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
+    const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
+    
+    return new Promise((resolve) => {
+      const pythonProcess = spawn(pythonExecutable, [
+        scriptPath,
+        'list',
+        '--json'
+      ], { stdio: 'pipe' });
+      
+      let output = '';
+      pythonProcess.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+      
+      pythonProcess.on('close', (code) => {
+        if (code === 0) {
+          try {
+            const keys = JSON.parse(output);
+            resolve(keys);
+          } catch (e) {
+            resolve({});
+          }
+        } else {
+          resolve({});
+        }
+      });
+    });
+  } catch (error) {
+    return {};
+  }
+}
+
+// Function to prompt for missing required API keys
+async function promptForMissingApiKeys(requiredApiKeys, storedKeys) {
+  if (!requiredApiKeys || !Array.isArray(requiredApiKeys) || requiredApiKeys.length === 0) {
+    return {};
+  }
+
+  const missingKeys = {};
+  const requiredMissingKeys = requiredApiKeys.filter(apiKey => 
+    apiKey.required && !storedKeys[apiKey.service.toLowerCase()]
+  );
+
+  if (requiredMissingKeys.length === 0) {
+    console.log(chalk.green('✅ All required API keys are already stored'));
+    return {};
+  }
+
+  console.log(chalk.yellow('\n🔑 Missing Required API Keys'));
+  console.log(chalk.gray('The following API keys are required for this repository:'));
+
+  for (const apiKey of requiredMissingKeys) {
+    console.log(chalk.bold(`\n📝 ${apiKey.name} (${apiKey.service})`));
+    console.log(chalk.gray(`Purpose: ${apiKey.description}`));
+    if (apiKey.documentation_url) {
+      console.log(chalk.blue(`Documentation: ${apiKey.documentation_url}`));
+    }
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'provideKey',
+        message: `Do you want to provide your ${apiKey.service} API key now?`,
+        default: true
+      }
+    ]);
+
+    if (answers.provideKey) {
+      const keyAnswer = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'key',
+          message: `Enter your ${apiKey.service} API key:`,
+          mask: '*',
+          validate: (input) => {
+            const key = input.trim();
+            if (key === '') return `${apiKey.service} API key is required`;
+            return true;
+          }
+        }
+      ]);
+
+      const storeAnswer = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'store',
+          message: `Store this API key locally for future use?`,
+          default: true
+        }
+      ]);
+
+      missingKeys[apiKey.service.toLowerCase()] = keyAnswer.key;
+
+      if (storeAnswer.store) {
+        // Store the key using the existing key management system
+        try {
+          const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
+          const pythonExecutable = process.env.PYTHON_EXECUTABLE || 'python';
+          
+          await new Promise((resolve, reject) => {
+            const pythonProcess = spawn(pythonExecutable, [
+              scriptPath,
+              'add',
+              '--service', apiKey.service.toLowerCase(),
+              '--key', keyAnswer.key
+            ], { stdio: 'pipe' });
+            
+            pythonProcess.on('close', (code) => {
+              if (code === 0) {
+                console.log(chalk.green(`✅ ${apiKey.service} API key stored successfully`));
+                resolve();
+              } else {
+                console.log(chalk.yellow(`⚠️ Could not store ${apiKey.service} API key locally`));
+                resolve(); // Don't fail the whole process
+              }
+            });
+          });
+        } catch (error) {
+          console.log(chalk.yellow(`⚠️ Could not store ${apiKey.service} API key: ${error.message}`));
+        }
+      }
+    } else {
+      console.log(chalk.yellow(`⚠️ Skipping ${apiKey.service} API key. Repository setup may fail without it.`));
+    }
+  }
+
+  return missingKeys;
+}
+
 // Helper to derive a default volume name from the repository URL
 function getDefaultVolumeName(repoUrl) {
   try {
@@ -321,10 +463,106 @@ 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 });
+async function fetchFullSetupAndRecs(repoUrl, storedCredentials = null) {
+  const spinner = ora('Analyzing repository with GitIngest...').start();
+  
+  try {
+    // Try to use local GitIngest CLI first
+    spinner.text = 'Running GitIngest analysis...';
+    const gitingestData = await fetchGitIngestData(repoUrl);
+    
+    let finalGitingestData;
+    if (!gitingestData) {
+      spinner.warn('GitIngest CLI not available, using basic analysis');
+      // Fallback to basic data
+      finalGitingestData = {
+        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: false
+      };
+    } else {
+      finalGitingestData = gitingestData;
+      spinner.text = 'GitIngest complete, generating AI recommendations...';
+    }
+
+    const envUrl = process.env.GITARSENAL_API_URL;
+    const endpoints = envUrl ? [envUrl] : ['https://www.gitarsenal.dev/api/best_gpu'];
+
+    const payload = {
+      repoUrl,
+      gitingestData: finalGitingestData,
+      storedCredentials,
+      preview: false // This is a full analysis, not preview
+    };
+
+    // console.log(chalk.gray('🐛 DEBUG: Payload being sent to API:'));
+    // console.log(chalk.gray('  - Repo URL:', repoUrl));
+    // console.log(chalk.gray('  - GitIngest Data Summary Length:', payload.gitingestData.repository_analysis.summary.length));
+    // console.log(chalk.gray('  - GitIngest Data Tree Length:', payload.gitingestData.repository_analysis.tree.length));
+    // console.log(chalk.gray('  - GitIngest Data Content Length:', payload.gitingestData.repository_analysis.content_preview.length));
+    // console.log(chalk.gray('  - Detected Language:', payload.gitingestData.system_info.detected_language));
+    // console.log(chalk.gray('  - Detected Technologies:', payload.gitingestData.system_info.detected_technologies.join(', ')));
+    // console.log(chalk.gray('  - Stored Credentials:', storedCredentials ? Object.keys(storedCredentials).length + ' keys' : 'none'));
+    // console.log(chalk.gray('  - Preview Mode:', payload.preview));
+
+    let data = null;
+    let lastErrorText = '';
+
+    for (const url of endpoints) {
+      try {
+        spinner.text = `Analyzing repository: ${url}`;
+        const res = await fetch(url, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'User-Agent': 'GitArsenal-CLI/1.0' },
+          body: JSON.stringify(payload),
+          redirect: 'follow'
+        });
+        if (!res.ok) {
+          const text = await res.text().catch(() => '');
+          lastErrorText = `${res.status} ${text.slice(0, 300)}`;
+          continue;
+        }
+        data = await res.json().catch(() => null);
+        if (data) {
+          console.log(chalk.gray('🐛 DEBUG: Received response from API:'));
+          console.log(chalk.gray('  - Response has commands:', !!data.commands));
+          console.log(chalk.gray('  - Commands count:', data.commands ? data.commands.length : 0));
+          console.log(chalk.gray('  - Response has API keys:', !!data.requiredApiKeys));
+          console.log(chalk.gray('  - API keys count:', data.requiredApiKeys ? data.requiredApiKeys.length : 0));
+          console.log(chalk.gray('  - Response has GPU rec:', !!data.gpuRecommendation));
+          console.log(chalk.gray('  - Response has CUDA rec:', !!data.cudaRecommendation));
+          console.log(chalk.gray('  - Response has Torch rec:', !!data.torchRecommendation));
+          spinner.succeed('Repository analysis complete');
+          return data;
+        }
+      } catch (err) {
+        lastErrorText = err && err.message ? err.message : 'request failed';
+        continue;
+      }
+    }
+
+    spinner.fail('Failed to analyze repository');
+    if (lastErrorText) console.log(chalk.gray(`Reason: ${lastErrorText}`));
+    return null;
+    
+  } catch (e) {
+    spinner.fail(`Analysis failed: ${e.message}`);
+    return null;
+  }
 }
 
 // Function to send user data to web application
@@ -761,8 +999,15 @@ async function runContainerCommand(options) {
       repoUrl = answers.repoUrl;
     }
 
-    // Analyze repository for GPU recommendations (repository setup is now handled by Agent)
+    // 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();
       
@@ -773,16 +1018,24 @@ async function runContainerCommand(options) {
         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; prefer its results if available.
-        mainSpinner.text = 'Finding the best machine for your code...';
-        const fullData = await fetchFullSetupAndRecs(repoUrl).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);
         
         if (fullData) {
           // Stop preview spinner immediately since we have a response
           previewAbort.abort();
           mainSpinner.succeed('Analysis complete!');
           printGpuTorchCudaSummary(fullData);
-          // Repository setup will be handled by Agent in container
+          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 {
           // Full fetch failed, wait for preview and show its results
           mainSpinner.text = 'Waiting for preview analysis to complete...';
@@ -790,16 +1043,19 @@ async function runContainerCommand(options) {
           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.'));
+        collectedApiKeys = await loadStoredApiKeys();
       }
     }
 
@@ -934,7 +1190,9 @@ async function runContainerCommand(options) {
         yes: skipConfirmation,
         userId,
         userName,
-        userEmail
+        userEmail,
+        apiKeys: collectedApiKeys,
+        analysisData
       });
       
     } catch (containerError) {

package/gitingest-integration.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+
+// Function to check if GitIngest CLI is available and working
+async function checkGitIngestCLI() {
+  try {
+    // Try a simple help command first
+    const checkProcess = spawn('gitingest', ['--version'], { 
+      stdio: 'pipe',
+      timeout: 5000  // 5 second timeout
+    });
+    
+    let stderr = '';
+    checkProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    return new Promise((resolve) => {
+      checkProcess.on('close', (code) => {
+        // If there are Python errors in stderr, consider it failed even if exit code is 0
+        if (stderr.includes('TypeError') || stderr.includes('Traceback') || stderr.includes('Error')) {
+          // console.log(chalk.yellow('⚠️ GitIngest CLI has Python compatibility issues'));
+          resolve(false);
+        } else if (code === 0) {
+          resolve(true);
+        } else {
+          resolve(false);
+        }
+      });
+      
+      checkProcess.on('error', () => {
+        resolve(false);
+      });
+      
+      // Handle timeout
+      setTimeout(() => {
+        if (!checkProcess.killed) {
+          checkProcess.kill();
+          resolve(false);
+        }
+      }, 5000);
+    });
+  } catch (error) {
+    return false;
+  }
+}
+
+// Function to fetch GitIngest data using local GitIngest CLI
+async function fetchGitIngestData(repoUrl) {
+  try {
+    // First check if GitIngest CLI is available
+    const gitingestAvailable = await checkGitIngestCLI();
+    if (!gitingestAvailable) {
+      // console.log(chalk.yellow('⚠️ GitIngest CLI not available or has compatibility issues.'));
+      // console.log(chalk.blue('💡 For best results, install with: pipx install gitingest'));
+      // console.log(chalk.blue('   Alternative: pip install gitingest (requires Python 3.10+)'));
+      // console.log(chalk.blue('📖 More info: https://github.com/coderamp-labs/gitingest'));
+      // console.log(chalk.gray('   Falling back to basic repository analysis...'));
+      return null;
+    }
+
+    console.log(chalk.gray('📥 Running GitIngest locally...'));
+    
+    // Run GitIngest CLI command with optimal settings for AI analysis
+    const gitingestProcess = spawn('gitingest', [
+      repoUrl,
+      '-o', '-',  // Output to stdout
+    ], { 
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let gitingestOutput = '';
+    let errorOutput = '';
+
+    gitingestProcess.stdout.on('data', (data) => {
+      gitingestOutput += data.toString();
+    });
+
+    gitingestProcess.stderr.on('data', (data) => {
+      errorOutput += data.toString();
+    });
+
+    return new Promise((resolve) => {
+      gitingestProcess.on('close', (code) => {
+        if (code === 0 && gitingestOutput.trim().length > 0) {
+          console.log(chalk.green('✅ GitIngest analysis complete'));
+          console.log(chalk.gray(`📊 Captured ${gitingestOutput.length} characters of repository content`));
+          resolve(parseGitIngestOutput(gitingestOutput, repoUrl));
+        } else {
+          console.log(chalk.yellow(`⚠️ GitIngest failed (exit code: ${code})`));
+          if (errorOutput) {
+            console.log(chalk.gray(`Error details: ${errorOutput.slice(0, 300)}`));
+          }
+          resolve(null);
+        }
+      });
+
+      gitingestProcess.on('error', (error) => {
+        console.log(chalk.yellow(`⚠️ GitIngest CLI error: ${error.message}`));
+        resolve(null);
+      });
+    });
+    
+  } catch (error) {
+    console.log(chalk.yellow(`⚠️ GitIngest execution failed: ${error.message}`));
+    return null;
+  }
+}
+
+// Function to parse GitIngest text output into structured data
+function parseGitIngestOutput(gitingestText, repoUrl) {
+  try {
+    // Extract repository info from URL
+    const urlMatch = repoUrl.match(/github\.com\/([^\/]+)\/([^\/]+)/);
+    const owner = urlMatch ? urlMatch[1] : 'unknown';
+    const repo = urlMatch ? urlMatch[2].replace('.git', '') : 'unknown';
+
+    // GitIngest output format:
+    // Repository: owner/repo-name
+    // Files analyzed: 42
+    // Estimated tokens: 15.2k
+    //
+    // Directory structure:
+    // └── project-name/
+    //     ├── src/
+    //     │   ├── main.py
+    //     └── README.md
+    //
+    // ================================================
+    // FILE: src/main.py
+    // ================================================
+    // [file content]
+
+    const lines = gitingestText.split('\n');
+    let summary = '';
+    let tree = '';
+    let content_preview = '';
+    let detectedLanguage = 'Unknown';
+    let detectedTechnologies = [];
+    let primaryPackageManager = 'Unknown';
+    
+    // Find sections
+    let summaryEnd = -1;
+    let treeStart = -1;
+    let treeEnd = -1;
+    let contentStart = -1;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.startsWith('Repository:') && summaryEnd === -1) {
+        // Find end of summary (first empty line after Repository line)
+        for (let j = i; j < lines.length; j++) {
+          if (lines[j].trim() === '' && j > i) {
+            summaryEnd = j;
+            break;
+          }
+        }
+      }
+      
+      if (line.startsWith('Directory structure:')) {
+        treeStart = i;
+      }
+      
+      if (line.includes('===') && line.includes('FILE:')) {
+        if (treeStart > -1 && treeEnd === -1) {
+          treeEnd = i;
+        }
+        if (contentStart === -1) {
+          contentStart = i;
+        }
+      }
+    }
+    
+    // Extract sections
+    if (summaryEnd > 0) {
+      summary = lines.slice(0, summaryEnd).join('\n');
+    } else {
+      // Fallback: take first 10 lines as summary
+      summary = lines.slice(0, 10).join('\n');
+    }
+    
+    if (treeStart > -1) {
+      const endIdx = treeEnd > -1 ? treeEnd : (contentStart > -1 ? contentStart : Math.min(treeStart + 50, lines.length));
+      tree = lines.slice(treeStart, endIdx).join('\n');
+    }
+    
+    if (contentStart > -1) {
+      // Take first 300 lines of content to provide good context without overwhelming
+      content_preview = lines.slice(contentStart, Math.min(contentStart + 300, lines.length)).join('\n');
+    }
+    
+    // Detect technologies from content
+    const contentLower = gitingestText.toLowerCase();
+    
+    // Language detection
+    if (contentLower.includes('import torch') || contentLower.includes('pytorch') || contentLower.includes('def ') || contentLower.includes('import ')) {
+      detectedLanguage = 'Python';
+      primaryPackageManager = 'pip';
+    } else if (contentLower.includes('package.json') || contentLower.includes('require(') || contentLower.includes('import ') || contentLower.includes('function ')) {
+      detectedLanguage = 'JavaScript';
+      primaryPackageManager = 'npm';
+    } else if (contentLower.includes('cargo.toml') || contentLower.includes('fn ') || contentLower.includes('use ')) {
+      detectedLanguage = 'Rust';
+      primaryPackageManager = 'cargo';
+    } else if (contentLower.includes('go.mod') || contentLower.includes('func ') || contentLower.includes('package ')) {
+      detectedLanguage = 'Go';
+      primaryPackageManager = 'go mod';
+    }
+    
+    // AI/ML Technology detection
+    if (contentLower.includes('torch') || contentLower.includes('pytorch')) {
+      detectedTechnologies.push('PyTorch');
+    }
+    if (contentLower.includes('tensorflow') || contentLower.includes('tf.')) {
+      detectedTechnologies.push('TensorFlow');
+    }
+    if (contentLower.includes('transformers') || contentLower.includes('huggingface')) {
+      detectedTechnologies.push('Hugging Face');
+    }
+    if (contentLower.includes('numpy') || contentLower.includes('np.')) {
+      detectedTechnologies.push('NumPy');
+    }
+    if (contentLower.includes('openai') && (contentLower.includes('import openai') || contentLower.includes('openai.')) && !contentLower.includes('# example') && !contentLower.includes('# TODO')) {
+      detectedTechnologies.push('OpenAI API');
+    }
+    if (contentLower.includes('anthropic') && contentLower.includes('import anthropic')) {
+      detectedTechnologies.push('Anthropic API');
+    }
+    
+    // Count files from summary
+    const filesMatch = summary.match(/Files analyzed: (\d+)/);
+    const fileCount = filesMatch ? parseInt(filesMatch[1]) : 0;
+
+    const structuredData = {
+      system_info: {
+        platform: process.platform,
+        python_version: process.version,
+        detected_language: detectedLanguage,
+        detected_technologies: detectedTechnologies,
+        file_count: fileCount,
+        repo_stars: 0, // Would need GitHub API
+        repo_forks: 0, // Would need GitHub API
+        primary_package_manager: primaryPackageManager,
+        complexity_level: fileCount > 50 ? 'high' : fileCount > 20 ? 'medium' : 'low'
+      },
+      repository_analysis: {
+        summary: summary || `Repository: ${owner}/${repo}\nAnalyzed with GitIngest`,
+        tree: tree || 'Directory structure not available',
+        content_preview: content_preview || 'Content preview not available'
+      },
+      success: true
+    };
+
+    console.log(chalk.gray('🔍 Analysis Summary:'));
+    console.log(chalk.gray(`  - Language: ${detectedLanguage}`));
+    console.log(chalk.gray(`  - Technologies: ${detectedTechnologies.join(', ') || 'None detected'}`));
+    console.log(chalk.gray(`  - Files: ${fileCount}`));
+    console.log(chalk.gray(`  - Package Manager: ${primaryPackageManager}`));
+
+    return structuredData;
+    
+  } catch (error) {
+    console.log(chalk.yellow(`⚠️ Failed to parse GitIngest output: ${error.message}`));
+    return null;
+  }
+}
+
+module.exports = {
+  fetchGitIngestData,
+  checkGitIngestCLI
+}; 

package/kill_claude/prompts/claude-code-tool-prompts.md

@@ -44,7 +44,8 @@ Before executing the command, please follow these steps:
      - cd /Users/name/My Documents (incorrect - will fail)
      - python "/path/with spaces/script.py" (correct)
      - python /path/with spaces/script.py (incorrect - will fail)
-   - After ensuring proper quoting, execute the command.
+   - **PLACEHOLDER HANDLING**: When executing commands that contain placeholder values (e.g., `<filename>`, `{variable}`, `[value]`), you MUST first use the Task tool with a general-purpose agent to read the relevant files and gather the necessary information to fill in the placeholder values before executing the command.
+   - After ensuring proper quoting and placeholder resolution, execute the command.
    - Capture the output of the command.
 
 Usage notes:

package/package.json

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

package/python/credentials_manager.py

@@ -113,176 +113,7 @@ class CredentialsManager:
         except Exception as e:
             print(f"❌ Error getting input: {e}")
             return None
-    
-    def get_openai_api_key(self):
-        """Get OpenAI API key with validation - for user's repository execution"""
-        def validate_openai_key(key):
-            # Basic validation - OpenAI keys usually start with "sk-" and are 51 chars
-            return key.startswith("sk-") and len(key) > 40
-        
-        # First check stored credentials (user's key)
-        credentials = self.load_credentials()
-        if "openai_api_key" in credentials:
-            stored_key = credentials["openai_api_key"]
-            if validate_openai_key(stored_key):
-                return stored_key
-        
-        # Then check environment variable
-        env_key = os.environ.get("OPENAI_API_KEY")
-        if env_key and validate_openai_key(env_key):
-            return env_key
-            
-        # For user's repository execution, prompt if no key found
-        prompt = "An OpenAI API key is needed to run this repository.\nYou can get your API key from: https://platform.openai.com/api-keys"
-        return self.get_credential("openai_api_key", prompt, is_password=True, validate_func=validate_openai_key)
-    
-    def get_gitarsenal_openai_api_key(self):
-        """Get GitArsenal's OpenAI API key for debugging - never prompts user"""
-        def validate_openai_key(key):
-            # Basic validation - OpenAI keys usually start with "sk-" and are 51 chars
-            return key.startswith("sk-") and len(key) > 40
-        
-        # First try to fetch from server using fetch_modal_tokens (GitArsenal's key)
-        try:
-            from fetch_modal_tokens import get_tokens
-            _, _, api_key, _, _ = get_tokens()
-            if api_key and validate_openai_key(api_key):
-                # Set in environment for future use
-                os.environ["OPENAI_API_KEY"] = api_key
-                return api_key
-        except ImportError:
-            pass
-        except Exception as e:
-            print(f"⚠️ Error fetching GitArsenal API key from server: {e}")
-        
-        # Then check environment variable (for development/testing)
-        env_key = os.environ.get("GITARSENAL_OPENAI_API_KEY")
-        if env_key and validate_openai_key(env_key):
-            return env_key
-            
-        # Check for GitArsenal's key in credentials (for development)
-        credentials = self.load_credentials()
-        if "gitarsenal_openai_api_key" in credentials:
-            stored_key = credentials["gitarsenal_openai_api_key"]
-            if validate_openai_key(stored_key):
-                return stored_key
-        
-        # If no GitArsenal key found, return None (don't prompt user)
-        print("⚠️ GitArsenal's OpenAI API key not available for debugging")
-        return None
-    
-    def get_modal_token(self):
-        """Get Modal token with basic validation"""
-        # First check if we have a built-in token from setup_modal_token.py
-        try:
-            from setup_modal_token import BUILT_IN_MODAL_TOKEN
-            return BUILT_IN_MODAL_TOKEN
-        except ImportError:
-            pass
-        
-        # Fall back to credentials file if needed
-        credentials = self.load_credentials()
-        if "modal_token" in credentials:
-            return credentials["modal_token"]
-            
-        # Return the built-in token as a last resort
-        return "mo-abcdef1234567890abcdef1234567890"  # Same as in setup_modal_token.py
-    
-    def get_huggingface_token(self):
-        """Get Hugging Face token with basic validation"""
-        def validate_hf_token(token):
-            # HF tokens are typically non-empty strings
-            return bool(token) and len(token) > 8
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "huggingface_token" in credentials:
-            stored_token = credentials["huggingface_token"]
-            if validate_hf_token(stored_token):
-                return stored_token
-            
-        prompt = "A Hugging Face token is required.\nYou can get your token from: https://huggingface.co/settings/tokens"
-        return self.get_credential("huggingface_token", prompt, is_password=True, validate_func=validate_hf_token)
-    
-    def get_wandb_api_key(self):
-        """Get Weights & Biases API key with validation"""
-        def validate_wandb_key(key):
-            # W&B API keys are typically 40 characters
-            return len(key) == 40
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "wandb_api_key" in credentials:
-            stored_key = credentials["wandb_api_key"]
-            if validate_wandb_key(stored_key):
-                return stored_key
-            
-        prompt = "A Weights & Biases API key is required.\nYou can get your API key from: https://wandb.ai/authorize"
-        return self.get_credential("wandb_api_key", prompt, is_password=True, validate_func=validate_wandb_key)
-    
-    def get_anthropic_api_key(self):
-        """Get Anthropic API key with validation"""
-        def validate_anthropic_key(key):
-            # Anthropic keys usually start with "sk-ant-" and are typically 48+ characters
-            return key.startswith("sk-ant-") and len(key) > 40
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "anthropic_api_key" in credentials:
-            stored_key = credentials["anthropic_api_key"]
-            if validate_anthropic_key(stored_key):
-                return stored_key
-        
-        # Then check environment variable
-        env_key = os.environ.get("ANTHROPIC_API_KEY")
-        if env_key and validate_anthropic_key(env_key):
-            return env_key
-            
-        prompt = "An Anthropic API key is required.\nYou can get your API key from: https://console.anthropic.com/"
-        return self.get_credential("anthropic_api_key", prompt, is_password=True, validate_func=validate_anthropic_key)
 
-    def get_groq_api_key(self):
-        """Get Groq API key with validation"""
-        def validate_groq_key(key):
-            # Groq keys are non-empty; basic length check
-            return bool(key) and len(key) > 20
-
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "groq_api_key" in credentials:
-            stored_key = credentials["groq_api_key"]
-            if validate_groq_key(stored_key):
-                return stored_key
-
-        # Then check environment variable
-        env_key = os.environ.get("GROQ_API_KEY")
-        if env_key and validate_groq_key(env_key):
-            return env_key
-
-        prompt = "A Groq API key is required for Groq models.\nYou can get your key from: https://console.groq.com/keys"
-        return self.get_credential("groq_api_key", prompt, is_password=True, validate_func=validate_groq_key)
-    
-    def get_exa_api_key(self):
-        """Get Exa API key with validation"""
-        def validate_exa_key(key):
-            # Exa API keys are typically 32+ characters
-            return len(key) >= 32
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "exa_api_key" in credentials:
-            stored_key = credentials["exa_api_key"]
-            if validate_exa_key(stored_key):
-                return stored_key
-        
-        # Then check environment variable
-        env_key = os.environ.get("EXA_API_KEY")
-        if env_key and validate_exa_key(env_key):
-            return env_key
-            
-        prompt = "An Exa API key is required for web search functionality.\nYou can get your API key from: https://exa.ai/"
-        return self.get_credential("exa_api_key", prompt, is_password=True, validate_func=validate_exa_key)
-    
     def clear_credential(self, key):
         """Remove a specific credential"""
         credentials = self.load_credentials()

package/python/gitarsenal_keys.py

@@ -16,6 +16,7 @@ def main():
     parser.add_argument('command', choices=['add', 'list', 'view', 'delete'], help='Command to execute')
     parser.add_argument('--service', help='Service name (openai_api_key, WANDB_API_KEY, HUGGINGFACE_TOKEN, modal_token)')
     parser.add_argument('--key', help='API key (for add command)')
+    parser.add_argument('--json', action='store_true', help='Output in JSON format (for list command)')
     
     args = parser.parse_args()
     
@@ -25,7 +26,7 @@ def main():
     if args.command == 'add':
         handle_add(credentials_manager, args)
     elif args.command == 'list':
-        handle_list(credentials_manager)
+        handle_list(credentials_manager, args)
     elif args.command == 'view':
         handle_view(credentials_manager, args)
     elif args.command == 'delete':
@@ -94,10 +95,15 @@ def handle_add(credentials_manager, args):
         print("❌ Failed to save API key")
         sys.exit(1)
 
-def handle_list(credentials_manager):
+def handle_list(credentials_manager, args=None):
     """Handle listing all stored API keys"""
     credentials = credentials_manager.load_credentials()
     
+    if args and args.json:
+        # Return JSON format for programmatic access
+        print(json.dumps(credentials))
+        return
+    
     if not credentials:
         print("📭 No API keys stored")
         return