gitarsenal-cli 1.9.76 → 1.9.78

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-17T05:50:53.850Z","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:
@@ -56,6 +57,15 @@ Usage notes:
   - VERY IMPORTANT: You MUST avoid using search commands like `find` and `grep`. Instead use Grep, Glob, or Task to search. You MUST avoid read tools like `cat`, `head`, `tail`, and `ls`, and use Read and LS to read files.
  - If you _still_ need to run `grep`, STOP. ALWAYS USE ripgrep at `rg` first, which all Claude Code users have pre-installed.
   - IMPORTANT: Always use `uv pip` instead of just `pip` when running pip commands. For example, use `uv pip install package_name` instead of `pip install package_name`.
+  - TESTING MODE: For ML training and inference commands, always use minimal/quick parameters to enable fast testing:
+    - FIRST: Read and examine the training script/config files to understand which parameters actually control training speed and duration
+    - Add `--max_steps 10` or `--epochs 1` for training commands
+    - Add `--batch_size 1` or `--batch_size 2` for memory efficiency
+    - Add `--eval_steps 5` for quick evaluation
+    - Use `--fast_dev_run` flag when available (PyTorch Lightning)
+    - Check for GPU availability with `nvidia-smi` or `python -c "import torch; print(torch.cuda.is_available())"` and adjust device settings accordingly
+    - Use `--device cuda` or `--gpu` flags when GPU is available, `--device cpu` when not
+    - Example: `python train.py --epochs 1 --batch_size 2 --max_steps 10 --device cuda`
   - When issuing multiple commands, use the ';' or '&&' operator to separate them. DO NOT use newlines (newlines are ok in quoted strings).
   - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of `cd`. You may use `cd` if the User explicitly requests it.