popeye-cli 2.1.0 → 2.7.0

package/src/adapters/grok.ts

@@ -10,6 +10,7 @@ import type { ConsensusResult, ArbitrationResult } from '../types/consensus.js';
 import type { OutputLanguage } from '../types/project.js';
 import { getGrokToken, GROK_API_URL } from '../auth/grok.js';
 import { DEFAULT_GROK_MODEL } from '../types/consensus.js';
+import { normalizeIssueList } from '../shared/text-utils.js';
 
 /**
  * Default Grok configuration
@@ -79,6 +80,44 @@ export async function requestConsensus(
   }
 }
 
+/**
+ * Send a prompt directly to the Grok API and return the raw response string.
+ * No prompt wrapping or response parsing — used by the consensus runner
+ * which builds its own prompts and parses responses itself.
+ *
+ * @param prompt - The complete prompt to send
+ * @param config - Configuration for model/temperature/maxTokens
+ * @returns Raw LLM response text
+ */
+export async function requestRawReview(
+  prompt: string,
+  config: { model?: string; temperature?: number; maxTokens?: number } = {},
+): Promise<string> {
+  const {
+    model = DEFAULT_GROK_CONFIG.model,
+    temperature = DEFAULT_GROK_CONFIG.temperature,
+    maxTokens = DEFAULT_GROK_CONFIG.maxTokens,
+  } = config;
+
+  const client = await createClient();
+
+  try {
+    const completion = await client.chat.completions.create({
+      model,
+      messages: [{ role: 'user', content: prompt }],
+      temperature,
+      max_tokens: maxTokens,
+    });
+    return completion.choices[0]?.message?.content || '';
+  } catch (error) {
+    if (error instanceof OpenAI.RateLimitError) {
+      await sleep(5000);
+      return requestRawReview(prompt, config);
+    }
+    throw error;
+  }
+}
+
 /**
  * Request arbitration from Grok when consensus is stuck
  *
@@ -144,10 +183,13 @@ STRENGTHS:
 - [etc.]
 
 CONCERNS:
-- [Concern 1]
-- [Concern 2]
+- [Non-blocking concern 1]
+- [Non-blocking concern 2]
 - [etc.]
 
+BLOCKING_ISSUES:
+- [Critical issue that must be resolved, or "None"]
+
 RECOMMENDATIONS:
 - [Recommendation 1]
 - [Recommendation 2]
@@ -253,11 +295,13 @@ export function parseConsensusResponse(response: string): ConsensusResult {
   const analysis = extractSection(response, ['ANALYSIS', '## Analysis', '### Analysis']);
   const strengthsText = extractSection(response, ['STRENGTHS', '## Strengths', '### Strengths']);
   const concernsText = extractSection(response, ['CONCERNS', '## Concerns', '### Concerns']);
+  const blockingIssuesText = extractSection(response, ['BLOCKING_ISSUES', '## Blocking Issues', '### Blocking Issues']);
   const recommendationsText = extractSection(response, ['RECOMMENDATIONS', '## Recommendations', '### Recommendations']);
 
   // Parse lists from sections
   const strengths = parseList(strengthsText);
   const concerns = parseList(concernsText);
+  const blockingIssues = normalizeIssueList(parseList(blockingIssuesText));
   const recommendations = parseList(recommendationsText);
 
   return {
@@ -265,6 +309,7 @@ export function parseConsensusResponse(response: string): ConsensusResult {
     analysis: analysis.trim(),
     strengths,
     concerns,
+    blockingIssues,
     recommendations,
     approved: score >= 95,
     rawResponse: response,
@@ -295,11 +340,11 @@ function parseArbitrationResponse(response: string): ArbitrationResult {
     approved,
     score,
     analysis,
-    criticalConcerns: criticalConcerns.filter(c => c.toLowerCase() !== 'none'),
-    minorConcerns: minorConcerns.filter(c => c.toLowerCase() !== 'none'),
-    subjectiveConcerns: subjectiveConcerns.filter(c => c.toLowerCase() !== 'none'),
+    criticalConcerns: normalizeIssueList(criticalConcerns),
+    minorConcerns: normalizeIssueList(minorConcerns),
+    subjectiveConcerns: normalizeIssueList(subjectiveConcerns),
     reasoning,
-    suggestedChanges: suggestedChanges.filter(c => !c.toLowerCase().includes('none')),
+    suggestedChanges: normalizeIssueList(suggestedChanges),
     rawResponse: response,
   };
 }

package/src/adapters/openai.ts

@@ -7,6 +7,7 @@ import OpenAI from 'openai';
 import type { ConsensusResult, ConsensusConfig, OpenAIModel, OutputLanguage } from '../types/index.js';
 import { getOpenAIToken } from '../auth/index.js';
 import { DEFAULT_CONSENSUS_CONFIG } from '../types/consensus.js';
+import { normalizeIssueList } from '../shared/text-utils.js';
 
 /**
  * Create an OpenAI client with stored credentials
@@ -87,9 +88,10 @@ ${plan}
 Please provide:
 1. ANALYSIS: Detailed review of the plan
 2. STRENGTHS: What works well
-3. CONCERNS: Issues or gaps identified
-4. RECOMMENDATIONS: Specific improvements
-5. CONSENSUS SCORE: A percentage (0-100%) indicating your agreement
+3. CONCERNS: Non-blocking issues, minor gaps, or suggestions for improvement
+4. BLOCKING_ISSUES: Critical issues that MUST be resolved before proceeding (security, data loss, missing requirements, broken architecture). Write "None" if no blocking issues.
+5. RECOMMENDATIONS: Specific improvements
+6. CONSENSUS SCORE: A percentage (0-100%) indicating your agreement
    - 95-100%: Ready for execution
    - 80-94%: Minor revisions needed
    - 60-79%: Significant revisions needed
@@ -109,15 +111,22 @@ export function parseConsensusResponse(response: string): ConsensusResult {
   const scoreMatch = response.match(/CONSENSUS:\s*(\d+)%/i);
   const score = scoreMatch ? parseInt(scoreMatch[1], 10) : 0;
 
-  // Extract sections
+  // Extract sections — handle backward compat when BLOCKING_ISSUES is absent
   const analysis = extractSection(response, 'ANALYSIS', 'STRENGTHS');
   const strengthsText = extractSection(response, 'STRENGTHS', 'CONCERNS');
-  const concernsText = extractSection(response, 'CONCERNS', 'RECOMMENDATIONS');
+  const hasBlockingIssues = /BLOCKING_ISSUES[:\s]/i.test(response);
+  const concernsText = hasBlockingIssues
+    ? extractSection(response, 'CONCERNS', 'BLOCKING_ISSUES')
+    : extractSection(response, 'CONCERNS', 'RECOMMENDATIONS');
+  const blockingIssuesText = hasBlockingIssues
+    ? extractSection(response, 'BLOCKING_ISSUES', 'RECOMMENDATIONS')
+    : '';
   const recommendationsText = extractSection(response, 'RECOMMENDATIONS', 'CONSENSUS');
 
   // Parse lists from sections
   const strengths = parseList(strengthsText);
   const concerns = parseList(concernsText);
+  const blockingIssues = normalizeIssueList(parseList(blockingIssuesText));
   const recommendations = parseList(recommendationsText);
 
   return {
@@ -125,6 +134,7 @@ export function parseConsensusResponse(response: string): ConsensusResult {
     analysis: analysis.trim(),
     strengths,
     concerns,
+    blockingIssues,
     recommendations,
     approved: score >= 95,
     rawResponse: response,
@@ -217,6 +227,44 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * Send a prompt directly to the OpenAI API and return the raw response string.
+ * No prompt wrapping or response parsing — used by the consensus runner
+ * which builds its own prompts and parses responses itself.
+ *
+ * @param prompt - The complete prompt to send
+ * @param config - Consensus configuration for model/temperature/maxTokens
+ * @returns Raw LLM response text
+ */
+export async function requestRawReview(
+  prompt: string,
+  config: Partial<ConsensusConfig> = {},
+): Promise<string> {
+  const {
+    openaiModel = DEFAULT_CONSENSUS_CONFIG.openaiModel,
+    temperature = DEFAULT_CONSENSUS_CONFIG.temperature,
+    maxTokens = DEFAULT_CONSENSUS_CONFIG.maxTokens,
+  } = config;
+
+  const client = await createClient();
+
+  try {
+    const completion = await client.chat.completions.create({
+      model: openaiModel,
+      messages: [{ role: 'user', content: prompt }],
+      temperature,
+      max_tokens: maxTokens,
+    });
+    return completion.choices[0]?.message?.content || '';
+  } catch (error) {
+    if (error instanceof OpenAI.RateLimitError) {
+      await sleep(5000);
+      return requestRawReview(prompt, config);
+    }
+    throw error;
+  }
+}
+
 /**
  * Validate that a model is available
  */

package/src/cli/commands/create.ts

@@ -241,7 +241,7 @@ export function createCreateCommand(): Command {
             printConsensusResult(
               workflowResult.planResult.consensusResult.iterations[
                 workflowResult.planResult.consensusResult.iterations.length - 1
-              ]?.result || { score: 0, analysis: '', approved: false, rawResponse: '' }
+              ]?.result || { score: 0, analysis: '', approved: false, rawResponse: '', strengths: [], concerns: [], blockingIssues: [], recommendations: [] }
             );
           }