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

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) {
@@ -458,10 +488,20 @@ class TourRenderer {
   scrollToStop(index) {
     const row = this._mounted.get(index);
     if (!row || !row.isConnected) return;
-    row.scrollIntoView({
+    const options = {
       behavior: this._reduceMotion ? 'auto' : 'smooth',
       block: 'center'
-    });
+    };
+    // Lazy bodies between the viewport and the stop render as the scroll
+    // passes them, shifting layout so a plain scrollIntoView lands off
+    // target. The stable variant re-corrects once the scroll settles.
+    // Fire-and-forget: it bails on its own if the row unmounts (tour exit)
+    // or the user scrolls.
+    if (window.ScrollUtils?.scrollIntoViewStable) {
+      window.ScrollUtils.scrollIntoViewStable(row, options);
+    } else {
+      row.scrollIntoView(options);
+    }
   }
 
   /**