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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "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.2",
+  "version": "1.3.3",
   "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.2",
+  "version": "1.3.3",
   "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/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/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

package/src/utils/json-extractor.js

@@ -2,9 +2,18 @@
 const logger = require('./logger');
 
 /**
- * Extract JSON from text responses using multiple strategies
- * This is a shared utility to ensure consistent JSON extraction across the application
- * @param {string} response - Raw response text
+ * Extract JSON from text responses using multiple strategies.
+ * This is a shared utility to ensure consistent JSON extraction across the application.
+ *
+ * Strategies are tried in order:
+ *   1. Markdown code blocks (```json ... ```)
+ *   2. Direct JSON.parse of the trimmed response
+ *   3. First { to last } substring
+ *   4. Known JSON key anchors (e.g. {"level", {"suggestions")
+ *   5. Forward scan: try JSON.parse from every top-level { in the text
+ *   6. Bracket-matched substring from the first {
+ *
+ * @param {string} response - Raw response text (may include preamble/postamble prose)
  * @param {string|number} level - Level identifier for logging (e.g., 1, 2, 3, 'orchestration', 'unknown')
  * @returns {Object} Extraction result with success flag and data/error
  */
@@ -35,51 +44,132 @@ function extractJSON(response, level = 'unknown') {
       }
       throw new Error('No JSON code block found');
     },
-    
-    // Strategy 2: Look for JSON between first { and last }
+
+    // Strategy 2: Try the entire response as JSON (fast path for clean responses)
+    () => {
+      return JSON.parse(response.trim());
+    },
+
+    // Strategy 3: Look for JSON between first { and last }
+    // Works when the response is just JSON or has minimal wrapping
     () => {
       const firstBrace = response.indexOf('{');
       const lastBrace = response.lastIndexOf('}');
-      if (firstBrace !== -1 && lastBrace !== -1 && lastBrace >= firstBrace) {
+      if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
         return JSON.parse(response.substring(firstBrace, lastBrace + 1));
       }
       throw new Error('No valid JSON braces found');
     },
-    
-    // Strategy 3: Try to find JSON-like structure with bracket matching
+
+    // Strategy 4: Anchor-based extraction — look for known JSON key patterns
+    // that mark the start of our expected response structures.
+    // This handles the common case where preamble text contains { characters
+    // (e.g. LLM discussing code: "the function handleEvent(event) { ... }")
+    // which would cause Strategy 3 to grab the wrong first brace.
     () => {
-      const jsonMatch = response.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        // Try to find the complete JSON by matching brackets
-        const jsonStr = jsonMatch[0];
-        let braceCount = 0;
-        let endIndex = -1;
-        const maxIterations = Math.min(jsonStr.length, 100000); // Prevent infinite loops
-        
-        for (let i = 0; i < maxIterations; i++) {
-          if (jsonStr[i] === '{') braceCount++;
-          else if (jsonStr[i] === '}') {
-            braceCount--;
-            if (braceCount === 0) {
-              endIndex = i;
-              break;
+      // Look for patterns that start our expected JSON structures
+      const anchors = [
+        /\{"level"\s*:/,
+        /\{"suggestions"\s*:/,
+        /\{"fileLevelSuggestions"\s*:/,
+        /\{"summary"\s*:/,
+        /\{"overview"\s*:/,
+      ];
+
+      for (const anchor of anchors) {
+        const match = response.match(anchor);
+        if (match) {
+          const startIdx = match.index;
+          // Find the matching closing brace from the end
+          const lastBrace = response.lastIndexOf('}');
+          if (lastBrace > startIdx) {
+            const candidate = response.substring(startIdx, lastBrace + 1);
+            return JSON.parse(candidate);
+          }
+        }
+      }
+      throw new Error('No known JSON anchor found');
+    },
+
+    // Strategy 5: Forward scan — try JSON.parse starting from each { in the text.
+    // Handles arbitrary preamble text with braces by trying every { as a potential
+    // JSON start. Stops at the first successful parse.
+    () => {
+      let searchFrom = 0;
+      // Limit attempts to avoid excessive parsing on very large non-JSON text
+      const maxAttempts = 20;
+      let attempts = 0;
+      const lastBrace = response.lastIndexOf('}');
+
+      while (searchFrom < response.length && attempts < maxAttempts) {
+        const braceIdx = response.indexOf('{', searchFrom);
+        if (braceIdx === -1) break;
+
+        attempts++;
+        try {
+          // Try parsing from this brace to the end of the response.
+          // JSON.parse is lenient about trailing content only if we trim to the
+          // right boundary, so use lastIndexOf('}') from the end.
+          if (lastBrace > braceIdx) {
+            const candidate = response.substring(braceIdx, lastBrace + 1);
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === 'object') {
+              return parsed;
             }
           }
+        } catch {
+          // This { wasn't the start of valid JSON, try the next one
         }
-        
-        if (endIndex > -1) {
-          return JSON.parse(jsonStr.substring(0, endIndex + 1));
+        searchFrom = braceIdx + 1;
+      }
+      throw new Error('Forward scan found no valid JSON');
+    },
+
+    // Strategy 6: Bracket-matched substring from the first {.
+    // Counts balanced braces (ignoring those inside JSON strings) to find
+    // the end of the first top-level object. No iteration cap — the loop
+    // runs for the full length of the matched region.
+    () => {
+      const firstBrace = response.indexOf('{');
+      if (firstBrace === -1) throw new Error('No opening brace found');
+
+      let braceCount = 0;
+      let inString = false;
+      let escaped = false;
+
+      for (let i = firstBrace; i < response.length; i++) {
+        const ch = response[i];
+
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+
+        if (ch === '\\' && inString) {
+          escaped = true;
+          continue;
+        }
+
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
+
+        if (inString) continue;
+
+        if (ch === '{') braceCount++;
+        else if (ch === '}') {
+          braceCount--;
+          if (braceCount === 0) {
+            return JSON.parse(response.substring(firstBrace, i + 1));
+          }
         }
       }
       throw new Error('No balanced JSON structure found');
     },
-    
-    // Strategy 4: Try the entire response as JSON (for simple cases)
-    () => {
-      return JSON.parse(response.trim());
-    }
   ];
 
+  const strategyErrors = [];
   for (let i = 0; i < strategies.length; i++) {
     try {
       const data = strategies[i]();
@@ -88,17 +178,17 @@ function extractJSON(response, level = 'unknown') {
         return { success: true, data };
       }
     } catch (error) {
-      // Continue to next strategy
-      if (i === strategies.length - 1) {
-        // Last strategy failed, log the error
-        logger.warn(`${levelPrefix} All JSON extraction strategies failed`);
-        logger.warn(`${levelPrefix} Response preview: ${response.substring(0, 200)}...`);
-      }
+      strategyErrors.push(`S${i + 1}: ${error.message}`);
     }
   }
 
-  return { 
-    success: false, 
+  // All strategies failed — log details for debugging
+  logger.warn(`${levelPrefix} All JSON extraction strategies failed`);
+  logger.warn(`${levelPrefix} Strategy errors: ${strategyErrors.join('; ')}`);
+  logger.warn(`${levelPrefix} Response length: ${response.length} chars, preview: ${response.substring(0, 200)}...`);
+
+  return {
+    success: false,
     error: 'Failed to extract JSON from response',
     response: response.substring(0, 500) // Include preview for debugging
   };