@in-the-loop-labs/pair-review 2.0.3 → 2.1.1

package/src/config.js

@@ -5,6 +5,7 @@ const os = require('os');
 const logger = require('./utils/logger');
 
 const CONFIG_DIR = path.join(os.homedir(), '.pair-review');
+const DEFAULT_CHECKOUT_TIMEOUT_MS = 300000;
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const CONFIG_EXAMPLE_FILE = path.join(CONFIG_DIR, 'config.example.json');
 const PACKAGE_ROOT = path.join(__dirname, '..');
@@ -316,6 +317,81 @@ function getMonorepoPath(config, repository) {
   return null;
 }
 
+/**
+ * Gets the configured checkout script for a monorepo repository
+ * @param {Object} config - Configuration object from loadConfig()
+ * @param {string} repository - Repository in "owner/repo" format
+ * @returns {string|null} - Checkout script path or null if not configured
+ */
+function getMonorepoCheckoutScript(config, repository) {
+  const monorepoConfig = config.monorepos?.[repository];
+  return monorepoConfig?.checkout_script || null;
+}
+
+/**
+ * Gets the configured worktree directory for a monorepo repository
+ * @param {Object} config - Configuration object from loadConfig()
+ * @param {string} repository - Repository in "owner/repo" format
+ * @returns {string|null} - Expanded worktree directory path or null if not configured
+ */
+function getMonorepoWorktreeDirectory(config, repository) {
+  const monorepoConfig = config.monorepos?.[repository];
+  if (monorepoConfig?.worktree_directory) {
+    return expandPath(monorepoConfig.worktree_directory);
+  }
+  return null;
+}
+
+/**
+ * Gets the configured worktree name template for a monorepo repository
+ * @param {Object} config - Configuration object from loadConfig()
+ * @param {string} repository - Repository in "owner/repo" format
+ * @returns {string|null} - Template string or null if not configured
+ */
+function getMonorepoWorktreeNameTemplate(config, repository) {
+  const monorepoConfig = config.monorepos?.[repository];
+  return monorepoConfig?.worktree_name_template || null;
+}
+
+/**
+ * Gets the configured checkout script timeout for a monorepo repository
+ * @param {Object} config - Configuration object from loadConfig()
+ * @param {string} repository - Repository in "owner/repo" format
+ * @returns {number} - Timeout in milliseconds (default: 300000 = 5 minutes)
+ */
+function getMonorepoCheckoutTimeout(config, repository) {
+  const monorepoConfig = config.monorepos?.[repository];
+  if (monorepoConfig?.checkout_timeout_seconds > 0) {
+    return monorepoConfig.checkout_timeout_seconds * 1000;
+  }
+  return DEFAULT_CHECKOUT_TIMEOUT_MS; // 5 minutes default
+}
+
+/**
+ * Resolves all monorepo worktree options for a repository into a single object.
+ * Composite helper that combines the individual getters into the shape expected
+ * by GitWorktreeManager and createWorktreeForPR.
+ *
+ * @param {Object} config - Configuration object from loadConfig()
+ * @param {string} repository - Repository in "owner/repo" format
+ * @returns {{ checkoutScript: string|null, checkoutTimeout: number, worktreeConfig: Object|null }}
+ */
+function resolveMonorepoOptions(config, repository) {
+  const checkoutScript = getMonorepoCheckoutScript(config, repository);
+  const checkoutTimeout = getMonorepoCheckoutTimeout(config, repository);
+  const worktreeDirectory = getMonorepoWorktreeDirectory(config, repository);
+  const nameTemplate = getMonorepoWorktreeNameTemplate(config, repository);
+
+  let worktreeConfig = null;
+  if (worktreeDirectory || nameTemplate) {
+    worktreeConfig = {};
+    if (worktreeDirectory) worktreeConfig.worktreeBaseDir = worktreeDirectory;
+    if (nameTemplate) worktreeConfig.nameTemplate = nameTemplate;
+  }
+
+  return { checkoutScript, checkoutTimeout, worktreeConfig };
+}
+
 /**
  * Resolves the database filename to use.
  * Priority:
@@ -358,6 +434,12 @@ module.exports = {
   showWelcomeMessage,
   expandPath,
   getMonorepoPath,
+  getMonorepoCheckoutScript,
+  getMonorepoWorktreeDirectory,
+  getMonorepoWorktreeNameTemplate,
+  getMonorepoCheckoutTimeout,
+  resolveMonorepoOptions,
   resolveDbName,
-  warnIfDevModeWithoutDbName
+  warnIfDevModeWithoutDbName,
+  DEFAULT_CHECKOUT_TIMEOUT_MS
 };

package/src/database.js

@@ -2193,8 +2193,12 @@ class CommentRepository {
     }
 
     for (const suggestion of normalized) {
+      const suggestionText = suggestion.suggestion;
+      const hasSuggestionBlock = suggestionText?.trimStart().startsWith('```suggestion');
       const body = suggestion.description +
-        (suggestion.suggestion ? '\n\n**Suggestion:** ' + suggestion.suggestion : '');
+        (suggestionText
+          ? (hasSuggestionBlock ? '\n\n' + suggestionText : '\n\n**Suggestion:** ' + suggestionText)
+          : '');
 
       // File-level suggestions have is_file_level=true or have null line_start
       const isFileLevel = suggestion.is_file_level === true || suggestion.line_start === null ? 1 : 0;

package/src/git/worktree.js

@@ -3,10 +3,11 @@ const simpleGit = require('simple-git');
 const path = require('path');
 const fs = require('fs').promises;
 const os = require('os');
-const { getConfigDir } = require('../config');
+const { getConfigDir, DEFAULT_CHECKOUT_TIMEOUT_MS } = require('../config');
 const { WorktreeRepository, generateWorktreeId } = require('../database');
 const { getGeneratedFilePatterns } = require('./gitattributes');
 const { normalizeRepository, resolveRenamedFile, resolveRenamedFileOld } = require('../utils/paths');
+const { spawn, execSync } = require('child_process');
 
 /**
  * Git worktree manager for handling PR branch checkouts and diffs
@@ -15,13 +16,43 @@ class GitWorktreeManager {
   /**
    * Create a new GitWorktreeManager instance
    * @param {sqlite3.Database} [db] - Optional database instance for worktree tracking
+   * @param {Object} [options] - Optional settings
+   * @param {string} [options.worktreeBaseDir] - Custom base directory for worktrees
+   * @param {string} [options.nameTemplate] - Template for worktree directory names
+   *   Supported variables: {id}, {pr_number}, {repo}, {owner}
+   *   Default: '{id}' (preserves current behavior)
    */
-  constructor(db = null) {
-    this.worktreeBaseDir = path.join(getConfigDir(), 'worktrees');
+  constructor(db = null, options = {}) {
+    this.worktreeBaseDir = options.worktreeBaseDir || path.join(getConfigDir(), 'worktrees');
+    this.nameTemplate = options.nameTemplate || '{id}';
     this.db = db;
     this.worktreeRepo = db ? new WorktreeRepository(db) : null;
   }
 
+  /**
+   * Apply the name template to generate a worktree directory name
+   * @param {Object} context - Template context variables
+   * @param {string} context.id - Random worktree ID
+   * @param {number} [context.prNumber] - PR number
+   * @param {string} [context.repo] - Repository name
+   * @param {string} [context.owner] - Repository owner
+   * @returns {string} Resolved directory name
+   */
+  applyNameTemplate(context) {
+    let name = this.nameTemplate;
+    name = name.replace(/\{id\}/g, context.id);
+    if (context.prNumber !== undefined) {
+      name = name.replace(/\{pr_number\}/g, String(context.prNumber));
+    }
+    if (context.repo) {
+      name = name.replace(/\{repo\}/g, context.repo);
+    }
+    if (context.owner) {
+      name = name.replace(/\{owner\}/g, context.owner);
+    }
+    return name;
+  }
+
   /**
    * Resolve which git remote points to the given repository URLs.
    * Compares normalized URLs against all configured remotes. If no match is
@@ -129,6 +160,65 @@ class GitWorktreeManager {
     return this.resolveRemoteForRepo(git, cloneUrl, sshUrl);
   }
 
+  /**
+   * Execute a user-provided checkout script in the worktree.
+   * The script receives PR context as environment variables and is responsible
+   * for configuring sparse-checkout (or any other worktree setup).
+   *
+   * @param {string} script - Script path or command to execute
+   * @param {string} worktreePath - Path to the worktree (used as cwd)
+   * @param {Object} env - Environment variables to pass (BASE_BRANCH, HEAD_BRANCH, etc.)
+   * @param {number} [timeout=DEFAULT_CHECKOUT_TIMEOUT_MS] - Timeout in milliseconds (default: 5 minutes)
+   * @returns {Promise<{stdout: string, stderr: string}>} Script output
+   */
+  async executeCheckoutScript(script, worktreePath, env, timeout = DEFAULT_CHECKOUT_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(script, [], {
+        cwd: worktreePath,
+        shell: true,
+        env: { ...process.env, ...env },
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        process.stdout.write(chunk);
+      });
+      child.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        process.stderr.write(chunk);
+      });
+
+      const timer = setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`Checkout script timed out after ${timeout}ms.\nstdout: ${stdout}\nstderr: ${stderr}`));
+      }, timeout);
+
+      child.on('error', (err) => {
+        clearTimeout(timer);
+        if (err.code === 'ENOENT') {
+          reject(new Error(`Checkout script not found: ${script}`));
+        } else {
+          reject(new Error(`Checkout script failed to start: ${err.message}`));
+        }
+      });
+
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve({ stdout, stderr });
+        } else {
+          reject(new Error(`Checkout script exited with code ${code}.\nstdout: ${stdout}\nstderr: ${stderr}`));
+        }
+      });
+    });
+  }
+
   /**
    * Create a git worktree for a PR and checkout to the PR head commit
    * @param {Object} prInfo - PR information { owner, repo, number }
@@ -137,10 +227,14 @@ class GitWorktreeManager {
    * @param {Object} [options] - Optional settings
    * @param {string} [options.worktreeSourcePath] - Path to use as cwd for git worktree add
    *   (to inherit sparse-checkout from an existing worktree). Falls back to repositoryPath.
+   * @param {string} [options.checkoutScript] - Path to a script that configures sparse-checkout in the worktree.
+   *   When set, worktree is created with --no-checkout from the main git root (no sparse-checkout inheritance),
+   *   and the script is executed before checkout with PR context as environment variables.
+   * @param {number} [options.checkoutTimeout] - Timeout in ms for checkout script (default: 300000 = 5 minutes)
    * @returns {Promise<string>} Path to created worktree
    */
   async createWorktreeForPR(prInfo, prData, repositoryPath, options = {}) {
-    const { worktreeSourcePath } = options;
+    const { worktreeSourcePath, checkoutScript, checkoutTimeout } = options;
     // Check if worktree already exists in DB
     const repository = normalizeRepository(prInfo.owner, prInfo.repo);
     let worktreePath;
@@ -157,7 +251,7 @@ class GitWorktreeManager {
       // Check if the directory still exists on disk
       const directoryExists = await this.pathExists(worktreePath);
 
-      if (directoryExists) {
+      if (directoryExists && await this.isValidGitWorktree(worktreePath)) {
         // Try to reuse existing worktree by refreshing it
         console.log(`Found existing worktree for PR #${prInfo.number} at ${worktreePath}`);
         try {
@@ -170,6 +264,8 @@ class GitWorktreeManager {
           // For other errors, log and fall through to recreate
           console.log(`Could not refresh existing worktree, will recreate: ${refreshError.message}`);
         }
+      } else if (directoryExists) {
+        console.log(`Worktree directory at ${worktreePath} is not a valid git worktree, will recreate`);
       } else {
         console.log(`Worktree directory no longer exists at ${worktreePath}, will recreate`);
       }
@@ -207,9 +303,15 @@ class GitWorktreeManager {
         }
       }
 
-      // Generate new random ID for worktree directory
+      // Generate new random ID for worktree directory and apply name template
       const worktreeId = generateWorktreeId();
-      worktreePath = path.join(this.worktreeBaseDir, worktreeId);
+      const worktreeDirName = this.applyNameTemplate({
+        id: worktreeId,
+        prNumber: prInfo.number,
+        repo: prInfo.repo,
+        owner: prInfo.owner
+      });
+      worktreePath = path.join(this.worktreeBaseDir, worktreeDirName);
     }
 
     try {
@@ -243,23 +345,39 @@ class GitWorktreeManager {
         }
       }
       
-      // Create worktree and checkout to base branch
-      // Use worktreeSourcePath as cwd if provided (to inherit sparse-checkout from existing worktree)
-      const worktreeAddGit = worktreeSourcePath ? simpleGit(worktreeSourcePath) : git;
-      if (worktreeSourcePath) {
-        console.log(`Creating worktree at ${worktreePath} from ${prData.base_branch} (inheriting sparse-checkout from ${worktreeSourcePath})...`);
+      // Create worktree — strategy depends on whether a checkout script is configured
+      if (checkoutScript) {
+        // With checkout_script: create worktree with --no-checkout from main git root.
+        // The script will configure sparse-checkout before files are populated.
+        console.log(`Creating worktree at ${worktreePath} from ${prData.base_branch} (--no-checkout, script will configure sparse-checkout)...`);
+        try {
+          await git.raw(['worktree', 'add', '--no-checkout', worktreePath, `${remote}/${prData.base_branch}`]);
+        } catch (worktreeError) {
+          if (worktreeError.message.includes('already registered')) {
+            console.log('Worktree already registered, trying with --force...');
+            await git.raw(['worktree', 'add', '--force', '--no-checkout', worktreePath, `${remote}/${prData.base_branch}`]);
+          } else {
+            throw worktreeError;
+          }
+        }
       } else {
-        console.log(`Creating worktree at ${worktreePath} from ${prData.base_branch}...`);
-      }
-      try {
-        await worktreeAddGit.raw(['worktree', 'add', worktreePath, `${remote}/${prData.base_branch}`]);
-      } catch (worktreeError) {
-        // If worktree creation fails due to existing registration, try with --force
-        if (worktreeError.message.includes('already registered')) {
-          console.log('Worktree already registered, trying with --force...');
-          await worktreeAddGit.raw(['worktree', 'add', '--force', worktreePath, `${remote}/${prData.base_branch}`]);
+        // Without checkout_script: use worktreeSourcePath as cwd if provided
+        // (to inherit sparse-checkout from existing worktree)
+        const worktreeAddGit = worktreeSourcePath ? simpleGit(worktreeSourcePath) : git;
+        if (worktreeSourcePath) {
+          console.log(`Creating worktree at ${worktreePath} from ${prData.base_branch} (inheriting sparse-checkout from ${worktreeSourcePath})...`);
         } else {
-          throw worktreeError;
+          console.log(`Creating worktree at ${worktreePath} from ${prData.base_branch}...`);
+        }
+        try {
+          await worktreeAddGit.raw(['worktree', 'add', worktreePath, `${remote}/${prData.base_branch}`]);
+        } catch (worktreeError) {
+          if (worktreeError.message.includes('already registered')) {
+            console.log('Worktree already registered, trying with --force...');
+            await worktreeAddGit.raw(['worktree', 'add', '--force', worktreePath, `${remote}/${prData.base_branch}`]);
+          } else {
+            throw worktreeError;
+          }
         }
       }
       
@@ -280,6 +398,35 @@ class GitWorktreeManager {
       console.log(`Fetching PR #${prInfo.number} head...`);
       await worktreeGit.fetch([remote, `+refs/pull/${prInfo.number}/head:refs/remotes/${remote}/pr-${prInfo.number}`]);
 
+      // Execute checkout script if configured (before checkout so sparse-checkout is set up)
+      if (checkoutScript) {
+        // Fetch the actual head branch by name (for checkout scripts that expect branch refs)
+        // This may fail for fork PRs where the branch is in a different repo - that's okay
+        if (prData.head_branch) {
+          try {
+            console.log(`Fetching head branch ${prData.head_branch}...`);
+            await worktreeGit.fetch([remote, `+refs/heads/${prData.head_branch}:refs/remotes/${remote}/${prData.head_branch}`]);
+            // Create/update a local branch pointing to the fetched ref so tooling can reference it by name
+            await worktreeGit.branch(['-f', prData.head_branch, `${remote}/${prData.head_branch}`]);
+          } catch (branchFetchError) {
+            // Expected for fork PRs - the branch exists in the fork, not the base repo
+            console.log(`Could not fetch head branch (may be from a fork): ${branchFetchError.message}`);
+          }
+        }
+
+        console.log(`Executing checkout script: ${checkoutScript}`);
+        const scriptEnv = {
+          BASE_BRANCH: prData.base_branch,
+          HEAD_BRANCH: prData.head_branch,
+          BASE_SHA: prData.base_sha,
+          HEAD_SHA: prData.head_sha,
+          PR_NUMBER: String(prInfo.number),
+          WORKTREE_PATH: worktreePath
+        };
+        await this.executeCheckoutScript(checkoutScript, worktreePath, scriptEnv, checkoutTimeout);
+        console.log('Checkout script completed successfully');
+      }
+
       // Checkout to PR head commit
       console.log(`Checking out to PR head commit ${prData.head_sha}...`);
       await worktreeGit.checkout([`${remote}/pr-${prInfo.number}`]);
@@ -596,7 +743,6 @@ class GitWorktreeManager {
       await fs.rm(dirPath, { recursive: true, force: true });
     } catch (error) {
       // Fallback for older Node.js versions
-      const { execSync } = require('child_process');
       if (process.platform === 'win32') {
         execSync(`rmdir /s /q "${dirPath}"`, { stdio: 'ignore' });
       } else {

package/src/main.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 const fs = require('fs');
-const { loadConfig, getConfigDir, getGitHubToken, showWelcomeMessage, resolveDbName } = require('./config');
+const { loadConfig, getConfigDir, getGitHubToken, showWelcomeMessage, resolveDbName, resolveMonorepoOptions } = require('./config');
 const { initializeDatabase, run, queryOne, query, migrateExistingWorktrees, WorktreeRepository, ReviewRepository, RepoSettingsRepository, GitHubReviewRepository } = require('./database');
 const { PRArgumentParser } = require('./github/parser');
 const { GitHubClient } = require('./github/client');
@@ -466,8 +466,6 @@ AI PROVIDERS:
  * @param {Object} flags - Parsed command line flags
  */
 async function handlePullRequest(args, config, db, flags = {}) {
-  let prInfo = null; // Declare prInfo outside try block for error handling
-  
   try {
     // Get GitHub token (env var takes precedence over config)
     const githubToken = getGitHubToken(config);
@@ -477,136 +475,36 @@ async function handlePullRequest(args, config, db, flags = {}) {
 
     // Parse PR arguments
     const parser = new PRArgumentParser();
-    prInfo = await parser.parsePRArguments(args);
-
-    console.log(`Processing pull request #${prInfo.number} from ${prInfo.owner}/${prInfo.repo}`);
-
-    // Create GitHub client and verify repository access
-    const githubClient = new GitHubClient(githubToken);
-    const repoExists = await githubClient.repositoryExists(prInfo.owner, prInfo.repo);
-    if (!repoExists) {
-      throw new Error(`Repository ${prInfo.owner}/${prInfo.repo} not found or not accessible`);
-    }
-
-    // Fetch PR data from GitHub
-    console.log('Fetching pull request data from GitHub...');
-    const prData = await githubClient.fetchPullRequest(prInfo.owner, prInfo.repo, prInfo.number);
+    const prInfo = await parser.parsePRArguments(args);
 
-    // Determine repository path: only use cwd if it matches the target repo
+    // Register cwd as known repo path if it matches the target repo
     const currentDir = parser.getCurrentDirectory();
     const isMatchingRepo = await parser.isMatchingRepository(currentDir, prInfo.owner, prInfo.repo);
-
-    let repositoryPath;
     if (isMatchingRepo) {
-      // Current directory is a checkout of the target repository
-      repositoryPath = currentDir;
-      // Register the known repository location for future web UI usage
       await registerRepositoryLocation(db, currentDir, prInfo.owner, prInfo.repo);
-    } else {
-      // Current directory is not the target repository - find or clone it
-      console.log(`Current directory is not a checkout of ${prInfo.owner}/${prInfo.repo}, locating repository...`);
-      const repository = normalizeRepository(prInfo.owner, prInfo.repo);
-      const result = await findRepositoryPath({
-        db,
-        owner: prInfo.owner,
-        repo: prInfo.repo,
-        repository,
-        prNumber: prInfo.number,
-        onProgress: (progress) => {
-          if (progress.message) {
-            console.log(progress.message);
-          }
-        }
-      });
-      repositoryPath = result.repositoryPath;
     }
 
-    // Setup git worktree
-    console.log('Setting up git worktree...');
-    const worktreeManager = new GitWorktreeManager(db);
-    const worktreePath = await worktreeManager.createWorktreeForPR(prInfo, prData, repositoryPath);
-
-    // Generate unified diff
-    console.log('Generating unified diff...');
-    const diff = await worktreeManager.generateUnifiedDiff(worktreePath, prData);
-    const changedFiles = await worktreeManager.getChangedFiles(worktreePath, prData);
+    // Set model override if provided via CLI flag
+    if (flags.model) {
+      process.env.PAIR_REVIEW_MODEL = flags.model;
+    }
 
-    // Store PR data in database
-    console.log('Storing pull request data...');
-    await storePRData(db, prInfo, prData, diff, changedFiles, worktreePath);
+    // Start server and open browser to setup page
+    const port = await startServer(db);
 
-    // Start server with PR context
-    console.log('Starting server...');
-    const port = await startServerWithPRContext(config, prInfo, flags);
+    // Async cleanup of stale worktrees (don't block startup)
+    cleanupStaleWorktreesAsync(config);
 
-    // Trigger AI analysis server-side if --ai flag is present
+    let url = `http://localhost:${port}/pr/${prInfo.owner}/${prInfo.repo}/${prInfo.number}`;
     if (flags.ai) {
-      console.log('Starting AI analysis...');
-
-      // Wait for server to be ready with retry logic
-      const maxRetries = 5;
-      const retryDelay = 200; // ms
-      let lastError;
-
-      for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        try {
-          // Add small delay to ensure server is fully initialized
-          if (attempt > 1) {
-            await new Promise(resolve => setTimeout(resolve, retryDelay * attempt));
-          }
-
-          const response = await fetch(`http://localhost:${port}/api/pr/${prInfo.owner}/${prInfo.repo}/${prInfo.number}/analyses`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' }
-          });
-
-          if (response.ok) {
-            const result = await response.json();
-            console.log(`AI analysis started (ID: ${result.analysisId})`);
-            break; // Success, exit retry loop
-          } else {
-            lastError = `Server responded with ${response.status}: ${await response.text()}`;
-            if (attempt === maxRetries) {
-              console.warn('Failed to start AI analysis:', lastError);
-            }
-          }
-        } catch (error) {
-          lastError = error.message;
-          if (attempt === maxRetries) {
-            console.warn('Could not start AI analysis after', maxRetries, 'attempts:', lastError);
-          }
-        }
-      }
+      url += '?analyze=true';
     }
 
-    // Open browser to PR view
-    const url = `http://localhost:${port}/pr/${prInfo.owner}/${prInfo.repo}/${prInfo.number}`;
-
     console.log(`Opening browser to: ${url}`);
     await open(url);
 
   } catch (error) {
-    // Provide cleaner error messages for common issues
-    if (error.message && error.message.includes('not found in repository')) {
-      if (prInfo) {
-        console.error(`\n❌ Pull request #${prInfo.number} does not exist in ${prInfo.owner}/${prInfo.repo}`);
-      } else {
-        console.error(`\n❌ ${error.message}`);
-      }
-      console.error('Please check the PR number and try again.\n');
-    } else if (error.message && error.message.includes('authentication failed')) {
-      console.error('\n❌ GitHub authentication failed');
-      console.error('Please check your token in ~/.pair-review/config.json\n');
-    } else if (error.message && error.message.includes('Repository') && error.message.includes('not found')) {
-      console.error(`\n❌ ${error.message}`);
-      console.error('Please check the repository name and your access permissions.\n');
-    } else if (error.message && error.message.includes('Network error')) {
-      console.error('\n❌ Network connection error');
-      console.error('Please check your internet connection and try again.\n');
-    } else {
-      // For other errors, show a clean message without stack trace
-      console.error(`\n❌ Error: ${error.message}\n`);
-    }
+    console.error(`\n❌ Error: ${error.message}\n`);
     process.exit(1);
   }
 }
@@ -627,36 +525,6 @@ async function startServerOnly(config) {
   await open(url);
 }
 
-/**
- * Start server with PR context
- * @param {Object} config - Application configuration
- * @param {Object} prInfo - PR information
- * @param {Object} flags - Command line flags
- * @returns {Promise<number>} Server port
- */
-async function startServerWithPRContext(config, prInfo, flags = {}) {
-  // Set environment variable for PR context
-  process.env.PAIR_REVIEW_PR = JSON.stringify(prInfo);
-
-  // Set environment variable for auto-AI flag
-  if (flags.ai) {
-    process.env.PAIR_REVIEW_AUTO_AI = 'true';
-  }
-
-  // Set environment variable for model override (CLI takes priority)
-  if (flags.model) {
-    process.env.PAIR_REVIEW_MODEL = flags.model;
-  }
-
-  const { startServer } = require('./server');
-  const actualPort = await startServer(db);
-
-  // Async cleanup of stale worktrees (don't block startup)
-  cleanupStaleWorktreesAsync(config);
-
-  // Return the actual port the server started on
-  return actualPort;
-}
 
 /**
  * Format AI suggestion with emoji and category prefix
@@ -784,10 +652,21 @@ async function performHeadlessReview(args, config, db, flags, options) {
       const isMatchingRepo = await parser.isMatchingRepository(currentDir, prInfo.owner, prInfo.repo);
 
       let repositoryPath;
+      let worktreeSourcePath;
+      let checkoutScript;
+      let checkoutTimeout;
+      let worktreeConfig = null;
       if (isMatchingRepo) {
         // Current directory is a checkout of the target repository
         repositoryPath = currentDir;
         await registerRepositoryLocation(db, currentDir, prInfo.owner, prInfo.repo);
+
+        // Resolve monorepo config options (checkout_script, worktree_directory, worktree_name_template)
+        // even when running from inside the target repo, so they are not silently ignored.
+        const resolved = resolveMonorepoOptions(config, repository);
+        checkoutScript = resolved.checkoutScript;
+        checkoutTimeout = resolved.checkoutTimeout;
+        worktreeConfig = resolved.worktreeConfig;
       } else {
         // Current directory is not the target repository - find or clone it
         console.log(`Current directory is not a checkout of ${prInfo.owner}/${prInfo.repo}, locating repository...`);
@@ -797,6 +676,7 @@ async function performHeadlessReview(args, config, db, flags, options) {
           repo: prInfo.repo,
           repository,
           prNumber: prInfo.number,
+          config,
           onProgress: (progress) => {
             if (progress.message) {
               console.log(progress.message);
@@ -804,11 +684,19 @@ async function performHeadlessReview(args, config, db, flags, options) {
           }
         });
         repositoryPath = result.repositoryPath;
+        worktreeSourcePath = result.worktreeSourcePath;
+        checkoutScript = result.checkoutScript;
+        checkoutTimeout = result.checkoutTimeout;
+        worktreeConfig = result.worktreeConfig;
       }
 
       console.log('Setting up git worktree...');
-      const worktreeManager = new GitWorktreeManager(db);
-      worktreePath = await worktreeManager.createWorktreeForPR(prInfo, prData, repositoryPath);
+      const worktreeManager = new GitWorktreeManager(db, worktreeConfig || {});
+      worktreePath = await worktreeManager.createWorktreeForPR(prInfo, prData, repositoryPath, {
+        worktreeSourcePath,
+        checkoutScript,
+        checkoutTimeout
+      });
 
       console.log('Generating unified diff...');
       diff = await worktreeManager.generateUnifiedDiff(worktreePath, prData);