@blockdeepanshu/ai-pr-review-cli 1.2.0

package/src/git.js

@@ -0,0 +1,190 @@
+const simpleGit = require("simple-git");
+const fs = require("fs");
+
+const git = simpleGit();
+
+async function getCurrentBranch() {
+  try {
+    const status = await git.status();
+    return status.current;
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
+async function checkBranchExists(branchName) {
+  try {
+    await git.raw(['rev-parse', '--verify', branchName]);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+async function detectBaseBranch() {
+  // List of common base branch names in order of preference
+  const commonBranches = [
+    'origin/main',
+    'origin/master', 
+    'origin/develop',
+    'main',
+    'master',
+    'develop'
+  ];
+
+  for (const branch of commonBranches) {
+    if (await checkBranchExists(branch)) {
+      return branch;
+    }
+  }
+
+  // Fallback to HEAD~1 if no common branch found
+  return 'HEAD~1';
+}
+
+async function getAllBranches() {
+  try {
+    const result = await git.branch(['-a']);
+    return result.all;
+  } catch (error) {
+    return [];
+  }
+}
+
+async function getDiff(baseBranch) {
+  try {
+    // First try the original approach
+    const committedDiff = await git.diff([`${baseBranch}...HEAD`]);
+    
+    // Also check for working directory changes
+    const workingDiff = await git.diff();
+    const stagedDiff = await git.diff(['--cached']);
+    
+    // Combine all diffs
+    const totalDiff = [committedDiff, workingDiff, stagedDiff].filter(d => d.length > 0).join('\n\n--- NEXT DIFF SECTION ---\n\n');
+    
+    // Limit diff size to prevent rate limit issues
+    const maxDiffLength = 10000;
+    if (totalDiff.length > maxDiffLength) {
+      console.warn(`⚠️  Large diff detected (${totalDiff.length} chars). Truncating to ${maxDiffLength} chars to avoid rate limits.`);
+      return totalDiff.slice(0, maxDiffLength) + '\n\n[... diff truncated to avoid rate limits ...]';
+    }
+    
+    return totalDiff;
+  } catch (error) {
+    // Silently try alternative approaches
+    
+    try {
+      // Try diffing against the previous commit
+      return await git.diff(['HEAD~1']);
+    } catch (error2) {
+      try {
+        // Fallback: show changes in working directory and staged changes
+        const workingDiff = await git.diff();
+        const stagedDiff = await git.diff(['--cached']);
+        return workingDiff + '\n' + stagedDiff;
+      } catch (error3) {
+        return '';
+      }
+    }
+  }
+}
+
+async function getChangedFiles(baseBranch) {
+  try {
+    // Get committed changes
+    const committedSummary = await git.diffSummary([`${baseBranch}...HEAD`]);
+    const committedFiles = committedSummary.files.map((f) => f.file);
+    
+    // Also check for working directory changes
+    const workingSummary = await git.diffSummary();
+    const workingFiles = workingSummary.files.map((f) => f.file);
+    
+    // Also check for staged changes
+    const stagedSummary = await git.diffSummary(['--cached']);
+    const stagedFiles = stagedSummary.files.map((f) => f.file);
+    
+    // Combine all changed files (remove duplicates)
+    const allFiles = [...new Set([...committedFiles, ...workingFiles, ...stagedFiles])];
+    
+    return allFiles;
+  } catch (error) {
+    // Try alternatives silently
+    
+    try {
+      // Try diffing against the previous commit
+      const summary = await git.diffSummary(['HEAD~1']);
+      return summary.files.map((f) => f.file);
+    } catch (error2) {
+      try {
+        // Fallback: show changes in working directory
+        const summary = await git.diffSummary();
+        return summary.files.map((f) => f.file);
+      } catch (error3) {
+        // Return all JavaScript/TypeScript files in src directory
+        const files = [];
+        if (fs.existsSync('src')) {
+          const srcFiles = fs.readdirSync('src', { recursive: true });
+          files.push(...srcFiles
+            .filter(f => typeof f === 'string' && (f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.jsx') || f.endsWith('.tsx')))
+            .map(f => `src/${f}`)
+          );
+        }
+        // Also check root directory for common files
+        const rootFiles = ['package.json', 'README.md', 'index.js', 'app.js', 'server.js'];
+        rootFiles.forEach(file => {
+          if (fs.existsSync(file)) {
+            files.push(file);
+          }
+        });
+        return files;
+      }
+    }
+  }
+}
+
+function readFiles(files, batchSize = 5) {
+  // Don't limit files here - let the caller handle batching
+  // This function should read ALL requested files
+  
+  return files
+    .filter((f) => fs.existsSync(f))
+    .filter((f) => {
+      // Skip large generated files common in frontend projects
+      const skipPatterns = [
+        /node_modules/,
+        /\.git/,
+        /dist\//,
+        /build\//,
+        /public\/.*\.(js|css)$/,  // Built assets
+        /\.min\.(js|css)$/,       // Minified files
+        /bundle.*\.js$/,          // Webpack bundles
+        /chunk.*\.js$/,           // Code-split chunks
+        /vendor.*\.js$/,          // Vendor bundles
+        /\.map$/,                 // Source maps
+        /coverage\//,             // Test coverage
+        /\.lock$/,                // Lock files
+        /\.log$/                  // Log files
+      ];
+      
+      return !skipPatterns.some(pattern => pattern.test(f));
+    })
+    .map((file) => {
+      let content = fs.readFileSync(file, "utf-8");
+      
+      // Special handling for package-lock.json (huge files)
+      if (file.includes('package-lock.json')) {
+        const lines = content.split('\n');
+        if (lines.length > 50) {
+          content = lines.slice(0, 30).join('\n') + '\n... [truncated large package-lock.json]';
+        }
+      }
+      
+      return {
+        name: file,
+        content: content.slice(0, 3000),
+      };
+    });
+}
+
+module.exports = { getDiff, getChangedFiles, readFiles, getCurrentBranch, checkBranchExists, detectBaseBranch, getAllBranches };

package/src/prompt.js

@@ -0,0 +1,22 @@
+function buildPrompt(diff, files) {
+  return `You are a strict code reviewer. Find ALL problems in these code changes. Check for:
+
+ISSUES: Syntax errors, logic bugs, invalid JSON/config, security flaws, broken imports, undefined variables, type errors
+TYPOS: Spelling/grammar mistakes in comments, strings, documentation  
+IMPROVEMENTS: Code quality, performance, best practices, refactoring opportunities
+
+DIFF:
+${diff}
+
+FILES:
+${files.map((f) => `${f.name}:\n${f.content}`).join("\n\n")}
+
+Be thorough and critical. Return ONLY this JSON (no other text):
+{
+  "issues": ["list specific problems found"],
+  "typos": ["list spelling/grammar errors"], 
+  "improvements": ["list enhancement suggestions"]
+}`;
+}
+
+module.exports = { buildPrompt };

package/src/reviewer.js

@@ -0,0 +1,207 @@
+const { getDiff, getChangedFiles, readFiles, getCurrentBranch, checkBranchExists, detectBaseBranch } = require("./git");
+const { buildPrompt } = require("./prompt");
+const { runAI } = require("./ai");
+const { getConfig } = require("./config");
+
+async function reviewFileBatch(files, diff, config, batchIndex, totalBatches, options) {
+  const { default: chalk } = await import("chalk");
+  
+  console.log(chalk.gray(`\n--- Batch ${batchIndex + 1}/${totalBatches} ---`));
+  console.log(chalk.gray(`Files: ${files.map(f => f.name).join(', ')}`));
+  
+  if (options.verbose) {
+    console.log(chalk.gray('\n🔍 Debug - Files with content:'));
+    files.forEach((f, i) => {
+      console.log(chalk.gray(`  ${i + 1}. ${f.name} (${f.content.length} chars): "${f.content.substring(0, 50)}..."`));
+    });
+  }
+  
+  const prompt = buildPrompt(diff, files);
+  
+  if (options.verbose) {
+    console.log(chalk.gray(`\n📝 Debug - Prompt length: ${prompt.length} characters`));
+  }
+  
+  try {
+    const result = await runAI(prompt, config);
+    
+    let parsed;
+    try {
+      parsed = JSON.parse(result);
+    } catch (jsonError) {
+      // Try to extract JSON from response
+      const jsonMatch = result.match(/\{[\s\S]*?"issues"[\s\S]*?"typos"[\s\S]*?"improvements"[\s\S]*?\}/);
+      if (jsonMatch) {
+        try {
+          parsed = JSON.parse(jsonMatch[0]);
+        } catch (extractError) {
+          parsed = {
+            issues: [`Batch ${batchIndex + 1}: JSON parsing failed. Response: ${result.substring(0, 200)}...`],
+            typos: [], improvements: []
+          };
+        }
+      } else {
+        parsed = {
+          issues: [`Batch ${batchIndex + 1}: AI response format error. Response: ${result.substring(0, 200)}...`],
+          typos: [], improvements: []
+        };
+      }
+    }
+    
+    // Ensure structure
+    if (!parsed.issues) parsed.issues = [];
+    if (!parsed.typos) parsed.typos = [];
+    if (!parsed.improvements) parsed.improvements = [];
+    
+    console.log(chalk.green(`✅ Batch ${batchIndex + 1} completed: ${parsed.issues.length} issues, ${parsed.typos.length} typos, ${parsed.improvements.length} improvements`));
+    
+    return parsed;
+  } catch (error) {
+    console.log(chalk.red(`❌ Batch ${batchIndex + 1} failed: ${error.message}`));
+    return { issues: [`Batch ${batchIndex + 1} failed: ${error.message}`], typos: [], improvements: [] };
+  }
+}
+
+async function review(options = {}) {
+  const { default: ora } = await import("ora");
+  const { default: chalk } = await import("chalk");
+  
+  const spinner = ora("🤖 AI is analyzing your code changes...").start();
+
+  try {
+    // Merge config with CLI options
+    const baseConfig = getConfig();
+    const config = {
+      ...baseConfig,
+      ...(options.provider && { provider: options.provider }),
+      ...(options.model && { model: options.model })
+    };
+
+    // Determine base branch: CLI option > config file > auto-detection
+    let baseBranch = options.base || config.baseBranch;
+    
+    if (!baseBranch) {
+      if (options.verbose) console.log(chalk.gray("🔍 Auto-detecting base branch..."));
+      baseBranch = await detectBaseBranch();
+    }
+
+    // Get current git status  
+    const currentBranch = await getCurrentBranch();
+    const baseBranchExists = await checkBranchExists(baseBranch);
+
+    console.log(chalk.blue(`\n📊 Analyzing changes on branch: ${chalk.bold(currentBranch)}`));
+    if (options.verbose || !baseBranchExists) {
+      console.log(chalk.gray(`   Comparing against: ${baseBranch} ${baseBranchExists ? '✓' : '❌'}`));
+    }
+
+    const diff = await getDiff(baseBranch);
+    const changedFiles = await getChangedFiles(baseBranch);
+    
+    console.log(chalk.green(`📁 Found ${changedFiles.length} changed file${changedFiles.length === 1 ? '' : 's'}: ${chalk.bold(changedFiles.join(', '))}`));
+    
+    if (changedFiles.length === 0 && diff.length === 0) {
+      spinner.info(chalk.yellow('No changes found to review'));
+      console.log(chalk.yellow('\n💡 Possible reasons:'));
+      if (currentBranch === baseBranch.replace('origin/', '')) {
+        console.log(chalk.gray('  • You are currently on the base branch. Create a feature branch first.'));
+      }
+      if (!baseBranchExists) {
+        console.log(chalk.gray('  • The base branch does not exist. Try "main", "master", or "origin/master".'));
+      }
+      console.log(chalk.gray('  • No commits made yet on this branch.'));
+      console.log(chalk.gray('  • Try: git fetch origin (to update remote branches)'));
+      console.log(chalk.gray('  • Try: git status (to see uncommitted changes)'));
+      return;
+    }
+    
+    // Process files in batches to avoid rate limits
+    const BATCH_SIZE = 5;
+    const fileBatches = [];
+    
+    // Split files into batches and read their content
+    for (let i = 0; i < changedFiles.length; i += BATCH_SIZE) {
+      const batchFileNames = changedFiles.slice(i, i + BATCH_SIZE);
+      const batchFiles = readFiles(batchFileNames);
+      if (batchFiles.length > 0) {
+        fileBatches.push(batchFiles);
+      }
+    }
+    
+    if (fileBatches.length === 0) {
+      spinner.info(chalk.yellow('No valid files to review'));
+      return;
+    }
+    
+    console.log(chalk.blue(`\n🔄 Processing ${fileBatches.length} batch${fileBatches.length === 1 ? '' : 'es'} of files (${BATCH_SIZE} files per batch)...`));
+    
+    // Process each batch
+    const allResults = { issues: [], typos: [], improvements: [] };
+    
+    for (let batchIndex = 0; batchIndex < fileBatches.length; batchIndex++) {
+      const files = fileBatches[batchIndex];
+      
+      spinner.text = `🤖 AI is analyzing batch ${batchIndex + 1}/${fileBatches.length}...`;
+      
+      const batchResult = await reviewFileBatch(files, diff, config, batchIndex, fileBatches.length, options);
+      
+      // Combine results
+      allResults.issues.push(...batchResult.issues);
+      allResults.typos.push(...batchResult.typos);
+      allResults.improvements.push(...batchResult.improvements);
+      
+      // Wait between batches (except for last batch)
+      if (batchIndex < fileBatches.length - 1) {
+        console.log(chalk.gray('⏳ Waiting 3 seconds before next batch...'));
+        await new Promise(resolve => setTimeout(resolve, 3000));
+      }
+    }
+    
+    const parsed = allResults;
+    
+
+    console.log(chalk.green(`📁 Found ${changedFiles.length} changed file${changedFiles.length === 1 ? '' : 's'}: ${chalk.bold(changedFiles.join(', '))}`));
+
+    spinner.succeed(chalk.green('Review completed!'));
+
+    // Display results with better formatting
+    console.log(chalk.red.bold("\n🚨 Issues"));
+    if (parsed.issues.length === 0) {
+      console.log(chalk.gray("  No critical issues found"));
+    } else {
+      parsed.issues.forEach((i, index) => 
+        console.log(chalk.red(`  ${index + 1}. ${i}`))
+      );
+    }
+
+    console.log(chalk.yellow.bold("\n✏️  Typos"));
+    if (parsed.typos.length === 0) {
+      console.log(chalk.gray("  No typos found"));
+    } else {
+      parsed.typos.forEach((t, index) => 
+        console.log(chalk.yellow(`  ${index + 1}. ${t}`))
+      );
+    }
+
+    console.log(chalk.cyan.bold("\n💡 Improvements"));
+    if (parsed.improvements.length === 0) {
+      console.log(chalk.gray("  No improvement suggestions"));
+    } else {
+      parsed.improvements.forEach((i, index) => 
+        console.log(chalk.cyan(`  ${index + 1}. ${i}`))
+      );
+    }
+
+    // Summary
+    const totalCount = parsed.issues.length + parsed.typos.length + parsed.improvements.length;
+    if (totalCount === 0) {
+      console.log(chalk.green.bold("\n✨ Great job! Your code looks clean and well-written."));
+    } else {
+      console.log(chalk.blue(`\n📋 Review Summary: ${parsed.issues.length} issues, ${parsed.typos.length} typos, ${parsed.improvements.length} improvements`));
+    }
+  } catch (e) {
+    spinner.fail(chalk.red("Review failed"));
+    console.error(chalk.red(`❌ Error: ${e.message}`));
+  }
+}
+
+module.exports = review;