@in-the-loop-labs/pair-review 1.6.2 → 2.0.1

package/src/routes/shared.js

@@ -23,8 +23,9 @@ class CancellationError extends Error {
 // Store active analysis runs in memory for status tracking
 const activeAnalyses = new Map();
 
-// Store mapping of PR (owner/repo/number) to analysis ID for tracking
-const prToAnalysisId = new Map();
+// Store mapping of integer reviewId to analysis UUID for tracking.
+// Unified map: replaces the previous separate prToAnalysisId and localReviewToAnalysisId maps.
+const reviewToAnalysisId = new Map();
 
 // Store SSE clients for real-time progress updates
 const progressClients = new Map();
@@ -37,9 +38,6 @@ const localReviewDiffs = new Map();
 // Maps analysisId -> Set of ChildProcess objects
 const activeProcesses = new Map();
 
-// Store mapping of local review key to analysis ID for tracking
-const localReviewToAnalysisId = new Map();
-
 // Store active review setup operations (concurrency guard)
 // Maps setupKey (e.g., "pr:owner/repo/123" or "local:/path") -> { setupId, promise }
 const activeSetups = new Map();
@@ -48,26 +46,6 @@ const activeSetups = new Map();
 // Maps setupId -> Set of response objects
 const setupProgressClients = new Map();
 
-/**
- * Generate a consistent PR key for mapping
- * @param {string} owner - Repository owner
- * @param {string} repo - Repository name
- * @param {number} prNumber - Pull request number
- * @returns {string} PR key in format "owner/repo/number"
- */
-function getPRKey(owner, repo, prNumber) {
-  return `${owner}/${repo}/${prNumber}`;
-}
-
-/**
- * Generate a consistent key for local review mapping
- * @param {number} reviewId - Local review ID
- * @returns {string} Review key
- */
-function getLocalReviewKey(reviewId) {
-  return `local/${reviewId}`;
-}
-
 /**
  * Get the model to use for AI analysis
  * Priority: CLI flag (PAIR_REVIEW_MODEL env var) > config.default_model > 'opus' default
@@ -447,15 +425,12 @@ function parseEnabledLevels(requestEnabledLevels, skipLevel3 = false) {
 module.exports = {
   CancellationError,
   activeAnalyses,
-  prToAnalysisId,
-  localReviewToAnalysisId,
+  reviewToAnalysisId,
   progressClients,
   localReviewDiffs,
   activeProcesses,
   activeSetups,
   setupProgressClients,
-  getPRKey,
-  getLocalReviewKey,
   getModel,
   determineCompletionInfo,
   broadcastProgress,

package/src/server.js

@@ -9,6 +9,7 @@ const logger = require('./utils/logger');
 
 let db = null;
 let server = null;
+let chatSessionManager = null;
 
 /**
  * Request logging middleware (disabled for cleaner output)
@@ -248,20 +249,29 @@ async function startServer(sharedDb = null) {
     // API routes - split into focused modules
     // Order matters: more specific routes must be mounted before general ones
     // to ensure proper route matching
-    const analysisRoutes = require('./routes/analysis');
+    const analysisRoutes = require('./routes/analyses');
     const worktreesRoutes = require('./routes/worktrees');
-    const commentsRoutes = require('./routes/comments');
+    const reviewsRoutes = require('./routes/reviews');
     const configRoutes = require('./routes/config');
     const prRoutes = require('./routes/pr');
     const localRoutes = require('./routes/local');
     const setupRoutes = require('./routes/setup');
     const mcpRoutes = require('./routes/mcp');
     const councilRoutes = require('./routes/councils');
+    const chatRoutes = require('./routes/chat');
+    const contextFilesRoutes = require('./routes/context-files');
+
+    // Initialize chat session manager
+    const ChatSessionManager = require('./chat/session-manager');
+    chatSessionManager = new ChatSessionManager(db);
+    app.chatSessionManager = chatSessionManager;
 
     // Mount specific routes first to ensure they match before general PR routes
+    app.use('/', chatRoutes);
     app.use('/', analysisRoutes);
     app.use('/', councilRoutes);
-    app.use('/', commentsRoutes);
+    app.use('/', reviewsRoutes);
+    app.use('/', contextFilesRoutes);
     app.use('/', configRoutes);
     app.use('/', worktreesRoutes);
     app.use('/', localRoutes);
@@ -283,15 +293,18 @@ async function startServer(sharedDb = null) {
     // Find available port and start server
     const port = await findAvailablePort(app, config.port);
 
+    // Check provider availability before accepting requests so /api/config
+    // returns accurate pi_available on the very first request (avoids race
+    // condition where the frontend fetches config before the cache is populated)
+    const defaultProvider = config.default_provider || 'claude';
+    try {
+      await checkAllProviders(defaultProvider);
+    } catch (err) {
+      console.warn('Provider availability check failed:', err.message);
+    }
+
     server = app.listen(port, () => {
       console.log(`Server running on http://localhost:${port}`);
-
-      // Check provider availability in background after server is listening
-      // Use the configured default provider as priority (if set)
-      const defaultProvider = config.default_provider || 'claude';
-      checkAllProviders(defaultProvider).catch(err => {
-        console.warn('Background provider availability check failed:', err.message);
-      });
     });
 
     server.on('error', (error) => {
@@ -318,9 +331,18 @@ async function startServer(sharedDb = null) {
 /**
  * Graceful shutdown handler
  */
-function gracefulShutdown(signal) {
+async function gracefulShutdown(signal) {
   console.log('\nServer shutting down...');
-  
+
+  // Close all active chat sessions
+  if (chatSessionManager) {
+    try {
+      await chatSessionManager.closeAll();
+    } catch (error) {
+      console.error('Error closing chat sessions:', error.message);
+    }
+  }
+
   if (server) {
     server.close(() => {
       if (db) {

package/src/sse/review-events.js

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * Shared SSE client registry and review-scoped event broadcaster.
+ *
+ * All SSE connections (chat, analysis, etc.) share a single Set of
+ * Express response objects.  broadcastReviewEvent sends review-level
+ * events (as opposed to session-level events handled in chat.js).
+ */
+
+const logger = require('../utils/logger');
+
+/**
+ * Connected SSE clients shared across all route modules.
+ * Each entry is an Express response object with an open SSE connection.
+ * @type {Set<import('express').Response>}
+ */
+const sseClients = new Set();
+
+/**
+ * Broadcast a review-scoped SSE event to all connected clients.
+ * Optionally includes a `sourceClientId` so the originating browser tab
+ * can recognise (and skip) its own echo.
+ *
+ * @param {number} reviewId - Review ID to include in the event
+ * @param {Object} payload - Event data (must include at minimum a `type` field)
+ * @param {Object} [options]
+ * @param {string} [options.sourceClientId] - Client ID of the tab that triggered the mutation
+ */
+function broadcastReviewEvent(reviewId, payload, options = {}) {
+  const envelope = { ...payload, reviewId };
+  if (options.sourceClientId) {
+    envelope.sourceClientId = options.sourceClientId;
+  }
+  const data = JSON.stringify(envelope);
+  for (const client of sseClients) {
+    try {
+      client.write(`data: ${data}\n\n`);
+    } catch {
+      // Client disconnected — remove from set
+      sseClients.delete(client);
+      logger.debug('[ReviewEvents] Removed disconnected SSE client');
+    }
+  }
+}
+
+module.exports = { sseClients, broadcastReviewEvent };

package/src/utils/auto-context.js

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+const { getDiffFileList } = require('./diff-file-list');
+const { ContextFileRepository } = require('../database');
+const logger = require('./logger');
+
+const LINE_PADDING = 10;
+const FILE_COMMENT_DEFAULT_LINES = 50;
+const MAX_RANGE = 500;
+
+/**
+ * Ensure a context file entry exists for a comment that targets a file
+ * outside the review's diff. If the file IS in the diff, this is a no-op.
+ *
+ * @param {object} db       - SQLite database handle
+ * @param {object} review   - Review row from the database
+ * @param {object} opts
+ * @param {string} opts.file       - File path the comment targets
+ * @param {number|null} opts.line_start - Start line (falsy for file-level comments)
+ * @param {number|null} opts.line_end   - End line
+ * @returns {Promise<{created: boolean, expanded: boolean, contextFileId?: number}>}
+ */
+async function ensureContextFileForComment(db, review, { file, line_start, line_end }) {
+  try {
+    // 1. If the file is already in the diff, nothing to do
+    const diffFiles = await getDiffFileList(db, review);
+    if (diffFiles.includes(file)) {
+      return { created: false, expanded: false };
+    }
+
+    // 2. Compute desired range
+    let desiredStart, desiredEnd;
+    if (line_start) {
+      desiredStart = Math.max(1, line_start - LINE_PADDING);
+      desiredEnd = (line_end ?? line_start) + LINE_PADDING;
+    } else {
+      desiredStart = 1;
+      desiredEnd = FILE_COMMENT_DEFAULT_LINES;
+    }
+
+    // 3. Clamp total range to MAX_RANGE
+    if (desiredEnd - desiredStart + 1 > MAX_RANGE) {
+      desiredEnd = desiredStart + MAX_RANGE - 1;
+    }
+
+    // 4. Look up existing context file entries for this file
+    const contextFileRepo = new ContextFileRepository(db);
+    const existing = await contextFileRepo.getByReviewIdAndFile(review.id, file);
+
+    if (existing.length > 0) {
+      // 5. Check if ANY existing entry already covers the desired range
+      const covering = existing.find(e => e.line_start <= desiredStart && e.line_end >= desiredEnd);
+      if (covering) {
+        return { created: false, expanded: false };
+      }
+
+      // 6. Find an entry that overlaps with the desired range
+      const overlapping = existing.find(e =>
+        e.line_start <= desiredEnd && e.line_end >= desiredStart
+      );
+
+      if (overlapping) {
+        // 7. Expand to the union of old and desired ranges
+        let newStart = Math.min(overlapping.line_start, desiredStart);
+        let newEnd = Math.max(overlapping.line_end, desiredEnd);
+
+        if (newEnd - newStart + 1 > MAX_RANGE) {
+          newEnd = newStart + MAX_RANGE - 1;
+        }
+
+        await contextFileRepo.updateRange(overlapping.id, newStart, newEnd);
+        return { created: false, expanded: true, contextFileId: overlapping.id };
+      }
+
+      // No overlapping entry — fall through to create a new one
+    }
+
+    // 8. No existing entry — create one
+    const inserted = await contextFileRepo.add(
+      review.id, file, desiredStart, desiredEnd, 'Auto-added for comment'
+    );
+    return { created: true, expanded: false, contextFileId: inserted.id };
+  } catch (err) {
+    logger.warn(`[AutoContext] Failed to ensure context file: ${err.message}`);
+    return { created: false, expanded: false };
+  }
+}
+
+module.exports = { ensureContextFileForComment };

package/src/utils/category-emoji.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * Canonical category-to-emoji mapping for AI suggestion types.
+ * Used by server-side code to format adopted comments.
+ *
+ * Canonical types from src/ai/prompts/shared/output-schema.js:
+ * bug|improvement|praise|suggestion|design|performance|security|code-style
+ */
+
+const CATEGORY_EMOJI_MAP = {
+  'bug': '\u{1F41B}',           // bug
+  'improvement': '\u{1F4A1}',   // lightbulb
+  'praise': '\u{2B50}',         // star
+  'suggestion': '\u{1F4AC}',    // speech bubble
+  'design': '\u{1F4D0}',        // triangular ruler
+  'performance': '\u{26A1}',    // high voltage
+  'security': '\u{1F512}',      // lock
+  'code-style': '\u{1F3A8}',    // artist palette
+  'style': '\u{1F3A8}'          // artist palette (alias for code-style)
+};
+
+const DEFAULT_EMOJI = '\u{1F4AC}'; // speech bubble
+
+/**
+ * Get emoji for a suggestion category
+ * @param {string} category - Category name
+ * @returns {string} Emoji character
+ */
+function getEmoji(category) {
+  return CATEGORY_EMOJI_MAP[category] || DEFAULT_EMOJI;
+}
+
+module.exports = { CATEGORY_EMOJI_MAP, DEFAULT_EMOJI, getEmoji };

package/src/utils/diff-annotator.js

@@ -187,6 +187,7 @@ function annotateDiff(rawDiff) {
   }
 
   const lines = rawDiff.split('\n');
+  if (lines[lines.length - 1] === '') lines.pop();
   const output = [];
 
   let currentFile = {};
@@ -404,11 +405,84 @@ function parseAnnotatedDiff(annotatedDiff) {
   return files;
 }
 
+/**
+ * Build a lookup of which file+side+line combinations appear in diff hunks.
+ * Used to determine whether a comment targets a line GitHub can render inline
+ * (inside a hunk) vs. one that must be submitted as file-level.
+ *
+ * @param {string} rawDiff - Raw unified diff from git
+ * @returns {{ isLineInDiff: (file: string, line: number, side?: string) => boolean }}
+ */
+function buildDiffLineSet(rawDiff) {
+  if (!rawDiff || rawDiff.trim() === '') {
+    return { isLineInDiff: () => false };
+  }
+
+  const entries = new Set();
+  const diffLines = rawDiff.split('\n');
+  // Trim trailing empty element produced by split('\n') on newline-terminated input.
+  // Without this, the empty string matches the context-line branch and adds phantom
+  // entries for lines beyond the actual hunk boundary.
+  if (diffLines[diffLines.length - 1] === '') diffLines.pop();
+  let currentFile = {};
+  let oldLineNum = 0;
+  let newLineNum = 0;
+  let inHunk = false;
+
+  for (const line of diffLines) {
+    if (line.startsWith('diff --git')) {
+      currentFile = {};
+      inHunk = false;
+      parseFileHeader(line, currentFile);
+      continue;
+    }
+
+    if (parseFileHeader(line, currentFile)) {
+      continue;
+    }
+
+    const hunkInfo = parseHunkHeader(line);
+    if (hunkInfo) {
+      oldLineNum = hunkInfo.oldStart;
+      newLineNum = hunkInfo.newStart;
+      inHunk = true;
+      continue;
+    }
+
+    if (!inHunk) continue;
+
+    if (line.startsWith('\\ No newline')) continue;
+
+    const filePath = currentFile.newPath || currentFile.oldPath;
+    if (!filePath) continue;
+
+    if (line.startsWith('+')) {
+      entries.add(`${filePath}:RIGHT:${newLineNum}`);
+      newLineNum++;
+    } else if (line.startsWith('-')) {
+      entries.add(`${filePath}:LEFT:${oldLineNum}`);
+      oldLineNum++;
+    } else if (line.startsWith(' ') || line === '') {
+      entries.add(`${filePath}:LEFT:${oldLineNum}`);
+      entries.add(`${filePath}:RIGHT:${newLineNum}`);
+      oldLineNum++;
+      newLineNum++;
+    }
+  }
+
+  return {
+    isLineInDiff(file, lineNum, side = 'RIGHT') {
+      return entries.has(`${file}:${side}:${lineNum}`);
+    }
+  };
+}
+
 module.exports = {
   annotateDiff,
   parseAnnotatedDiff,
   parseHunkHeader,
   formatLineNum,
   getLineMarker,
-  getLineContent
+  getLineContent,
+  buildDiffLineSet
 };

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

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const { queryOne } = require('../database');
+
+const execPromise = promisify(exec);
+
+/**
+ * Return the list of file paths that belong to the review's diff.
+ * Works for both PR-mode and local-mode reviews.
+ *
+ * @param {object} db   - SQLite database handle
+ * @param {object} review - Review row from the database
+ * @returns {Promise<string[]>} Array of relative file paths in the diff
+ */
+async function getDiffFileList(db, review) {
+  // PR mode – pull from pr_metadata table
+  if (review.pr_number && review.repository) {
+    try {
+      const prRecord = await queryOne(db, `
+        SELECT pr_data FROM pr_metadata
+        WHERE pr_number = ? AND repository = ? COLLATE NOCASE
+      `, [review.pr_number, review.repository]);
+
+      if (prRecord?.pr_data) {
+        const prData = JSON.parse(prRecord.pr_data);
+        return (prData.changed_files || []).map(f => f.file);
+      }
+    } catch {
+      // parse / query error – fall through to empty list
+    }
+    return [];
+  }
+
+  // Local mode – ask git for changed / untracked files
+  if (review.local_path) {
+    try {
+      const opts = { cwd: review.local_path };
+      const [{ stdout: unstaged }, { stdout: untracked }] = await Promise.all([
+        execPromise('git diff --name-only', opts),
+        execPromise('git ls-files --others --exclude-standard', opts),
+      ]);
+      const combined = `${unstaged}\n${untracked}`
+        .split('\n')
+        .map(l => l.trim())
+        .filter(Boolean);
+      return [...new Set(combined)];
+    } catch {
+      // git error – fall through to empty list
+    }
+    return [];
+  }
+
+  return [];
+}
+
+module.exports = { getDiffFileList };