agentic-qe 3.8.5 → 3.8.6

package/dist/learning/agent-routing.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Agentic QE v3 - Agent Routing
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Static agent capability mapping and routing score calculation
+ * used by QEReasoningBank.routeTask().
+ */
+import type { QEDomain } from './qe-patterns.js';
+/**
+ * Profile describing an agent's domains, capabilities, and performance.
+ */
+export interface AgentCapabilityProfile {
+    domains: QEDomain[];
+    capabilities: string[];
+    performanceScore: number;
+}
+/**
+ * Static mapping of QE agent types to their capability profiles.
+ */
+export declare const AGENT_CAPABILITIES: Record<string, AgentCapabilityProfile>;
+/**
+ * Scored agent with reasoning trace.
+ */
+export interface ScoredAgent {
+    agent: string;
+    score: number;
+    reasoning: string[];
+}
+/**
+ * Routing weight configuration.
+ */
+export interface RoutingWeights {
+    similarity: number;
+    performance: number;
+    capabilities: number;
+}
+/**
+ * Calculate agent scores for a routing request.
+ *
+ * @param detectedDomains - Domains detected from the task description
+ * @param requestCapabilities - Required capabilities from the routing request
+ * @param agentDomainPatternCounts - Map from agent type to number of matching patterns
+ * @param routingWeights - Weights for the scoring components
+ * @param agentCapabilities - Agent capability map (defaults to AGENT_CAPABILITIES)
+ * @returns Sorted array of scored agents (highest score first)
+ */
+export declare function calculateAgentScores(detectedDomains: QEDomain[], requestCapabilities: string[] | undefined, agentDomainPatternCounts: Map<string, number>, routingWeights: RoutingWeights, agentCapabilities?: Record<string, AgentCapabilityProfile>): ScoredAgent[];
+/**
+ * Domain compatibility matrix for cross-domain pattern transfer.
+ * Maps each domain to its related domains (same as TransferSpecialistService).
+ */
+export declare const RELATED_DOMAINS: Record<QEDomain, QEDomain[]>;
+//# sourceMappingURL=agent-routing.d.ts.map

package/dist/learning/agent-routing.js

@@ -0,0 +1,142 @@
+/**
+ * Agentic QE v3 - Agent Routing
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Static agent capability mapping and routing score calculation
+ * used by QEReasoningBank.routeTask().
+ */
+// ============================================================================
+// Agent Capabilities Map
+// ============================================================================
+/**
+ * Static mapping of QE agent types to their capability profiles.
+ */
+export const AGENT_CAPABILITIES = {
+    'qe-test-generator': {
+        domains: ['test-generation'],
+        capabilities: ['test-generation', 'tdd', 'bdd', 'unit-test', 'integration-test'],
+        performanceScore: 0.85,
+    },
+    'qe-coverage-analyzer': {
+        domains: ['coverage-analysis'],
+        capabilities: ['coverage-analysis', 'gap-detection', 'risk-scoring'],
+        performanceScore: 0.92,
+    },
+    'qe-coverage-specialist': {
+        domains: ['coverage-analysis'],
+        capabilities: ['sublinear-analysis', 'branch-coverage', 'mutation-testing'],
+        performanceScore: 0.88,
+    },
+    'qe-test-architect': {
+        domains: ['test-generation', 'coverage-analysis'],
+        capabilities: ['test-strategy', 'test-pyramid', 'architecture'],
+        performanceScore: 0.9,
+    },
+    'qe-api-contract-validator': {
+        domains: ['contract-testing'],
+        capabilities: ['contract-testing', 'openapi', 'graphql', 'pact'],
+        performanceScore: 0.87,
+    },
+    'qe-security-auditor': {
+        domains: ['security-compliance'],
+        capabilities: ['sast', 'dast', 'vulnerability', 'owasp'],
+        performanceScore: 0.82,
+    },
+    'qe-visual-tester': {
+        domains: ['visual-accessibility'],
+        capabilities: ['screenshot', 'visual-regression', 'percy', 'chromatic'],
+        performanceScore: 0.8,
+    },
+    'qe-a11y-ally': {
+        domains: ['visual-accessibility'],
+        capabilities: ['wcag', 'aria', 'screen-reader', 'contrast'],
+        performanceScore: 0.85,
+    },
+    'qe-performance-tester': {
+        domains: ['chaos-resilience'],
+        capabilities: ['load-testing', 'stress-testing', 'k6', 'artillery'],
+        performanceScore: 0.83,
+    },
+    'qe-flaky-investigator': {
+        domains: ['test-execution'],
+        capabilities: ['flaky-detection', 'test-stability', 'retry'],
+        performanceScore: 0.78,
+    },
+    'qe-chaos-engineer': {
+        domains: ['chaos-resilience'],
+        capabilities: ['chaos-testing', 'resilience', 'fault-injection'],
+        performanceScore: 0.75,
+    },
+};
+/**
+ * Calculate agent scores for a routing request.
+ *
+ * @param detectedDomains - Domains detected from the task description
+ * @param requestCapabilities - Required capabilities from the routing request
+ * @param agentDomainPatternCounts - Map from agent type to number of matching patterns
+ * @param routingWeights - Weights for the scoring components
+ * @param agentCapabilities - Agent capability map (defaults to AGENT_CAPABILITIES)
+ * @returns Sorted array of scored agents (highest score first)
+ */
+export function calculateAgentScores(detectedDomains, requestCapabilities, agentDomainPatternCounts, routingWeights, agentCapabilities = AGENT_CAPABILITIES) {
+    const agentScores = [];
+    for (const [agentType, profile] of Object.entries(agentCapabilities)) {
+        let score = 0;
+        const reasoning = [];
+        // Domain match (0-0.4)
+        const domainMatch = detectedDomains.filter((d) => profile.domains.includes(d)).length;
+        const domainScore = domainMatch > 0 ? (domainMatch / detectedDomains.length) * 0.4 : 0;
+        score += domainScore * routingWeights.similarity;
+        if (domainScore > 0) {
+            reasoning.push(`Domain match: ${(domainScore * 100).toFixed(0)}%`);
+        }
+        // Capability match (0-0.3)
+        if (requestCapabilities && requestCapabilities.length > 0) {
+            const capMatch = requestCapabilities.filter((c) => profile.capabilities.some((pc) => pc.toLowerCase().includes(c.toLowerCase()))).length;
+            const capScore = capMatch > 0 ? (capMatch / requestCapabilities.length) * 0.3 : 0;
+            score += capScore * routingWeights.capabilities;
+            if (capScore > 0) {
+                reasoning.push(`Capability match: ${(capScore * 100).toFixed(0)}%`);
+            }
+        }
+        else {
+            score += 0.15 * routingWeights.capabilities;
+        }
+        // Historical performance (0-0.3)
+        score += profile.performanceScore * 0.3 * routingWeights.performance;
+        reasoning.push(`Performance score: ${(profile.performanceScore * 100).toFixed(0)}%`);
+        // Pattern similarity boost
+        const patternCount = agentDomainPatternCounts.get(agentType) || 0;
+        if (patternCount > 0) {
+            const patternBoost = Math.min(0.1, patternCount * 0.02);
+            score += patternBoost;
+            reasoning.push(`Pattern matches: ${patternCount}`);
+        }
+        agentScores.push({ agent: agentType, score, reasoning });
+    }
+    // Sort by score descending
+    agentScores.sort((a, b) => b.score - a.score);
+    return agentScores;
+}
+// ============================================================================
+// Cross-Domain Compatibility Matrix
+// ============================================================================
+/**
+ * Domain compatibility matrix for cross-domain pattern transfer.
+ * Maps each domain to its related domains (same as TransferSpecialistService).
+ */
+export const RELATED_DOMAINS = {
+    'test-generation': ['test-execution', 'coverage-analysis', 'requirements-validation'],
+    'test-execution': ['test-generation', 'coverage-analysis', 'quality-assessment'],
+    'coverage-analysis': ['test-generation', 'test-execution', 'quality-assessment'],
+    'quality-assessment': ['test-execution', 'coverage-analysis', 'defect-intelligence'],
+    'defect-intelligence': ['quality-assessment', 'code-intelligence'],
+    'requirements-validation': ['test-generation', 'quality-assessment'],
+    'code-intelligence': ['defect-intelligence', 'security-compliance'],
+    'security-compliance': ['code-intelligence', 'quality-assessment'],
+    'contract-testing': ['test-generation', 'test-execution'],
+    'visual-accessibility': ['quality-assessment'],
+    'chaos-resilience': ['test-execution', 'quality-assessment'],
+    'learning-optimization': ['test-generation', 'test-execution', 'coverage-analysis', 'quality-assessment', 'defect-intelligence'],
+};
+//# sourceMappingURL=agent-routing.js.map

package/dist/learning/embedding-utils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Agentic QE v3 - Embedding Utilities
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Pure functions for embedding manipulation: resizing, hashing,
+ * and normalization. Used by QEReasoningBank.embed().
+ */
+/**
+ * Resize an embedding vector to a target dimension using averaging (downscale)
+ * or interpolation (upscale), then normalize to unit length.
+ *
+ * @param embedding - Source embedding vector
+ * @param targetDim - Desired output dimension
+ * @returns Resized and normalized embedding
+ */
+export declare function resizeEmbedding(embedding: number[], targetDim: number): number[];
+/**
+ * Generate a hash-based embedding for text. This is a deterministic fallback
+ * that always works (including ARM64) when ONNX embeddings are unavailable.
+ *
+ * @param text - Input text to embed
+ * @param dimension - Output embedding dimension
+ * @returns Hash-based embedding vector normalized to unit length
+ */
+export declare function hashEmbedding(text: string, dimension: number): number[];
+/**
+ * Normalize a vector to unit length (L2 normalization).
+ * Returns the input unchanged if magnitude is zero.
+ *
+ * @param vector - Input vector
+ * @returns Normalized vector
+ */
+export declare function normalizeVector(vector: number[]): number[];
+//# sourceMappingURL=embedding-utils.d.ts.map

package/dist/learning/embedding-utils.js

@@ -0,0 +1,95 @@
+/**
+ * Agentic QE v3 - Embedding Utilities
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Pure functions for embedding manipulation: resizing, hashing,
+ * and normalization. Used by QEReasoningBank.embed().
+ */
+// ============================================================================
+// Embedding Resize
+// ============================================================================
+/**
+ * Resize an embedding vector to a target dimension using averaging (downscale)
+ * or interpolation (upscale), then normalize to unit length.
+ *
+ * @param embedding - Source embedding vector
+ * @param targetDim - Desired output dimension
+ * @returns Resized and normalized embedding
+ */
+export function resizeEmbedding(embedding, targetDim) {
+    if (embedding.length === targetDim) {
+        return embedding;
+    }
+    if (embedding.length > targetDim) {
+        // Average adjacent values to reduce dimension
+        const ratio = embedding.length / targetDim;
+        const result = new Array(targetDim).fill(0);
+        for (let i = 0; i < targetDim; i++) {
+            const start = Math.floor(i * ratio);
+            const end = Math.floor((i + 1) * ratio);
+            let sum = 0;
+            for (let j = start; j < end; j++) {
+                sum += embedding[j];
+            }
+            result[i] = sum / (end - start);
+        }
+        return normalizeVector(result);
+    }
+    else {
+        // Interpolate to increase dimension (less common)
+        const result = new Array(targetDim).fill(0);
+        const ratio = (embedding.length - 1) / (targetDim - 1);
+        for (let i = 0; i < targetDim; i++) {
+            const pos = i * ratio;
+            const lower = Math.floor(pos);
+            const upper = Math.min(lower + 1, embedding.length - 1);
+            const weight = pos - lower;
+            result[i] = embedding[lower] * (1 - weight) + embedding[upper] * weight;
+        }
+        return normalizeVector(result);
+    }
+}
+// ============================================================================
+// Hash-Based Embedding
+// ============================================================================
+/**
+ * Generate a hash-based embedding for text. This is a deterministic fallback
+ * that always works (including ARM64) when ONNX embeddings are unavailable.
+ *
+ * @param text - Input text to embed
+ * @param dimension - Output embedding dimension
+ * @returns Hash-based embedding vector normalized to unit length
+ */
+export function hashEmbedding(text, dimension) {
+    const embedding = new Array(dimension).fill(0);
+    const normalized = text.toLowerCase().trim();
+    // Use multiple hash passes for better distribution
+    for (let pass = 0; pass < 3; pass++) {
+        for (let i = 0; i < normalized.length; i++) {
+            const charCode = normalized.charCodeAt(i);
+            const idx = (charCode * (i + 1) * (pass + 1)) % dimension;
+            embedding[idx] += Math.sin(charCode * (pass + 1)) / (i + 1);
+        }
+    }
+    return normalizeVector(embedding);
+}
+// ============================================================================
+// Vector Normalization
+// ============================================================================
+/**
+ * Normalize a vector to unit length (L2 normalization).
+ * Returns the input unchanged if magnitude is zero.
+ *
+ * @param vector - Input vector
+ * @returns Normalized vector
+ */
+export function normalizeVector(vector) {
+    const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+    if (magnitude > 0) {
+        for (let i = 0; i < vector.length; i++) {
+            vector[i] /= magnitude;
+        }
+    }
+    return vector;
+}
+//# sourceMappingURL=embedding-utils.js.map

package/dist/learning/pattern-promotion.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Agentic QE v3 - Pattern Promotion & Cross-Domain Seeding
+ * Extracted from qe-reasoning-bank.ts for file size discipline
+ *
+ * Handles pattern promotion (short-term → long-term) with coherence gating (ADR-052),
+ * and cross-domain pattern seeding/transfer.
+ */
+import type { EventBus } from '../kernel/interfaces.js';
+import type { QEPattern } from './qe-patterns.js';
+import type { PatternStore, PatternSearchResult } from './pattern-store.js';
+import type { SQLitePatternStore } from './sqlite-persistence.js';
+import type { RvfDualWriter } from '../integrations/ruvector/rvf-dual-writer.js';
+import type { Result } from '../shared/types/index.js';
+/**
+ * Dependencies needed for promotion checks
+ */
+export interface PromotionDeps {
+    patternStore: PatternStore;
+    coherenceService?: {
+        isInitialized(): boolean;
+        checkCoherence(nodes: unknown[]): Promise<{
+            energy: number;
+            contradictions?: {
+                nodeIds: string[];
+            }[];
+        }>;
+    };
+    eventBus?: EventBus;
+    coherenceThreshold: number;
+    getSqliteStore: () => SQLitePatternStore;
+    rvfDualWriter: RvfDualWriter | null;
+    searchPatterns: (query: string | number[], options?: Record<string, unknown>) => Promise<Result<PatternSearchResult[]>>;
+    getPattern: (id: string) => Promise<QEPattern | null>;
+}
+/**
+ * Check if a pattern should be promoted with coherence gate (ADR-052)
+ *
+ * Two-stage check:
+ * 1. Basic criteria (usage and quality) - cheap
+ * 2. Coherence criteria (only if basic passes) - expensive
+ */
+export declare function checkPatternPromotionWithCoherence(pattern: QEPattern, deps: PromotionDeps): Promise<boolean>;
+/**
+ * Promote a pattern to long-term storage
+ */
+export declare function promotePattern(patternId: string, deps: PromotionDeps): Promise<void>;
+/**
+ * Dependencies for cross-domain seeding
+ */
+export interface SeedingDeps {
+    searchPatterns: (query: string | number[], options?: Record<string, unknown>) => Promise<Result<PatternSearchResult[]>>;
+    storePattern: (options: Record<string, unknown>) => Promise<Result<QEPattern>>;
+    patternStore: PatternStore;
+}
+/**
+ * Seed cross-domain patterns by transferring generalizable patterns
+ * from populated domains to their related domains.
+ */
+export declare function seedCrossDomainPatterns(deps: SeedingDeps): Promise<{
+    transferred: number;
+    skipped: number;
+}>;
+//# sourceMappingURL=pattern-promotion.d.ts.map

package/dist/learning/pattern-promotion.js

@@ -0,0 +1,187 @@
+/**
+ * Agentic QE v3 - Pattern Promotion & Cross-Domain Seeding
+ * Extracted from qe-reasoning-bank.ts for file size discipline
+ *
+ * Handles pattern promotion (short-term → long-term) with coherence gating (ADR-052),
+ * and cross-domain pattern seeding/transfer.
+ */
+import { LoggerFactory } from '../logging/index.js';
+import { toErrorMessage } from '../shared/error-utils.js';
+import { shouldPromotePattern } from './qe-patterns.js';
+import { getWitnessChain } from '../audit/witness-chain.js';
+import { RELATED_DOMAINS } from './agent-routing.js';
+const logger = LoggerFactory.create('PatternPromotion');
+/**
+ * Check if a pattern should be promoted with coherence gate (ADR-052)
+ *
+ * Two-stage check:
+ * 1. Basic criteria (usage and quality) - cheap
+ * 2. Coherence criteria (only if basic passes) - expensive
+ */
+export async function checkPatternPromotionWithCoherence(pattern, deps) {
+    const basicCheck = shouldPromotePattern(pattern);
+    if (!basicCheck.meetsUsageCriteria || !basicCheck.meetsQualityCriteria) {
+        return false;
+    }
+    if (deps.coherenceService && deps.coherenceService.isInitialized()) {
+        const longTermResult = await deps.searchPatterns('', {
+            tier: 'long-term',
+            limit: 1000,
+        });
+        const longTermPatterns = longTermResult.success
+            ? longTermResult.value.map((r) => r.pattern)
+            : [];
+        const allPatterns = [...longTermPatterns, pattern];
+        const coherenceNodes = allPatterns.map((p) => ({
+            id: p.id,
+            embedding: p.embedding || [],
+            weight: p.confidence,
+            metadata: { name: p.name, domain: p.qeDomain },
+        }));
+        const coherenceResult = await deps.coherenceService.checkCoherence(coherenceNodes);
+        if (coherenceResult.energy >= deps.coherenceThreshold) {
+            const event = {
+                patternId: pattern.id,
+                patternName: pattern.name,
+                reason: 'coherence_violation',
+                energy: coherenceResult.energy,
+                existingPatternConflicts: coherenceResult.contradictions
+                    ?.map((c) => c.nodeIds)
+                    .flat(),
+            };
+            if (deps.eventBus) {
+                await deps.eventBus.publish({
+                    id: `pattern-promotion-blocked-${pattern.id}`,
+                    type: 'pattern:promotion_blocked',
+                    timestamp: new Date(),
+                    source: 'learning-optimization',
+                    payload: event,
+                });
+            }
+            logger.info('Pattern promotion blocked due to coherence violation', {
+                name: pattern.name,
+                energy: coherenceResult.energy,
+            });
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Promote a pattern to long-term storage
+ */
+export async function promotePattern(patternId, deps) {
+    const result = await deps.patternStore.promote(patternId);
+    if (result.success) {
+        try {
+            deps.getSqliteStore().promotePattern(patternId);
+        }
+        catch (e) {
+            logger.warn('SQLite pattern promotion persist failed', {
+                error: toErrorMessage(e),
+            });
+        }
+        if (deps.rvfDualWriter) {
+            try {
+                const promoted = await deps.getPattern(patternId);
+                if (promoted?.embedding && promoted.embedding.length > 0) {
+                    deps.rvfDualWriter.writePattern(patternId, promoted.embedding);
+                }
+            }
+            catch (rvfErr) {
+                logger.warn('RVF dual-write on promote failed (non-fatal)', {
+                    patternId,
+                    error: toErrorMessage(rvfErr),
+                });
+            }
+        }
+        getWitnessChain()
+            .then((wc) => wc.append('PATTERN_PROMOTE', { patternId }, 'reasoning-bank'))
+            .catch((e) => {
+            logger.warn('Witness chain PATTERN_PROMOTE failed', {
+                error: toErrorMessage(e),
+            });
+        });
+        logger.info('Promoted pattern to long-term', { patternId });
+        if (deps.eventBus) {
+            await deps.eventBus.publish({
+                id: `pattern-promoted-${patternId}`,
+                type: 'pattern:promoted',
+                timestamp: new Date(),
+                source: 'learning-optimization',
+                payload: { patternId, newTier: 'long-term' },
+            });
+        }
+    }
+    else {
+        logger.error('Failed to promote pattern', result.error, { patternId });
+    }
+}
+/**
+ * Seed cross-domain patterns by transferring generalizable patterns
+ * from populated domains to their related domains.
+ */
+export async function seedCrossDomainPatterns(deps) {
+    const stats = await deps.patternStore.getStats();
+    let transferred = 0;
+    let skipped = 0;
+    for (const [sourceDomainStr, targetDomains] of Object.entries(RELATED_DOMAINS)) {
+        const sourceDomain = sourceDomainStr;
+        const sourceCount = stats.byDomain[sourceDomain] || 0;
+        if (sourceCount === 0)
+            continue;
+        const sourceResult = await deps.searchPatterns('', {
+            domain: sourceDomain,
+            limit: 50,
+        });
+        if (!sourceResult.success)
+            continue;
+        for (const targetDomain of targetDomains) {
+            const targetCount = stats.byDomain[targetDomain] || 0;
+            if (targetCount >= sourceCount) {
+                skipped++;
+                continue;
+            }
+            for (const { pattern: sourcePattern } of sourceResult.value) {
+                const existingCheck = await deps.searchPatterns(sourcePattern.name, {
+                    domain: targetDomain,
+                    limit: 1,
+                });
+                if (existingCheck.success && existingCheck.value.length > 0) {
+                    const bestMatch = existingCheck.value[0];
+                    if (bestMatch.score > 0.8) {
+                        skipped++;
+                        continue;
+                    }
+                }
+                const transferredConfidence = Math.max(0.3, (sourcePattern.confidence || 0.5) * 0.8);
+                const transferResult = await deps.storePattern({
+                    patternType: sourcePattern.patternType,
+                    qeDomain: targetDomain,
+                    name: `${sourcePattern.name} (from ${sourceDomain})`,
+                    description: `${sourcePattern.description} [Transferred from ${sourceDomain} domain]`,
+                    template: sourcePattern.template,
+                    context: {
+                        ...sourcePattern.context,
+                        relatedDomains: [sourceDomain, targetDomain],
+                        tags: [
+                            ...sourcePattern.context.tags,
+                            'cross-domain-transfer',
+                            `source:${sourceDomain}`,
+                        ],
+                    },
+                    confidence: transferredConfidence,
+                });
+                if (transferResult.success) {
+                    transferred++;
+                }
+                else {
+                    skipped++;
+                }
+            }
+        }
+    }
+    logger.info('Cross-domain transfer complete', { transferred, skipped });
+    return { transferred, skipped };
+}
+//# sourceMappingURL=pattern-promotion.js.map

package/dist/learning/pretrained-patterns.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Agentic QE v3 - Pretrained Patterns
+ * ADR-021: QE ReasoningBank for Pattern Learning
+ *
+ * Static pretrained pattern definitions that seed the QE ReasoningBank
+ * on first initialization when no existing patterns are found.
+ */
+import type { CreateQEPatternOptions } from './qe-patterns.js';
+/**
+ * Foundational QE patterns loaded on first initialization.
+ * These cover all 8+ QE domains with seed patterns.
+ */
+export declare const PRETRAINED_PATTERNS: CreateQEPatternOptions[];
+//# sourceMappingURL=pretrained-patterns.d.ts.map