@in-the-loop-labs/pair-review 1.3.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Your AI-powered code review partner - Close the feedback loop with AI coding agents",
   "main": "src/server.js",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pair-review",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "pair-review app integration — Open PRs and local changes in the pair-review web UI, run server-side AI analysis, and address review feedback. Requires the pair-review MCP server.",
   "author": {
     "name": "in-the-loop-labs",

package/plugin-code-critic/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "code-critic",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "AI-powered code review analysis — Run three-level AI analysis and implement-review-fix loops directly in your coding agent. Works standalone, no server required.",
   "author": {
     "name": "in-the-loop-labs",

package/public/index.html

@@ -746,6 +746,57 @@
             font-size: 14px;
         }
 
+        /* Show More button for pagination */
+        .show-more-container {
+            display: flex;
+            justify-content: center;
+            padding: 16px 0 0;
+        }
+
+        .btn-show-more {
+            display: inline-flex;
+            align-items: center;
+            gap: 8px;
+            padding: 8px 24px;
+            font-family: var(--font-sans);
+            font-size: 13px;
+            font-weight: 500;
+            color: var(--color-text-secondary);
+            background: var(--color-bg-primary);
+            border: 1px solid var(--color-border-primary);
+            border-radius: var(--radius-md);
+            cursor: pointer;
+            transition: all var(--transition-fast);
+        }
+
+        .btn-show-more:hover:not(:disabled) {
+            background: var(--color-bg-secondary);
+            color: var(--color-text-primary);
+        }
+
+        .btn-show-more:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+
+        .btn-show-more .spinner {
+            width: 14px;
+            height: 14px;
+            border: 2px solid var(--color-border-primary);
+            border-top-color: var(--color-accent-primary);
+            border-radius: 50%;
+            animation: spin 0.8s linear infinite;
+            display: none;
+        }
+
+        .btn-show-more.loading .spinner {
+            display: block;
+        }
+
+        .btn-show-more.loading .btn-show-more-text {
+            display: none;
+        }
+
         /* Initial loading state - hide content until JS determines what to show */
         .loading-hidden {
             display: none !important;
@@ -1081,18 +1132,36 @@
             }
         }
 
-        // Event delegation for delete buttons
+        // Event delegation for delete buttons and show-more button
         document.addEventListener('click', function(event) {
             const deleteBtn = event.target.closest('.btn-delete-worktree');
             if (deleteBtn) {
                 event.preventDefault();
                 event.stopPropagation();
                 deleteWorktree(deleteBtn);
+                return;
+            }
+
+            const showMoreBtn = event.target.closest('#btn-show-more');
+            if (showMoreBtn) {
+                event.preventDefault();
+                loadMoreReviews();
             }
         });
 
+        /** Pagination state for the recent reviews list */
+        const recentReviewsPagination = {
+            /** ISO timestamp of the last loaded item (cursor for next fetch) */
+            lastTimestamp: null,
+            /** Number of worktrees to fetch per page */
+            pageSize: 10,
+            /** Whether the server has indicated more results exist */
+            hasMore: false
+        };
+
         /**
-         * Fetch and display recent reviews
+         * Fetch and display recent reviews (initial load).
+         * Resets pagination state and renders the full table from scratch.
          */
         async function loadRecentReviews() {
             const container = document.getElementById('recent-reviews-container');
@@ -1100,8 +1169,12 @@
             const sectionHeader = document.getElementById('recent-reviews-header');
             const usageInfo = document.getElementById('usage-info');
 
+            // Reset pagination state
+            recentReviewsPagination.lastTimestamp = null;
+            recentReviewsPagination.hasMore = false;
+
             try {
-                const response = await fetch('/api/worktrees/recent?limit=10');
+                const response = await fetch(`/api/worktrees/recent?limit=${recentReviewsPagination.pageSize}`);
 
                 if (!response.ok) {
                     throw new Error('Failed to fetch recent reviews');
@@ -1123,6 +1196,10 @@
                     return;
                 }
 
+                // Update pagination state — track the cursor for the next page
+                recentReviewsPagination.lastTimestamp = data.worktrees[data.worktrees.length - 1].last_accessed_at;
+                recentReviewsPagination.hasMore = !!data.hasMore;
+
                 // Hide usage info when there are reviews (keep loading-hidden class)
                 // Show the section header
                 if (sectionHeader) sectionHeader.classList.remove('loading-hidden');
@@ -1140,10 +1217,11 @@
                                 <th>Actions</th>
                             </tr>
                         </thead>
-                        <tbody>
+                        <tbody id="recent-reviews-tbody">
                             ${data.worktrees.map(renderRecentReviewRow).join('')}
                         </tbody>
                     </table>
+                    ${renderShowMoreButton(data.hasMore)}
                 `;
                 container.innerHTML = html;
                 container.classList.remove('recent-reviews-loading');
@@ -1156,6 +1234,90 @@
             }
         }
 
+        /**
+         * Render the "Show more" button HTML.
+         * @param {boolean} hasMore - Whether more results are available
+         * @returns {string} HTML string for the show-more container
+         */
+        function renderShowMoreButton(hasMore) {
+            if (!hasMore) return '';
+            return `
+                <div class="show-more-container" id="show-more-container">
+                    <button class="btn-show-more" id="btn-show-more" type="button">
+                        <span class="btn-show-more-text">Show more</span>
+                        <span class="spinner"></span>
+                    </button>
+                </div>
+            `;
+        }
+
+        /**
+         * Load the next page of worktrees and append them to the existing table.
+         * Called when the "Show more" button is clicked.
+         */
+        async function loadMoreReviews() {
+            const btn = document.getElementById('btn-show-more');
+            const tbody = document.getElementById('recent-reviews-tbody');
+            if (!btn || !tbody) return;
+
+            // Show loading state on the button
+            btn.classList.add('loading');
+            btn.disabled = true;
+
+            try {
+                const { lastTimestamp, pageSize } = recentReviewsPagination;
+                const params = new URLSearchParams({ limit: pageSize });
+                if (lastTimestamp) params.set('before', lastTimestamp);
+                const response = await fetch(`/api/worktrees/recent?${params}`);
+
+                if (!response.ok) {
+                    throw new Error('Failed to fetch more reviews');
+                }
+
+                const data = await response.json();
+
+                // Guard against stale response if the table was refreshed (e.g. by a delete) while loading
+                if (!document.contains(btn)) return;
+
+                if (!data.success || !data.worktrees || data.worktrees.length === 0) {
+                    // No more results - remove the button
+                    const showMoreContainer = document.getElementById('show-more-container');
+                    if (showMoreContainer) showMoreContainer.remove();
+                    recentReviewsPagination.hasMore = false;
+                    return;
+                }
+
+                // Append new rows to the existing table body
+                tbody.insertAdjacentHTML('beforeend', data.worktrees.map(renderRecentReviewRow).join(''));
+
+                // Update pagination state — advance the cursor
+                recentReviewsPagination.lastTimestamp = data.worktrees[data.worktrees.length - 1].last_accessed_at;
+                recentReviewsPagination.hasMore = !!data.hasMore;
+
+                // Update or remove the "Show more" button
+                if (!data.hasMore) {
+                    const showMoreContainer = document.getElementById('show-more-container');
+                    if (showMoreContainer) showMoreContainer.remove();
+                } else {
+                    // Reset button state
+                    btn.classList.remove('loading');
+                    btn.disabled = false;
+                }
+
+            } catch (error) {
+                console.error('Error loading more reviews:', error);
+                // Reset button state and show error so the user knows what happened
+                btn.classList.remove('loading');
+                btn.disabled = false;
+                const textEl = btn.querySelector('.btn-show-more-text');
+                if (textEl) {
+                    textEl.textContent = 'Failed to load — click to retry';
+                    // Restore original text after a brief delay so the user sees the error
+                    setTimeout(() => { textEl.textContent = 'Show more'; }, 4000);
+                }
+            }
+        }
+
         /**
          * Parse a PR URL using the backend API
          * Supports GitHub and Graphite URLs (with or without protocol)

package/public/js/local.js

@@ -1192,6 +1192,15 @@ class LocalManager {
       // Reload the diff display
       await this.loadLocalDiff();
 
+      // Re-render comments and AI suggestions on the fresh DOM
+      // (renderDiff clears the diff container, so we must re-populate)
+      const includeDismissed = window.aiPanel?.showDismissedComments || false;
+      await manager.loadUserComments(includeDismissed);
+      // Note: Unlike loadLocalReview() which skips this when analysisHistoryManager exists
+      // (because the manager triggers loadAISuggestions via onSelectionChange on init),
+      // refresh must call unconditionally since the manager won't re-fire its callback.
+      await manager.loadAISuggestions(null, manager.selectedRunId);
+
       // Show success toast
       if (window.toast) {
         window.toast.showSuccess('Diff refreshed successfully');

package/public/js/pr.js

@@ -3676,6 +3676,15 @@ class PRManager {
         // Reload the files/diff with fresh data
         await this.loadAndDisplayFiles(owner, repo, number);
 
+        // Re-render comments and AI suggestions on the fresh DOM
+        // (renderDiff clears the diff container, so we must re-populate)
+        const includeDismissed = window.aiPanel?.showDismissedComments || false;
+        await this.loadUserComments(includeDismissed);
+        // Note: Unlike loadPR() which skips this when analysisHistoryManager exists
+        // (because the manager triggers loadAISuggestions via onSelectionChange on init),
+        // refresh must call unconditionally since the manager won't re-fire its callback.
+        await this.loadAISuggestions(null, this.selectedRunId);
+
         // Restore expanded folders
         this.expandedFolders = expandedFolders;
 

package/src/routes/worktrees.js

@@ -116,33 +116,73 @@ router.post('/api/worktrees/create', async (req, res) => {
 });
 
 /**
- * Get recently accessed worktrees
- * Returns list of recently reviewed PRs with metadata
- * Filters out stale worktrees where the directory no longer exists
+ * Get recently accessed worktrees with cursor-based pagination.
+ * Returns list of recently reviewed PRs with metadata.
+ * Filters out stale worktrees where the directory no longer exists.
+ *
+ * Query parameters:
+ *   limit  - Number of worktrees to return (default 10, max 50)
+ *   before - ISO timestamp cursor: return worktrees accessed before this time.
+ *            For subsequent pages, send the last_accessed_at of the last item
+ *            from the previous page. Omit for the initial load.
+ *
+ * Response includes:
+ *   worktrees - Array of worktree objects
+ *   hasMore   - Whether more worktrees are available beyond this page
  */
 router.get('/api/worktrees/recent', async (req, res) => {
   try {
     const limit = Math.min(parseInt(req.query.limit) || 10, 50); // Default 10, max 50
+    const before = req.query.before || null; // ISO timestamp cursor
     const db = req.app.get('db');
 
-    // Get more worktrees than requested to account for stale ones we'll filter out
-    const enrichedWorktrees = await query(db, `
-      SELECT
-        w.id,
-        w.repository,
-        w.pr_number,
-        w.branch,
-        w.path,
-        w.last_accessed_at,
-        w.created_at,
-        pm.title as pr_title,
-        pm.author,
-        pm.head_branch
-      FROM worktrees w
-      LEFT JOIN pr_metadata pm ON w.pr_number = pm.pr_number AND w.repository = pm.repository COLLATE NOCASE
-      ORDER BY w.last_accessed_at DESC
-      LIMIT ?
-    `, [limit * 2]); // Fetch extra to account for stale entries
+    // Fetch a constant overshoot per page to account for stale entries
+    // that will be filtered out, plus one extra to determine hasMore
+    const fetchCount = limit * 3 + 1;
+
+    let enrichedWorktrees;
+    if (before) {
+      // Cursor-based: fetch rows older than the cursor.
+      // Strict less-than: entries sharing the cursor timestamp may be skipped,
+      // acceptable given millisecond precision and small dataset size.
+      enrichedWorktrees = await query(db, `
+        SELECT
+          w.id,
+          w.repository,
+          w.pr_number,
+          w.branch,
+          w.path,
+          w.last_accessed_at,
+          w.created_at,
+          pm.title as pr_title,
+          pm.author,
+          pm.head_branch
+        FROM worktrees w
+        LEFT JOIN pr_metadata pm ON w.pr_number = pm.pr_number AND w.repository = pm.repository COLLATE NOCASE
+        WHERE w.last_accessed_at < ?
+        ORDER BY w.last_accessed_at DESC
+        LIMIT ?
+      `, [before, fetchCount]);
+    } else {
+      // Initial load: no cursor, just fetch from the top
+      enrichedWorktrees = await query(db, `
+        SELECT
+          w.id,
+          w.repository,
+          w.pr_number,
+          w.branch,
+          w.path,
+          w.last_accessed_at,
+          w.created_at,
+          pm.title as pr_title,
+          pm.author,
+          pm.head_branch
+        FROM worktrees w
+        LEFT JOIN pr_metadata pm ON w.pr_number = pm.pr_number AND w.repository = pm.repository COLLATE NOCASE
+        ORDER BY w.last_accessed_at DESC
+        LIMIT ?
+      `, [fetchCount]);
+    }
 
     // Filter out worktrees where:
     // 1. The directory no longer exists
@@ -167,8 +207,9 @@ router.get('/api/worktrees/recent', async (req, res) => {
       }
     }
 
-    // Cleanup stale worktree records in background (don't block response)
-    if (staleIds.length > 0) {
+    // Only run stale cleanup on initial (non-paginated) requests to keep the
+    // dataset stable while the user pages through results.
+    if (staleIds.length > 0 && !before) {
       setImmediate(async () => {
         try {
           const placeholders = staleIds.map(() => '?').join(',');
@@ -180,8 +221,12 @@ router.get('/api/worktrees/recent', async (req, res) => {
       });
     }
 
-    // Format the results with fallback values, limited to requested count
-    const formattedWorktrees = validWorktrees.slice(0, limit).map(w => ({
+    // Take the first `limit` valid results; anything beyond means hasMore
+    const pageWorktrees = validWorktrees.slice(0, limit);
+    const hasMore = validWorktrees.length > limit;
+
+    // Format the results with fallback values
+    const formattedWorktrees = pageWorktrees.map(w => ({
       id: w.id,
       repository: w.repository,
       pr_number: w.pr_number,
@@ -195,12 +240,14 @@ router.get('/api/worktrees/recent', async (req, res) => {
 
     res.json({
       success: true,
-      worktrees: formattedWorktrees
+      worktrees: formattedWorktrees,
+      hasMore
     });
 
   } catch (error) {
-    console.error('Error fetching recent worktrees:', error);
+    logger.error('Error fetching recent worktrees:', error);
     res.status(500).json({
+      success: false,
       error: 'Failed to fetch recent worktrees'
     });
   }