agentic-qe 3.7.15 → 3.7.17

package/dist/validation/pipeline.js

@@ -0,0 +1,173 @@
+/**
+ * Structured Validation Pipeline Framework (BMAD-003)
+ *
+ * Generic pipeline runner that executes validation steps sequentially,
+ * enforcing gates and producing structured reports.
+ */
+const DEFAULT_CATEGORY_WEIGHTS = {
+    format: 0.10,
+    content: 0.30,
+    quality: 0.25,
+    traceability: 0.20,
+    compliance: 0.15,
+};
+/**
+ * Execute a validation pipeline.
+ */
+export async function runPipeline(config, content, filePath, metadata) {
+    const startTime = Date.now();
+    const weights = config.categoryWeights || DEFAULT_CATEGORY_WEIGHTS;
+    const context = {
+        content,
+        filePath,
+        metadata,
+        previousResults: [],
+    };
+    const stepResults = [];
+    const blockers = [];
+    let halted = false;
+    let haltedAt;
+    // Filter steps if specified
+    const stepsToRun = config.stepFilter
+        ? config.steps.filter(s => config.stepFilter.includes(s.id))
+        : config.steps;
+    for (const step of stepsToRun) {
+        const stepStart = Date.now();
+        let result;
+        try {
+            result = await step.execute(context);
+        }
+        catch (err) {
+            result = {
+                stepId: step.id,
+                stepName: step.name,
+                status: 'fail',
+                score: 0,
+                findings: [{
+                        id: `${step.id}-error`,
+                        stepId: step.id,
+                        severity: 'critical',
+                        title: `Step execution failed: ${step.name}`,
+                        description: err.message,
+                    }],
+                evidence: ['Step threw an exception during execution'],
+                duration: Date.now() - stepStart,
+            };
+        }
+        // Ensure duration is set
+        if (!result.duration) {
+            result.duration = Date.now() - stepStart;
+        }
+        stepResults.push(result);
+        context.previousResults.push(result);
+        // Check for blocking failure
+        if (step.severity === 'blocking' && result.status === 'fail') {
+            blockers.push(...result.findings);
+            if (!config.continueOnFailure) {
+                halted = true;
+                haltedAt = step.id;
+                break;
+            }
+        }
+    }
+    // Calculate overall score (weighted average by category)
+    const categoryScores = {};
+    for (const result of stepResults) {
+        const step = config.steps.find(s => s.id === result.stepId);
+        if (!step)
+            continue;
+        if (!categoryScores[step.category]) {
+            categoryScores[step.category] = { total: 0, count: 0 };
+        }
+        categoryScores[step.category].total += result.score;
+        categoryScores[step.category].count += 1;
+    }
+    let weightedScore = 0;
+    let totalWeight = 0;
+    for (const [category, { total, count }] of Object.entries(categoryScores)) {
+        const avgScore = count > 0 ? total / count : 0;
+        const weight = weights[category] || 0.1;
+        weightedScore += avgScore * weight;
+        totalWeight += weight;
+    }
+    const finalScore = totalWeight > 0 ? Math.round(weightedScore / totalWeight) : 0;
+    // Determine overall status
+    let overall;
+    if (blockers.length > 0) {
+        overall = 'fail';
+    }
+    else if (stepResults.some(r => r.status === 'warn')) {
+        overall = 'warn';
+    }
+    else if (finalScore >= 70) {
+        overall = 'pass';
+    }
+    else {
+        overall = 'warn';
+    }
+    return {
+        pipelineId: config.id,
+        pipelineName: config.name,
+        overall,
+        score: finalScore,
+        steps: stepResults,
+        blockers,
+        halted,
+        haltedAt,
+        totalDuration: Date.now() - startTime,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Format pipeline result as markdown report.
+ */
+export function formatPipelineReport(result) {
+    const lines = [];
+    const statusLabel = result.overall === 'pass' ? 'PASS' : result.overall === 'fail' ? 'FAIL' : 'WARN';
+    lines.push(`# Validation Report: ${result.pipelineName}`);
+    lines.push('');
+    lines.push(`**Overall**: ${statusLabel} | **Score**: ${result.score}/100 | **Duration**: ${result.totalDuration}ms`);
+    if (result.halted) {
+        lines.push(`**Halted at**: ${result.haltedAt} (blocking failure)`);
+    }
+    lines.push('');
+    // Step results table
+    lines.push('## Step Results');
+    lines.push('');
+    lines.push('| # | Step | Status | Score | Findings | Duration |');
+    lines.push('|---|------|--------|-------|----------|----------|');
+    for (let i = 0; i < result.steps.length; i++) {
+        const step = result.steps[i];
+        lines.push(`| ${i + 1} | ${step.stepName} | ${step.status.toUpperCase()} | ${step.score} | ${step.findings.length} | ${step.duration}ms |`);
+    }
+    lines.push('');
+    // Blockers
+    if (result.blockers.length > 0) {
+        lines.push('## Blockers');
+        lines.push('');
+        for (const blocker of result.blockers) {
+            lines.push(`- **${blocker.title}** (${blocker.severity}): ${blocker.description}`);
+            if (blocker.suggestion) {
+                lines.push(`  - Suggestion: ${blocker.suggestion}`);
+            }
+        }
+        lines.push('');
+    }
+    // Detailed findings
+    const allFindings = result.steps.flatMap(s => s.findings);
+    if (allFindings.length > 0) {
+        lines.push('## All Findings');
+        lines.push('');
+        for (const finding of allFindings) {
+            lines.push(`- [${finding.severity.toUpperCase()}] **${finding.title}**: ${finding.description}`);
+            if (finding.location)
+                lines.push(`  - Location: ${finding.location}`);
+            if (finding.suggestion)
+                lines.push(`  - Fix: ${finding.suggestion}`);
+        }
+    }
+    lines.push('');
+    lines.push(`_Generated: ${result.timestamp}_`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/validation/steps/requirements.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Requirements Validation Steps (BMAD-003)
+ *
+ * 13 structured validation steps for requirements documents,
+ * inspired by BMAD-METHOD's PRD validation.
+ */
+import type { ValidationStep } from '../pipeline.js';
+export declare const formatCheckStep: ValidationStep;
+export declare const completenessCheckStep: ValidationStep;
+export declare const investCriteriaStep: ValidationStep;
+export declare const smartAcceptanceStep: ValidationStep;
+export declare const testabilityScoreStep: ValidationStep;
+export declare const vagueTermStep: ValidationStep;
+export declare const informationDensityStep: ValidationStep;
+export declare const traceabilityCheckStep: ValidationStep;
+export declare const implementationLeakageStep: ValidationStep;
+export declare const domainComplianceStep: ValidationStep;
+export declare const dependencyAnalysisStep: ValidationStep;
+export declare const bddScenarioStep: ValidationStep;
+export declare const holisticQualityStep: ValidationStep;
+/**
+ * All 13 requirements validation steps in order.
+ */
+export declare const REQUIREMENTS_VALIDATION_STEPS: ValidationStep[];
+/**
+ * Create a requirements validation pipeline config.
+ */
+export declare function createRequirementsPipeline(options?: {
+    continueOnFailure?: boolean;
+    stepFilter?: string[];
+}): import('../pipeline.js').PipelineConfig;
+//# sourceMappingURL=requirements.d.ts.map