@agentic-qe/v3 3.0.0-alpha.3

package/dist/domains/quality-assessment/coherence/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Agentic QE v3 - Coherence-Gated Quality Gates Module
+ * ADR-030: RuVector lambda-coherence integration with 4-tier compute allocation
+ *
+ * This module provides coherence-based quality gate decisions using:
+ * - Lambda calculation (minimum cut in quality dimension graph)
+ * - 4-tier response allocation (Normal, Reduced, Safe, Quarantine)
+ * - Quality partition detection (clusters of related issues)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   calculateQualityLambda,
+ *   evaluateQualityGate,
+ *   detectQualityPartitions,
+ *   QualityTier,
+ * } from './coherence';
+ *
+ * // Calculate lambda from raw metrics
+ * const lambda = calculateQualityLambda({
+ *   lineCoverage: 85,
+ *   testPassRate: 98,
+ *   criticalVulns: 0,
+ *   p95Latency: 150,
+ *   targetLatency: 200,
+ *   maintainabilityIndex: 75,
+ * });
+ *
+ * // Get 4-tier decision
+ * const decision = evaluateQualityGate(lambda);
+ *
+ * if (decision.tier === QualityTier.NORMAL) {
+ *   console.log('Deployment allowed');
+ * } else {
+ *   console.log(`Actions required: ${decision.actions.join(', ')}`);
+ * }
+ *
+ * // Detect quality partitions
+ * const partitions = detectQualityPartitions(lambda.dimensions);
+ * console.log(`Found ${partitions.partitionCount} quality partitions`);
+ * ```
+ */
+export type { QualityLambda, QualityDimensions, QualityMetricsInput, QualityGateReason, QualityAction, QualityGateDecision, CoherenceGatePolicy, QualityPartition, LambdaHistoryPoint, LambdaTrend, } from './types.js';
+export { QualityTier, QualityLambdaFlags, DEFAULT_COHERENCE_GATE_POLICY, } from './types.js';
+export type { QualityPartitionType } from './types.js';
+export { LambdaCalculator, createLambdaCalculator, calculateQualityLambda, } from './lambda-calculator.js';
+export type { LambdaCalculatorConfig, } from './lambda-calculator.js';
+export { CoherenceGateController, createCoherenceGateController, evaluateQualityGate, } from './gate-controller.js';
+export type { CoherenceGateControllerConfig, } from './gate-controller.js';
+export { PartitionDetector, createPartitionDetector, detectQualityPartitions, } from './partition-detector.js';
+export type { PartitionDetectorConfig, PartitionDetectionResult, RemediationStep, RemediationPlan, } from './partition-detector.js';
+import type { QualityMetricsInput, QualityGateDecision } from './types.js';
+/**
+ * End-to-end coherence gate evaluation from raw metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Complete quality gate decision with lambda and partitions
+ */
+export declare function evaluateCoherenceGate(metrics: QualityMetricsInput): QualityGateDecision;
+/**
+ * Quick check if deployment is allowed based on metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns true if deployment is allowed
+ */
+export declare function canDeploy(metrics: QualityMetricsInput): boolean;
+/**
+ * Get the quality tier from raw metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Quality tier (0-3)
+ */
+export declare function getQualityTier(metrics: QualityMetricsInput): number;
+/**
+ * Calculate and return just the lambda value from metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Lambda value (0-100)
+ */
+export declare function getLambdaValue(metrics: QualityMetricsInput): number;
+/**
+ * Get a summary of quality issues
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Summary object with issues and recommendations
+ */
+export declare function getQualitySummary(metrics: QualityMetricsInput): QualitySummary;
+/**
+ * Quality summary result type
+ */
+export interface QualitySummary {
+    lambda: number;
+    tier: number;
+    decision: string;
+    partitionCount: number;
+    isFragmented: boolean;
+    actions: string[];
+    explanation: string;
+    topIssue?: string;
+    topRemediation?: string;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/domains/quality-assessment/coherence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domains/quality-assessment/coherence/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,YAAY,EAEV,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EAGnB,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EAGnB,mBAAmB,EAGnB,gBAAgB,EAGhB,kBAAkB,EAClB,WAAW,GACZ,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,6BAA6B,GAC9B,MAAM,YAAY,CAAC;AAGpB,YAAY,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,6BAA6B,GAC9B,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,EACf,eAAe,GAChB,MAAM,yBAAyB,CAAC;AAMjC,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAiB,MAAM,YAAY,CAAC;AAK1F;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,mBAAmB,GAAG,mBAAmB,CAUvF;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAG/D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAGnE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAGnE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAiB9E;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/domains/quality-assessment/coherence/index.js

@@ -0,0 +1,122 @@
+/**
+ * Agentic QE v3 - Coherence-Gated Quality Gates Module
+ * ADR-030: RuVector lambda-coherence integration with 4-tier compute allocation
+ *
+ * This module provides coherence-based quality gate decisions using:
+ * - Lambda calculation (minimum cut in quality dimension graph)
+ * - 4-tier response allocation (Normal, Reduced, Safe, Quarantine)
+ * - Quality partition detection (clusters of related issues)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   calculateQualityLambda,
+ *   evaluateQualityGate,
+ *   detectQualityPartitions,
+ *   QualityTier,
+ * } from './coherence';
+ *
+ * // Calculate lambda from raw metrics
+ * const lambda = calculateQualityLambda({
+ *   lineCoverage: 85,
+ *   testPassRate: 98,
+ *   criticalVulns: 0,
+ *   p95Latency: 150,
+ *   targetLatency: 200,
+ *   maintainabilityIndex: 75,
+ * });
+ *
+ * // Get 4-tier decision
+ * const decision = evaluateQualityGate(lambda);
+ *
+ * if (decision.tier === QualityTier.NORMAL) {
+ *   console.log('Deployment allowed');
+ * } else {
+ *   console.log(`Actions required: ${decision.actions.join(', ')}`);
+ * }
+ *
+ * // Detect quality partitions
+ * const partitions = detectQualityPartitions(lambda.dimensions);
+ * console.log(`Found ${partitions.partitionCount} quality partitions`);
+ * ```
+ */
+// Runtime values (enums and constants)
+export { QualityTier, QualityLambdaFlags, DEFAULT_COHERENCE_GATE_POLICY, } from './types.js';
+// Lambda Calculator
+export { LambdaCalculator, createLambdaCalculator, calculateQualityLambda, } from './lambda-calculator.js';
+// Gate Controller
+export { CoherenceGateController, createCoherenceGateController, evaluateQualityGate, } from './gate-controller.js';
+// Partition Detector
+export { PartitionDetector, createPartitionDetector, detectQualityPartitions, } from './partition-detector.js';
+import { calculateQualityLambda } from './lambda-calculator.js';
+import { evaluateQualityGate } from './gate-controller.js';
+import { createPartitionDetector } from './partition-detector.js';
+/**
+ * End-to-end coherence gate evaluation from raw metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Complete quality gate decision with lambda and partitions
+ */
+export function evaluateCoherenceGate(metrics) {
+    // Step 1: Calculate lambda
+    const lambda = calculateQualityLambda(metrics);
+    // Step 2: Detect partitions and update lambda
+    const partitionDetector = createPartitionDetector();
+    const updatedLambda = partitionDetector.updateLambdaWithPartitions(lambda);
+    // Step 3: Get gate decision
+    return evaluateQualityGate(updatedLambda);
+}
+/**
+ * Quick check if deployment is allowed based on metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns true if deployment is allowed
+ */
+export function canDeploy(metrics) {
+    const decision = evaluateCoherenceGate(metrics);
+    return decision.decision === 'allow';
+}
+/**
+ * Get the quality tier from raw metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Quality tier (0-3)
+ */
+export function getQualityTier(metrics) {
+    const decision = evaluateCoherenceGate(metrics);
+    return decision.tier;
+}
+/**
+ * Calculate and return just the lambda value from metrics
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Lambda value (0-100)
+ */
+export function getLambdaValue(metrics) {
+    const lambda = calculateQualityLambda(metrics);
+    return lambda.lambda;
+}
+/**
+ * Get a summary of quality issues
+ *
+ * @param metrics - Raw quality metrics
+ * @returns Summary object with issues and recommendations
+ */
+export function getQualitySummary(metrics) {
+    const lambda = calculateQualityLambda(metrics);
+    const partitionDetector = createPartitionDetector();
+    const partitionResult = partitionDetector.detect(lambda.dimensions);
+    const decision = evaluateQualityGate(partitionDetector.updateLambdaWithPartitions(lambda));
+    return {
+        lambda: lambda.lambda,
+        tier: decision.tier,
+        decision: decision.decision,
+        partitionCount: partitionResult.partitionCount,
+        isFragmented: partitionResult.isFragmented,
+        actions: decision.actions,
+        explanation: decision.explanation,
+        topIssue: partitionResult.priorityPartition?.type,
+        topRemediation: partitionResult.priorityPartition?.remediation,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/domains/quality-assessment/coherence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/domains/quality-assessment/coherence/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAyBH,uCAAuC;AACvC,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,6BAA6B,GAC9B,MAAM,YAAY,CAAC;AAKpB,oBAAoB;AACpB,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAMhC,kBAAkB;AAClB,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAM9B,qBAAqB;AACrB,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAcjC,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAA4B;IAChE,2BAA2B;IAC3B,MAAM,MAAM,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAE/C,8CAA8C;IAC9C,MAAM,iBAAiB,GAAG,uBAAuB,EAAE,CAAC;IACpD,MAAM,aAAa,GAAG,iBAAiB,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC;IAE3E,4BAA4B;IAC5B,OAAO,mBAAmB,CAAC,aAAa,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,OAA4B;IACpD,MAAM,QAAQ,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;IAChD,OAAO,QAAQ,CAAC,QAAQ,KAAK,OAAO,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,OAA4B;IACzD,MAAM,QAAQ,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;IAChD,OAAO,QAAQ,CAAC,IAAI,CAAC;AACvB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,OAA4B;IACzD,MAAM,MAAM,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAC/C,OAAO,MAAM,CAAC,MAAM,CAAC;AACvB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAA4B;IAC5D,MAAM,MAAM,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAC/C,MAAM,iBAAiB,GAAG,uBAAuB,EAAE,CAAC;IACpD,MAAM,eAAe,GAAG,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IACpE,MAAM,QAAQ,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC,CAAC;IAE3F,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;QAC3B,cAAc,EAAE,eAAe,CAAC,cAAc;QAC9C,YAAY,EAAE,eAAe,CAAC,YAAY;QAC1C,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,QAAQ,EAAE,eAAe,CAAC,iBAAiB,EAAE,IAAI;QACjD,cAAc,EAAE,eAAe,CAAC,iBAAiB,EAAE,WAAW;KAC/D,CAAC;AACJ,CAAC"}

package/dist/domains/quality-assessment/coherence/lambda-calculator.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Agentic QE v3 - Lambda Calculator for Coherence-Gated Quality Gates
+ * ADR-030: Calculates quality lambda (minimum cut) from metrics
+ *
+ * Lambda represents the "minimum cut" between acceptable and unacceptable quality states.
+ * Based on ruvector-mincut-gated-transformer's coherence calculation patterns.
+ */
+import { QualityLambda, QualityDimensions, QualityMetricsInput, QualityLambdaFlags, CoherenceGatePolicy } from './types';
+/**
+ * Configuration for lambda calculation
+ */
+export interface LambdaCalculatorConfig {
+    /** Policy settings for thresholds */
+    policy: CoherenceGatePolicy;
+    /** Dimension weights (default: equal weights) */
+    dimensionWeights?: Partial<Record<keyof QualityDimensions, number>>;
+    /** Critical dimensions that cannot be below threshold */
+    criticalDimensions?: (keyof QualityDimensions)[];
+}
+/**
+ * Calculator for quality lambda (minimum cut) values
+ */
+export declare class LambdaCalculator {
+    private readonly policy;
+    private readonly weights;
+    private readonly criticalDimensions;
+    constructor(config?: Partial<LambdaCalculatorConfig>);
+    /**
+     * Calculate quality lambda from raw metrics
+     */
+    calculate(metrics: QualityMetricsInput): QualityLambda;
+    /**
+     * Normalize raw metrics to 0-1 scale dimensions
+     */
+    normalizeMetrics(metrics: QualityMetricsInput): QualityDimensions;
+    /**
+     * Calculate the minimum cut (lambda) from dimensions
+     * This is the weakest quality dimension, representing the "minimum cut" in the quality graph
+     */
+    calculateMinimumCut(dimensions: QualityDimensions): number;
+    /**
+     * Count dimensions that are at the boundary (near threshold, unstable)
+     */
+    countBoundaryEdges(dimensions: QualityDimensions): number;
+    /**
+     * Calculate boundary concentration in Q15 fixed-point format (0-32767)
+     * Higher values indicate more concentrated instability
+     */
+    calculateBoundaryConcentration(dimensions: QualityDimensions): number;
+    /**
+     * Calculate control flags based on lambda and trend
+     */
+    calculateFlags(lambda: number, previousLambda?: number): QualityLambdaFlags;
+    /**
+     * Calculate the drop ratio in Q15 format (0-32767)
+     * Used by gate controller to detect rapid quality degradation
+     */
+    calculateDropRatioQ15(lambda: QualityLambda): number;
+    /**
+     * Get weighted dimension score for a specific dimension
+     */
+    getWeightedScore(dimension: keyof QualityDimensions, value: number): number;
+    /**
+     * Check if a dimension is critical
+     */
+    isCriticalDimension(dimension: keyof QualityDimensions): boolean;
+    /**
+     * Get all dimensions below a specific threshold
+     */
+    getDimensionsBelowThreshold(dimensions: QualityDimensions, threshold?: number): Array<{
+        dimension: keyof QualityDimensions;
+        value: number;
+        deficit: number;
+    }>;
+    /**
+     * Calculate a summary of dimension health
+     */
+    getDimensionSummary(dimensions: QualityDimensions): {
+        healthy: number;
+        warning: number;
+        critical: number;
+        total: number;
+    };
+}
+/**
+ * Factory function to create a lambda calculator with default settings
+ */
+export declare function createLambdaCalculator(config?: Partial<LambdaCalculatorConfig>): LambdaCalculator;
+/**
+ * Convenience function to calculate lambda from metrics
+ */
+export declare function calculateQualityLambda(metrics: QualityMetricsInput, config?: Partial<LambdaCalculatorConfig>): QualityLambda;
+//# sourceMappingURL=lambda-calculator.d.ts.map

package/dist/domains/quality-assessment/coherence/lambda-calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda-calculator.d.ts","sourceRoot":"","sources":["../../../../src/domains/quality-assessment/coherence/lambda-calculator.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,qCAAqC;IACrC,MAAM,EAAE,mBAAmB,CAAC;IAE5B,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC;IAEpE,yDAAyD;IACzD,kBAAkB,CAAC,EAAE,CAAC,MAAM,iBAAiB,CAAC,EAAE,CAAC;CAClD;AAwBD;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAClE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA+B;gBAEtD,MAAM,GAAE,OAAO,CAAC,sBAAsB,CAAM;IAQxD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,mBAAmB,GAAG,aAAa;IA6BtD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,iBAAiB;IAoDjE;;;OAGG;IACH,mBAAmB,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM;IAgC1D;;OAEG;IACH,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM;IAmBzD;;;OAGG;IACH,8BAA8B,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM;IA0BrE;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,kBAAkB;IAuB3E;;;OAGG;IACH,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM;IAcpD;;OAEG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAK3E;;OAEG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,iBAAiB,GAAG,OAAO;IAIhE;;OAEG;IACH,2BAA2B,CACzB,UAAU,EAAE,iBAAiB,EAC7B,SAAS,CAAC,EAAE,MAAM,GACjB,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAoBhF;;OAEG;IACH,mBAAmB,CAAC,UAAU,EAAE,iBAAiB,GAAG;QAClD,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;KACf;CA0BF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,GACvC,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,mBAAmB,EAC5B,MAAM,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,GACvC,aAAa,CAGf"}

package/dist/domains/quality-assessment/coherence/lambda-calculator.js

@@ -0,0 +1,293 @@
+/**
+ * Agentic QE v3 - Lambda Calculator for Coherence-Gated Quality Gates
+ * ADR-030: Calculates quality lambda (minimum cut) from metrics
+ *
+ * Lambda represents the "minimum cut" between acceptable and unacceptable quality states.
+ * Based on ruvector-mincut-gated-transformer's coherence calculation patterns.
+ */
+import { QualityLambdaFlags, DEFAULT_COHERENCE_GATE_POLICY, } from './types';
+/**
+ * Default dimension weights
+ */
+const DEFAULT_DIMENSION_WEIGHTS = {
+    coverage: 1.0,
+    passRate: 1.5, // Test pass rate is critical
+    security: 2.0, // Security is highest priority
+    performance: 1.0,
+    maintainability: 0.8,
+    reliability: 1.2,
+    technicalDebt: 0.6,
+    duplication: 0.5,
+};
+/**
+ * Default critical dimensions
+ */
+const DEFAULT_CRITICAL_DIMENSIONS = [
+    'passRate',
+    'security',
+];
+/**
+ * Calculator for quality lambda (minimum cut) values
+ */
+export class LambdaCalculator {
+    policy;
+    weights;
+    criticalDimensions;
+    constructor(config = {}) {
+        this.policy = { ...DEFAULT_COHERENCE_GATE_POLICY, ...config.policy };
+        this.weights = { ...DEFAULT_DIMENSION_WEIGHTS, ...config.dimensionWeights };
+        this.criticalDimensions = new Set(config.criticalDimensions || DEFAULT_CRITICAL_DIMENSIONS);
+    }
+    /**
+     * Calculate quality lambda from raw metrics
+     */
+    calculate(metrics) {
+        // Step 1: Normalize all metrics to 0-1 scale
+        const dimensions = this.normalizeMetrics(metrics);
+        // Step 2: Calculate lambda (minimum cut)
+        const lambda = this.calculateMinimumCut(dimensions);
+        // Step 3: Count boundary edges (dimensions near threshold)
+        const boundaryEdges = this.countBoundaryEdges(dimensions);
+        // Step 4: Calculate boundary concentration (Q15 fixed-point)
+        const boundaryConcentrationQ15 = this.calculateBoundaryConcentration(dimensions);
+        // Step 5: Calculate flags
+        const flags = this.calculateFlags(lambda, metrics.previousLambda);
+        // Step 6: Return complete lambda object
+        return {
+            lambda,
+            lambdaPrev: metrics.previousLambda ?? lambda,
+            boundaryEdges,
+            boundaryConcentrationQ15,
+            partitionCount: 0, // Will be set by partition detector
+            flags,
+            calculatedAt: new Date(),
+            dimensions,
+        };
+    }
+    /**
+     * Normalize raw metrics to 0-1 scale dimensions
+     */
+    normalizeMetrics(metrics) {
+        // Coverage: Direct percentage to 0-1
+        const coverage = Math.min(Math.max(metrics.lineCoverage / 100, 0), 1);
+        // Pass rate: Direct percentage to 0-1
+        const passRate = Math.min(Math.max(metrics.testPassRate / 100, 0), 1);
+        // Security: Inverse of vulnerability count, capped at 5 critical vulns
+        // 0 vulns = 1.0, 5+ critical vulns = 0.0
+        const criticalImpact = Math.min(metrics.criticalVulns / 5, 1);
+        const highImpact = Math.min((metrics.highVulns || 0) / 10, 0.3);
+        const mediumImpact = Math.min((metrics.mediumVulns || 0) / 20, 0.1);
+        const security = Math.max(1 - criticalImpact - highImpact - mediumImpact, 0);
+        // Performance: Ratio of target to actual P95 latency, capped at 1
+        const performance = metrics.targetLatency > 0
+            ? Math.min(metrics.targetLatency / Math.max(metrics.p95Latency, 1), 1)
+            : 1;
+        // Maintainability: Direct index to 0-1
+        const maintainability = Math.min(Math.max(metrics.maintainabilityIndex / 100, 0), 1);
+        // Reliability: Inverse of flaky test ratio
+        const reliability = 1 - (metrics.flakyTestRatio || 0);
+        // Technical debt: Inverse ratio of debt to max acceptable
+        let technicalDebt;
+        if (metrics.technicalDebtHours !== undefined && metrics.maxAcceptableDebtHours) {
+            technicalDebt = Math.max(1 - metrics.technicalDebtHours / metrics.maxAcceptableDebtHours, 0);
+        }
+        // Duplication: Inverse of duplication percentage (capped at 20%)
+        let duplication;
+        if (metrics.duplicationPercent !== undefined) {
+            duplication = Math.max(1 - metrics.duplicationPercent / 20, 0);
+        }
+        return {
+            coverage,
+            passRate,
+            security,
+            performance,
+            maintainability,
+            reliability,
+            technicalDebt,
+            duplication,
+        };
+    }
+    /**
+     * Calculate the minimum cut (lambda) from dimensions
+     * This is the weakest quality dimension, representing the "minimum cut" in the quality graph
+     */
+    calculateMinimumCut(dimensions) {
+        // Get all defined dimension values
+        const values = [];
+        const entries = Object.entries(dimensions);
+        for (const [key, value] of entries) {
+            if (value !== undefined) {
+                // Apply weight to the dimension
+                const weight = this.weights[key] || 1.0;
+                // For critical dimensions, don't apply weight reduction
+                if (this.criticalDimensions.has(key)) {
+                    values.push(value);
+                }
+                else {
+                    // Non-critical dimensions have weighted contribution
+                    // Higher weight means more impact on lambda
+                    values.push(value * (2 - weight) / 2 + value / 2);
+                }
+            }
+        }
+        if (values.length === 0) {
+            return 0;
+        }
+        // Lambda is the minimum value (minimum cut)
+        const minValue = Math.min(...values);
+        // Scale to 0-100
+        return Math.round(minValue * 100);
+    }
+    /**
+     * Count dimensions that are at the boundary (near threshold, unstable)
+     */
+    countBoundaryEdges(dimensions) {
+        const threshold = this.policy.boundaryThreshold;
+        const tolerance = this.policy.boundaryTolerance;
+        let boundaryCount = 0;
+        const entries = Object.entries(dimensions);
+        for (const [, value] of entries) {
+            if (value !== undefined) {
+                // A dimension is at the boundary if it's within tolerance of the threshold
+                if (value >= threshold - tolerance && value < threshold + tolerance) {
+                    boundaryCount++;
+                }
+            }
+        }
+        return boundaryCount;
+    }
+    /**
+     * Calculate boundary concentration in Q15 fixed-point format (0-32767)
+     * Higher values indicate more concentrated instability
+     */
+    calculateBoundaryConcentration(dimensions) {
+        const threshold = this.policy.boundaryThreshold;
+        // Get all dimensions below threshold
+        const belowThreshold = [];
+        const entries = Object.entries(dimensions);
+        for (const [, value] of entries) {
+            if (value !== undefined && value < threshold) {
+                belowThreshold.push(value);
+            }
+        }
+        if (belowThreshold.length === 0) {
+            // No dimensions below threshold = maximum stability
+            return 32767;
+        }
+        // Calculate average of below-threshold dimensions
+        const avgBelowThreshold = belowThreshold.reduce((a, b) => a + b, 0) / belowThreshold.length;
+        // Convert to Q15 (0-32767)
+        // Lower values in below-threshold = lower Q15 = more concerning
+        return Math.round(avgBelowThreshold * 32767);
+    }
+    /**
+     * Calculate control flags based on lambda and trend
+     */
+    calculateFlags(lambda, previousLambda) {
+        let flags = QualityLambdaFlags.NONE;
+        // Check if this is first evaluation
+        if (previousLambda === undefined) {
+            flags |= QualityLambdaFlags.FIRST_EVALUATION;
+            return flags;
+        }
+        // Calculate trend
+        const delta = lambda - previousLambda;
+        const deltaRatio = previousLambda > 0 ? Math.abs(delta) / previousLambda : 0;
+        // Set trend flags
+        if (delta > 0 && deltaRatio > 0.05) {
+            flags |= QualityLambdaFlags.TRENDING_UP;
+        }
+        else if (delta < 0 && deltaRatio > 0.05) {
+            flags |= QualityLambdaFlags.TRENDING_DOWN;
+        }
+        return flags;
+    }
+    /**
+     * Calculate the drop ratio in Q15 format (0-32767)
+     * Used by gate controller to detect rapid quality degradation
+     */
+    calculateDropRatioQ15(lambda) {
+        if (lambda.lambdaPrev === 0 || lambda.lambdaPrev === lambda.lambda) {
+            return 0;
+        }
+        const drop = lambda.lambdaPrev - lambda.lambda;
+        if (drop <= 0) {
+            return 0; // No drop (improved or stayed same)
+        }
+        const dropRatio = drop / lambda.lambdaPrev;
+        return Math.round(dropRatio * 32767);
+    }
+    /**
+     * Get weighted dimension score for a specific dimension
+     */
+    getWeightedScore(dimension, value) {
+        const weight = this.weights[dimension] || 1.0;
+        return value * weight;
+    }
+    /**
+     * Check if a dimension is critical
+     */
+    isCriticalDimension(dimension) {
+        return this.criticalDimensions.has(dimension);
+    }
+    /**
+     * Get all dimensions below a specific threshold
+     */
+    getDimensionsBelowThreshold(dimensions, threshold) {
+        const thresh = threshold ?? this.policy.boundaryThreshold;
+        const below = [];
+        const entries = Object.entries(dimensions);
+        for (const [key, value] of entries) {
+            if (value !== undefined && value < thresh) {
+                below.push({
+                    dimension: key,
+                    value,
+                    deficit: thresh - value,
+                });
+            }
+        }
+        // Sort by deficit (largest first)
+        return below.sort((a, b) => b.deficit - a.deficit);
+    }
+    /**
+     * Calculate a summary of dimension health
+     */
+    getDimensionSummary(dimensions) {
+        const thresh = this.policy.boundaryThreshold;
+        const criticalThresh = thresh - this.policy.boundaryTolerance;
+        let healthy = 0;
+        let warning = 0;
+        let critical = 0;
+        let total = 0;
+        const entries = Object.entries(dimensions);
+        for (const [, value] of entries) {
+            if (value !== undefined) {
+                total++;
+                if (value >= thresh) {
+                    healthy++;
+                }
+                else if (value >= criticalThresh) {
+                    warning++;
+                }
+                else {
+                    critical++;
+                }
+            }
+        }
+        return { healthy, warning, critical, total };
+    }
+}
+/**
+ * Factory function to create a lambda calculator with default settings
+ */
+export function createLambdaCalculator(config) {
+    return new LambdaCalculator(config);
+}
+/**
+ * Convenience function to calculate lambda from metrics
+ */
+export function calculateQualityLambda(metrics, config) {
+    const calculator = createLambdaCalculator(config);
+    return calculator.calculate(metrics);
+}
+//# sourceMappingURL=lambda-calculator.js.map

package/dist/domains/quality-assessment/coherence/lambda-calculator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda-calculator.js","sourceRoot":"","sources":["../../../../src/domains/quality-assessment/coherence/lambda-calculator.ts"],"names":[],"mappings":"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"}