@in-the-loop-labs/pair-review 3.6.0 → 3.7.0

package/public/js/index.js

@@ -90,6 +90,8 @@
 
   /** localStorage key for persisting the active tab */
   const TAB_STORAGE_KEY = 'pair-review-active-tab';
+  const BULK_ANALYSIS_TAB_STORAGE_KEY = 'pair-review-bulk-analysis-tab';
+  const BULK_ANALYSIS_INSTRUCTIONS_STORAGE_KEY = 'pair-review-bulk-analysis-instructions';
 
   /**
    * Format a relative time string from a date
@@ -133,6 +135,10 @@
     return div.innerHTML;
   }
 
+  // encodeBase64Utf8 / getRepoStorageKey live in public/js/utils/storage-keys.js
+  // (window.encodeBase64Utf8 / window.getRepoStorageKey), shared with pr.js so the
+  // per-repo keys this page writes stay byte-identical to those the PR page reads.
+
   const LOCAL_REVIEW_PATH_URL_ERROR = 'Local reviews require a filesystem path, not a URL. Pass GitHub or Graphite URLs as PR review inputs instead.';
 
   function isUrlLikeLocalReviewPath(value) {
@@ -1377,6 +1383,9 @@
         window.__pairReview.chatProvider = config.chat_provider || 'pi';
         const chatProviders = config.chat_providers || [];
         window.__pairReview.chatProviders = chatProviders;
+        window.__pairReview.defaultProvider = config.default_provider || 'claude';
+        window.__pairReview.defaultModel = config.default_model || 'opus';
+        window.__pairReview.hasGithubToken = Boolean(config.has_github_token);
         window.__pairReview.enableGraphite = config.enable_graphite === true;
         window.__pairReview.chatSpinner = config.chat_spinner || 'dots';
         window.__pairReview.chatEnterToSend = config.chat_enter_to_send !== false;
@@ -1404,6 +1413,7 @@
 
   /** Currently active SelectionMode instance (only one tab at a time) */
   var activeSelection = null;
+  var bulkAnalysisConfigModal = null;
 
   /**
    * SelectionMode manages checkbox-based selection for a single tab's table.
@@ -1877,6 +1887,40 @@
     });
   }
 
+  /**
+   * Read selected collection rows as PR descriptors.
+   * @param {Set} selectedIds - PR URLs (data-pr-url values)
+   * @param {string} tbodyId - tbody element ID
+   * @returns {Array<{owner: string, repo: string, number: string, prUrl: string}>}
+   */
+  function getSelectedCollectionRows(selectedIds, tbodyId) {
+    var tbody = document.getElementById(tbodyId);
+    if (!tbody) return [];
+
+    var rows = [];
+    var trs = tbody.querySelectorAll('tr[data-pr-url]');
+    for (var i = 0; i < trs.length; i++) {
+      var tr = trs[i];
+      var prUrl = tr.dataset.prUrl;
+      if (!selectedIds.has(prUrl)) continue;
+      if (tr.dataset.owner && tr.dataset.repo && tr.dataset.number) {
+        rows.push({
+          owner: tr.dataset.owner,
+          repo: tr.dataset.repo,
+          number: tr.dataset.number,
+          prUrl: prUrl
+        });
+      }
+    }
+    return rows;
+  }
+
+  function buildReviewUrlsFromRows(rows, query) {
+    return rows.map(function (row) {
+      return '/pr/' + encodeURIComponent(row.owner) + '/' + encodeURIComponent(row.repo) + '/' + row.number + (query || '');
+    });
+  }
+
   /**
    * Build pair-review URLs from selected collection rows.
    * @param {Set} selectedIds - PR URLs (data-pr-url values)
@@ -1885,20 +1929,116 @@
    * @returns {string[]} array of pair-review URLs
    */
   function buildReviewUrls(selectedIds, tbodyId, query) {
-    var tbody = document.getElementById(tbodyId);
-    if (!tbody) return [];
-    var urls = [];
-    selectedIds.forEach(function (prUrl) {
-      var row = tbody.querySelector('tr[data-pr-url="' + CSS.escape(prUrl) + '"]');
-      if (!row) return;
-      var owner = row.dataset.owner;
-      var repo = row.dataset.repo;
-      var number = row.dataset.number;
-      if (owner && repo && number) {
-        urls.push('/pr/' + encodeURIComponent(owner) + '/' + encodeURIComponent(repo) + '/' + number + (query || ''));
+    return buildReviewUrlsFromRows(getSelectedCollectionRows(selectedIds, tbodyId), query);
+  }
+
+  function getCommonRepository(rows) {
+    if (rows.length === 0) return null;
+    var first = rows[0];
+    var firstKey = (first.owner + '/' + first.repo).toLowerCase();
+    for (var i = 1; i < rows.length; i++) {
+      if ((rows[i].owner + '/' + rows[i].repo).toLowerCase() !== firstKey) {
+        return null;
       }
+    }
+    return { owner: first.owner, repo: first.repo };
+  }
+
+  async function fetchBulkRepoSettings(commonRepo) {
+    if (!commonRepo) return null;
+    try {
+      var response = await fetch('/api/repos/' + encodeURIComponent(commonRepo.owner) + '/' + encodeURIComponent(commonRepo.repo) + '/settings');
+      if (!response.ok) return null;
+      return await response.json();
+    } catch (error) {
+      console.warn('Failed to fetch repo settings for bulk analysis:', error);
+      return null;
+    }
+  }
+
+  function getBulkAnalysisStorageKeys(commonRepo) {
+    if (!commonRepo) {
+      return {
+        tab: BULK_ANALYSIS_TAB_STORAGE_KEY,
+        instructions: BULK_ANALYSIS_INSTRUCTIONS_STORAGE_KEY
+      };
+    }
+    return {
+      tab: window.getRepoStorageKey('pair-review-tab', commonRepo.owner, commonRepo.repo),
+      instructions: window.getRepoStorageKey('pair-review-instructions', commonRepo.owner, commonRepo.repo)
+    };
+  }
+
+  // Cache the /api/providers metadata so the bulk modal can resolve a coherent
+  // provider/model pair before showing (mirrors PRManager._getProvidersInfo).
+  function getBulkProvidersInfo() {
+    window.__pairReview = window.__pairReview || {};
+    if (!window.__pairReview._providersInfoPromise) {
+      window.__pairReview._providersInfoPromise = fetch('/api/providers')
+        .then(function (r) { return r.ok ? r.json() : {}; })
+        .then(function (d) { return Array.isArray(d.providers) ? d.providers : []; })
+        .catch(function () { return []; });
+    }
+    return window.__pairReview._providersInfoPromise;
+  }
+
+  async function showBulkAnalysisConfig(rows) {
+    if (!window.AnalysisConfigModal) return null;
+
+    if (!bulkAnalysisConfigModal) {
+      bulkAnalysisConfigModal = new window.AnalysisConfigModal();
+    }
+
+    var commonRepo = getCommonRepository(rows);
+    var storageKeys = getBulkAnalysisStorageKeys(commonRepo);
+    var repoSettings = await fetchBulkRepoSettings(commonRepo);
+    var rememberedTab = localStorage.getItem(storageKeys.tab);
+    var lastInstructions = localStorage.getItem(storageKeys.instructions) || '';
+
+    bulkAnalysisConfigModal.onTabChange = function (tabId) {
+      localStorage.setItem(storageKeys.tab, tabId);
+    };
+
+    var providersInfo = await getBulkProvidersInfo();
+    var resolvedPair = window.resolveProviderModelPair([
+      { provider: repoSettings?.default_provider, model: repoSettings?.default_model },
+      { provider: window.__pairReview?.defaultProvider, model: window.__pairReview?.defaultModel }
+    ], providersInfo);
+
+    var config = await bulkAnalysisConfigModal.show({
+      currentModel: resolvedPair.model,
+      currentProvider: resolvedPair.provider,
+      defaultTab: rememberedTab || repoSettings?.default_tab || 'single',
+      repoInstructions: commonRepo ? (repoSettings?.default_instructions || '') : '',
+      lastInstructions: lastInstructions,
+      defaultCouncilId: commonRepo ? (repoSettings?.default_council_id || null) : null,
+      hasPr: true,
+      hasGithubToken: window.__pairReview?.hasGithubToken !== false
+    });
+
+    if (!config) return null;
+
+    var submittedInstructions = config.customInstructions || '';
+    if (submittedInstructions) {
+      localStorage.setItem(storageKeys.instructions, submittedInstructions);
+    } else {
+      localStorage.removeItem(storageKeys.instructions);
+    }
+
+    return config;
+  }
+
+  async function storeBulkAnalysisConfig(config) {
+    var response = await fetch('/api/bulk-analysis-configs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ analysisConfig: config })
     });
-    return urls;
+    var data = await response.json().catch(function () { return {}; });
+    if (!response.ok || !data.id) {
+      throw new Error(data.error || 'Failed to save analysis settings');
+    }
+    return data.id;
   }
 
   /**
@@ -1924,10 +2064,29 @@
     bulkOpenUrls(urls);
   }
 
-  function handleBulkAnalyze(selectedIds, selectionInstance) {
-    var urls = buildReviewUrls(selectedIds, selectionInstance.config.tbodyId, '?analyze=true');
-    selectionInstance.exit();
-    bulkOpenUrls(urls);
+  async function handleBulkAnalyze(selectedIds, selectionInstance) {
+    var rows = getSelectedCollectionRows(selectedIds, selectionInstance.config.tbodyId);
+    if (rows.length === 0) return;
+
+    if (!window.AnalysisConfigModal) {
+      selectionInstance.exit();
+      bulkOpenUrls(buildReviewUrlsFromRows(rows, '?analyze=true'));
+      return;
+    }
+
+    try {
+      var config = await showBulkAnalysisConfig(rows);
+      if (!config) return;
+
+      var configId = await storeBulkAnalysisConfig(config);
+      var query = '?analyze=true&analysisConfigId=' + encodeURIComponent(configId);
+      var urls = buildReviewUrlsFromRows(rows, query);
+      selectionInstance.exit();
+      bulkOpenUrls(urls);
+    } catch (error) {
+      console.error('Bulk analyze error:', error);
+      if (window.toast) window.toast.error('Failed to start bulk analysis: ' + error.message);
+    }
   }
 
   // ─── Event Delegation ───────────────────────────────────────────────────────

package/public/js/local.js

@@ -75,11 +75,12 @@ class LocalManager {
       try {
         // Fetch repo settings so we honour the repository's default provider/council
         const manager = window.prManager;
-        const [repoSettings, reviewSettings] = await Promise.all([
+        const [repoSettings, reviewSettings, appConfig] = await Promise.all([
           manager.fetchRepoSettings().catch(() => null),
-          manager.fetchLastReviewSettings().catch(() => ({ custom_instructions: '', last_council_id: null }))
+          manager.fetchLastReviewSettings().catch(() => ({ custom_instructions: '', last_council_id: null })),
+          manager._getAppConfig()
         ]);
-        const config = await manager._buildDefaultAnalysisConfig(repoSettings, reviewSettings);
+        const config = await manager._buildDefaultAnalysisConfig(repoSettings, reviewSettings, appConfig);
 
         await this.startLocalAnalysis(null, config);
       } finally {
@@ -268,11 +269,25 @@ class LocalManager {
           ? manager._stalenessPromise
           : self._fetchLocalStaleness();
         manager._stalenessPromise = null; // consume it
+        // Pass owner+repo to /api/config (when we have a remote) so
+        // has_github_token reflects the repo's actual auth — covers
+        // repo-scoped tokens, token_command, and alt-host bindings.
+        // Local sessions without a remote origin fall back to the
+        // global-only response (has_global_github_token), which the
+        // modal already treats as no-GitHub-auth for dedup purposes.
+        let configUrl = '/api/config';
+        const localRepo = self.localData?.repository;
+        if (typeof localRepo === 'string' && localRepo.includes('/')) {
+          const [lOwner, lRepo] = localRepo.split('/');
+          if (lOwner && lRepo) {
+            configUrl = `/api/config?owner=${encodeURIComponent(lOwner)}&repo=${encodeURIComponent(lRepo)}`;
+          }
+        }
         const [staleResult, repoSettings, reviewSettings, appConfig] = await Promise.all([
           staleCheckWithTimeout,
           manager.fetchRepoSettings().catch(() => null),
           manager.fetchLastReviewSettings().catch(() => ({ custom_instructions: '', last_council_id: null })),
-          fetch('/api/config').then(r => r.ok ? r.json() : {}).catch(() => ({}))
+          fetch(configUrl).then(r => r.ok ? r.json() : {}).catch(() => ({}))
         ]);
         console.debug(`[Analyze] parallel-fetch (stale+settings): ${Math.round(performance.now() - _tParallel0)}ms`);
 
@@ -310,9 +325,14 @@ class LocalManager {
 
         const lastCouncilId = reviewSettings.last_council_id;
 
-        // Determine model and provider (priority: repo default > defaults)
-        const currentModel = repoSettings?.default_model || 'opus';
-        const currentProvider = repoSettings?.default_provider || 'claude';
+        // Resolve provider and model as a MATCHED pair so the council/advanced tabs
+        // are never seeded with a cross-provider model (e.g. gemini + opus), which
+        // would blank the model <select> and be rejected by the backend.
+        const providersInfo = await manager._getProvidersInfo();
+        const { provider: currentProvider, model: currentModel } = window.resolveProviderModelPair([
+          { provider: repoSettings?.default_provider, model: repoSettings?.default_model },
+          { provider: appConfig.default_provider, model: appConfig.default_model }
+        ], providersInfo);
 
         // Determine default tab (priority: localStorage > repo settings > 'single')
         const tabStorageKey = `pair-review-tab:local-${reviewId}`;
@@ -340,7 +360,14 @@ class LocalManager {
           lastCouncilId,
           defaultCouncilId: repoSettings?.default_council_id || null,
           hasPr: false,
-          hasGithubToken: Boolean(appConfig.has_github_token)
+          // Prefer the repo-aware field when present (we passed owner+repo
+          // to /api/config). For local sessions without a remote origin
+          // we fall back to the global capability — there is no repo
+          // binding to honour, so the global token is the only token a
+          // dedup operation could use anyway.
+          hasGithubToken: Boolean(
+            appConfig.has_github_token ?? appConfig.has_global_github_token
+          )
         });
 
         if (!config) {
@@ -1046,6 +1073,29 @@ class LocalManager {
       // Update header with local info
       this.updateLocalHeader(reviewData);
 
+      // Apply per-repo header link customisation (Phase 7: alt-host support).
+      // Only render the external link when the local review is associated
+      // with a `repos` entry — i.e. the stored repository looks like
+      // `owner/repo`. Local sessions without a remote origin skip this
+      // entirely; built-in GitHub/Graphite links don't appear in Local
+      // mode's header today so suppression has no visible effect there
+      // either, but we still call through so any external link is
+      // inserted into the icon group.
+      if (window.RepoLinks && typeof reviewData.repository === 'string'
+          && reviewData.repository.includes('/')) {
+        const [linkOwner, linkRepo] = reviewData.repository.split('/');
+        window.RepoLinks.fetchAndApplyRepoLinks(linkOwner, linkRepo, {
+          owner: linkOwner,
+          repo: linkRepo,
+          // {number} is intentionally omitted for Local mode — templates
+          // that require it will fail substitution and the link will be
+          // dropped. Local reviews are not associated with a PR number.
+          branch: reviewData.branch,
+          base_branch: reviewData.baseBranch,
+          head_sha: reviewData.localHeadSha,
+        });
+      }
+
       // Fetch and display diff
       await this.loadLocalDiff();
 

package/public/js/modules/suggestion-manager.js

@@ -258,11 +258,35 @@ class SuggestionManager {
       existingSuggestionRows.forEach(row => row.remove());
       console.log(`[UI] Removed ${existingSuggestionRows.length} existing suggestion rows`);
 
+      // Only inline (line-targeted) suggestions need the diff body rendered
+      // ahead of time. File-level findings (is_file_level === 1 or no
+      // line_start) are handed to FileCommentManager and rendered above the
+      // diff — they never scan <tr> rows or call findHiddenSuggestions, so
+      // forcing their bodies to render would recreate the eager-render cost
+      // the lazy-body change removed (reviews dominated by file-level analyses
+      // are a common repository-wide pattern). Filter once and reuse below.
+      const inlineSuggestions = suggestions.filter(
+        s => s.file && s.line_start != null && s.is_file_level !== 1
+      );
+
+      // Render the lazy body of every file an INLINE suggestion targets BEFORE
+      // scanning rows. With lazy rendering an unrendered file has zero rows, so
+      // without this findHiddenSuggestions() would flag every line as "hidden"
+      // and we'd gap-expand against bodies that aren't even built yet.
+      // ensureFileBodyRendered is a cheap no-op for files already rendered or
+      // not in the diff.
+      if (this.prManager?.ensureFileBodyRendered) {
+        const targetFiles = new Set(inlineSuggestions.map(s => s.file));
+        for (const file of targetFiles) {
+          await this.prManager.ensureFileBodyRendered(file);
+        }
+      }
+
       // Auto-expand hidden lines for suggestions that target non-visible lines
       // Pass the side parameter so expandForSuggestion knows which coordinate system to use:
       // - RIGHT side = NEW coordinates (modified file, most common for AI suggestions)
       // - LEFT side = OLD coordinates (deleted lines from original file)
-      const hiddenSuggestions = this.findHiddenSuggestions(suggestions);
+      const hiddenSuggestions = this.findHiddenSuggestions(inlineSuggestions);
       if (hiddenSuggestions.length > 0) {
         console.log(`[UI] Found ${hiddenSuggestions.length} suggestions targeting hidden lines, expanding...`);
         for (const hidden of hiddenSuggestions) {

package/public/js/modules/tour-renderer.js

@@ -251,13 +251,29 @@ class TourRenderer {
    * `collapsedFiles` would leave the file-tree and viewed-badge state
    * lying.
    *
+   * Async because `toggleFileCollapse` is now async (it awaits the lazy file
+   * body render before revealing it). The caller (`_advanceTour`) awaits this
+   * so the file is visibly expanded before `scrollToStop` runs — otherwise a
+   * stop inside a just-expanded file could be scrolled to while its rows are
+   * still hidden.
+   *
    * @param {number} index
-   * @returns {HTMLTableRowElement|null}
+   * @returns {Promise<HTMLTableRowElement|null>}
    */
-  mountStop(index) {
+  async mountStop(index) {
     const stop = this._stops[index];
     if (!stop) return null;
 
+    // Capture the open-generation ONCE at entry. The `toggleFileCollapse`
+    // await below is a suspension window — the tour can be exited or
+    // restarted (Escape, reopen) while it's in flight, which bumps
+    // `_tourGen` and runs `unmountAll`. Mirrors prepareStop's guard so we
+    // can bail without recording state for a dead tour. `?.` because
+    // prManager may be absent (the non-collapsed path has no await, so
+    // isStale stays harmlessly false there).
+    const startGen = this.prManager?._tourGen;
+    const isStale = () => this.prManager?._tourGen !== startGen;
+
     if (this._mounted.has(index)) {
       const existing = this._mounted.get(index);
       if (existing && existing.isConnected) return existing;
@@ -324,7 +340,21 @@ class TourRenderer {
     if (wrapper.classList.contains('collapsed')) {
       if (this.prManager && typeof this.prManager.toggleFileCollapse === 'function') {
         try {
-          this.prManager.toggleFileCollapse(filePath);
+          // Await: toggleFileCollapse renders the lazy body and removes the
+          // `collapsed` class. Awaiting here means the row is built into a
+          // visible body and the caller's scrollToStop lands correctly.
+          await this.prManager.toggleFileCollapse(filePath);
+          // The await above is a suspension window. If the tour exited or
+          // restarted while it was in flight, `unmountAll` already ran
+          // against a snapshot that does NOT include this stop (the
+          // `_autoExpanded.add` / `_mounted.set` below hadn't run yet).
+          // Recording state now would orphan it forever — the file would
+          // never be re-collapsed and the annotation row never removed.
+          // Bail without mutating renderer state, matching prepareStop's
+          // stale-bail behavior. (The file is left expanded; that minor
+          // cosmetic residue is preferable to a corrupted `_autoExpanded`
+          // set that mis-collapses an unrelated file on the next exit.)
+          if (isStale()) return null;
           // Record so unmountAll() can re-collapse on tour exit.
           this._autoExpanded.add(filePath);
         } catch (err) {