codex-review-mcp 2.10.4 → 2.10.6

package/dist/mcp-server.js

@@ -30,78 +30,57 @@ server.registerTool('perform_code_review', {
     title: 'Perform Code Review',
     description: `Review code/diffs using GPT-5 Codex with expert prompts and project-specific context.
 
-🎯 RECOMMENDED USAGE (Agent-to-Agent):
+🚀 ZERO-CONFIG MODE - Just Call It!
 
-Pass the branch name and let us handle the diff collection:
+// Review current branch in current workspace
+await perform_code_review({});
 
-await perform_code_review({
-  branchName: "feature/new-auth",       // ⭐ RECOMMENDED: We collect the diff
-  workspaceDir: workspaceDir,           // ⭐ REQUIRED: Where the repo is
-  baseBranch: "main",                   // Optional: defaults to main/master
-  focus: "security and performance"     // Optional: specific areas
-});
-
-🔄 WHY USE BRANCH-BASED REVIEW?
-  ✅ Faster: No need to run git diff yourself
-  ✅ Simpler: Just pass branch name + workspace directory
-  ✅ Smart: Automatically handles both committed AND uncommitted changes
-  ✅ Reliable: We handle git operations correctly
-  ✅ Focused: Reviews only the actual code changes, not docs
-
-📋 ALTERNATIVE: CONTENT-BASED (Legacy)
+// Review with focus
+await perform_code_review({ focus: "security" });
 
-If you already have the diff, you can still pass it directly:
-
-await perform_code_review({
-  content: diff,                        // Your pre-collected diff
-  workspaceDir: workspaceDir,           // For context gathering
-  contentType: "diff"                   // "diff" or "code"
-});
+// Review specific branch
+await perform_code_review({ branchName: "feature/other-branch" });
 
-💡 KEY FEATURES:
-  - Smart Detection: Automatically reviews committed OR uncommitted changes
-  - Code-First: Reviews what code ACTUALLY does, not what docs say
-  - Codebase-Aware: Auto-finds .cursor/rules, tsconfig, eslint config
-  - Expert Prompts: GPT-5 Codex with project-specific context
-  - Smart Validation: Every finding includes file, line, and code quote
+✨ We Auto-Detect Everything:
+  ✅ Current workspace (from WORKSPACE_ROOT env)
+  ✅ Current branch (from git)
+  ✅ Base branch (main/master/develop)
+  ✅ All changes (committed + uncommitted)
+  ✅ Project context (.cursor/rules, configs)
 
-📝 HOW IT HANDLES CHANGES:
-  1. First tries: Committed changes between branches
-  2. If none found and you're ON that branch: Reviews uncommitted changes
-  3. Works in ANY state: coding, staged, committed, or mixed!
+💡 OPTIONAL - Only When You Need Them:
+  • focus: "security", "performance", "React patterns"
+  • branchName: Review different branch
+  • workspaceDir: Review different repo
+  • force: Bypass chunking for large diffs (>2000 lines)
 
-⚠️  IMPORTANT:
-  - Provide EITHER content OR branchName (not both)
-  - workspaceDir is REQUIRED when using branchName
-  - Reviews focus on actual code behavior over documentation
+🔍 WHAT YOU GET:
+Markdown report with:
+  • Quick summary + severity table
+  • Specific file:line references with code quotes
+  • Inline diff suggestions for fixes
+  • Clarifying questions (if context needed)
+  • Positive notes on good patterns
 
-📋 ALL PARAMETERS:
-  - branchName: Branch to review (RECOMMENDED - we handle git diff)
-  - baseBranch: Compare against this (default: main/master)
-  - content: Pre-collected diff/code (alternative to branchName)
-  - contentType: "diff" or "code" (when using content)
-  - workspaceDir: Repository root (REQUIRED for branchName, recommended always)
-  - focus: Specific review focus (e.g., "security", "performance")
-  - customContext: Override auto-gathered context
-  - skipContextGathering: Skip context gathering (not recommended)
-  - force: Force review of large diffs (>2000 lines)
-  - maxTokens: Limit review length`,
+📋 ADVANCED OPTIONS (Rarely Needed):
+  • baseBranch: Compare against non-default branch
+  • content: Pass diff directly instead of branchName (legacy)
+  • contentType: "diff" or "code" for static analysis
+  • customContext: Override auto-gathered project context
+  • maxTokens: Limit response length`,
     inputSchema: {
-        // CONTENT OPTIONS: Provide either content OR branchName
-        content: z.string().optional().describe('Code or diff content to review. Use this OR branchName (not both).'),
-        // GIT BRANCH OPTIONS: Alternative to content
-        branchName: z.string().optional().describe('Branch name to review (we\'ll run git diff). Faster for agent-to-agent! Requires workspaceDir.'),
-        baseBranch: z.string().optional().describe('Branch to compare against (defaults to main/master). Only used with branchName.'),
-        // CONTENT TYPE
-        contentType: z.enum(['diff', 'code']).optional().describe('Type of content: "diff" for git diffs, "code" for static code review'),
-        // CONTEXT OPTIONS
-        workspaceDir: z.string().optional().describe('⭐ CRITICAL: Project root directory for finding .cursor/rules and config files. REQUIRED when using branchName!'),
-        customContext: z.string().optional().describe('Optional: Provide manual context to skip auto-gathering (.cursor/rules, CODE_REVIEW.md, etc)'),
-        skipContextGathering: z.boolean().optional().describe('Set to true to skip automatic context gathering (only if no context needed)'),
-        // REVIEW OPTIONS
-        focus: z.string().optional().describe('Specific areas to focus on (e.g., "security and performance")'),
-        maxTokens: z.number().optional().describe('Maximum tokens for review response'),
-        force: z.boolean().optional().describe('Force review even if diff is large (>2000 lines). Use this to bypass chunking suggestions.'),
+        // ZERO-CONFIG: All parameters are optional!
+        focus: z.string().optional().describe('Specialized review focus: "security", "performance", "React patterns", etc.'),
+        branchName: z.string().optional().describe('Branch to review (defaults to current branch)'),
+        workspaceDir: z.string().optional().describe('Repo path (defaults to WORKSPACE_ROOT env, auto-resolves relative paths)'),
+        force: z.boolean().optional().describe('Review large diffs (>2000 lines) without chunking suggestion'),
+        // ADVANCED - Rarely needed
+        baseBranch: z.string().optional().describe('Compare against specific branch (auto-detects main/master/develop)'),
+        content: z.string().optional().describe('LEGACY: Pass diff/code directly instead of branch-based review'),
+        contentType: z.enum(['diff', 'code']).optional().describe('LEGACY: "diff" or "code" when using content parameter'),
+        customContext: z.string().optional().describe('ADVANCED: Override auto-gathered project context'),
+        skipContextGathering: z.boolean().optional().describe('ADVANCED: Skip context gathering'),
+        maxTokens: z.number().optional().describe('ADVANCED: Limit response length'),
     },
 }, async (input, extra) => {
     try {

package/dist/review/collectDiff.js

@@ -45,47 +45,53 @@ export async function collectDiff(input) {
             }
         }
         await debugLog(`Collecting diff: ${base}...${branchName} in ${workspaceDir}`);
-        // Run git diff for committed changes - use execFileSync to prevent command injection
-        let diff = execFileSync('git', ['diff', `${base}...${branchName}`], {
-            cwd: workspaceDir,
-            encoding: 'utf8',
-            maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large diffs
-        });
-        // If no committed changes, check for uncommitted changes on the branch
-        if (!diff.trim()) {
-            await debugLog(`No committed changes found, checking for uncommitted changes`);
-            // Check if we're currently on the target branch
-            let currentBranch;
-            try {
-                currentBranch = execSync('git rev-parse --abbrev-ref HEAD', {
-                    cwd: workspaceDir,
-                    encoding: 'utf8',
-                    stdio: ['ignore', 'pipe', 'ignore']
-                }).trim();
-            }
-            catch {
-                currentBranch = '';
+        // Check if we're currently on the target branch
+        let currentBranch;
+        try {
+            currentBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+                cwd: workspaceDir,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'ignore']
+            }).trim();
+        }
+        catch {
+            currentBranch = '';
+        }
+        const onTargetBranch = currentBranch === branchName;
+        // If on target branch, get ALL changes (committed + uncommitted)
+        // This reviews work-in-progress, not just committed code
+        let diff;
+        if (onTargetBranch) {
+            await debugLog(`On target branch ${branchName}, reviewing ALL changes (committed + uncommitted)`);
+            // Get all changes from base branch (includes both committed and uncommitted)
+            diff = execFileSync('git', ['diff', base], {
+                cwd: workspaceDir,
+                encoding: 'utf8',
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            if (diff.trim()) {
+                await debugLog(`Found changes: ${diff.length} chars (committed + uncommitted)`);
             }
-            if (currentBranch === branchName) {
-                // We're on the target branch - collect uncommitted changes
-                await debugLog(`On target branch ${branchName}, collecting uncommitted changes`);
-                // Get uncommitted changes (staged + unstaged)
-                diff = execFileSync('git', ['diff', base], {
-                    cwd: workspaceDir,
-                    encoding: 'utf8',
-                    maxBuffer: 10 * 1024 * 1024,
-                });
-                if (diff.trim()) {
-                    await debugLog(`Found uncommitted changes: ${diff.length} chars`);
-                }
+        }
+        else {
+            // Not on target branch, only get committed changes
+            await debugLog(`Not on target branch, reviewing only committed changes`);
+            diff = execFileSync('git', ['diff', `${base}...${branchName}`], {
+                cwd: workspaceDir,
+                encoding: 'utf8',
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            if (diff.trim()) {
+                await debugLog(`Found committed changes: ${diff.length} chars`);
             }
         }
         if (!diff.trim()) {
+            const checkType = onTargetBranch
+                ? `All changes (committed + uncommitted): git diff ${base}`
+                : `Committed changes: git diff ${base}...${branchName}`;
             throw new Error(`No changes found on branch ${branchName}.\n` +
-                `Tried:\n` +
-                `  1. Committed changes: git diff ${base}...${branchName}\n` +
-                `  2. Uncommitted changes (if on branch): git diff ${base}\n` +
-                `Make sure the branch exists and has changes (committed or uncommitted).`);
+                `Checked: ${checkType}\n` +
+                `Make sure the branch has changes compared to ${base}.`);
         }
         await debugLog(`Collected diff: ${diff.length} chars, ${diff.split('\n').length} lines`);
         return diff;

package/dist/tools/performCodeReview.js

@@ -46,26 +46,48 @@ function parseFilesFromDiff(diff) {
  * We handle: context gathering, expert prompt building, GPT-5 invocation, formatting.
  */
 export async function performCodeReview(input, onProgress) {
-    // Validate input: require either content OR branchName
-    if (!input.content && !input.branchName) {
-        throw new Error('Either content or branchName is required. ' +
-            'Provide content (diff/code) directly, or branchName to auto-collect the diff.');
+    // ZERO-CONFIG MODE: Default to current workspace and current branch!
+    // Perfect for "review this" or "review my changes"
+    // Auto-detect workspaceDir from Cursor's WORKSPACE_ROOT env var
+    let workspaceDir = input.workspaceDir || process.env.WORKSPACE_ROOT || process.cwd();
+    // Auto-resolve relative paths to absolute paths
+    if (!isAbsolute(workspaceDir)) {
+        workspaceDir = resolve(process.cwd(), workspaceDir);
+        await debugLog(`Resolved relative workspaceDir: ${input.workspaceDir} → ${workspaceDir}`);
     }
+    await debugLog(`Using workspaceDir: ${workspaceDir}`);
+    // Validate: content mode is mutually exclusive with branch mode
     if (input.content && input.branchName) {
         throw new Error('Cannot provide both content and branchName. ' +
             'Choose one: either provide the diff directly (content) or let us collect it (branchName).');
     }
-    // If branchName is provided, require workspaceDir
-    if (input.branchName && !input.workspaceDir) {
-        throw new Error('workspaceDir is required when using branchName. ' +
-            'We need to know where to run git commands.');
+    // If content provided, use that path (legacy mode)
+    if (input.content) {
+        // Continue with existing content-based flow
+        await debugLog(`Using provided content (${input.content.length} chars)`);
     }
-    // Auto-resolve relative paths to absolute paths for workspaceDir
-    // This prevents common pitfalls where agents pass relative paths
-    let workspaceDir = input.workspaceDir;
-    if (workspaceDir && !isAbsolute(workspaceDir)) {
-        workspaceDir = resolve(process.cwd(), workspaceDir);
-        await debugLog(`Resolved relative workspaceDir to absolute: ${input.workspaceDir} → ${workspaceDir}`);
+    else {
+        // Branch mode: auto-detect current branch if not provided
+        let branchName = input.branchName;
+        if (!branchName) {
+            // Auto-detect current branch
+            try {
+                const { execSync } = await import('node:child_process');
+                branchName = execSync('git rev-parse --abbrev-ref HEAD', {
+                    cwd: workspaceDir,
+                    encoding: 'utf8',
+                    stdio: ['ignore', 'pipe', 'ignore']
+                }).trim();
+                await debugLog(`Auto-detected current branch: ${branchName}`);
+            }
+            catch (error) {
+                throw new Error(`Could not auto-detect current branch. ` +
+                    `Make sure you're in a git repository. ` +
+                    `Error: ${error.message}`);
+            }
+        }
+        // Store detected/provided branchName for later use
+        input.branchName = branchName;
     }
     // Collect diff if branchName is provided
     let content = input.content;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-review-mcp",
-  "version": "2.10.4",
+  "version": "2.10.6",
   "main": "index.js",
   "scripts": {
     "build": "tsc",