claude-flow-novice
Version:
Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture Includes Local RuVector Accelerator and all CFN skills for complete functionality.
206 lines (205 loc) • 7.71 kB
JavaScript
/**
* Feedback Injection System for CFN Loop
* Migrated from legacy/v1/src/cfn-loop/feedback-injection-system.ts
*/ import { EventEmitter } from 'events';
import { Logger } from '../core/logger.js';
/**
* System for capturing and injecting consensus feedback into primary swarm
*/ export class FeedbackInjectionSystem extends EventEmitter {
logger;
config;
feedbackHistory = new Map();
constructor(config){
super();
this.config = {
maxIterations: config?.maxIterations ?? 10,
deduplicationEnabled: config?.deduplicationEnabled ?? true,
memoryNamespace: config?.memoryNamespace || 'cfn-loop/feedback'
};
const loggerConfig = process.env.CLAUDE_FLOW_ENV === 'test' ? {
level: 'error',
format: 'json',
destination: 'console'
} : {
level: 'info',
format: 'json',
destination: 'console'
};
this.logger = new Logger(loggerConfig, {
component: 'FeedbackInjectionSystem'
});
}
/**
* Capture feedback from consensus validation failure
*/ async captureFeedback(options) {
this.logger.info('Capturing consensus validation feedback', {
phaseId: options.phaseId,
iteration: options.iteration,
consensusScore: options.consensusScore
});
// Extract validator feedback
const validatorFeedback = this.extractValidatorFeedback(options.validatorResults);
// Identify failed criteria
const failedCriteria = this.identifyFailedCriteria(options.validatorResults);
// Generate actionable steps
const actionableSteps = this.generateActionableSteps(validatorFeedback, failedCriteria);
// Get previous iterations
const previousIterations = this.getPreviousIterations(options.phaseId);
const feedback = {
phaseId: options.phaseId,
iteration: options.iteration,
consensusFailed: options.consensusScore < options.requiredScore,
consensusScore: options.consensusScore,
requiredScore: options.requiredScore,
validatorFeedback,
failedCriteria,
actionableSteps,
previousIterations,
timestamp: Date.now()
};
// Store in history
this.storeFeedbackInHistory(options.phaseId, feedback);
return feedback;
}
/**
* Format feedback for injection into primary swarm prompt
*/ formatForInjection(feedback) {
const lines = [
'=== CONSENSUS VALIDATION FEEDBACK ===',
'',
`Iteration: ${feedback.iteration}`,
`Consensus Score: ${(feedback.consensusScore * 100).toFixed(1)}% (Required: ${(feedback.requiredScore * 100).toFixed(1)}%)`,
''
];
if (feedback.failedCriteria.length > 0) {
lines.push('Failed Criteria:');
for (const criterion of feedback.failedCriteria){
lines.push(` - ${criterion}`);
}
lines.push('');
}
if (feedback.actionableSteps.length > 0) {
lines.push('Actionable Steps:');
for (const step of feedback.actionableSteps){
lines.push(` [${step.priority.toUpperCase()}] ${step.category}: ${step.action}`);
}
lines.push('');
}
if (feedback.validatorFeedback.length > 0) {
lines.push('Validator Feedback:');
for (const validator of feedback.validatorFeedback){
lines.push(` ${validator.validator} (${validator.validatorType}):`);
for (const issue of validator.issues){
lines.push(` - [${issue.severity}] ${issue.message}`);
if (issue.suggestedFix) {
lines.push(` Fix: ${issue.suggestedFix}`);
}
}
}
}
return lines.join('\n');
}
/**
* Extract validator feedback from results
*/ // eslint-disable-next-line @typescript-eslint/no-explicit-any
extractValidatorFeedback(validatorResults) {
return validatorResults.map((result)=>({
validator: result.agentId || 'unknown',
validatorType: result.agentType || 'reviewer',
issues: result.issues || [],
recommendations: result.recommendations || [],
confidence: result.confidence || 0,
timestamp: Date.now()
}));
}
/**
* Identify failed criteria from validator results
*/ // eslint-disable-next-line @typescript-eslint/no-explicit-any
identifyFailedCriteria(validatorResults) {
const criteria = new Set();
for (const result of validatorResults){
if (result.issues && Array.isArray(result.issues)) {
for (const issue of result.issues){
if (issue.type) {
criteria.add(issue.type);
}
}
}
}
return Array.from(criteria);
}
/**
* Generate actionable steps from feedback
*/ generateActionableSteps(validatorFeedback, failedCriteria) {
const steps = [];
// Group issues by severity
const criticalIssues = [];
const highIssues = [];
for (const feedback of validatorFeedback){
for (const issue of feedback.issues){
if (issue.severity === 'critical') {
criticalIssues.push(issue);
} else if (issue.severity === 'high') {
highIssues.push(issue);
}
}
}
// Create steps for critical issues
for (const issue of criticalIssues){
steps.push({
priority: 'critical',
category: issue.type,
action: issue.suggestedFix || issue.message,
estimatedEffort: 'high'
});
}
// Create steps for high issues
for (const issue of highIssues){
steps.push({
priority: 'high',
category: issue.type,
action: issue.suggestedFix || issue.message,
estimatedEffort: 'medium'
});
}
return steps;
}
/**
* Get previous iterations for a phase
*/ getPreviousIterations(phaseId) {
const history = this.feedbackHistory.get(phaseId) || [];
return history.map((feedback)=>({
iteration: feedback.iteration,
consensusScore: feedback.consensusScore,
issues: feedback.validatorFeedback.flatMap((v)=>v.issues),
resolved: false
}));
}
/**
* Store feedback in history
*/ storeFeedbackInHistory(phaseId, feedback) {
if (!this.feedbackHistory.has(phaseId)) {
this.feedbackHistory.set(phaseId, []);
}
const history = this.feedbackHistory.get(phaseId);
history.push(feedback);
// Limit history size
if (history.length > this.config.maxIterations) {
history.shift();
}
}
/**
* Clear feedback history for a phase
*/ clearHistory(phaseId) {
this.feedbackHistory.delete(phaseId);
this.logger.info('Cleared feedback history', {
phaseId
});
}
/**
* Get feedback history for a phase
*/ getHistory(phaseId) {
return this.feedbackHistory.get(phaseId) || [];
}
}
//# sourceMappingURL=feedback-injection-system.js.map