@in-the-loop-labs/pair-review 1.3.2 → 1.4.0

package/public/js/local.js

@@ -1361,10 +1361,90 @@ class LocalManager {
     });
   }
 
+  /**
+   * Initialize inline name editing for the review title in the header
+   */
+  initNameEditing() {
+    const nameEl = document.getElementById('local-review-name');
+    if (!nameEl || nameEl.dataset.listenerAttached) return;
+    nameEl.dataset.listenerAttached = 'true';
+
+    const reviewId = this.reviewId;
+
+    nameEl.addEventListener('click', () => {
+      if (nameEl.querySelector('input')) return; // already editing
+
+      const currentName = nameEl.dataset.currentName || '';
+      const input = document.createElement('input');
+      input.type = 'text';
+      input.className = 'local-review-name-input';
+      input.value = currentName;
+      input.placeholder = 'Untitled';
+
+      nameEl.textContent = '';
+      nameEl.appendChild(input);
+      input.focus();
+      input.select();
+
+      let saved = false;
+
+      async function save() {
+        if (saved) return;
+        saved = true;
+        const newName = input.value.trim() || null;
+        try {
+          const response = await fetch(`/api/local/${reviewId}/name`, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: newName })
+          });
+          if (!response.ok) throw new Error('Save failed');
+          nameEl.dataset.currentName = newName || '';
+          nameEl.textContent = newName || 'Untitled';
+          nameEl.classList.toggle('unnamed', !newName);
+          nameEl.title = 'Click to rename';
+        } catch (error) {
+          // Revert the display to the previous name on failure
+          cancel();
+        }
+      }
+
+      function cancel() {
+        nameEl.textContent = currentName || 'Untitled';
+        nameEl.classList.toggle('unnamed', !currentName);
+        nameEl.title = 'Click to rename';
+      }
+
+      input.addEventListener('blur', save);
+      input.addEventListener('keydown', function(e) {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          input.removeEventListener('blur', save);
+          save();
+        } else if (e.key === 'Escape') {
+          e.preventDefault();
+          input.removeEventListener('blur', save);
+          cancel();
+        }
+      });
+    });
+  }
+
   /**
    * Update local header with review info
    */
   updateLocalHeader(reviewData) {
+    // Update review name/title in header
+    const nameEl = document.getElementById('local-review-name');
+    if (nameEl) {
+      const name = reviewData.name || '';
+      nameEl.textContent = name || 'Untitled';
+      nameEl.dataset.currentName = name;
+      nameEl.classList.toggle('unnamed', !name);
+      nameEl.title = 'Click to rename';
+      this.initNameEditing();
+    }
+
     // Update repository name
     const repoName = document.getElementById('local-repo-name');
     if (repoName) {

package/public/js/modules/analysis-history.js

@@ -748,7 +748,11 @@ class AnalysisHistoryManager {
       'o1': 'thorough',
       'o1-mini': 'balanced',
       // Copilot models
-      'gpt-4': 'balanced'
+      'gpt-4': 'balanced',
+      // Pi models
+      'default': 'balanced',
+      'multi-model': 'thorough',
+      'review-roulette': 'thorough'
     };
 
     return modelTiers[modelId] || null;

package/public/local.html

@@ -165,6 +165,49 @@
             unicode-bidi: bidi-override;
         }
 
+        /* Editable review name in header */
+        .local-review-name {
+            font-size: 15px;
+            font-weight: 500;
+            color: var(--color-text-primary);
+            cursor: text;
+            padding: 2px 6px;
+            border-radius: 4px;
+            border: 1px dashed var(--color-border-primary);
+            transition: all 0.15s ease;
+            max-width: 360px;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            position: relative;
+        }
+
+        .local-review-name:hover {
+            background: var(--color-bg-secondary);
+            border-color: var(--ai-primary);
+            border-style: solid;
+        }
+
+        .local-review-name.unnamed {
+            color: var(--color-text-tertiary);
+            font-style: italic;
+        }
+
+        .local-review-name-input {
+            font-family: 'DM Sans', -apple-system, sans-serif;
+            font-size: 15px;
+            font-weight: 500;
+            padding: 2px 6px;
+            border: 1px solid #d97706;
+            border-radius: 4px;
+            background: var(--color-bg-primary);
+            color: var(--color-text-primary);
+            outline: none;
+            box-shadow: 0 0 0 2px rgba(217, 119, 6, 0.15);
+            width: 280px;
+            max-width: 360px;
+        }
+
     </style>
 </head>
 <body>
@@ -205,8 +248,8 @@
                 </div>
             </div>
             <div class="header-center">
-                <!-- Title area intentionally left empty for local mode -->
-                <!-- The "Local Mode" badge and header info provide sufficient context -->
+                <!-- Editable review name/title -->
+                <span class="local-review-name" id="local-review-name" title="Click to rename">Untitled</span>
             </div>
             <div class="header-right">
                 <div class="header-icon-group">

package/src/ai/claude-provider.js

@@ -396,24 +396,28 @@ class ClaudeProvider extends AIProvider {
         } else {
           // Regex extraction failed, try LLM-based extraction as fallback
           logger.warn(`${levelPrefix} Regex extraction failed: ${parsed.error}`);
-          logger.info(`${levelPrefix} Raw response length: ${stdout.length} characters`);
+          // Pass extracted text content to LLM fallback (not raw JSONL stdout).
+          // The text content is the actual LLM response text extracted from JSONL
+          // events and is much smaller and more relevant than the full JSONL stream.
+          const llmFallbackInput = parsed.textContent || stdout;
+          logger.info(`${levelPrefix} LLM fallback input length: ${llmFallbackInput.length} characters (${parsed.textContent ? 'text content' : 'raw stdout'})`);
           logger.info(`${levelPrefix} Attempting LLM-based JSON extraction fallback...`);
 
           // Use async IIFE to handle the async LLM extraction
           (async () => {
             try {
-              const llmExtracted = await this.extractJSONWithLLM(stdout, { level, analysisId, registerProcess });
+              const llmExtracted = await this.extractJSONWithLLM(llmFallbackInput, { level, analysisId, registerProcess });
               if (llmExtracted.success) {
                 logger.success(`${levelPrefix} LLM extraction fallback succeeded`);
                 settle(resolve, llmExtracted.data);
               } else {
                 logger.warn(`${levelPrefix} LLM extraction fallback also failed: ${llmExtracted.error}`);
-                logger.info(`${levelPrefix} Raw response preview: ${stdout.substring(0, 500)}...`);
-                settle(resolve, { raw: stdout, parsed: false });
+                logger.info(`${levelPrefix} Raw response preview: ${llmFallbackInput.substring(0, 500)}...`);
+                settle(resolve, { raw: llmFallbackInput, parsed: false });
               }
             } catch (llmError) {
               logger.warn(`${levelPrefix} LLM extraction fallback error: ${llmError.message}`);
-              settle(resolve, { raw: stdout, parsed: false });
+              settle(resolve, { raw: llmFallbackInput, parsed: false });
             }
           })();
         }
@@ -731,9 +735,10 @@ class ClaudeProvider extends AIProvider {
           return extracted;
         }
 
-        // If no JSON found, return the raw text
+        // If no JSON found, return with textContent so the caller can
+        // pass it (not raw JSONL stdout) to the LLM extraction fallback
         logger.warn(`${levelPrefix} Text content is not JSON, treating as raw text`);
-        return { success: false, error: 'Text content is not valid JSON' };
+        return { success: false, error: 'Text content is not valid JSON', textContent };
       }
 
       // No text content found - don't fall back to raw stdout extraction

package/src/ai/codex-provider.js

@@ -271,24 +271,25 @@ class CodexProvider extends AIProvider {
         } else {
           // Regex extraction failed, try LLM-based extraction as fallback
           logger.warn(`${levelPrefix} Regex extraction failed: ${parsed.error}`);
-          logger.info(`${levelPrefix} Raw response length: ${stdout.length} characters`);
+          const llmFallbackInput = parsed.textContent || stdout;
+          logger.info(`${levelPrefix} LLM fallback input length: ${llmFallbackInput.length} characters (${parsed.textContent ? 'text content' : 'raw stdout'})`);
           logger.info(`${levelPrefix} Attempting LLM-based JSON extraction fallback...`);
 
           // Use async IIFE to handle the async LLM extraction
           (async () => {
             try {
-              const llmExtracted = await this.extractJSONWithLLM(stdout, { level, analysisId, registerProcess });
+              const llmExtracted = await this.extractJSONWithLLM(llmFallbackInput, { level, analysisId, registerProcess });
               if (llmExtracted.success) {
                 logger.success(`${levelPrefix} LLM extraction fallback succeeded`);
                 settle(resolve, llmExtracted.data);
               } else {
                 logger.warn(`${levelPrefix} LLM extraction fallback also failed: ${llmExtracted.error}`);
-                logger.info(`${levelPrefix} Raw response preview: ${stdout.substring(0, 500)}...`);
-                settle(resolve, { raw: stdout, parsed: false });
+                logger.info(`${levelPrefix} Raw response preview: ${llmFallbackInput.substring(0, 500)}...`);
+                settle(resolve, { raw: llmFallbackInput, parsed: false });
               }
             } catch (llmError) {
               logger.warn(`${levelPrefix} LLM extraction fallback error: ${llmError.message}`);
-              settle(resolve, { raw: stdout, parsed: false });
+              settle(resolve, { raw: llmFallbackInput, parsed: false });
             }
           })();
         }
@@ -373,9 +374,10 @@ class CodexProvider extends AIProvider {
           return extracted;
         }
 
-        // If no JSON found, return the raw message
+        // If no JSON found, return with textContent so the caller can
+        // pass it (not raw JSONL stdout) to the LLM extraction fallback
         logger.warn(`${levelPrefix} Agent message is not JSON, treating as raw text`);
-        return { success: false, error: 'Agent message is not valid JSON' };
+        return { success: false, error: 'Agent message is not valid JSON', textContent: agentMessageText };
       }
 
       // No agent message found, try extracting JSON directly from stdout

package/src/ai/cursor-agent-provider.js

@@ -314,7 +314,8 @@ class CursorAgentProvider extends AIProvider {
         } else {
           // Regex extraction failed, try LLM-based extraction as fallback
           logger.warn(`${levelPrefix} Regex extraction failed: ${parsed.error}`);
-          logger.info(`${levelPrefix} Raw response length: ${stdout.length} characters`);
+          const llmFallbackInput = parsed.textContent || stdout;
+          logger.info(`${levelPrefix} LLM fallback input length: ${llmFallbackInput.length} characters (${parsed.textContent ? 'text content' : 'raw stdout'})`);
           logger.info(`${levelPrefix} Attempting LLM-based JSON extraction fallback...`);
 
           // Use async IIFE to handle the async LLM extraction
@@ -324,18 +325,18 @@ class CursorAgentProvider extends AIProvider {
               // orphan processes if timeout fired between close-handler entry
               // and reaching this point.
               if (settled) return;
-              const llmExtracted = await this.extractJSONWithLLM(stdout, { level, analysisId, registerProcess });
+              const llmExtracted = await this.extractJSONWithLLM(llmFallbackInput, { level, analysisId, registerProcess });
               if (llmExtracted.success) {
                 logger.success(`${levelPrefix} LLM extraction fallback succeeded`);
                 settle(resolve, llmExtracted.data);
               } else {
                 logger.warn(`${levelPrefix} LLM extraction fallback also failed: ${llmExtracted.error}`);
-                logger.info(`${levelPrefix} Raw response preview: ${stdout.substring(0, 500)}...`);
-                settle(resolve, { raw: stdout, parsed: false });
+                logger.info(`${levelPrefix} Raw response preview: ${llmFallbackInput.substring(0, 500)}...`);
+                settle(resolve, { raw: llmFallbackInput, parsed: false });
               }
             } catch (llmError) {
               logger.warn(`${levelPrefix} LLM extraction fallback error: ${llmError.message}`);
-              settle(resolve, { raw: stdout, parsed: false });
+              settle(resolve, { raw: llmFallbackInput, parsed: false });
             }
           })();
         }
@@ -466,7 +467,9 @@ class CursorAgentProvider extends AIProvider {
         return extracted;
       }
 
-      return { success: false, error: 'No valid JSON found in assistant or result text' };
+      // Include textContent so the caller can pass it to LLM extraction fallback
+      const textContent = assistantText || resultText || null;
+      return { success: false, error: 'No valid JSON found in assistant or result text', textContent };
 
     } catch (parseError) {
       // stdout might not be valid JSONL at all, try extracting JSON from it

package/src/ai/gemini-provider.js

@@ -320,24 +320,25 @@ class GeminiProvider extends AIProvider {
         } else {
           // Regex extraction failed, try LLM-based extraction as fallback
           logger.warn(`${levelPrefix} Regex extraction failed: ${parsed.error}`);
-          logger.info(`${levelPrefix} Raw response length: ${stdout.length} characters`);
+          const llmFallbackInput = parsed.textContent || stdout;
+          logger.info(`${levelPrefix} LLM fallback input length: ${llmFallbackInput.length} characters (${parsed.textContent ? 'text content' : 'raw stdout'})`);
           logger.info(`${levelPrefix} Attempting LLM-based JSON extraction fallback...`);
 
           // Use async IIFE to handle the async LLM extraction
           (async () => {
             try {
-              const llmExtracted = await this.extractJSONWithLLM(stdout, { level, analysisId, registerProcess });
+              const llmExtracted = await this.extractJSONWithLLM(llmFallbackInput, { level, analysisId, registerProcess });
               if (llmExtracted.success) {
                 logger.success(`${levelPrefix} LLM extraction fallback succeeded`);
                 settle(resolve, llmExtracted.data);
               } else {
                 logger.warn(`${levelPrefix} LLM extraction fallback also failed: ${llmExtracted.error}`);
-                logger.info(`${levelPrefix} Raw response preview: ${stdout.substring(0, 500)}...`);
-                settle(resolve, { raw: stdout, parsed: false });
+                logger.info(`${levelPrefix} Raw response preview: ${llmFallbackInput.substring(0, 500)}...`);
+                settle(resolve, { raw: llmFallbackInput, parsed: false });
               }
             } catch (llmError) {
               logger.warn(`${levelPrefix} LLM extraction fallback error: ${llmError.message}`);
-              settle(resolve, { raw: stdout, parsed: false });
+              settle(resolve, { raw: llmFallbackInput, parsed: false });
             }
           })();
         }
@@ -424,9 +425,10 @@ class GeminiProvider extends AIProvider {
           return extracted;
         }
 
-        // If no JSON found, return the raw message
+        // If no JSON found, return with textContent so the caller can
+        // pass it (not raw JSONL stdout) to the LLM extraction fallback
         logger.warn(`${levelPrefix} Assistant message is not JSON, treating as raw text`);
-        return { success: false, error: 'Assistant message is not valid JSON' };
+        return { success: false, error: 'Assistant message is not valid JSON', textContent: assistantText };
       }
 
       // No assistant message found, try extracting JSON directly from stdout

package/src/ai/index.js

@@ -41,6 +41,7 @@ require('./codex-provider');
 require('./copilot-provider');
 require('./opencode-provider');
 require('./cursor-agent-provider');
+require('./pi-provider');
 
 // Export the unified API
 module.exports = {

package/src/ai/opencode-provider.js

@@ -255,24 +255,25 @@ class OpenCodeProvider extends AIProvider {
         } else {
           // Regex extraction failed, try LLM-based extraction as fallback
           logger.warn(`${levelPrefix} Regex extraction failed: ${parsed.error}`);
-          logger.info(`${levelPrefix} Raw response length: ${stdout.length} characters`);
+          const llmFallbackInput = parsed.textContent || stdout;
+          logger.info(`${levelPrefix} LLM fallback input length: ${llmFallbackInput.length} characters (${parsed.textContent ? 'text content' : 'raw stdout'})`);
           logger.info(`${levelPrefix} Attempting LLM-based JSON extraction fallback...`);
 
           // Use async IIFE to handle the async LLM extraction
           (async () => {
             try {
-              const llmExtracted = await this.extractJSONWithLLM(stdout, { level, analysisId, registerProcess });
+              const llmExtracted = await this.extractJSONWithLLM(llmFallbackInput, { level, analysisId, registerProcess });
               if (llmExtracted.success) {
                 logger.success(`${levelPrefix} LLM extraction fallback succeeded`);
                 settle(resolve, llmExtracted.data);
               } else {
                 logger.warn(`${levelPrefix} LLM extraction fallback also failed: ${llmExtracted.error}`);
-                logger.info(`${levelPrefix} Raw response preview: ${stdout.substring(0, 500)}...`);
-                settle(resolve, { raw: stdout, parsed: false });
+                logger.info(`${levelPrefix} Raw response preview: ${llmFallbackInput.substring(0, 500)}...`);
+                settle(resolve, { raw: llmFallbackInput, parsed: false });
               }
             } catch (llmError) {
               logger.warn(`${levelPrefix} LLM extraction fallback error: ${llmError.message}`);
-              settle(resolve, { raw: stdout, parsed: false });
+              settle(resolve, { raw: llmFallbackInput, parsed: false });
             }
           })();
         }
@@ -495,9 +496,10 @@ class OpenCodeProvider extends AIProvider {
           return extracted;
         }
 
-        // If no JSON found, return the raw text
+        // If no JSON found, return with textContent so the caller can
+        // pass it (not raw JSONL stdout) to the LLM extraction fallback
         logger.warn(`${levelPrefix} Text content is not JSON, treating as raw text`);
-        return { success: false, error: 'Text content is not valid JSON' };
+        return { success: false, error: 'Text content is not valid JSON', textContent };
       }
 
       // No text content found, try extracting JSON directly from stdout