popeye-cli 1.0.0

package/src/workflow/consensus.ts

@@ -0,0 +1,299 @@
+/**
+ * Consensus workflow module
+ * Handles the iterative consensus-building process between Claude and OpenAI
+ */
+
+import type { ConsensusResult, ConsensusIteration, ConsensusConfig } from '../types/consensus.js';
+import { DEFAULT_CONSENSUS_CONFIG } from '../types/consensus.js';
+import { requestConsensus } from '../adapters/openai.js';
+import { revisePlan } from '../adapters/claude.js';
+import { recordConsensusIteration } from '../state/index.js';
+
+/**
+ * Options for consensus iteration
+ */
+export interface ConsensusOptions {
+  projectDir: string;
+  config?: Partial<ConsensusConfig>;
+  onIteration?: (iteration: number, result: ConsensusResult) => void;
+  onRevision?: (iteration: number, revisedPlan: string) => void;
+}
+
+/**
+ * Result of the consensus process
+ */
+export interface ConsensusProcessResult {
+  approved: boolean;
+  finalPlan: string;
+  finalScore: number;
+  iterations: ConsensusIteration[];
+  totalIterations: number;
+}
+
+/**
+ * Format a plan for consensus review
+ * Structures the plan in a way that's optimal for review
+ *
+ * @param plan - The raw plan content
+ * @param context - Project context
+ * @returns Formatted plan string
+ */
+export function formatPlanForReview(plan: string, context: string): string {
+  return `
+## Development Plan
+
+${plan}
+
+## Project Context
+
+${context}
+`.trim();
+}
+
+/**
+ * Extract concerns from a consensus result for revision
+ *
+ * @param result - The consensus result
+ * @returns Array of concerns to address
+ */
+export function extractConcerns(result: ConsensusResult): string[] {
+  const concerns: string[] = [];
+
+  // Add explicit concerns
+  if (result.concerns && result.concerns.length > 0) {
+    concerns.push(...result.concerns);
+  }
+
+  // Add recommendations as concerns to address
+  if (result.recommendations && result.recommendations.length > 0) {
+    concerns.push(...result.recommendations.map((r) => `Consider: ${r}`));
+  }
+
+  return concerns;
+}
+
+/**
+ * Check if consensus threshold is met
+ *
+ * @param score - The consensus score
+ * @param threshold - The threshold to meet (default from config)
+ * @returns True if threshold is met
+ */
+export function meetsThreshold(
+  score: number,
+  threshold: number = DEFAULT_CONSENSUS_CONFIG.threshold
+): boolean {
+  return score >= threshold;
+}
+
+/**
+ * Iterate until consensus is reached
+ *
+ * @param initialPlan - The initial plan to review
+ * @param context - Project context
+ * @param options - Consensus options
+ * @returns The consensus process result
+ */
+export async function iterateUntilConsensus(
+  initialPlan: string,
+  context: string,
+  options: ConsensusOptions
+): Promise<ConsensusProcessResult> {
+  const {
+    projectDir,
+    config = {},
+    onIteration,
+    onRevision,
+  } = options;
+
+  const {
+    threshold = DEFAULT_CONSENSUS_CONFIG.threshold,
+    maxIterations = DEFAULT_CONSENSUS_CONFIG.maxIterations,
+  } = config;
+
+  const iterations: ConsensusIteration[] = [];
+  let currentPlan = initialPlan;
+  let iteration = 0;
+
+  while (iteration < maxIterations) {
+    iteration++;
+
+    // Request consensus review from OpenAI
+    const consensusResult = await requestConsensus(currentPlan, context, config);
+
+    // Record the iteration
+    const iterationRecord: ConsensusIteration = {
+      iteration,
+      plan: currentPlan,
+      result: consensusResult,
+      timestamp: new Date().toISOString(),
+    };
+
+    iterations.push(iterationRecord);
+
+    // Save to project state
+    await recordConsensusIteration(projectDir, iterationRecord);
+
+    // Notify callback
+    if (onIteration) {
+      onIteration(iteration, consensusResult);
+    }
+
+    // Check if we've reached consensus
+    if (meetsThreshold(consensusResult.score, threshold)) {
+      return {
+        approved: true,
+        finalPlan: currentPlan,
+        finalScore: consensusResult.score,
+        iterations,
+        totalIterations: iteration,
+      };
+    }
+
+    // If not at max iterations, revise the plan
+    if (iteration < maxIterations) {
+      const concerns = extractConcerns(consensusResult);
+
+      // Use Claude to revise the plan
+      const revisionResult = await revisePlan(
+        currentPlan,
+        consensusResult.analysis,
+        concerns
+      );
+
+      if (revisionResult.success && revisionResult.response) {
+        currentPlan = revisionResult.response;
+
+        if (onRevision) {
+          onRevision(iteration, currentPlan);
+        }
+      } else {
+        // If revision fails, try to continue with current plan
+        console.warn(`Plan revision failed at iteration ${iteration}:`, revisionResult.error);
+      }
+    }
+  }
+
+  // Max iterations reached without consensus
+  const lastIteration = iterations[iterations.length - 1];
+  return {
+    approved: false,
+    finalPlan: currentPlan,
+    finalScore: lastIteration?.result.score || 0,
+    iterations,
+    totalIterations: iteration,
+  };
+}
+
+/**
+ * Get a summary of the consensus process
+ *
+ * @param result - The consensus process result
+ * @returns Human-readable summary
+ */
+export function summarizeConsensusProcess(result: ConsensusProcessResult): string {
+  const lines: string[] = [];
+
+  lines.push(`## Consensus Summary`);
+  lines.push('');
+  lines.push(`**Status:** ${result.approved ? 'APPROVED' : 'NOT APPROVED'}`);
+  lines.push(`**Final Score:** ${result.finalScore}%`);
+  lines.push(`**Total Iterations:** ${result.totalIterations}`);
+  lines.push('');
+
+  lines.push(`### Iteration History`);
+  lines.push('');
+
+  for (const iteration of result.iterations) {
+    lines.push(`#### Iteration ${iteration.iteration}`);
+    lines.push(`- Score: ${iteration.result.score}%`);
+    lines.push(`- Strengths: ${iteration.result.strengths?.length || 0}`);
+    lines.push(`- Concerns: ${iteration.result.concerns?.length || 0}`);
+    lines.push('');
+  }
+
+  if (!result.approved) {
+    const lastResult = result.iterations[result.iterations.length - 1]?.result;
+    if (lastResult?.concerns && lastResult.concerns.length > 0) {
+      lines.push(`### Remaining Concerns`);
+      lines.push('');
+      for (const concern of lastResult.concerns) {
+        lines.push(`- ${concern}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Validate a plan structure has required sections
+ *
+ * @param plan - The plan to validate
+ * @returns Validation result with missing sections
+ */
+export function validatePlanStructure(plan: string): {
+  valid: boolean;
+  missingSections: string[];
+} {
+  const requiredSections = [
+    'Background',
+    'Goals',
+    'Milestones',
+    'Tasks',
+    'Test',
+  ];
+
+  const missingSections: string[] = [];
+
+  for (const section of requiredSections) {
+    // Check for section header (case-insensitive)
+    const pattern = new RegExp(`(^|\\n)#+\\s*${section}`, 'i');
+    if (!pattern.test(plan)) {
+      missingSections.push(section);
+    }
+  }
+
+  return {
+    valid: missingSections.length === 0,
+    missingSections,
+  };
+}
+
+/**
+ * Calculate average score across iterations
+ *
+ * @param iterations - The consensus iterations
+ * @returns Average score
+ */
+export function calculateAverageScore(iterations: ConsensusIteration[]): number {
+  if (iterations.length === 0) return 0;
+
+  const sum = iterations.reduce((acc, it) => acc + it.result.score, 0);
+  return Math.round(sum / iterations.length);
+}
+
+/**
+ * Get the score trend across iterations
+ *
+ * @param iterations - The consensus iterations
+ * @returns 'improving', 'declining', or 'stable'
+ */
+export function getScoreTrend(
+  iterations: ConsensusIteration[]
+): 'improving' | 'declining' | 'stable' {
+  if (iterations.length < 2) return 'stable';
+
+  const scores = iterations.map((it) => it.result.score);
+  const firstHalf = scores.slice(0, Math.floor(scores.length / 2));
+  const secondHalf = scores.slice(Math.floor(scores.length / 2));
+
+  const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
+  const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
+
+  const diff = secondAvg - firstAvg;
+
+  if (diff > 5) return 'improving';
+  if (diff < -5) return 'declining';
+  return 'stable';
+}