agentic-qe 3.8.4 → 3.8.6

package/dist/domains/visual-accessibility/services/visual-regression.d.ts

@@ -186,32 +186,6 @@ export interface IVisualRegressionService {
      */
     isBrowserAvailable(): Promise<boolean>;
 }
-/**
- * Visual Regression Service Implementation
- *
- * Orchestrates visual regression testing with browser-based capture,
- * baseline management, and result aggregation.
- *
- * @example
- * ```typescript
- * const service = new VisualRegressionService(memory, vibiumClient, {
- *   diffThreshold: 0.5,
- *   useBrowserCapture: true,
- * });
- *
- * // Run a single test
- * const result = await service.runTest('https://example.com');
- * if (result.success && result.value.passed) {
- *   console.log('Visual regression test passed');
- * }
- *
- * // Run tests across multiple viewports
- * const report = await service.runTests(
- *   ['https://example.com', 'https://example.com/about'],
- *   [{ width: 1920, height: 1080, ... }, { width: 375, height: 667, ... }]
- * );
- * ```
- */
 export declare class VisualRegressionService implements IVisualRegressionService {
     private readonly memory;
     private readonly vibiumClient;

package/dist/domains/visual-accessibility/services/visual-regression.js

@@ -19,6 +19,7 @@
  *
  * @module domains/visual-accessibility/services/visual-regression
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
 import { FilePath } from '../../../shared/value-objects/index.js';
@@ -73,6 +74,7 @@ const DEFAULT_CONFIG = {
  * );
  * ```
  */
+const logger = LoggerFactory.create('visual-accessibility/visual-regression');
 export class VisualRegressionService {
     memory;
     vibiumClient;
@@ -117,7 +119,7 @@ export class VisualRegressionService {
             }
             catch (error) {
                 // Non-critical: browser client acquisition failed
-                console.debug('[VisualRegression] Browser client error:', error instanceof Error ? error.message : error);
+                logger.debug('Browser client error:');
             }
         }
         return null;
@@ -506,7 +508,7 @@ export class VisualRegressionService {
                     if (clientCapture.success) {
                         return clientCapture;
                     }
-                    console.warn(`[VisualRegression] Browser client capture failed, trying Vibium`);
+                    logger.warn(`Browser client capture failed, trying Vibium`);
                 }
                 // Fall back to Vibium
                 if (this.vibiumClient && await this.isBrowserAvailable()) {

package/dist/domains/visual-accessibility/services/visual-tester.d.ts

@@ -31,10 +31,6 @@ export interface VisualTesterDependencies {
     memory: MemoryBackend;
     llmRouter?: HybridRouter;
 }
-/**
- * Visual Testing Service Implementation
- * Provides screenshot capture and comparison capabilities
- */
 export declare class VisualTesterService implements IVisualTestingService {
     private readonly config;
     private readonly memory;

package/dist/domains/visual-accessibility/services/visual-tester.js

@@ -2,6 +2,7 @@
  * Agentic QE v3 - Visual Testing Service
  * Implements visual regression testing with screenshot comparison
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types/index.js';
 import { FilePath } from '../../../shared/value-objects/index.js';
@@ -27,6 +28,7 @@ const DEFAULT_CONFIG = {
  * Visual Testing Service Implementation
  * Provides screenshot capture and comparison capabilities
  */
+const logger = LoggerFactory.create('visual-accessibility/visual-tester');
 export class VisualTesterService {
     config;
     memory;
@@ -227,7 +229,7 @@ export class VisualTesterService {
                     return browserResult;
                 }
                 // Log fallback but don't fail - use deterministic instead
-                console.warn('[VisualTester] Browser comparison failed, falling back to deterministic:', browserResult.error.message);
+                logger.warn(`Browser comparison failed, falling back to deterministic: ${browserResult.error.message}`);
             }
             // Fallback to deterministic comparison
             const diffResult = this.calculateDiff(baseline, screenshot);
@@ -368,7 +370,7 @@ Provide:
             return response.content;
         }
         catch (error) {
-            console.warn('[VisualTesterService] LLM analysis failed:', error);
+            logger.warn('LLM analysis failed:');
             return null;
         }
     }

package/dist/governance/deterministic-gateway-integration.js

@@ -10,7 +10,7 @@
  * @see ADR-058-guidance-governance-integration.md
  */
 import { governanceFlags, isStrictMode, isDeterministicGatewayEnabled } from './feature-flags.js';
-import { createSafeRegex } from '../mcp/security/validators/regex-safety-validator.js';
+import { createSafeRegex } from '../shared/security/regex-safety-validator.js';
 // isDeterministicGatewayEnabled is imported from feature-flags.js
 /**
  * Get deterministic gateway flags with defaults

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