bit-cli-ai 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bit-cli-ai",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Git with a brain - intelligent Git wrapper with AI-powered commits, ghost branches, and predictive merge",
   "type": "module",
   "main": "src/index.js",

package/src/commands/branch.js

@@ -36,28 +36,50 @@ function createGhostBranch(name) {
   const spinner = ora(`Creating ghost branch: ${name}`).start();
   
   try {
-    const fullName = `${GHOST_PREFIX}${name}`;
+    // Get current state
+    const currentBranch = getCurrentBranch();
+    let currentCommit = '';
+    try {
+      currentCommit = execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+    } catch {
+      // If no commits yet, use empty string
+      currentCommit = '';
+    }
 
-    // Create the actual git branch
-    execSync(`git branch ${fullName}`, { stdio: 'pipe' });
-    
-    // Record in metadata
+    // Get staged and unstaged files
+    const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' })
+      .split('\n')
+      .filter(f => f.trim());
+    const unstaged = execSync('git diff --name-only', { encoding: 'utf-8' })
+      .split('\n')
+      .filter(f => f.trim());
+
+    // DO NOT create git branch - ghost branches are metadata only
+    // Record in metadata only
     const metadata = loadMetadata();
     metadata.ghostBranches = metadata.ghostBranches || [];
     
-    if (!metadata.ghostBranches.find(b => b.name === fullName)) {
+    if (!metadata.ghostBranches.find(b => b.name === name)) {
       metadata.ghostBranches.push({
-        name: fullName,
+        name: name,  // NO ghost/ prefix
+        baseCommit: currentCommit,
         createdFrom: currentBranch,
         createdAt: new Date().toISOString(),
-        isGhost: true
+        isGhost: true,
+        status: {
+          commit: currentCommit,
+          staged: staged,
+          unstaged: unstaged
+        }
       });
       saveMetadata(metadata);
     }
     
-    spinner.succeed(`Ghost branch created: ${chalk.magenta(fullName)}`);
-    console.log(chalk.gray(`  Created from: ${currentBranch}`));
-    console.log(chalk.gray(`  To checkout: bit checkout ${name} --ghost`));
+    spinner.succeed(`Ghost branch created: ${chalk.magenta(name)} 👻`);
+    console.log(chalk.gray(`  Based on: ${currentCommit.substring(0, 8)}...`));
+    console.log(chalk.gray(`  Created from: ${chalk.cyan(currentBranch)}`));
+    console.log(chalk.gray(`  To checkout: ${chalk.yellow('bit checkout --ghost ' + name)}`));
+    console.log(chalk.gray(`  Note: Ghost branches exist only in metadata, not as git branches`));
     
   } catch (error) {
     spinner.fail('Failed to create ghost branch');
@@ -68,24 +90,24 @@ function createGhostBranch(name) {
 // List all branches (including ghost)
 function listAllBranches(showOnlyGhost = false) {
   try {
-    // Get all git branches
-    const branches = execSync('git branch -a', { encoding: 'utf-8' })
-      .split('\n')
-      .map(b => b.trim())
-      .filter(b => b);
-    
     const currentBranch = getCurrentBranch();
     const metadata = loadMetadata();
     const ghostBranches = metadata.ghostBranches || [];
     
     console.log(chalk.cyan('\n--- Branches ---\n'));
     
-    // Regular branches
+    // Regular branches (from git)
     if (!showOnlyGhost) {
+      const branches = execSync('git branch', { encoding: 'utf-8' })
+        .split('\n')
+        .map(b => b.trim())
+        .filter(b => b && !b.includes('HEAD'));
+      
       console.log(chalk.yellow('Regular branches:'));
-      branches
-        .filter(b => !b.includes(GHOST_PREFIX) && !b.startsWith('remotes/'))
-        .forEach(branch => {
+      if (branches.length === 0) {
+        console.log(chalk.gray('  No branches yet'));
+      } else {
+        branches.forEach(branch => {
           const isCurrent = branch.startsWith('*');
           const name = branch.replace('* ', '');
           if (isCurrent) {
@@ -94,30 +116,23 @@ function listAllBranches(showOnlyGhost = false) {
             console.log(chalk.gray(`    ${name}`));
           }
         });
+      }
       console.log('');
     }
     
-    // Ghost branches
-    console.log(chalk.magenta('Ghost branches:'));
-    const gitGhostBranches = branches.filter(b => b.includes(GHOST_PREFIX));
+    // Ghost branches (from metadata only)
+    console.log(chalk.magenta('Ghost branches: 👻'));
     
-    if (gitGhostBranches.length === 0) {
+    if (ghostBranches.length === 0) {
       console.log(chalk.gray('  No ghost branches'));
+      console.log(chalk.gray(`  Create one with: ${chalk.yellow('bit branch --ghost <name>')}`));
     } else {
-      gitGhostBranches.forEach(branch => {
-        const isCurrent = branch.startsWith('*');
-        const name = branch.replace('* ', '').replace(GHOST_PREFIX, '');
-        const ghostMeta = ghostBranches.find(g => g.name.includes(name));
-        
-        if (isCurrent) {
-          console.log(chalk.green(`  * ${name}`));
-        } else {
-          console.log(chalk.magenta(`    ${name}`));
-        }
+      ghostBranches.forEach((g, i) => {
+        const age = Math.round((Date.now() - new Date(g.createdAt).getTime()) / 60000);
+        const ageText = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
         
-        if (ghostMeta) {
-          console.log(chalk.gray(`      Created from: ${ghostMeta.createdFrom}`));
-        }
+        console.log(chalk.magenta(`    ${g.name}`));
+        console.log(chalk.gray(`      ${chalk.dim('Based on:')} ${g.baseCommit ? g.baseCommit.substring(0, 8) : 'initial'} ${chalk.dim('•')} Created from: ${g.createdFrom} ${chalk.dim('•')} ${ageText}`));
       });
     }
     
@@ -134,17 +149,26 @@ function deleteGhostBranch(name) {
   const spinner = ora(`Deleting ghost branch: ${name}`).start();
   
   try {
-    const fullName = name.startsWith(GHOST_PREFIX) ? name : `${GHOST_PREFIX}${name}`;
-    
-    // Delete git branch
-    execSync(`git branch -D ${fullName}`, { stdio: 'pipe' });
+    // Find in metadata
+    const fullName = name.startsWith(GHOST_PREFIX) ? name.replace(GHOST_PREFIX, '') : name;
     
-    // Remove from metadata
+    // Remove from metadata only (no git branch to delete)
     const metadata = loadMetadata();
+    const ghostData = metadata.ghostBranches?.find(g => g.name === fullName);
+    
+    if (!ghostData) {
+      spinner.fail(`Ghost branch not found: ${fullName}`);
+      console.log(chalk.gray('\nAvailable ghost branches:'));
+      metadata.ghostBranches?.forEach(b => {
+        console.log(chalk.gray(`  ${b.name}`));
+      });
+      return;
+    }
+    
     metadata.ghostBranches = (metadata.ghostBranches || []).filter(b => b.name !== fullName);
     saveMetadata(metadata);
     
-    spinner.succeed(`Ghost branch deleted: ${chalk.magenta(fullName)}`);
+    spinner.succeed(`Ghost branch deleted: ${chalk.magenta(fullName)} 👻`);
     
   } catch (error) {
     spinner.fail('Failed to delete ghost branch');
@@ -174,17 +198,45 @@ export function checkoutGhost(branch, options) {
   
   try {
     let targetBranch = branch;
+    let isGhost = false;
+    let ghostData = null;
     
     if (options.ghost) {
-      // It's a ghost branch
-      targetBranch = branch.startsWith(GHOST_PREFIX) ? branch : `${GHOST_PREFIX}${branch}`;
+      // It's a ghost branch - find in metadata
+      const metadata = loadMetadata();
+      const ghostName = branch.startsWith(GHOST_PREFIX) ? branch.replace(GHOST_PREFIX, '') : branch;
+      ghostData = metadata.ghostBranches?.find(g => g.name === ghostName);
+      
+      if (!ghostData) {
+        spinner.fail(`Ghost branch not found: ${ghostName}`);
+        console.log(chalk.yellow('\nAvailable ghost branches:'));
+        metadata.ghostBranches?.forEach(b => {
+          console.log(chalk.gray(`  ${b.name}`));
+        });
+        return;
+      }
+      
+      targetBranch = ghostData.baseCommit || 'HEAD';
+      isGhost = true;
     }
     
-    execSync(`git checkout ${targetBranch}`, { stdio: 'pipe' });
-    spinner.succeed(`Switched to: ${chalk.cyan(targetBranch)}`);
-    
-    if (options.ghost) {
-      console.log(chalk.magenta('  (This is a ghost branch)'));
+    if (isGhost && ghostData) {
+      // Checkout in detached HEAD state
+      execSync(`git checkout ${targetBranch}`, { stdio: 'pipe' });
+      
+      const age = Math.round((Date.now() - new Date(ghostData.createdAt).getTime()) / 60000);
+      const ageText = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+      
+      spinner.succeed(`Switched to ghost workspace: ${chalk.cyan(ghostData.name)} 👻`);
+      console.log(chalk.magenta(`  🎭 Ghost Branch (Detached HEAD)`));
+      console.log(chalk.gray(`     Based on: ${targetBranch.substring(0, 8)}...`));
+      console.log(chalk.gray(`     Created from: ${chalk.cyan(ghostData.createdFrom)}`));
+      console.log(chalk.gray(`     Created: ${ageText}`));
+      console.log(chalk.yellow(`     Note: Changes won't be tracked to any branch until you create a real branch or commit them`));
+    } else {
+      // Regular branch checkout
+      execSync(`git checkout ${targetBranch}`, { stdio: 'pipe' });
+      spinner.succeed(`Switched to: ${chalk.cyan(targetBranch)}`);
     }
     
   } catch (error) {
@@ -195,7 +247,7 @@ export function checkoutGhost(branch, options) {
       console.log(chalk.yellow('\nAvailable ghost branches:'));
       const metadata = loadMetadata();
       (metadata.ghostBranches || []).forEach(b => {
-        console.log(chalk.gray(`  ${b.name.replace(GHOST_PREFIX, '')}`));
+        console.log(chalk.gray(`  ${b.name}`));
       });
     }
   }

package/src/commands/commit.js

@@ -4,172 +4,109 @@ import path from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 
-// Simple AI message generation (without external API)
+/* ------------------ FALLBACK (RULE-BASED) ------------------ */
 function generateSimpleMessage(diff) {
   const lines = diff.split('\n');
   const stats = {
     additions: 0,
     deletions: 0,
     files: new Set(),
-    types: new Set()
   };
 
   for (const line of lines) {
-    if (line.startsWith('+') && !line.startsWith('+++')) {
-      stats.additions++;
-    } else if (line.startsWith('-') && !line.startsWith('---')) {
-      stats.deletions++;
-    } else if (line.startsWith('diff --git')) {
+    if (line.startsWith('+') && !line.startsWith('+++')) stats.additions++;
+    else if (line.startsWith('-') && !line.startsWith('---')) stats.deletions++;
+    else if (line.startsWith('diff --git')) {
       const match = line.match(/b\/(.+)$/);
-      if (match) {
-        stats.files.add(match[1]);
-        const ext = path.extname(match[1]);
-        if (ext) stats.types.add(ext);
-      }
+      if (match) stats.files.add(match[1]);
     }
   }
 
-  // Detect change type
+  const files = Array.from(stats.files);
   let type = 'chore';
-  const fileList = Array.from(stats.files);
-  
-  if (fileList.some(f => f.includes('test') || f.includes('spec'))) {
-    type = 'test';
-  } else if (fileList.some(f => f.includes('README') || f.includes('docs'))) {
-    type = 'docs';
-  } else if (fileList.some(f => f.includes('fix') || diff.includes('fix'))) {
-    type = 'fix';
-  } else if (stats.additions > stats.deletions * 2) {
-    type = 'feat';
-  } else if (stats.deletions > stats.additions) {
-    type = 'refactor';
-  }
 
-  // Generate scope from files
-  let scope = '';
-  if (fileList.length === 1) {
-    scope = path.basename(fileList[0], path.extname(fileList[0]));
-  } else if (fileList.length > 1) {
-    const dirs = fileList.map(f => path.dirname(f)).filter(d => d !== '.');
-    if (dirs.length > 0) {
-      scope = dirs[0].split('/')[0];
-    }
-  }
+  if (files.some(f => f.includes('test'))) type = 'test';
+  else if (files.some(f => f.includes('README') || f.includes('docs'))) type = 'docs';
+  else if (stats.additions > stats.deletions * 2) type = 'feat';
+  else if (stats.deletions > stats.additions) type = 'refactor';
 
-  // Generate description
-  let description = '';
-  if (stats.additions > 0 && stats.deletions === 0) {
-    description = `add ${fileList.length} file${fileList.length > 1 ? 's' : ''}`;
-  } else if (stats.deletions > 0 && stats.additions === 0) {
-    description = `remove ${fileList.length} file${fileList.length > 1 ? 's' : ''}`;
-  } else {
-    description = `update ${fileList.length} file${fileList.length > 1 ? 's' : ''} (+${stats.additions}/-${stats.deletions})`;
-  }
+  const scope =
+    files.length === 1
+      ? path.basename(files[0], path.extname(files[0]))
+      : '';
+
+  const desc =
+    stats.additions && !stats.deletions
+      ? `add ${files.length} file(s)`
+      : `update ${files.length} file(s) (+${stats.additions}/-${stats.deletions})`;
 
-  // Format: type(scope): description
-  return scope ? `${type}(${scope}): ${description}` : `${type}: ${description}`;
+  return scope ? `${type}(${scope}): ${desc}` : `${type}: ${desc}`;
 }
 
-// AI-powered message generation using OpenAI
+/* ------------------ OPENAI GENERATION ------------------ */
 async function generateAIMessage(diff) {
   const apiKey = process.env.OPENAI_API_KEY;
-  
-  if (!apiKey) {
-    // Fall back to simple generation
-    return generateSimpleMessage(diff);
-  }
+  if (!apiKey) return generateSimpleMessage(diff);
 
   try {
     const OpenAI = (await import('openai')).default;
     const openai = new OpenAI({ apiKey });
 
-    const response = await openai.chat.completions.create({
+    const res = await openai.responses.create({
       model: 'gpt-4o-mini',
-      messages: [
-        {
-          role: 'system',
-          content: `You are a commit message generator. Generate a concise, meaningful commit message following Conventional Commits format.
-
-Format: type(scope): description
-
-Types: feat, fix, docs, style, refactor, test, chore
-- Keep description under 50 characters
-- Use imperative mood ("add" not "added")
-- No period at the end
-- Be specific about what changed
-
-Respond with ONLY the commit message, nothing else.`
-        },
-        {
-          role: 'user',
-          content: `Generate a commit message for this diff:\n\n${diff.slice(0, 4000)}`
-        }
-      ],
-      max_tokens: 100,
-      temperature: 0.3
+      input: `Generate a concise Conventional Commit message for this git diff. Respond ONLY with the commit message itself, no explanations.\n\n${diff.slice(0, 4000)}`,
+      temperature: 0.3,
     });
 
-    return response.choices[0].message.content.trim();
+    return res.output_text.trim();
   } catch (error) {
-    // Fall back to simple generation on error
+    console.log(chalk.red(`\n⚠️ AI Generation Failed: ${error.message}`));
+    if (error.status === 429) {
+      console.log(chalk.yellow('💡 Your OpenAI quota is insufficient. Please check your billing at:'));
+      console.log(chalk.yellow('   https://platform.openai.com/account/billing'));
+    } else if (error.status === 401) {
+      console.log(chalk.yellow('💡 Your API key is invalid. Please check your OPENAI_API_KEY environment variable.'));
+    }
+    console.log(chalk.gray('\nFalling back to rule-based generator...\n'));
     return generateSimpleMessage(diff);
   }
 }
 
-// Update symbol tracking after commit
+/* ------------------ SYMBOL TRACKING ------------------ */
 function updateSymbolTracking(diff) {
-  const symbolsPath = '.bit/symbols.json';
-  
-  if (!fs.existsSync(symbolsPath)) return;
+  const file = '.bit/symbols.json';
+  if (!fs.existsSync(file)) return;
 
   try {
-    const symbols = JSON.parse(fs.readFileSync(symbolsPath, 'utf-8'));
-    
-    // Extract function names from diff (simple regex)
-    const functionMatches = diff.match(/(?:function|const|let|var)\s+(\w+)/g) || [];
-    const classMatches = diff.match(/class\s+(\w+)/g) || [];
-
-    for (const match of functionMatches) {
-      const name = match.split(/\s+/)[1];
-      if (name) {
-        symbols.functions[name] = symbols.functions[name] || { changes: 0, lastModified: null };
-        symbols.functions[name].changes++;
-        symbols.functions[name].lastModified = new Date().toISOString();
-      }
-    }
+    const db = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    const matches = diff.match(/(?:function|class|const)\s+(\w+)/g) || [];
 
-    for (const match of classMatches) {
-      const name = match.split(/\s+/)[1];
-      if (name) {
-        symbols.classes[name] = symbols.classes[name] || { changes: 0, lastModified: null };
-        symbols.classes[name].changes++;
-        symbols.classes[name].lastModified = new Date().toISOString();
-      }
-    }
+    matches.forEach(m => {
+      const name = m.split(/\s+/)[1];
+      db[name] = (db[name] || 0) + 1;
+    });
 
-    symbols.lastAnalyzed = new Date().toISOString();
-    fs.writeFileSync(symbolsPath, JSON.stringify(symbols, null, 2));
+    fs.writeFileSync(file, JSON.stringify(db, null, 2));
   } catch (error) {
-    // Silently fail - don't interrupt commit
+    // Silent fail - file corruption not critical
   }
 }
 
-export async function aiCommit(options) {
+/* ------------------ MAIN COMMAND ------------------ */
+export async function aiCommit(options = {}) {
   const spinner = ora('Analyzing changes...').start();
 
   try {
-    // Check if there are staged changes
-    const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' }).trim();
-    
+    const staged = execSync('git diff --cached --name-only', {
+      encoding: 'utf-8',
+    }).trim();
+
     if (!staged) {
       spinner.fail('No staged changes');
-      console.log(chalk.yellow('\nStage your changes first:'));
-      console.log(chalk.gray('  git add <files>'));
-      console.log(chalk.gray('  git add .'));
+      console.log(chalk.yellow('Run: git add .'));
       return;
     }
 
-    // If manual message provided, use it
     if (options.message) {
       spinner.text = 'Committing...';
       execSync(`git commit -m "${options.message}"`, { stdio: 'inherit' });
@@ -177,35 +114,38 @@ export async function aiCommit(options) {
       return;
     }
 
-    // Get the diff
     const diff = execSync('git diff --cached', { encoding: 'utf-8' });
 
-    // Generate AI message
+    /* -------- AI STATUS (CORRECT PLACE) -------- */
+    spinner.stop();
+    if (process.env.OPENAI_API_KEY) {
+      console.log(chalk.green('🧠 AI ENABLED: OpenAI will generate commit message\n'));
+    } else {
+      console.log(chalk.blue('ℹ AI DISABLED: Using local rule-based generator'));
+      console.log(chalk.gray('  To enable AI commits:'));
+      console.log(chalk.gray('  setx OPENAI_API_KEY "your-api-key"'));
+      console.log(chalk.gray('  Restart terminal after setting the key.\n'));
+    }
+    spinner.start();
+    /* ------------------------------------------ */
+
     spinner.text = 'Generating commit message...';
     const message = await generateAIMessage(diff);
     spinner.succeed(`Generated: ${chalk.cyan(message)}`);
 
-    // Show preview and confirm
-    console.log('\n' + chalk.gray('─'.repeat(50)));
-    console.log(chalk.yellow('Staged files:'));
-    staged.split('\n').forEach(file => {
-      console.log(chalk.gray(`  ${file}`));
-    });
-    console.log(chalk.gray('─'.repeat(50)));
+    console.log('\n' + chalk.gray('Staged files:'));
+    staged.split('\n').forEach(f => console.log(chalk.gray(`  ${f}`)));
 
-    // Commit with generated message
     spinner.start('Committing...');
     execSync(`git commit -m "${message}"`, { stdio: 'pipe' });
-    
-    // Update symbol tracking
+
     updateSymbolTracking(diff);
-    
-    spinner.succeed(chalk.green('Committed successfully!'));
-    console.log(chalk.gray(`\n  ${message}\n`));
 
-  } catch (error) {
+    spinner.succeed(chalk.green('Committed successfully!'));
+    console.log(chalk.gray(`\n${message}\n`));
+  } catch (err) {
     spinner.fail('Commit failed');
-    console.error(chalk.red(error.message));
+    console.error(chalk.red(err.message));
     process.exit(1);
   }
 }

package/src/utils/ai.js

@@ -7,7 +7,7 @@ import OpenAI from 'openai';
 import { config } from './config.js';
 import { log } from './logger.js';
 import { APIKeyError, RateLimitError, AIError } from './errors.js';
-
+import chalk from 'chalk';
 /**
  * Get OpenAI client instance
  */
@@ -40,18 +40,20 @@ export async function generateCommitMessage(diff, options = {}) {
     log.ai('generate_commit', { model: aiConfig.model, diffLength: diff.length });
     
     const systemPrompt = getCommitSystemPrompt(style, maxLength);
+    console.log('🧠 OPENAI REQUEST SENT');
     
     const response = await client.chat.completions.create({
-      model: aiConfig.model,
-      messages: [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: truncateDiff(diff, 4000) },
-      ],
-      max_tokens: aiConfig.maxTokens,
-      temperature: aiConfig.temperature,
-    });
-    
-    const message = response.choices[0]?.message?.content?.trim();
+  model: aiConfig.model,
+  messages: [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: truncateDiff(diff, 4000) },
+  ],
+  max_tokens: aiConfig.maxTokens,
+  temperature: aiConfig.temperature,
+});
+console.log('🧠 OPENAI RESPONSE RECEIVED');
+const message = response.choices[0]?.message?.content?.trim() || '';
+
     
     log.ai('generate_commit_success', { message });
     
@@ -59,16 +61,20 @@ export async function generateCommitMessage(diff, options = {}) {
   } catch (error) {
     log.exception(error, { operation: 'generate_commit' });
     
-    if (error.status === 429) {
-      throw new RateLimitError();
-    }
+    console.log(chalk.red(`\n⚠️ AI Generation Failed: ${error.message}`));
     
-    if (error.status === 401) {
-      throw new APIKeyError('OpenAI');
+    if (error.status === 429) {
+      log.ai('fallback', { reason: 'insufficient_quota' });
+      console.log(chalk.yellow('💡 Your OpenAI quota is insufficient. Please check your billing at:'));
+      console.log(chalk.yellow('   https://platform.openai.com/account/billing'));
+    } else if (error.status === 401) {
+      log.ai('fallback', { reason: 'invalid_api_key' });
+      console.log(chalk.yellow('💡 Your API key is invalid. Please check your OPENAI_API_KEY environment variable.'));
+    } else {
+      log.ai('fallback', { reason: error.message });
+      console.log(chalk.gray('  Falling back to rule-based generator...\n'));
     }
     
-    // Fallback to rule-based on any error
-    log.ai('fallback', { reason: error.message });
     return generateRuleBasedMessage(diff);
   }
 }
@@ -84,26 +90,27 @@ export async function analyzeCodeChanges(diff, options = {}) {
   }
   
   try {
-    const response = await client.chat.completions.create({
-      model: config.get('ai.model'),
-      messages: [
-        {
-          role: 'system',
-          content: `Analyze the following git diff and provide:
+   const response = await client.chat.completions.create({
+  model: config.get('ai.model'),
+  messages: [
+    {
+      role: 'system',
+      content: `Analyze the following git diff and provide:
 1. A brief summary of changes (1-2 sentences)
 2. List of modified functions/methods
 3. Potential risks or areas needing review
 4. Suggested reviewers based on code areas
 
 Format as JSON with keys: summary, modifiedFunctions, risks, suggestedAreas`,
-        },
-        { role: 'user', content: truncateDiff(diff, 4000) },
-      ],
-      max_tokens: 1000,
-      temperature: 0.3,
-    });
-    
-    const content = response.choices[0]?.message?.content;
+    },
+    { role: 'user', content: truncateDiff(diff, 4000) },
+  ],
+  max_tokens: 1000,
+  temperature: 0.3,
+});
+
+const content = response.choices[0]?.message?.content || '';
+
     
     try {
       return JSON.parse(content);
@@ -112,6 +119,11 @@ Format as JSON with keys: summary, modifiedFunctions, risks, suggestedAreas`,
     }
   } catch (error) {
     log.exception(error, { operation: 'analyze_code' });
+    if (error.status === 429) {
+      console.log(chalk.yellow('⚠️ Code analysis skipped: Insufficient OpenAI quota'));
+    } else if (error.status === 401) {
+      console.log(chalk.yellow('⚠️ Code analysis skipped: Invalid API key'));
+    }
     return null;
   }
 }