@in-the-loop-labs/pair-review 3.3.6 → 3.4.0

package/src/single-port.js

@@ -0,0 +1,191 @@
+// Copyright 2026 Tim Perkins (tjwp) | SPDX-License-Identifier: Apache-2.0
+const http = require('http');
+const path = require('path');
+const semver = require('semver');
+const { PRArgumentParser } = require('./github/parser');
+const logger = require('./utils/logger');
+const { version: packageVersion } = require('../package.json');
+
+const HEALTH_TIMEOUT_MS = 2000;
+
+// Default dependencies (overridable for testing)
+const defaults = {
+  httpGet: http.get,
+  httpRequest: http.request,
+  logger,
+  open: (...args) => process.env.PAIR_REVIEW_NO_OPEN
+    ? Promise.resolve()
+    : import('open').then(({ default: open }) => open(...args)),
+  PRArgumentParser
+};
+
+/**
+ * Check if a pair-review server is already running on the given port.
+ * @param {number} port
+ * @param {object} [_deps] - Dependency overrides for testing
+ * @returns {Promise<{running: boolean, isPairReview?: boolean, version?: string}>}
+ */
+function detectRunningServer(port, _deps) {
+  const deps = { ...defaults, ..._deps };
+  return new Promise((resolve) => {
+    const req = deps.httpGet(`http://localhost:${port}/health`, { timeout: HEALTH_TIMEOUT_MS }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const body = JSON.parse(data);
+          if (body.service === 'pair-review') {
+            resolve({ running: true, isPairReview: true, version: body.version || null });
+          } else {
+            resolve({ running: true, isPairReview: false });
+          }
+        } catch {
+          resolve({ running: true, isPairReview: false });
+        }
+      });
+    });
+
+    req.on('error', () => {
+      resolve({ running: false });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ running: false });
+    });
+  });
+}
+
+/**
+ * Notify the running server that a newer version is available.
+ * Fire-and-forget — does not block on response.
+ * @param {number} port
+ * @param {string} currentVersion - Version of the current CLI invocation
+ * @param {object} [_deps] - Dependency overrides for testing
+ */
+function notifyVersion(port, currentVersion, _deps) {
+  const deps = { ...defaults, ..._deps };
+  const payload = JSON.stringify({ version: currentVersion });
+  const req = deps.httpRequest({
+    hostname: 'localhost',
+    port,
+    path: '/api/notify-update',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(payload)
+    },
+    timeout: HEALTH_TIMEOUT_MS
+  }, () => { /* ignore response */ });
+
+  req.on('error', () => { /* fire and forget */ });
+  req.on('timeout', () => { req.destroy(); });
+  req.write(payload);
+  req.end();
+}
+
+/**
+ * Build the URL to delegate to an existing server.
+ * @param {number} port
+ * @param {'pr'|'local'|'server'} mode
+ * @param {object} context
+ * @param {string} [context.owner]
+ * @param {string} [context.repo]
+ * @param {number} [context.number]
+ * @param {string} [context.localPath]
+ * @param {boolean} [context.analyze] - Whether to trigger auto-analysis
+ * @returns {string} Full URL
+ */
+function buildDelegationUrl(port, mode, context = {}) {
+  const base = `http://localhost:${port}`;
+  if (mode === 'pr') {
+    let url = `${base}/pr/${context.owner}/${context.repo}/${context.number}`;
+    if (context.analyze) url += '?analyze=true';
+    return url;
+  }
+  if (mode === 'local') {
+    let url = `${base}/local?path=${encodeURIComponent(context.localPath)}`;
+    if (context.analyze) url += '&analyze=true';
+    return url;
+  }
+  return `${base}/`;
+}
+
+/**
+ * Parse PR arguments for URL construction without starting a server.
+ * Reuses PRArgumentParser — synchronous for URLs, async for bare numbers.
+ * @param {string[]} prArgs - Raw CLI PR arguments
+ * @param {object} [_deps] - Dependency overrides for testing
+ * @returns {Promise<{owner: string, repo: string, number: number}>}
+ */
+async function parsePRArgsForDelegation(prArgs, _deps) {
+  const deps = { ...defaults, ..._deps };
+  const parser = new deps.PRArgumentParser();
+  return parser.parsePRArguments(prArgs);
+}
+
+/**
+ * Attempt single-port delegation. Returns true if delegation happened (caller should exit).
+ * Returns false if no running server was found (caller should start normally).
+ * Throws if port is occupied by a non-pair-review service.
+ *
+ * @param {object} config - Loaded config
+ * @param {object} flags - Parsed CLI flags
+ * @param {string[]} prArgs - PR arguments from CLI
+ * @param {object} [_deps] - Dependency overrides for testing
+ * @returns {Promise<boolean>} true if delegated, false if should start fresh
+ */
+async function attemptDelegation(config, flags, prArgs, _deps) {
+  const deps = { ...defaults, ..._deps };
+  const port = config.port;
+
+  const result = await detectRunningServer(port, _deps);
+
+  if (result.running && !result.isPairReview) {
+    throw new Error(
+      `Port ${port} is in use by another service. ` +
+      `Either stop that service, or set a different port in ~/.pair-review/config.json`
+    );
+  }
+
+  if (!result.running) {
+    return false;
+  }
+
+  // Server is running — delegate to it
+  deps.logger.info(`Existing pair-review server detected on port ${port} (v${result.version})`);
+
+  // Determine mode and build URL
+  let url;
+  if (flags.local) {
+    const targetPath = path.resolve(flags.localPath || process.cwd());
+    url = buildDelegationUrl(port, 'local', { localPath: targetPath, analyze: flags.ai });
+  } else if (prArgs.length > 0) {
+    const prInfo = await parsePRArgsForDelegation(prArgs, _deps);
+    url = buildDelegationUrl(port, 'pr', { ...prInfo, analyze: flags.ai });
+  } else {
+    url = buildDelegationUrl(port, 'server');
+  }
+
+  // Notify running server of newer version if applicable
+  if (result.version && semver.valid(packageVersion) && semver.valid(result.version)) {
+    if (semver.gt(packageVersion, result.version)) {
+      deps.logger.info(`Notifying server of newer version: ${packageVersion} > ${result.version}`);
+      notifyVersion(port, packageVersion, _deps);
+    }
+  }
+
+  // Open browser and exit
+  deps.logger.info(`Delegating to running server: ${url}`);
+  await deps.open(url);
+  return true;
+}
+
+module.exports = {
+  detectRunningServer,
+  notifyVersion,
+  buildDelegationUrl,
+  parsePRArgsForDelegation,
+  attemptDelegation,
+  HEALTH_TIMEOUT_MS
+};

package/src/utils/diff-file-list.js

@@ -3,9 +3,111 @@ const { promisify } = require('util');
 const { exec } = require('child_process');
 const { queryOne } = require('../database');
 const { GIT_DIFF_FLAGS } = require('../git/diff-flags');
+const { normalizePath, resolveRenamedFile } = require('./paths');
 
 const execPromise = promisify(exec);
 
+/**
+ * Parse a unified diff into a map of file path -> per-file patch.
+ * Uses the "b/" path from the diff header as the canonical file path.
+ *
+ * @param {string} diff - Full unified diff
+ * @returns {Map<string, string>} Map of file paths to full patch text
+ */
+function parseUnifiedDiffPatches(diff) {
+  const filePatchMap = new Map();
+  if (!diff) return filePatchMap;
+
+  const parts = diff.split(/(?=^diff --git )/m);
+
+  for (const part of parts) {
+    if (!part.trim()) continue;
+
+    const match = part.match(/^diff --git a\/(.+?) b\/(.+)$/m);
+    if (match) {
+      filePatchMap.set(match[2], part);
+    }
+  }
+
+  return filePatchMap;
+}
+
+/**
+ * Count additions and deletions inside a single patch body.
+ *
+ * @param {string} patch - Per-file patch text
+ * @returns {{ insertions: number, deletions: number }}
+ */
+function countPatchStats(patch) {
+  let insertions = 0;
+  let deletions = 0;
+
+  for (const line of patch.split('\n')) {
+    if (line.startsWith('+') && !line.startsWith('+++ ')) {
+      insertions++;
+    } else if (line.startsWith('-') && !line.startsWith('--- ')) {
+      deletions++;
+    }
+  }
+
+  return { insertions, deletions };
+}
+
+/**
+ * Merge changed_files metadata with the authoritative file list from the diff.
+ * This recovers files when cached changed_files were derived from abbreviated
+ * diff --stat output and no longer match the full patch headers.
+ *
+ * @param {Array<object|string>} changedFiles - Existing changed_files array
+ * @param {string} diff - Full unified diff
+ * @returns {Array<object|string>} Merged changed_files array
+ */
+function mergeChangedFilesWithDiff(changedFiles, diff) {
+  const patchMap = parseUnifiedDiffPatches(diff);
+  if (patchMap.size === 0) {
+    return Array.isArray(changedFiles) ? changedFiles : [];
+  }
+
+  // Drop cached `git diff --stat` ellipsis stubs once we have authoritative
+  // patch headers to recover the full file paths from.
+  const existing = (Array.isArray(changedFiles) ? changedFiles : []).filter(entry => {
+    const filePath = typeof entry === 'string' ? entry : entry?.file;
+    return filePath && !filePath.includes('...');
+  });
+
+  const normalizedExisting = new Set(existing.map(file => {
+    const filePath = typeof file === 'string' ? file : file?.file;
+    return normalizePath(resolveRenamedFile(filePath));
+  }).filter(Boolean));
+
+  const merged = [...existing];
+
+  for (const [filePath, patch] of patchMap.entries()) {
+    const normalizedPatchPath = normalizePath(resolveRenamedFile(filePath));
+    if (normalizedExisting.has(normalizedPatchPath)) {
+      continue;
+    }
+
+    const { insertions, deletions } = countPatchStats(patch);
+    const renameFrom = patch.match(/^rename from (.+)$/m)?.[1] || null;
+    const renameTo = patch.match(/^rename to (.+)$/m)?.[1] || null;
+    const binary = /^Binary files .* differ$/m.test(patch) || /^GIT binary patch$/m.test(patch);
+
+    merged.push({
+      file: filePath,
+      insertions,
+      deletions,
+      changes: insertions + deletions,
+      binary,
+      renamed: Boolean(renameFrom && renameTo),
+      renamedFrom: renameFrom
+    });
+    normalizedExisting.add(normalizedPatchPath);
+  }
+
+  return merged;
+}
+
 /**
  * Return the list of file paths that belong to the review's diff.
  * Works for both PR-mode and local-mode reviews.
@@ -25,7 +127,9 @@ async function getDiffFileList(db, review) {
 
       if (prRecord?.pr_data) {
         const prData = JSON.parse(prRecord.pr_data);
-        return (prData.changed_files || []).map(f => f.file);
+        return mergeChangedFilesWithDiff(prData.changed_files || [], prData.diff || '')
+          .map(f => typeof f === 'string' ? f : f.file)
+          .filter(Boolean);
       }
     } catch {
       // parse / query error – fall through to empty list
@@ -55,4 +159,9 @@ async function getDiffFileList(db, review) {
   return [];
 }
 
-module.exports = { getDiffFileList };
+module.exports = {
+  getDiffFileList,
+  parseUnifiedDiffPatches,
+  countPatchStats,
+  mergeChangedFilesWithDiff
+};

package/src/utils/paths.js

@@ -13,6 +13,8 @@
  * - Handles interleaved patterns like '/./src' by iterating
  * - Normalizes multiple consecutive slashes to single slash
  * - Does NOT modify case (paths are case-sensitive on most systems)
+ * - Frontend mirror lives in `DiffRenderer.normalizeFilePath`
+ *   (`public/js/modules/diff-renderer.js`); keep behavior in sync
  *
  * @param {string} filePath - The file path to normalize
  * @returns {string} Normalized path
@@ -159,6 +161,8 @@ function normalizeRepository(owner, repo) {
  *   "tests/{old.js => new.js}"      → "tests/new.js"
  *   "{old-dir => new-dir}/file.js"  → "new-dir/file.js"
  *   "a/{b => c}/d.js"              → "a/c/d.js"
+ * Frontend mirror lives in `DiffRenderer.normalizeFilePath`
+ * (`public/js/modules/diff-renderer.js`); keep behavior in sync.
  *
  * @param {string} fileName - File name possibly containing rename syntax
  * @returns {string} Resolved file name with the new path, or original if no rename syntax