agentic-qe/dist/agents/RequirementsValidatorAgent.d.ts

Agentic Quality Engineering Fleet System - AI-driven quality management platform

/**
 * RequirementsValidatorAgent - Validates requirements testability and generates BDD scenarios
 *
 * Core capabilities:
 * - Testability analysis using SMART/INVEST criteria
 * - BDD scenario generation in Gherkin format
 * - Risk assessment with heat mapping
 * - Acceptance criteria validation
 * - Traceability mapping
 * - Edge case identification
 * - Requirement completeness check
 *
 * Memory namespaces:
 * - aqe/requirements/* - Requirement validation data
 * - aqe/bdd-scenarios/* - Generated BDD scenarios
 * - aqe/risk-scores/* - Risk assessment results
 * - aqe/traceability/* - Traceability matrices
 */
import { BaseAgent, BaseAgentConfig } from './BaseAgent';
import { QETask } from '../types';
export interface RequirementsValidatorConfig extends BaseAgentConfig {
    /** Validation thresholds */
    thresholds?: {
        minTestabilityScore: number;
        maxHighRiskRequirements: number;
        minBddCoverage: number;
    };
    /** Validation rules to apply */
    validationRules?: string[];
    /** Output format for reports */
    reportFormat?: 'json' | 'markdown' | 'html';
}
export interface Requirement {
    id: string;
    title: string;
    description: string;
    acceptanceCriteria?: string[];
    priority?: 'low' | 'medium' | 'high' | 'critical';
    type?: 'functional' | 'non-functional' | 'technical' | 'business';
    dependencies?: string[];
    metadata?: Record<string, any>;
}
export interface TestabilityScore {
    overall: number;
    specific: boolean;
    measurable: boolean;
    achievable: boolean;
    relevant: boolean;
    timeBound: boolean;
    issues: string[];
    recommendations: string[];
}
export interface BddScenario {
    feature: string;
    background?: string[];
    scenarios: {
        name: string;
        type: 'scenario' | 'scenario_outline';
        given: string[];
        when: string[];
        then: string[];
        examples?: {
            headers: string[];
            rows: string[][];
        };
    }[];
    metadata: {
        requirementId: string;
        generatedAt: Date;
        scenarioCount: number;
        testCaseProjection: number;
    };
}
export interface RiskAssessment {
    requirementId: string;
    overallRisk: 'low' | 'medium' | 'high' | 'critical';
    riskScore: number;
    factors: {
        technicalComplexity: number;
        externalDependencies: number;
        performanceImpact: number;
        securityImplications: number;
        regulatoryCompliance: number;
    };
    mitigation: string[];
    testingPriority: number;
}
export interface TraceabilityMap {
    requirementId: string;
    businessRequirement?: string;
    epic?: string;
    userStory?: string;
    acceptanceCriteria: string[];
    bddScenarios: string[];
    testCases: string[];
    codeModules: string[];
    deployments: string[];
}
export interface ValidationReport {
    requirementId: string;
    testabilityScore: TestabilityScore;
    riskAssessment: RiskAssessment;
    bddScenarios: BddScenario;
    traceability: TraceabilityMap;
    edgeCases: string[];
    completeness: {
        who: boolean;
        what: boolean;
        when: boolean;
        where: boolean;
        why: boolean;
        how: boolean;
        score: number;
    };
    timestamp: Date;
}
export declare class RequirementsValidatorAgent extends BaseAgent {
    private readonly config;
    private validationPatterns;
    private riskRules;
    constructor(config: RequirementsValidatorConfig);
    protected initializeComponents(): Promise<void>;
    protected loadKnowledge(): Promise<void>;
    protected cleanup(): Promise<void>;
    protected performTask(task: QETask): Promise<any>;
    /**
     * Validate a requirement for testability using SMART/INVEST criteria
     */
    private validateRequirement;
    /**
     * Calculate testability score using SMART criteria
     */
    private calculateTestabilityScore;
    private checkSpecific;
    private checkMeasurable;
    private checkAchievable;
    private checkRelevant;
    private checkTimeBound;
    /**
     * Generate BDD scenarios in Gherkin format
     */
    private generateBddScenarios;
    private extractFeatureName;
    private generateBackground;
    private generateScenarios;
    private generateHappyPathScenario;
    private generateErrorScenarios;
    private generateEdgeCaseScenarios;
    private generateScenarioOutlines;
    private extractActionVerb;
    private extractPreconditions;
    private extractActions;
    private extractExpectedOutcomes;
    /**
     * Assess risk level of a requirement
     */
    private assessRisk;
    private assessTechnicalComplexity;
    private assessExternalDependencies;
    private assessPerformanceImpact;
    private assessSecurityImplications;
    private assessRegulatoryCompliance;
    private generateMitigationStrategies;
    /**
     * Validate acceptance criteria using SMART framework
     */
    private validateAcceptanceCriteria;
    private isAcceptanceCriteriaValid;
    /**
     * Create bidirectional traceability map
     */
    private createTraceabilityMap;
    private extractBusinessRequirement;
    private extractEpic;
    private extractUserStory;
    /**
     * Identify edge cases using combinatorial testing
     */
    private identifyEdgeCases;
    /**
     * Check requirement completeness using 5Ws framework
     */
    private checkCompleteness;
    /**
     * Batch validate multiple requirements
     */
    private batchValidate;
    /**
     * Generate comprehensive validation report
     */
    private generateValidationReport;
    private formatReportAsMarkdown;
    private formatReportAsHtml;
}
//# sourceMappingURL=RequirementsValidatorAgent.d.ts.map