@in-the-loop-labs/pair-review 2.6.2 → 2.7.0

package/src/git/base-branch.js

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+const { execSync } = require('child_process');
+const logger = require('../utils/logger');
+
+const defaults = {
+  execSync,
+  // Callers should pass a resolved token via _deps.getGitHubToken.
+  // This default returns empty so GitHub lookup is silently skipped
+  // when no token is provided — never re-resolve config internally.
+  getGitHubToken: () => '',
+  createGitHubClient: (token) => {
+    const { GitHubClient } = require('../github/client');
+    return new GitHubClient(token);
+  }
+};
+
+/**
+ * Detect the base branch for the current branch.
+ *
+ * Priority:
+ *   1. Graphite — `gt trunk` and `gt parent`
+ *   2. GitHub PR — look up an open PR for this branch
+ *   3. Default branch — `git remote show origin` or local main/master
+ *
+ * @param {string} repoPath - Absolute path to the repository
+ * @param {string} currentBranch - Current branch name (or 'HEAD' if detached)
+ * @param {Object} [options]
+ * @param {string} [options.repository] - owner/repo string (needed for GitHub lookup)
+ * @param {boolean} [options.enableGraphite] - When true, try Graphite CLI for parent branch
+ * @param {Object} [options._deps] - Dependency overrides for testing
+ * @returns {Promise<{baseBranch: string, source: string, prNumber?: number}|null>}
+ */
+async function detectBaseBranch(repoPath, currentBranch, options = {}) {
+  const deps = { ...defaults, ...options._deps };
+
+  // Guard: detached HEAD — nothing to compare
+  if (!currentBranch || currentBranch === 'HEAD') {
+    return null;
+  }
+
+  // 1. Graphite (only when enabled via config)
+  if (options.enableGraphite) {
+    const graphiteResult = tryGraphite(repoPath, currentBranch, deps);
+    if (graphiteResult) return graphiteResult;
+  }
+
+  // 2. GitHub PR
+  const ghResult = await tryGitHubPR(repoPath, currentBranch, options.repository, deps);
+  if (ghResult) return ghResult;
+
+  // 3. Default branch
+  const defaultResult = tryDefaultBranch(repoPath, currentBranch, deps);
+  if (defaultResult) return defaultResult;
+
+  return null;
+}
+
+/**
+ * Try Graphite CLI to find the parent branch.
+ */
+function tryGraphite(repoPath, currentBranch, deps) {
+  try {
+    // Check if gt is installed
+    deps.execSync('which gt', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 3000
+    });
+
+    // Get trunk branch
+    const trunk = deps.execSync('gt trunk', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 3000
+    }).trim();
+
+    // Get parent branch
+    const parent = deps.execSync('gt parent', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 3000
+    }).trim();
+
+    if (parent && parent !== currentBranch) {
+      return { baseBranch: parent, source: 'graphite' };
+    }
+
+    // If parent is ourselves or empty, try trunk
+    if (trunk && trunk !== currentBranch) {
+      return { baseBranch: trunk, source: 'graphite' };
+    }
+  } catch {
+    // Graphite not installed or failed — fall through silently
+  }
+
+  return null;
+}
+
+/**
+ * Try GitHub API to find an open PR for this branch.
+ */
+async function tryGitHubPR(repoPath, currentBranch, repository, deps) {
+  if (!repository || !repository.includes('/')) return null;
+
+  try {
+    const token = deps.getGitHubToken();
+    if (!token) return null;
+
+    const [owner, repo] = repository.split('/');
+    const client = deps.createGitHubClient(token);
+    const result = await client.findPRByBranch(owner, repo, currentBranch);
+
+    if (result) {
+      // Guard: base branch same as current branch (shouldn't happen but be safe)
+      if (result.baseBranch === currentBranch) return null;
+      return {
+        baseBranch: result.baseBranch,
+        source: 'github-pr',
+        prNumber: result.prNumber
+      };
+    }
+  } catch (error) {
+    logger.warn(`GitHub PR lookup failed: ${error.message}`);
+  }
+
+  return null;
+}
+
+/**
+ * Try to determine the default branch from git remote or local refs.
+ */
+function tryDefaultBranch(repoPath, currentBranch, deps) {
+  // Try `git remote show origin`
+  try {
+    const output = deps.execSync('git remote show origin', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000
+    });
+
+    const match = output.match(/HEAD branch:\s*(.+)/);
+    if (match) {
+      const branch = match[1].trim();
+      if (branch && branch !== currentBranch && branch !== '(unknown)') {
+        return { baseBranch: branch, source: 'default-branch' };
+      }
+    }
+  } catch {
+    // No remote or network issue — try local refs
+  }
+
+  // Fallback: check if main or master exists locally
+  for (const candidate of ['main', 'master']) {
+    if (candidate === currentBranch) continue;
+    try {
+      deps.execSync(`git rev-parse --verify ${candidate}`, {
+        cwd: repoPath,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      return { baseBranch: candidate, source: 'default-branch' };
+    } catch {
+      // Branch doesn't exist
+    }
+  }
+
+  return null;
+}
+
+module.exports = { detectBaseBranch };

package/src/git/sha-abbrev.js

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+const { execSync } = require('child_process');
+
+const DEFAULT_SHA_ABBREV_LENGTH = 7;
+
+const defaults = {
+  execSync,
+};
+
+/**
+ * Get the SHA abbreviation length that Git uses for a given repository.
+ *
+ * Calls `git rev-parse --short HEAD` and measures the output length.
+ * This respects the repository's `core.abbrev` setting and Git's
+ * auto-scaling logic (larger repos get longer abbreviations).
+ *
+ * @param {string} repoPath - Absolute path to the repository
+ * @param {Object} [_deps] - Dependency overrides for testing
+ * @returns {number} The abbreviation length Git uses for this repo
+ */
+function getShaAbbrevLength(repoPath, _deps) {
+  const deps = { ...defaults, ..._deps };
+  try {
+    const shortSha = deps.execSync('git rev-parse --short HEAD', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    return shortSha.length || DEFAULT_SHA_ABBREV_LENGTH;
+  } catch {
+    return DEFAULT_SHA_ABBREV_LENGTH;
+  }
+}
+
+module.exports = { getShaAbbrevLength, DEFAULT_SHA_ABBREV_LENGTH };

package/src/git/worktree.js

@@ -536,7 +536,8 @@ class GitWorktreeManager {
       // This ensures we compare the exact commits from the PR, even if the base branch has moved
       const diff = await git.diff([
         `${prData.base_sha}...${prData.head_sha}`,
-        '--unified=3'
+        '--unified=3',
+        '--no-ext-diff'
       ]);
 
       return diff;
@@ -559,7 +560,7 @@ class GitWorktreeManager {
 
       // Get file changes with stats using base SHA and head SHA
       // This ensures we get the exact files changed in the PR, even if the base branch has moved
-      const diffSummary = await git.diffSummary([`${prData.base_sha}...${prData.head_sha}`]);
+      const diffSummary = await git.diffSummary([`${prData.base_sha}...${prData.head_sha}`, '--no-ext-diff']);
 
       // Parse .gitattributes to identify generated files
       const gitattributes = await getGeneratedFilePatterns(worktreePath);

package/src/github/client.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 const { Octokit } = require('@octokit/rest');
 const logger = require('../utils/logger');
+const { DEFAULT_SHA_ABBREV_LENGTH } = require('../git/sha-abbrev');
 
 /**
  * Custom error class for GitHub API errors that preserves the HTTP status code.
@@ -332,7 +333,7 @@ class GitHubClient {
       // Extract commit_id from first comment (all comments should have the same one)
       const commitId = comments.length > 0 ? comments[0].commit_id : null;
       if (commitId) {
-        console.log(`Using commit_id for review: ${commitId.substring(0, 7)}`);
+        console.log(`Using commit_id for review: ${commitId.substring(0, DEFAULT_SHA_ABBREV_LENGTH)}`);
       } else {
         console.warn('No commit_id available - review may fail for lines outside diff');
       }
@@ -1225,6 +1226,36 @@ class GitHubClient {
     
     throw lastError;
   }
+
+  /**
+   * Find an open PR for the given branch name.
+   * @param {string} owner - Repository owner
+   * @param {string} repo - Repository name
+   * @param {string} branch - Head branch name (without owner: prefix)
+   * @returns {Promise<{baseBranch: string, prNumber: number}|null>} Base branch info or null
+   */
+  async findPRByBranch(owner, repo, branch) {
+    try {
+      const { data: pulls } = await this.octokit.rest.pulls.list({
+        owner,
+        repo,
+        head: `${owner}:${branch}`,
+        state: 'open',
+        per_page: 1
+      });
+
+      if (pulls.length > 0) {
+        return {
+          baseBranch: pulls[0].base.ref,
+          prNumber: pulls[0].number
+        };
+      }
+      return null;
+    } catch (error) {
+      logger.warn(`Could not look up PR for branch ${branch}: ${error.message}`);
+      return null;
+    }
+  }
 }
 
 module.exports = { GitHubClient, GitHubApiError, isComplexityError };

package/src/hooks/hook-runner.js

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * Hook execution engine.
+ *
+ * Spawns user-configured commands for lifecycle events, piping a JSON
+ * payload to each command's stdin.  All hooks are fire-and-forget —
+ * failures are logged but never block the caller.
+ */
+
+const { spawn } = require('child_process');
+const logger = require('../utils/logger');
+
+const HOOK_TIMEOUT_MS = 5000;
+
+const defaults = {
+  spawn,
+  logger,
+};
+
+/**
+ * Fire all hooks registered for `eventName`.
+ *
+ * @param {string} eventName  - e.g. 'review.started', 'analysis.completed'
+ * @param {Object} payload    - JSON-serialisable event data
+ * @param {Object} config     - app config (must contain `hooks` key)
+ * @param {Object} [_deps]    - dependency overrides (testing)
+ */
+function fireHooks(eventName, payload, config, _deps) {
+  const deps = { ...defaults, ..._deps };
+  const hookMap = config?.hooks?.[eventName];
+  if (!hookMap || typeof hookMap !== 'object') return;
+
+  const json = JSON.stringify(payload);
+
+  for (const [name, hook] of Object.entries(hookMap)) {
+    if (!hook?.command) continue;
+    spawnHook(name, hook.command, json, deps);
+  }
+}
+
+/**
+ * Spawn a single hook command, pipe `json` to its stdin, and enforce a timeout.
+ */
+function spawnHook(name, command, json, deps) {
+  const label = `${name} (${command})`;
+  try {
+    const child = deps.spawn(command, [], {
+      shell: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    const timer = setTimeout(() => {
+      deps.logger.warn(`Hook timed out after ${HOOK_TIMEOUT_MS}ms, killing: ${label}`);
+      child.kill('SIGTERM');
+    }, HOOK_TIMEOUT_MS);
+
+    child.on('close', () => clearTimeout(timer));
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      deps.logger.warn(`Hook error (${label}): ${err.message}`);
+    });
+
+    if (child.stdout) {
+      child.stdout.on('data', (data) => {
+        deps.logger.debug(`Hook stdout [${name}]: ${data.toString().trimEnd()}`);
+      });
+    }
+
+    if (child.stderr) {
+      child.stderr.on('data', (data) => {
+        deps.logger.warn(`Hook stderr [${name}]: ${data.toString().trimEnd()}`);
+      });
+    }
+
+    child.stdin.on('error', (err) => {
+      deps.logger.warn(`Hook stdin error (${label}): ${err.message}`);
+    });
+
+    child.stdin.write(json);
+    child.stdin.end();
+  } catch (err) {
+    deps.logger.warn(`Hook spawn failed (${label}): ${err.message}`);
+  }
+}
+
+/**
+ * Check whether any hooks are registered for `eventName`.
+ * Use this to skip expensive async work (e.g. getCachedUser) when no hooks exist.
+ *
+ * @param {string} eventName - e.g. 'chat.started'
+ * @param {Object} config    - app config
+ * @returns {boolean}
+ */
+function hasHooks(eventName, config) {
+  const hookMap = config?.hooks?.[eventName];
+  return hookMap && typeof hookMap === 'object' && Object.keys(hookMap).length > 0;
+}
+
+module.exports = { fireHooks, hasHooks };

package/src/hooks/payloads.js

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * Hook payload builders.
+ *
+ * Pure functions that assemble event-specific JSON payloads from
+ * route-level data.  Keeps integration-point changes minimal.
+ */
+
+const { version } = require('../../package.json');
+const logger = require('../utils/logger');
+const { getGitHubToken } = require('../config');
+
+const defaultDeps = {
+  GitHubClient: null,   // lazy-loaded to avoid circular deps
+  getGitHubToken,
+  logger,
+};
+
+// Module-level user cache (one GitHub API call per server session)
+let cachedUser = undefined; // undefined = not yet resolved, null = no token / failed
+
+// ── Shared context builder ──────────────────────────────────────
+
+function buildContextFields({ mode, prContext, localContext, user }) {
+  const fields = { mode };
+  if (user) fields.user = user;
+  if (mode === 'pr' && prContext) {
+    fields.pr = { ...prContext };
+  } else if (mode === 'local' && localContext) {
+    fields.local = { ...localContext };
+  }
+  return fields;
+}
+
+// ── Review payloads ─────────────────────────────────────────────
+
+function buildReviewPayload(event, { reviewId, mode, prContext, localContext, user }) {
+  return {
+    event,
+    timestamp: new Date().toISOString(),
+    version,
+    reviewId,
+    ...buildContextFields({ mode, prContext, localContext, user }),
+  };
+}
+
+function buildReviewStartedPayload(opts) {
+  return buildReviewPayload('review.started', opts);
+}
+
+function buildReviewLoadedPayload(opts) {
+  return buildReviewPayload('review.loaded', opts);
+}
+
+// ── Analysis payloads ───────────────────────────────────────────
+
+function buildAnalysisStartedPayload({ reviewId, analysisId, provider, model, mode, prContext, localContext, user }) {
+  return {
+    event: 'analysis.started',
+    timestamp: new Date().toISOString(),
+    version,
+    reviewId,
+    analysisId,
+    provider: provider ?? null,
+    model: model ?? null,
+    ...buildContextFields({ mode, prContext, localContext, user }),
+  };
+}
+
+function buildAnalysisCompletedPayload({
+  reviewId, analysisId, provider, model, status,
+  totalSuggestions, mode, prContext, localContext, user,
+}) {
+  return {
+    event: 'analysis.completed',
+    timestamp: new Date().toISOString(),
+    version,
+    reviewId,
+    analysisId,
+    provider: provider ?? null,
+    model: model ?? null,
+    status,
+    totalSuggestions: totalSuggestions ?? 0,
+    ...buildContextFields({ mode, prContext, localContext, user }),
+  };
+}
+
+// ── Chat payloads ───────────────────────────────────────────────
+
+function buildChatPayload(event, { reviewId, sessionId, provider, model, mode, prContext, localContext, user }) {
+  return {
+    event,
+    timestamp: new Date().toISOString(),
+    version,
+    reviewId,
+    sessionId,
+    provider: provider ?? null,
+    model: model ?? null,
+    ...buildContextFields({ mode, prContext, localContext, user }),
+  };
+}
+
+function buildChatStartedPayload(opts) {
+  return buildChatPayload('chat.started', opts);
+}
+
+function buildChatResumedPayload(opts) {
+  return buildChatPayload('chat.resumed', opts);
+}
+
+/**
+ * Derive hook context fields (mode, prContext/localContext) from a review record.
+ * @param {Object} review - Review record from the database
+ * @returns {{ mode: string, prContext?: Object, localContext?: Object }}
+ */
+function buildChatHookContext(review) {
+  if (review.review_type === 'local') {
+    return {
+      mode: 'local',
+      localContext: {
+        path: review.local_path ?? null,
+        branch: review.local_head_branch ?? null,
+        headSha: review.local_head_sha ?? null,
+      },
+    };
+  }
+  const [owner, repo] = (review.repository || '').split('/');
+  return {
+    mode: 'pr',
+    prContext: {
+      number: review.pr_number ?? null,
+      owner: owner || null,
+      repo: repo || null,
+    },
+  };
+}
+
+// ── User identity ───────────────────────────────────────────────
+
+/**
+ * Resolve the current GitHub user, caching the result for the server session.
+ * Returns `{ login }` or `null` if no token / lookup fails.
+ */
+async function getCachedUser(config, _deps) {
+  if (cachedUser !== undefined) return cachedUser;
+
+  const deps = { ...defaultDeps, ..._deps };
+
+  const token = deps.getGitHubToken(config || {});
+  if (!token) {
+    cachedUser = null;
+    return null;
+  }
+
+  try {
+    // Lazy-load to avoid circular dependency at require time
+    const GHClient = deps.GitHubClient || require('../github/client').GitHubClient;
+    const client = new GHClient(token);
+    const user = await client.getAuthenticatedUser();
+    cachedUser = { login: user.login };
+  } catch (err) {
+    deps.logger.warn(`Failed to resolve GitHub user for hooks: ${err.message}`);
+    cachedUser = null;
+  }
+
+  return cachedUser;
+}
+
+function _resetUserCache() {
+  cachedUser = undefined;
+}
+
+// ── Convenience: fire review.started in one call ────────────────
+
+const defaultFireDeps = {
+  fireHooks: null, // lazy-loaded to avoid circular deps
+};
+
+/**
+ * Build and fire a `review.started` hook for a PR review.
+ *
+ * Encapsulates the full sequence: build prContext, resolve the GitHub
+ * user, assemble the payload, and fire. Callers should use `.catch()`.
+ */
+async function fireReviewStartedHook({ reviewId, prNumber, owner, repo, prData, config }, _deps) {
+  const deps = { ...defaultFireDeps, ..._deps };
+  const { hasHooks } = require('./hook-runner');
+  if (!hasHooks('review.started', config)) return;
+
+  const prContext = {
+    number: prNumber, owner, repo,
+    author: prData.author, baseBranch: prData.base_branch, headBranch: prData.head_branch,
+    baseSha: prData.base_sha || null, headSha: prData.head_sha || null,
+  };
+  const user = await getCachedUser(config);
+  const payload = buildReviewStartedPayload({ reviewId, mode: 'pr', prContext, user });
+  const fire = deps.fireHooks || require('./hook-runner').fireHooks;
+  fire('review.started', payload, config);
+}
+
+module.exports = {
+  buildReviewStartedPayload,
+  buildReviewLoadedPayload,
+  buildAnalysisStartedPayload,
+  buildAnalysisCompletedPayload,
+  buildChatStartedPayload,
+  buildChatResumedPayload,
+  buildChatHookContext,
+  getCachedUser,
+  fireReviewStartedHook,
+  _resetUserCache,
+};