@pellux/goodvibes-tui 0.18.4

package/src/agents/wrfc-gate-runtime.ts

@@ -0,0 +1,75 @@
+import type { ConfigManager } from '../config/manager.ts';
+import type { RuntimeEventBus } from '../runtime/events/index.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import type { QualityGateResult } from './wrfc-types.ts';
+import {
+  executeGateCommand,
+  getSkippedGateReason,
+  loadPackageScripts,
+} from '@pellux/goodvibes-sdk/platform/agents/wrfc-gates';
+import { getEnabledWrfcGates } from './wrfc-config.ts';
+import { emitWrfcGateResult } from './wrfc-runtime-events.ts';
+
+export async function runWrfcGateChecks(options: {
+  readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
+  readonly projectRoot: string;
+  readonly runtimeBus: RuntimeEventBus;
+  readonly sessionId: string;
+  readonly chainId: string;
+  readonly onResult?: (results: readonly QualityGateResult[], result: QualityGateResult) => void;
+}): Promise<QualityGateResult[]> {
+  const gates = getEnabledWrfcGates(options.configManager);
+  if (gates.length === 0) {
+    logger.debug('Wrfc gate runner: no gates configured', { chainId: options.chainId });
+    return [];
+  }
+
+  logger.debug('Wrfc gate runner: executing gates', {
+    chainId: options.chainId,
+    gateCount: gates.length,
+  });
+
+  const pkgScripts = await loadPackageScripts(options.projectRoot);
+  const results: QualityGateResult[] = [];
+
+  for (const gate of gates) {
+    const skipReason = getSkippedGateReason(gate.name, options.projectRoot, pkgScripts);
+    if (skipReason !== null) {
+      const result: QualityGateResult = {
+        gate: gate.name,
+        passed: true,
+        output: skipReason,
+        durationMs: 0,
+      };
+      results.push(result);
+      emitWrfcGateResult(options.runtimeBus, options.sessionId, options.chainId, gate.name, true);
+      options.onResult?.(results.slice(), result);
+      logger.debug('Wrfc gate runner: gate skipped', {
+        chainId: options.chainId,
+        gate: gate.name,
+        reason: skipReason,
+      });
+      continue;
+    }
+
+    const startedAt = Date.now();
+    const { passed, output } = await executeGateCommand(gate.command);
+    const result: QualityGateResult = {
+      gate: gate.name,
+      passed,
+      output,
+      durationMs: Date.now() - startedAt,
+    };
+    results.push(result);
+    emitWrfcGateResult(options.runtimeBus, options.sessionId, options.chainId, gate.name, passed);
+    options.onResult?.(results.slice(), result);
+    logger.debug('Wrfc gate runner: gate result', {
+      chainId: options.chainId,
+      gate: gate.name,
+      passed,
+      durationMs: result.durationMs,
+    });
+  }
+
+  return results;
+}

package/src/agents/wrfc-reporting.ts

@@ -0,0 +1,284 @@
+import type { CompletionReport, EngineerReport, ReviewerReport } from '@pellux/goodvibes-sdk/platform/agents/completion-report';
+import { parseCompletionReport } from '@pellux/goodvibes-sdk/platform/agents/completion-report';
+import type { QualityGateResult } from './wrfc-types.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+
+const REVIEW_BRIEF_ITEM_LIMIT = 6;
+const REVIEW_BRIEF_FILE_LIMIT = 8;
+const REVIEW_BRIEF_TEXT_LIMIT = 220;
+
+export function extractScoreFromText(text: string): number | null {
+  const scorePattern = /\*{0,2}(?:overall\s+)?score\s*:?\s*\*{0,2}\s*(\d+(?:\.\d+)?)\s*\/\s*10/i;
+  const matchScore = text.match(scorePattern);
+  if (matchScore) {
+    const value = parseFloat(matchScore[1]);
+    if (value <= 10) return value;
+  }
+
+  const slashPattern = /(\d+(?:\.\d+)?)\s*\/\s*10/;
+  const matchSlash = text.match(slashPattern);
+  if (matchSlash) {
+    const value = parseFloat(matchSlash[1]);
+    if (value <= 10) return value;
+  }
+
+  const ratedPattern = /\b(?:rated|scored|rating)\s*:?\s*(\d+(?:\.\d+)?)/i;
+  const matchRated = text.match(ratedPattern);
+  if (matchRated) {
+    const value = parseFloat(matchRated[1]);
+    if (value <= 10) return value;
+  }
+
+  return null;
+}
+
+export function extractPassedFromText(text: string, score: number, threshold: number): boolean {
+  if (score >= threshold) return true;
+  if (/\bpass(ed|es|ing)?\b/i.test(text) && !/\bfail/i.test(text)) return true;
+  if (/\bapproved?\b/i.test(text)) return true;
+  return false;
+}
+
+export function extractIssuesFromText(text: string): ReviewerReport['issues'] {
+  const issues: ReviewerReport['issues'] = [];
+  const issuePattern = /(?:^|\n)\s*(?:\d+\.\s*|-\s*|\*\s*)?(?:\*{1,2})?\[?\(?(critical|major|minor|suggestion)\)?\]?(?:\*{1,2})?[\s:*]*(.+)/gi;
+  let match: RegExpExecArray | null;
+  while ((match = issuePattern.exec(text)) !== null) {
+    const severity = match[1].toLowerCase() as 'critical' | 'major' | 'minor' | 'suggestion';
+    issues.push({
+      severity,
+      description: match[2].trim(),
+      pointValue: severity === 'critical' ? 3 : severity === 'major' ? 2 : 1,
+    });
+  }
+  return issues;
+}
+
+export function parseEngineerCompletionReport(rawOutput: string, _template?: string): CompletionReport {
+  const report = parseCompletionReport(rawOutput);
+  if (report) return report;
+  return {
+    version: 1,
+    archetype: 'engineer',
+    summary: rawOutput.slice(0, 500) || '(no output)',
+    gatheredContext: [],
+    plannedActions: [],
+    appliedChanges: [],
+    filesCreated: [],
+    filesModified: [],
+    filesDeleted: [],
+    decisions: [],
+    issues: [],
+    uncertainties: [],
+  } as EngineerReport;
+}
+
+export function parseReviewerCompletionReport(
+  chainId: string,
+  rawOutput: string,
+  threshold: number,
+): ReviewerReport {
+  const reviewerReport = parseCompletionReport(rawOutput);
+  if (reviewerReport && reviewerReport.archetype === 'reviewer') {
+    return reviewerReport as ReviewerReport;
+  }
+
+  const extractedScore = extractScoreFromText(rawOutput);
+  const extractedPassed = extractedScore !== null
+    ? extractPassedFromText(rawOutput, extractedScore, threshold)
+    : false;
+  const extractedIssues = extractIssuesFromText(rawOutput);
+
+  logger.warn('WrfcController: no structured ReviewerReport found, extracting from text', {
+    chainId,
+    extractedScore,
+  });
+  if (extractedScore === null) {
+    logger.warn('WrfcController: score extraction returned null, defaulting to 0', { chainId });
+  }
+
+  return {
+    version: 1,
+    archetype: 'reviewer',
+    summary: rawOutput.slice(0, 500) || '(no reviewer output)',
+    score: extractedScore ?? 0,
+    passed: extractedPassed,
+    dimensions: [],
+    issues: extractedIssues,
+  };
+}
+
+export function buildReviewTask(
+  chainId: string,
+  report: CompletionReport,
+  threshold: number,
+): string {
+  const lines = buildReviewBrief(report);
+  return [
+    `WRFC Review Request`,
+    `Chain ID: ${chainId}`,
+    ``,
+    `Engineer report digest:`,
+    ...lines,
+    ``,
+    `Instructions:`,
+    `1. Read the referenced files directly before scoring. Do not rely on this digest alone.`,
+    `2. Inspect the engineer's gatheredContext, plannedActions, appliedChanges, and decisions for discipline and coherence.`,
+    `3. Verify the implementation meets all stated requirements.`,
+    `4. Score the implementation using the 10-dimension review rubric.`,
+    `5. The passing score threshold is ${threshold}/10.`,
+    `6. Return a structured ReviewerReport JSON block in your final response.`,
+    ``,
+    `The ReviewerReport must include:`,
+    `- version: 1`,
+    `- archetype: "reviewer"`,
+    `- score: <number 0-10>`,
+    `- passed: <boolean>`,
+    `- dimensions: array of { name, score, maxScore, issues[] }`,
+    `- issues: array of { severity, description, file?, line?, pointValue }`,
+  ].join('\n');
+}
+
+function truncateReviewText(text: string, max = REVIEW_BRIEF_TEXT_LIMIT): string {
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  if (normalized.length <= max) return normalized;
+  return `${normalized.slice(0, max - 3)}...`;
+}
+
+function formatInlineList(items: readonly string[], limit: number): string {
+  if (items.length === 0) return 'none';
+  const visible = items.slice(0, limit).map((item) => truncateReviewText(item, 120));
+  if (items.length <= limit) return visible.join(', ');
+  return `${visible.join(', ')} (+${items.length - limit} more)`;
+}
+
+function appendListSection(
+  lines: string[],
+  title: string,
+  items: readonly string[],
+  limit = REVIEW_BRIEF_ITEM_LIMIT,
+): void {
+  if (items.length === 0) return;
+  lines.push(`${title}:`);
+  for (const item of items.slice(0, limit)) {
+    lines.push(`- ${truncateReviewText(item)}`);
+  }
+  if (items.length > limit) {
+    lines.push(`- (+${items.length - limit} more)`);
+  }
+}
+
+function appendDecisionSection(
+  lines: string[],
+  decisions: EngineerReport['decisions'],
+  limit = 4,
+): void {
+  if (decisions.length === 0) return;
+  lines.push('Decisions:');
+  for (const decision of decisions.slice(0, limit)) {
+    lines.push(`- ${truncateReviewText(decision.what, 120)} | why: ${truncateReviewText(decision.why, 120)}`);
+  }
+  if (decisions.length > limit) {
+    lines.push(`- (+${decisions.length - limit} more)`);
+  }
+}
+
+function normalizeEngineerReport(report: CompletionReport): EngineerReport {
+  const candidate = report as Partial<EngineerReport>;
+  return {
+    version: 1,
+    archetype: 'engineer',
+    summary: typeof candidate.summary === 'string' ? candidate.summary : '(no summary)',
+    ...(typeof candidate.wrfcId === 'string' ? { wrfcId: candidate.wrfcId } : {}),
+    gatheredContext: Array.isArray(candidate.gatheredContext) ? candidate.gatheredContext.filter((item): item is string => typeof item === 'string') : [],
+    plannedActions: Array.isArray(candidate.plannedActions) ? candidate.plannedActions.filter((item): item is string => typeof item === 'string') : [],
+    appliedChanges: Array.isArray(candidate.appliedChanges) ? candidate.appliedChanges.filter((item): item is string => typeof item === 'string') : [],
+    filesCreated: Array.isArray(candidate.filesCreated) ? candidate.filesCreated.filter((item): item is string => typeof item === 'string') : [],
+    filesModified: Array.isArray(candidate.filesModified) ? candidate.filesModified.filter((item): item is string => typeof item === 'string') : [],
+    filesDeleted: Array.isArray(candidate.filesDeleted) ? candidate.filesDeleted.filter((item): item is string => typeof item === 'string') : [],
+    decisions: Array.isArray(candidate.decisions)
+      ? candidate.decisions.filter((decision): decision is { what: string; why: string } =>
+        Boolean(decision) &&
+        typeof decision === 'object' &&
+        typeof decision.what === 'string' &&
+        typeof decision.why === 'string')
+      : [],
+    issues: Array.isArray(candidate.issues) ? candidate.issues.filter((item): item is string => typeof item === 'string') : [],
+    uncertainties: Array.isArray(candidate.uncertainties) ? candidate.uncertainties.filter((item): item is string => typeof item === 'string') : [],
+  };
+}
+
+function buildReviewBrief(report: CompletionReport): string[] {
+  const engineer = normalizeEngineerReport(report);
+  const lines = [
+    `- Summary: ${truncateReviewText(engineer.summary)}`,
+    `- Files created (${engineer.filesCreated.length}): ${formatInlineList(engineer.filesCreated, REVIEW_BRIEF_FILE_LIMIT)}`,
+    `- Files modified (${engineer.filesModified.length}): ${formatInlineList(engineer.filesModified, REVIEW_BRIEF_FILE_LIMIT)}`,
+    `- Files deleted (${engineer.filesDeleted.length}): ${formatInlineList(engineer.filesDeleted, REVIEW_BRIEF_FILE_LIMIT)}`,
+  ];
+
+  appendListSection(lines, 'Gathered context', engineer.gatheredContext);
+  appendListSection(lines, 'Planned actions', engineer.plannedActions);
+  appendListSection(lines, 'Applied changes', engineer.appliedChanges);
+  appendDecisionSection(lines, engineer.decisions);
+  appendListSection(lines, 'Known issues', engineer.issues, 4);
+  appendListSection(lines, 'Uncertainties', engineer.uncertainties, 4);
+
+  return lines;
+}
+
+export function buildFixTask(
+  chainId: string,
+  review: ReviewerReport,
+  threshold: number,
+  fixAttempts: number,
+): string {
+  const issueList = review.issues
+    .map((issue) => {
+      const location = issue.file ? ` (${issue.file}${issue.line ? `:${issue.line}` : ''})` : '';
+      return `- [${issue.severity.toUpperCase()}] ${issue.description}${location} (-${issue.pointValue} pts)`;
+    })
+    .join('\n');
+  return [
+    `WRFC Fix Request`,
+    `Chain ID: ${chainId}`,
+    ``,
+    `Review score: ${review.score}/10 (threshold: ${threshold}/10)`,
+    `Fix attempt: ${fixAttempts}`,
+    ``,
+    `Issues to address:`,
+    issueList || '(no structured issues — see review summary)',
+    ``,
+    `Review summary: ${review.summary}`,
+    ``,
+    `Instructions:`,
+    `1. Address ALL issues listed above, prioritizing critical and major items.`,
+    `2. Fix each issue completely — partial fixes will reduce your score.`,
+    `3. Re-run Gather, Plan, Apply explicitly before writing your final answer.`,
+    `4. Return a structured EngineerReport JSON block including gatheredContext, plannedActions, and appliedChanges in your final response.`,
+  ].join('\n');
+}
+
+export function buildGateFailureTask(
+  chainId: string,
+  task: string,
+  failedGates: readonly QualityGateResult[],
+): string {
+  const gateFailureSummary = failedGates
+    .map((result) => `- ${result.gate}: ${result.output.slice(0, 300)}`)
+    .join('\n');
+  return [
+    `WRFC Gate Failure Fix`,
+    `Parent Chain ID: ${chainId}`,
+    ``,
+    `The following quality gates failed after review passed:`,
+    gateFailureSummary,
+    ``,
+    `Original task: ${task}`,
+    ``,
+    `Instructions:`,
+    `1. Fix all gate failures listed above.`,
+    `2. Ensure typecheck, lint, and test gates pass.`,
+    `3. Return a structured EngineerReport in your final response.`,
+  ].join('\n');
+}

package/src/agents/wrfc-runtime-events.ts

@@ -0,0 +1,150 @@
+import type { RuntimeEventBus } from '../runtime/events/index.ts';
+import type { WrfcState } from './wrfc-types.ts';
+import {
+  emitOrchestrationGraphCreated,
+  emitOrchestrationNodeAdded,
+  emitOrchestrationNodeCompleted,
+  emitOrchestrationNodeFailed,
+  emitOrchestrationNodeStarted,
+  emitWorkflowAutoCommitted,
+  emitWorkflowCascadeAborted,
+  emitWorkflowChainCreated,
+  emitWorkflowChainPassed,
+  emitWorkflowGateResult,
+  emitWorkflowStateChanged,
+} from '../runtime/emitters/index.ts';
+
+export type WorkflowContext = { sessionId: string; traceId: string; source: string };
+export type WrfcNodeRole = 'engineer' | 'reviewer' | 'fixer' | 'verifier';
+
+export function createWrfcWorkflowContext(sessionId: string, chainId: string): WorkflowContext {
+  return {
+    sessionId,
+    traceId: `${sessionId}:workflow:${chainId}`,
+    source: 'wrfc-controller',
+  };
+}
+
+export function createWrfcOrchestrationGraphId(chainId: string): string {
+  return `wrfc:${chainId}`;
+}
+
+export function emitWrfcStateChanged(
+  runtimeBus: RuntimeEventBus,
+  sessionId: string,
+  chainId: string,
+  from: WrfcState,
+  to: WrfcState,
+): void {
+  emitWorkflowStateChanged(runtimeBus, createWrfcWorkflowContext(sessionId, chainId), { chainId, from, to });
+}
+
+export function emitWrfcChainCreated(runtimeBus: RuntimeEventBus, sessionId: string, chainId: string, task: string): void {
+  emitWorkflowChainCreated(runtimeBus, createWrfcWorkflowContext(sessionId, chainId), { chainId, task });
+}
+
+export function emitWrfcGateResult(runtimeBus: RuntimeEventBus, sessionId: string, chainId: string, gate: string, passed: boolean): void {
+  emitWorkflowGateResult(runtimeBus, createWrfcWorkflowContext(sessionId, chainId), { chainId, gate, passed });
+}
+
+export function emitWrfcChainPassed(runtimeBus: RuntimeEventBus, sessionId: string, chainId: string): void {
+  emitWorkflowChainPassed(runtimeBus, createWrfcWorkflowContext(sessionId, chainId), { chainId });
+}
+
+export function emitWrfcAutoCommitted(
+  runtimeBus: RuntimeEventBus,
+  sessionId: string,
+  chainId: string,
+  commitHash?: string,
+): void {
+  emitWorkflowAutoCommitted(runtimeBus, createWrfcWorkflowContext(sessionId, chainId), { chainId, commitHash });
+}
+
+export function emitWrfcCascadeAbort(
+  runtimeBus: RuntimeEventBus,
+  sessionId: string,
+  chainId: string,
+  reason: string,
+): void {
+  emitWorkflowCascadeAborted(runtimeBus, createWrfcWorkflowContext(sessionId, chainId), { chainId, reason });
+}
+
+export function emitWrfcGraphCreated(
+  runtimeBus: RuntimeEventBus,
+  sessionId: string,
+  chainId: string,
+  title: string,
+): void {
+  emitOrchestrationGraphCreated(runtimeBus, createWrfcWorkflowContext(sessionId, chainId), {
+    graphId: createWrfcOrchestrationGraphId(chainId),
+    title,
+    mode: 'review-loop',
+  });
+}
+
+export function startWrfcOrchestrationNode(
+  runtimeBus: RuntimeEventBus,
+  sessionId: string,
+  chainId: string,
+  suffix: string,
+  role: WrfcNodeRole,
+  title: string,
+  agentId?: string,
+): string {
+  const nodeId = `${chainId}:${suffix}`;
+  const context = {
+    sessionId,
+    traceId: `${sessionId}:orchestration:${chainId}:${suffix}`,
+    source: 'wrfc-controller',
+    ...(agentId !== undefined ? { agentId } : {}),
+  };
+  emitOrchestrationNodeAdded(runtimeBus, context, {
+    graphId: createWrfcOrchestrationGraphId(chainId),
+    nodeId,
+    title,
+    role,
+    ...(agentId !== undefined ? { agentId } : {}),
+  });
+  emitOrchestrationNodeStarted(runtimeBus, context, {
+    graphId: createWrfcOrchestrationGraphId(chainId),
+    nodeId,
+    ...(agentId !== undefined ? { agentId } : {}),
+  });
+  return nodeId;
+}
+
+export function completeWrfcOrchestrationNode(
+  runtimeBus: RuntimeEventBus,
+  sessionId: string,
+  chainId: string,
+  nodeId: string,
+  summary?: string,
+): void {
+  emitOrchestrationNodeCompleted(runtimeBus, {
+    sessionId,
+    traceId: `${sessionId}:orchestration:${nodeId}:complete`,
+    source: 'wrfc-controller',
+  }, {
+    graphId: createWrfcOrchestrationGraphId(chainId),
+    nodeId,
+    ...(summary !== undefined ? { summary } : {}),
+  });
+}
+
+export function failWrfcOrchestrationNode(
+  runtimeBus: RuntimeEventBus,
+  sessionId: string,
+  chainId: string,
+  nodeId: string,
+  error: string,
+): void {
+  emitOrchestrationNodeFailed(runtimeBus, {
+    sessionId,
+    traceId: `${sessionId}:orchestration:${nodeId}:fail`,
+    source: 'wrfc-controller',
+  }, {
+    graphId: createWrfcOrchestrationGraphId(chainId),
+    nodeId,
+    error,
+  });
+}

package/src/agents/wrfc-types.ts

@@ -0,0 +1,67 @@
+import type { CompletionReport, ReviewerReport } from '@pellux/goodvibes-sdk/platform/agents/completion-report';
+import type { AgentRecord } from '../tools/agent/index.ts';
+
+/** Queued chain waiting to start. */
+export interface QueuedChain {
+  record: AgentRecord;
+  queuedAt: number;
+}
+
+/** WRFC chain lifecycle states. */
+export type WrfcState =
+  | 'pending'
+  | 'engineering'
+  | 'reviewing'
+  | 'fixing'
+  | 'awaiting_gates'
+  | 'gating'
+  | 'passed'
+  | 'failed'
+  | 'committing';
+
+/** A single WRFC chain instance. */
+export interface WrfcChain {
+  id: string;
+  state: WrfcState;
+  task: string;
+  currentNodeId?: string;
+  engineerAgentId?: string;
+  reviewerAgentId?: string;
+  fixerAgentId?: string;
+  /** All agent IDs involved in this chain (for worktree cleanup). */
+  allAgentIds: string[];
+  engineerReport?: CompletionReport;
+  reviewerReport?: ReviewerReport;
+  fixAttempts: number;
+  reviewCycles: number;
+  gateResults?: QualityGateResult[];
+  createdAt: number;
+  completedAt?: number;
+  parentChainId?: string;
+  /** Whether quality gates passed. Only meaningful when state is 'passed'. */
+  gatesPassed?: boolean;
+  /** Fingerprint of gate failures: used for same-error detection across chained chains. */
+  gateFailureFingerprint?: string;
+  /** How many gate-failure retry cycles deep this chain is. 0 = original chain. */
+  gateRetryDepth: number;
+  /** Review scores history — used to detect regression (2 consecutive below initial). */
+  reviewScores: number[];
+  error?: string;
+  /** Buffered agent completion — set when agent finishes while chain is still queued/pending. */
+  bufferedCompletion?: { agentId: string; fullOutput?: string };
+}
+
+/** Quality gate definition. */
+export interface QualityGate {
+  name: string;
+  command: string;
+  enabled: boolean;
+}
+
+/** Result of running a quality gate. */
+export interface QualityGateResult {
+  gate: QualityGate['name'];
+  passed: boolean;
+  output: string;
+  durationMs: number;
+}