ai-pr-review-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI PR Review CLI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+# 🤖 AI PR Review CLI
+
+An intelligent command-line tool that uses AI to review your code changes and provide instant feedback on pull requests, issues, typos, and improvements.
+
+## ✨ Features
+
+- 🔍 **Intelligent Code Analysis** - Uses GPT to analyze your code changes
+- 🎯 **Smart Branch Detection** - Automatically detects common base branches
+- 🎨 **Beautiful CLI Interface** - Clean, colorful output with emojis
+- ⚡ **Fast & Easy** - One command to get comprehensive feedback
+- 🔧 **Flexible Configuration** - Multiple ways to configure base branch and AI model
+- 📊 **Categorized Feedback** - Issues, typos, and improvements clearly separated
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Install globally for use anywhere
+npm install -g ai-pr-review-cli
+
+# Or use with npx (no installation needed)
+npx ai-pr-review-cli review
+```
+
+### Setup
+
+1. **Get an OpenAI API key** from [OpenAI](https://platform.openai.com/api-keys)
+
+2. **Set your API key**:
+```bash
+# Option 1: Environment variable (recommended)
+export OPENAI_API_KEY="your-api-key-here"
+
+# Option 2: Create .env file in your project
+echo "OPENAI_API_KEY=your-api-key-here" > .env
+```
+
+3. **Run a review**:
+```bash
+# In your git repository
+ai-pr-review review
+
+# Or use the short alias
+aipr review
+```
+
+## 📖 Usage
+
+### Basic Usage
+
+```bash
+# Review current branch against main
+ai-pr-review review
+
+# Review against specific branch
+ai-pr-review review --base origin/develop
+
+# Use different AI model
+ai-pr-review review --model gpt-4o
+
+# Show detailed output
+ai-pr-review review --verbose
+```
+
+### Command Options
+
+| Option | Short | Description | Example |
+|--------|-------|-------------|---------|
+| `--base <branch>` | `-b` | Base branch to compare against | `-b origin/main` |
+| `--model <model>` | `-m` | AI model to use | `-m gpt-4o` |
+| `--provider <provider>` | | AI provider (currently only openai) | `--provider openai` |
+| `--verbose` | `-v` | Show detailed output | `-v` |
+
+### Examples
+
+```bash
+# Review feature branch against main
+git checkout feature/new-feature
+ai-pr-review review --base main
+
+# Review with GPT-4 and verbose output  
+ai-pr-review review --model gpt-4o --verbose
+
+# Review staged changes only
+git add .
+ai-pr-review review
+
+# Review uncommitted changes
+ai-pr-review review  # Automatically includes working directory changes
+```
+
+## ⚙️ Configuration
+
+### Method 1: Command Line Arguments (Recommended)
+```bash
+ai-pr-review review --base origin/main --model gpt-4o-mini
+```
+
+### Method 2: Project Configuration File
+Create `.aiprconfig.json` in your project root:
+
+```json
+{
+  "provider": "openai",
+  "model": "gpt-4o-mini", 
+  "baseBranch": "origin/main"
+}
+```
+
+### Method 3: Auto-Detection
+The tool automatically detects common base branches in this order:
+1. `origin/main`
+2. `origin/master`
+3. `origin/develop`
+4. `main`
+5. `master` 
+6. `develop`
+7. `HEAD~1` (fallback)
+
+## 🎯 What Gets Reviewed
+
+The tool analyzes:
+- ✅ **Committed changes** between branches
+- ✅ **Staged changes** (files added with `git add`)
+- ✅ **Working directory changes** (uncommitted modifications)
+- ✅ **File contents** for context
+
+## 📊 Output Categories
+
+### 🚨 Issues
+- Critical bugs and logic errors
+- Security vulnerabilities  
+- Performance problems
+- Breaking changes
+
+### ✏️ Typos
+- Spelling mistakes in comments
+- Grammar errors in strings
+- Documentation typos
+
+### 💡 Improvements  
+- Code quality suggestions
+- Best practice recommendations
+- Performance optimizations
+- Refactoring opportunities
+
+## 🔧 Supported AI Models
+
+| Model | Speed | Quality | Cost |
+|-------|-------|---------|------|
+| `gpt-4o-mini` | ⚡⚡⚡ | ⭐⭐⭐ | 💰 |
+| `gpt-4o` | ⚡⚡ | ⭐⭐⭐⭐⭐ | 💰💰💰 |
+| `gpt-3.5-turbo` | ⚡⚡⚡ | ⭐⭐ | 💰 |
+
+## 🛠️ Troubleshooting
+
+### "No changes found to review"
+- Make sure you're on a feature branch (not main/master)
+- Check if you have uncommitted changes: `git status`
+- Try specifying a different base branch: `--base main`
+- Update remote branches: `git fetch origin`
+
+### "API key not found"
+```bash
+# Set your OpenAI API key
+export OPENAI_API_KEY="your-key-here"
+
+# Or create .env file
+echo "OPENAI_API_KEY=your-key-here" > .env
+```
+
+### "Branch not found"
+```bash
+# List all available branches
+git branch -a
+
+# Use a branch that exists
+ai-pr-review review --base origin/master
+```
+
+## 🔐 Security & Privacy
+
+- Your code is sent to OpenAI's API for analysis
+- API keys are read from environment variables or .env files
+- No code is stored permanently by the tool
+- Consider using this on non-sensitive codebases
+- Review OpenAI's [data usage policies](https://openai.com/policies/api-data-usage-policies)
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 💡 Tips
+
+- **Use on feature branches** for best results
+- **Commit changes first** for more accurate reviews  
+- **Use `--verbose`** to see what's being analyzed
+- **Try different models** for varying levels of detail
+- **Set up aliases** in your shell for quick access:
+  ```bash
+  alias review="ai-pr-review review"
+  alias aipr="ai-pr-review review"
+  ```
+
+---
+
+Made with ❤️ for developers who want better code reviews!

package/bin/cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+const { Command } = require("commander");
+const review = require("../src/reviewer");
+const { createGlobalConfig } = require("../src/config");
+
+const program = new Command();
+
+program
+  .name("ai-pr-review")
+  .description("🤖 AI-powered Pull Request reviewer")
+  .version("1.0.0");
+
+program
+  .command("review")
+  .description("🔍 Review current branch changes with AI")
+  .option("-b, --base <branch>", "Base branch to compare against (e.g., main, origin/main, develop)")
+  .option("-m, --model <model>", "AI model to use (default: gpt-4o-mini)")
+  .option("--provider <provider>", "AI provider (default: openai)")
+  .option("-v, --verbose", "Show detailed output")
+  .action(async (options) => {
+    // Show a nice header
+    const { default: chalk } = await import("chalk");
+    console.log(chalk.blue.bold("\n🤖 AI PR Review"));
+    console.log(chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+    
+    await review(options);
+  });
+
+program
+  .command("config")
+  .description("⚙️  Set up global configuration")
+  .option("-m, --model <model>", "Default AI model to use")
+  .option("-b, --base <branch>", "Default base branch")
+  .option("--provider <provider>", "Default AI provider")
+  .action(async (options) => {
+    const { default: chalk } = await import("chalk");
+    
+    if (Object.keys(options).length === 0) {
+      console.log(chalk.yellow("Please specify configuration options:"));
+      console.log(chalk.gray("  ai-pr-review config --model gpt-4o-mini --base main"));
+      console.log(chalk.gray("  ai-pr-review config --provider openai"));
+      return;
+    }
+
+    try {
+      const configPath = createGlobalConfig(options);
+      console.log(chalk.green("✅ Global configuration saved!"));
+      console.log(chalk.gray(`   Config file: ${configPath}`));
+      
+      if (options.model) console.log(chalk.blue(`   Default model: ${options.model}`));
+      if (options.provider) console.log(chalk.blue(`   Default provider: ${options.provider}`));
+      if (options.base) console.log(chalk.blue(`   Default base branch: ${options.base}`));
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to save configuration: ${error.message}`));
+    }
+  });
+
+// Also support direct usage without subcommand
+program
+  .option("-b, --base <branch>", "Base branch to compare against")
+  .option("-m, --model <model>", "AI model to use")
+  .option("--provider <provider>", "AI provider")  
+  .option("-v, --verbose", "Show detailed output")
+  .action(async (options) => {
+    // If no specific command was run, default to review
+    if (process.argv.length > 2 && !process.argv.includes('review')) {
+      const { default: chalk } = await import("chalk");
+      console.log(chalk.blue.bold("\n🤖 AI PR Review"));
+      console.log(chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
+      await review(options);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "ai-pr-review-cli",
+  "version": "1.0.0",
+  "description": "🤖 AI-powered Pull Request reviewer - Get instant feedback on your code changes using GPT",
+  "main": "src/reviewer.js",
+  "bin": {
+    "ai-pr-review": "./bin/cli.js",
+    "aipr": "./bin/cli.js"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "start": "node bin/cli.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "echo 'Ready to publish!'"
+  },
+  "keywords": [
+    "ai",
+    "artificial-intelligence", 
+    "pr-review",
+    "pull-request",
+    "code-review",
+    "cli",
+    "git",
+    "github",
+    "openai",
+    "gpt",
+    "developer-tools",
+    "automation"
+  ],
+  "author": {
+    "name": "Deepanshu Chauhan",
+    "email": "chauhandeepanshu336@gmail.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/ai-pr-review-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/ai-pr-review-cli/issues"
+  },
+  "homepage": "https://github.com/yourusername/ai-pr-review-cli#readme",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "preferGlobal": true,
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "dotenv": "^17.3.1",
+    "ora": "^6.3.1",
+    "simple-git": "^3.19.1"
+  },
+  "devDependencies": {},
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/blockDeepanshu"
+  }
+}

package/src/ai.js

@@ -0,0 +1,25 @@
+const axios = require("axios");
+require("dotenv").config();
+async function openai(prompt, model) {
+  const res = await axios.post(
+    "https://api.openai.com/v1/chat/completions",
+    {
+      model,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.2,
+    },
+    {
+      headers: {
+        Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+      },
+    },
+  );
+
+  return res.data.choices[0].message.content;
+}
+
+async function runAI(prompt, config) {
+  return openai(prompt, config.model);
+}
+
+module.exports = { runAI };

package/src/config.js

@@ -0,0 +1,52 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function getConfig() {
+  // Default configuration
+  const defaultConfig = {
+    provider: "openai",
+    model: "gpt-4o-mini",
+    baseBranch: null, // Will be auto-detected
+  };
+
+  // Try to load global config from user's home directory
+  const globalConfigPath = path.join(os.homedir(), ".aiprconfig.json");
+  let config = { ...defaultConfig };
+
+  if (fs.existsSync(globalConfigPath)) {
+    try {
+      const globalConfig = JSON.parse(fs.readFileSync(globalConfigPath, "utf-8"));
+      config = { ...config, ...globalConfig };
+    } catch (error) {
+      console.warn("Warning: Could not parse global config file:", globalConfigPath);
+    }
+  }
+
+  // Try to load local project config (overrides global)
+  const localConfigPath = path.join(process.cwd(), ".aiprconfig.json");
+  if (fs.existsSync(localConfigPath)) {
+    try {
+      const localConfig = JSON.parse(fs.readFileSync(localConfigPath, "utf-8"));
+      config = { ...config, ...localConfig };
+    } catch (error) {
+      console.warn("Warning: Could not parse local config file:", localConfigPath);
+    }
+  }
+
+  return config;
+}
+
+function createGlobalConfig(options) {
+  const globalConfigPath = path.join(os.homedir(), ".aiprconfig.json");
+  const config = {
+    provider: options.provider || "openai",
+    model: options.model || "gpt-4o-mini",
+    ...(options.baseBranch && { baseBranch: options.baseBranch })
+  };
+  
+  fs.writeFileSync(globalConfigPath, JSON.stringify(config, null, 2));
+  return globalConfigPath;
+}
+
+module.exports = { getConfig, createGlobalConfig };

package/src/git.js

@@ -0,0 +1,148 @@
+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');
+    
+    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) {
+  return files
+    .filter((f) => fs.existsSync(f))
+    .map((file) => ({
+      name: file,
+      content: fs.readFileSync(file, "utf-8").slice(0, 5000),
+    }));
+}
+
+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,151 @@
+const { getDiff, getChangedFiles, readFiles, getCurrentBranch, checkBranchExists, detectBaseBranch } = require("./git");
+const { buildPrompt } = require("./prompt");
+const { runAI } = require("./ai");
+const { getConfig } = require("./config");
+
+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);
+    const files = readFiles(changedFiles);
+    
+    if (files.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;
+    }
+
+    console.log(chalk.green(`📁 Found ${changedFiles.length} changed file${changedFiles.length === 1 ? '' : 's'}: ${chalk.bold(changedFiles.join(', '))}`));
+
+    const prompt = buildPrompt(diff, files);
+    const result = await runAI(prompt, config);
+
+    spinner.succeed(chalk.green('Review completed!'));
+    
+    let parsed;
+    try {
+      parsed = JSON.parse(result);
+    } catch (jsonError) {
+      // Try multiple strategies to extract JSON
+      let jsonText = null;
+      
+      // Strategy 1: Find JSON object with proper structure
+      const jsonMatch = result.match(/\{[\s\S]*?"issues"[\s\S]*?"typos"[\s\S]*?"improvements"[\s\S]*?\}/);
+      if (jsonMatch) {
+        jsonText = jsonMatch[0];
+      } else {
+        // Strategy 2: Find any JSON object
+        const anyJsonMatch = result.match(/\{[\s\S]*?\}/);
+        if (anyJsonMatch) {
+          jsonText = anyJsonMatch[0];
+        }
+      }
+      
+      if (jsonText) {
+        try {
+          parsed = JSON.parse(jsonText);
+          // Ensure required structure
+          if (!parsed.issues) parsed.issues = [];
+          if (!parsed.typos) parsed.typos = [];
+          if (!parsed.improvements) parsed.improvements = [];
+        } catch (extractError) {
+          // Create fallback response
+          parsed = {
+            issues: [`JSON parsing failed. Raw AI response: ${result.substring(0, 200)}...`],
+            typos: [],
+            improvements: []
+          };
+        }
+      } else {
+        // No JSON found at all - create fallback response
+        parsed = {
+          issues: [`AI response format error. Response: ${result.substring(0, 200)}...`],
+          typos: [],
+          improvements: []
+        };
+      }
+    }
+
+    // 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;