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

package/src/utils/comment-formatter.js

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/**
+ * Shared comment formatter for adopted AI suggestions.
+ * Provides configurable formatting with preset templates.
+ */
+
+const { getEmoji } = require('./category-emoji');
+
+/**
+ * Preset format templates for adopted comments.
+ * Template placeholders: {emoji}, {category}, {title}, {description}, {suggestion}
+ * Conditional sections: {?field}...{/field} — content is kept when field is truthy, stripped when falsy.
+ */
+const PRESETS = {
+  legacy: '{emoji} **{category}**: {description}{?suggestion}\n\n**Suggestion:** {suggestion}{/suggestion}',
+  minimal: '[{category}] {description}{?suggestion}\n\n{suggestion}{/suggestion}',
+  plain: '{description}{?suggestion}\n\n{suggestion}{/suggestion}',
+  'emoji-only': '{emoji} {description}{?suggestion}\n\n{suggestion}{/suggestion}',
+  maximal: '{emoji} **{category}**{?title}: {title}{/title}\n\n{description}{?suggestion}\n\n**Suggestion:** {suggestion}{/suggestion}'
+};
+
+/**
+ * Resolve a config value into a format configuration object.
+ * @param {string|Object|undefined} config - Preset name string, custom config object, or undefined
+ * @returns {{ template: string, emojiOverrides: Object, categoryOverrides: Object }}
+ */
+function resolveFormat(config) {
+  if (!config || typeof config === 'string') {
+    const presetName = config || 'legacy';
+    const template = PRESETS[presetName] || PRESETS.legacy;
+    return { template, emojiOverrides: {}, categoryOverrides: {} };
+  }
+
+  // Custom object config
+  return {
+    template: config.template || PRESETS.legacy,
+    emojiOverrides: config.emojiOverrides || {},
+    categoryOverrides: config.categoryOverrides || {}
+  };
+}
+
+/**
+ * Capitalize a hyphenated category name.
+ * e.g., 'code-style' -> 'Code Style', 'bug' -> 'Bug'
+ * @param {string} category
+ * @returns {string}
+ */
+function capitalizeCategory(category) {
+  return category
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+/**
+ * Process conditional sections in a template.
+ * Syntax: {?fieldName}content{/fieldName}
+ * When the field value is truthy, the delimiters are stripped and content is kept.
+ * When the field value is falsy/empty/undefined, the entire block is removed.
+ *
+ * @param {string} template - Template with conditional sections
+ * @param {Object} values - Map of field names to their values
+ * @returns {string} Template with conditional sections resolved
+ */
+function processConditionalSections(template, values) {
+  return template.replace(/\{\?(\w+)\}([\s\S]*?)\{\/\1\}/g, (match, fieldName, content) => {
+    const value = values[fieldName];
+    if (value !== undefined && value !== null && value !== '') {
+      return content;
+    }
+    return '';
+  });
+}
+
+/**
+ * Format an adopted comment using the given format configuration.
+ * Handles legacy data where suggestion_text was concatenated into body.
+ *
+ * @param {{ body: string, suggestionText?: string, category?: string, title?: string }} fields
+ * @param {{ template: string, emojiOverrides: Object, categoryOverrides: Object }} formatConfig
+ * @returns {string} Formatted comment text
+ */
+function formatAdoptedComment(fields, formatConfig) {
+  const { body, title } = fields;
+  let { category, suggestionText } = fields;
+
+  if (!category) {
+    return body || '';
+  }
+
+  category = category.toLowerCase();
+
+  // Legacy handling: if no separate suggestionText, try to split from body
+  let description = body || '';
+  if (!suggestionText && description.includes('\n\n**Suggestion:** ')) {
+    const splitIndex = description.indexOf('\n\n**Suggestion:** ');
+    suggestionText = description.slice(splitIndex + '\n\n**Suggestion:** '.length);
+    description = description.slice(0, splitIndex);
+  }
+
+  const config = formatConfig || resolveFormat();
+
+  // Resolve emoji from original category BEFORE applying overrides,
+  // so overridden categories keep the original category's emoji
+  const emoji = config.emojiOverrides?.[category] || getEmoji(category);
+
+  // Apply category overrides (e.g., "bug" -> "defect")
+  if (config.categoryOverrides && config.categoryOverrides[category]) {
+    category = config.categoryOverrides[category];
+  }
+  const capitalizedCategory = capitalizeCategory(category);
+
+  // Process conditional sections first, then replace individual placeholders
+  const fieldValues = {
+    suggestion: suggestionText || '',
+    title: title || '',
+    emoji,
+    category: capitalizedCategory,
+    description
+  };
+
+  let result = processConditionalSections(config.template, fieldValues);
+
+  // Replace placeholders
+  result = result.replace(/\{emoji\}/g, emoji);
+  result = result.replace(/\{category\}/g, capitalizedCategory);
+  result = result.replace(/\{title\}/g, title || '');
+  result = result.replace(/\{description\}/g, description);
+  result = result.replace(/\{suggestion\}/g, suggestionText || '');
+
+  // Ensure code fences start on their own line
+  result = result.replace(/([^\n])(```)/g, '$1\n$2');
+
+  return result.trimEnd();
+}
+
+module.exports = { PRESETS, resolveFormat, formatAdoptedComment, capitalizeCategory, processConditionalSections };

package/src/ws/index.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+module.exports = require('./server');

package/src/ws/server.js

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+const { WebSocketServer } = require('ws');
+const logger = require('../utils/logger');
+
+const HEARTBEAT_INTERVAL = 30000;
+
+let wss = null;
+let heartbeatTimer = null;
+
+/**
+ * Attach a WebSocket server to an existing HTTP server.
+ * Operates in noServer mode, handling upgrade requests on the /ws path only.
+ * @param {import('http').Server} httpServer
+ */
+function attachWebSocket(httpServer) {
+  wss = new WebSocketServer({ noServer: true });
+
+  httpServer.on('upgrade', (request, socket, head) => {
+    const { pathname } = new URL(request.url, `http://${request.headers.host}`);
+    if (pathname !== '/ws') {
+      socket.destroy();
+      return;
+    }
+
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      wss.emit('connection', ws, request);
+    });
+  });
+
+  wss.on('connection', (ws) => {
+    ws._topics = new Set();
+    ws.isAlive = true;
+
+    ws.on('pong', () => {
+      ws.isAlive = true;
+    });
+
+    ws.on('message', (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data);
+      } catch {
+        logger.warn('WS: received non-JSON message');
+        return;
+      }
+
+      const { action, topic } = msg;
+      if (!topic) return;
+
+      if (action === 'subscribe') {
+        ws._topics.add(topic);
+      } else if (action === 'unsubscribe') {
+        ws._topics.delete(topic);
+      }
+    });
+
+    ws.on('close', () => {
+      ws._topics.clear();
+    });
+
+    ws.on('error', (err) => {
+      logger.warn(`WS: client error: ${err.message}`);
+      ws._topics.clear();
+    });
+  });
+
+  // Heartbeat: ping every HEARTBEAT_INTERVAL, terminate dead connections
+  heartbeatTimer = setInterval(() => {
+    wss.clients.forEach((ws) => {
+      if (!ws.isAlive) {
+        logger.debug('WS: terminating unresponsive client');
+        ws.terminate();
+        return;
+      }
+      ws.isAlive = false;
+      ws.ping();
+    });
+  }, HEARTBEAT_INTERVAL);
+
+  logger.info('WebSocket server attached on /ws');
+}
+
+/**
+ * Broadcast a payload to all clients subscribed to the given topic.
+ * @param {string} topic
+ * @param {object} payload
+ */
+function broadcast(topic, payload) {
+  if (!wss) return;
+
+  const message = JSON.stringify({ ...payload, topic });
+
+  wss.clients.forEach((ws) => {
+    if (ws.readyState === ws.OPEN && ws._topics && ws._topics.has(topic)) {
+      try {
+        ws.send(message);
+      } catch (err) {
+        logger.debug(`WS: failed to send to client: ${err.message}`);
+      }
+    }
+  });
+}
+
+/**
+ * Close all connections and shut down the WebSocket server.
+ */
+function closeAll() {
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+
+  if (!wss) return;
+
+  wss.clients.forEach((ws) => {
+    ws.terminate();
+  });
+
+  wss.close();
+  wss = null;
+}
+
+module.exports = { attachWebSocket, broadcast, closeAll, get _wss() { return wss; } };

package/src/sse/review-events.js

@@ -1,46 +0,0 @@
-// 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 };