agentic-qe 3.8.4 → 3.8.5

package/dist/domains/test-execution/services/e2e/e2e-coordinator.d.ts

@@ -11,20 +11,6 @@ import type { VibiumClient } from '@integrations/vibium';
 import type { IBrowserClient } from '@integrations/browser';
 import type { E2ETestCase, E2ETestResult, E2ETestSuite, E2ETestSuiteResult } from '../../types';
 import type { E2ERunnerConfig, IE2ETestRunnerService, ExecutionStrategy } from './types';
-/**
- * E2E Test Runner Service
- *
- * Executes E2E test cases using browser automation clients.
- * Supports both the Vibium browser automation client and the agent-browser CLI tool.
- * Provides step-by-step execution with retry logic, timeout handling,
- * and comprehensive result aggregation.
- *
- * Agent-browser provides enhanced E2E testing capabilities:
- * - Snapshot-based element refs (@e1, @e2) for reliable element selection
- * - Session management for state persistence
- * - Network interception and API mocking
- * - Device emulation for responsive testing
- */
 export declare class E2ETestRunnerService implements IE2ETestRunnerService {
     private readonly client;
     private readonly config;

package/dist/domains/test-execution/services/e2e/e2e-coordinator.js

@@ -7,6 +7,7 @@
  *
  * @module test-execution/services/e2e/e2e-coordinator
  */
+import { LoggerFactory } from '../../../../logging/index.js';
 import { getBrowserClientForUseCase, } from '@integrations/browser';
 import { DEFAULT_E2E_RUNNER_CONFIG } from './types';
 import { createBrowserOrchestrator } from './browser-orchestrator';
@@ -31,6 +32,7 @@ import { toErrorMessage } from '@shared/error-utils.js';
  * - Network interception and API mocking
  * - Device emulation for responsive testing
  */
+const logger = LoggerFactory.create('test-execution/e2e-coordinator');
 export class E2ETestRunnerService {
     client;
     config;
@@ -244,7 +246,7 @@ export class E2ETestRunnerService {
      */
     log(message) {
         if (this.config.verbose) {
-            console.log(`[E2ERunner] ${message}`);
+            logger.info(`${message}`);
         }
     }
 }

package/dist/domains/test-execution/services/flaky-detector.js

@@ -2,6 +2,7 @@
  * Agentic QE v3 - Flaky Test Detector Service
  * Identifies and analyzes flaky tests from execution history
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { spawn } from 'child_process';
 import * as path from 'path';
@@ -23,6 +24,7 @@ const DEFAULT_FLAKY_CONFIG = {
 // ============================================================================
 // Flaky Detector Service
 // ============================================================================
+const logger = LoggerFactory.create('test-execution/flaky-detector');
 export class FlakyDetectorService {
     memory;
     testHistory = new Map();
@@ -345,7 +347,7 @@ export class FlakyDetectorService {
         }
         catch (error) {
             // Non-critical: not valid JSON, try other formats
-            console.debug('[FlakyDetector] Vitest JSON parse failed:', error instanceof Error ? error.message : error);
+            logger.debug('Vitest JSON parse failed:');
         }
         // Try to parse Jest JSON output
         try {
@@ -359,7 +361,7 @@ export class FlakyDetectorService {
         }
         catch (error) {
             // Non-critical: not Jest format
-            console.debug('[FlakyDetector] Jest JSON parse failed:', error instanceof Error ? error.message : error);
+            logger.debug('Jest JSON parse failed:');
         }
         // Try to parse TAP format
         if (stdout.includes('TAP version') || stdout.match(/^(ok|not ok)\s+\d+/m)) {

package/dist/domains/test-execution/services/retry-handler.js

@@ -2,6 +2,7 @@
  * Agentic QE v3 - Retry Handler Service
  * Implements intelligent retry logic for failed tests
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { ok, err } from '../../../shared/types';
@@ -21,6 +22,7 @@ const DEFAULT_RETRY_CONFIG = {
 // ============================================================================
 // Retry Handler Service
 // ============================================================================
+const logger = LoggerFactory.create('test-execution/retry-handler');
 export class RetryHandlerService {
     memory;
     retryHistory = new Map();
@@ -323,7 +325,7 @@ export class RetryHandlerService {
         }
         catch (error) {
             // Non-critical: package.json read errors during test runner detection
-            console.debug('[RetryHandler] package.json read failed:', error instanceof Error ? error.message : error);
+            logger.debug('package.json read failed:');
         }
         return null;
     }

package/dist/domains/test-execution/services/test-executor.js

@@ -2,6 +2,7 @@
  * Agentic QE v3 - Test Executor Service
  * Implements ITestExecutionService for running test suites
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { v4 as uuidv4 } from 'uuid';
@@ -22,6 +23,7 @@ const DEFAULT_CONFIG = {
 // ============================================================================
 // Test Executor Service
 // ============================================================================
+const logger = LoggerFactory.create('test-execution/test-executor');
 export class TestExecutorService {
     runResults = new Map();
     runStats = new Map();
@@ -264,7 +266,7 @@ Provide:
             return response.content;
         }
         catch (error) {
-            console.warn('[TestExecutorService] LLM analysis failed:', error);
+            logger.warn('LLM analysis failed:');
             return null;
         }
     }

package/dist/domains/test-generation/coordinator.d.ts

@@ -62,23 +62,6 @@ export interface CoordinatorConfig extends BaseDomainCoordinatorConfig {
     consensusConfig?: Partial<ConsensusEnabledConfig>;
 }
 type TestGenWorkflowType = 'generate' | 'tdd' | 'property' | 'data' | 'learn';
-/**
- * Test Generation Coordinator
- * Orchestrates test generation workflows and coordinates with agents
- *
- * Enhanced with @ruvector integration per ADR-040:
- * - QESONA for pattern learning (test generation patterns)
- * - QEFlashAttention for test similarity detection
- * - DecisionTransformer for test case selection
- *
- * Enhanced with MinCut topology awareness per ADR-047:
- * - Topology-based routing decisions
- * - Health monitoring for test generation workflows
- *
- * Enhanced with Multi-Model Consensus per MM-001:
- * - Consensus verification for high-stakes test design decisions
- * - Verifies test patterns, mock strategies, and edge cases
- */
 export declare class TestGenerationCoordinator extends BaseDomainCoordinator<CoordinatorConfig, TestGenWorkflowType> implements ITestGenerationCoordinator {
     private readonly memory;
     private readonly agentCoordinator;

package/dist/domains/test-generation/coordinator.js

@@ -7,9 +7,10 @@
  * - QEFlashAttention for test similarity detection
  * - DecisionTransformer for test case selection
  */
+import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { err, } from '../../shared/types';
-import { toError, toErrorMessage } from '../../shared/error-utils.js';
+import { toError } from '../../shared/error-utils.js';
 import { TestGenerationEvents, LearningOptimizationEvents, createEvent, } from '../../shared/events/domain-events';
 import { createTestGeneratorService, } from './services/test-generator';
 import { PatternMatcherService, } from './services/pattern-matcher';
@@ -67,6 +68,7 @@ const DEFAULT_CONFIG = {
  * - Consensus verification for high-stakes test design decisions
  * - Verifies test patterns, mock strategies, and edge cases
  */
+const logger = LoggerFactory.create('test-generation');
 export class TestGenerationCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -124,12 +126,12 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                     patternClusters: 50,
                     minConfidence: 0.5,
                 });
-                console.log('[TestGenerationCoordinator] PersistentSONAEngine initialized for test-generation domain');
+                logger.info('PersistentSONAEngine initialized for test-generation domain');
             }
             catch (error) {
                 // Log and continue - SONA is enhancement, not critical
-                console.error('[TestGenerationCoordinator] Failed to initialize PersistentSONAEngine:', error);
-                console.warn('[TestGenerationCoordinator] Continuing without SONA pattern persistence');
+                logger.error('Failed to initialize PersistentSONAEngine:', error instanceof Error ? error : undefined);
+                logger.warn('Continuing without SONA pattern persistence');
                 this.qesona = null;
             }
         }
@@ -137,11 +139,11 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         if (this.config.enableFlashAttention) {
             try {
                 this.flashAttention = await createQEFlashAttention(this.config.flashAttentionWorkload, { dim: 384, strategy: 'flash', blockSize: 64 });
-                console.log('[TestGenerationCoordinator] QEFlashAttention initialized for test-similarity');
+                logger.info('QEFlashAttention initialized for test-similarity');
             }
             catch (error) {
                 // Graceful degradation: native module may not be available on all platforms
-                console.warn('[TestGenerationCoordinator] QEFlashAttention unavailable (optional native module), continuing without it:', toErrorMessage(error));
+                logger.warn('QEFlashAttention unavailable (optional native module), continuing without it');
                 this.flashAttention = null;
             }
         }
@@ -153,11 +155,11 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                     embeddingDim: 384,
                 });
                 // Note: DecisionTransformer will auto-initialize on first predict() call
-                console.log('[TestGenerationCoordinator] DecisionTransformer created for test case selection');
+                logger.info('DecisionTransformer created for test case selection');
             }
             catch (error) {
                 // Graceful degradation: native module may not be available on all platforms
-                console.warn('[TestGenerationCoordinator] DecisionTransformer unavailable (optional native module), continuing without it:', toErrorMessage(error));
+                logger.warn('DecisionTransformer unavailable (optional native module), continuing without it');
                 this.decisionTransformer = null;
             }
         }
@@ -216,7 +218,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'generate');
             // ADR-047: Check topology health before expensive operations
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn('[TestGenerationCoordinator] Topology degraded, using conservative strategy');
+                logger.warn('Topology degraded, using conservative strategy');
                 // Continue with reduced parallelism when topology is unhealthy
             }
             // ADR-047: Check if operations should be paused due to critical topology
@@ -239,13 +241,13 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                             hookPatternIds.push(...hookResult.data.patterns);
                         }
                         if (hookResult.guidance) {
-                            console.log(`[TestGenerationCoordinator] Hook guidance: ${hookResult.guidance.join('; ')}`);
+                            logger.info(`Hook guidance: ${hookResult.guidance.join('; ')}`);
                         }
                     }
                 }
                 catch (e) {
                     // Hook failures are non-critical
-                    console.debug('[TestGenerationCoordinator] PreTestGeneration hook failed:', e instanceof Error ? e.message : e);
+                    logger.debug('PreTestGeneration hook failed:');
                 }
             }
             // Check if we can spawn agents
@@ -265,7 +267,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                 const sonaPatterns = await this.adaptTestGenerationPatterns(request);
                 if (sonaPatterns.length > 0) {
                     adaptedPatterns = sonaPatterns;
-                    console.log(`[TestGenerationCoordinator] Adapted ${sonaPatterns.length} patterns using QESONA`);
+                    logger.info(`Adapted ${sonaPatterns.length} patterns using QESONA`);
                 }
             }
             // Find matching patterns if pattern learning is enabled
@@ -290,13 +292,13 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                 if (this.config.enableFlashAttention && this.flashAttention) {
                     const similarTests = await this.findSimilarTests(result.value.tests);
                     if (similarTests.length > 0) {
-                        console.log(`[TestGenerationCoordinator] Found ${similarTests.length} similar tests using Flash Attention`);
+                        logger.info(`Found ${similarTests.length} similar tests using Flash Attention`);
                     }
                 }
                 // Use DecisionTransformer to prioritize generated tests
                 if (this.config.enableDecisionTransformer && this.decisionTransformer) {
                     const prioritizedTests = await this.prioritizeTestCases(result.value.tests, request);
-                    console.log(`[TestGenerationCoordinator] Prioritized ${prioritizedTests.length} tests using DecisionTransformer`);
+                    logger.info(`Prioritized ${prioritizedTests.length} tests using DecisionTransformer`);
                 }
                 // Publish events
                 if (this.config.publishEvents) {
@@ -585,7 +587,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         if (relevantInsights.length === 0) {
             return;
         }
-        console.log(`[${this.domainName}] Received ${relevantInsights.length} relevant dream insights from cycle ${cycleId}`);
+        logger.info(`[${this.domainName}] Received ${relevantInsights.length} relevant dream insights from cycle ${cycleId}`);
         // Apply high-confidence actionable insights
         for (const insight of relevantInsights) {
             if (insight.confidenceScore > 0.7 && insight.actionable) {
@@ -610,7 +612,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
      * @param cycleId - The dream cycle ID for tracking
      */
     async applyDreamInsight(insight, cycleId) {
-        console.log(`[${this.domainName}] Applying dream insight: ${insight.description.slice(0, 100)}...`);
+        logger.info(`[${this.domainName}] Applying dream insight: ${insight.description.slice(0, 100)}...`);
         // Store as a learned pattern via SONA if available
         if (this.qesona) {
             try {
@@ -640,10 +642,10 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                     description: insight.description,
                     suggestedAction: insight.suggestedAction,
                 });
-                console.log(`[${this.domainName}] Created SONA pattern ${pattern.id} from dream insight`);
+                logger.info(`[${this.domainName}] Created SONA pattern ${pattern.id} from dream insight`);
             }
             catch (error) {
-                console.error(`[${this.domainName}] Failed to store dream insight pattern:`, error);
+                logger.error(`[${this.domainName}] Failed to store dream insight pattern`, error instanceof Error ? error : undefined);
             }
         }
         // Store insight in memory for downstream usage
@@ -778,14 +780,14 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             // Adapt pattern using QESONA
             const adaptationResult = await this.qesona.adaptPattern(state, this.config.sonaPatternType, 'test-generation');
             if (adaptationResult.success && adaptationResult.pattern) {
-                console.log(`[TestGenerationCoordinator] QESONA adapted pattern with ${adaptationResult.similarity.toFixed(3)} similarity in ${adaptationResult.adaptationTimeMs.toFixed(2)}ms`);
+                logger.info(`QESONA adapted pattern with ${adaptationResult.similarity.toFixed(3)} similarity in ${adaptationResult.adaptationTimeMs.toFixed(2)}ms`);
                 // Return pattern IDs from SONA adaptation
                 return [adaptationResult.pattern.id];
             }
             return [];
         }
         catch (error) {
-            console.error('[TestGenerationCoordinator] QESONA pattern adaptation failed:', error);
+            logger.error('QESONA pattern adaptation failed:', error instanceof Error ? error : undefined);
             return [];
         }
     }
@@ -827,10 +829,10 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                 framework: request.framework,
                 testType: request.testType,
             });
-            console.log(`[TestGenerationCoordinator] Stored test generation pattern ${pattern.id} in QESONA`);
+            logger.info(`Stored test generation pattern ${pattern.id} in QESONA`);
         }
         catch (error) {
-            console.error('[TestGenerationCoordinator] Failed to store pattern in QESONA:', error);
+            logger.error('Failed to store pattern in QESONA:', error instanceof Error ? error : undefined);
         }
     }
     /**
@@ -874,7 +876,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             return results;
         }
         catch (error) {
-            console.error('[TestGenerationCoordinator] Flash Attention similarity detection failed:', error);
+            logger.error('Flash Attention similarity detection failed:', error instanceof Error ? error : undefined);
             return [];
         }
     }
@@ -904,7 +906,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             };
             // Get prediction from Decision Transformer
             const prediction = await this.decisionTransformer.predict(state);
-            console.log(`[TestGenerationCoordinator] DecisionTransformer prediction: ${prediction.reasoning}`);
+            logger.info(`DecisionTransformer prediction: ${prediction.reasoning}`);
             // Prioritize tests based on prediction confidence
             // High confidence = prioritize tests based on action type
             if (prediction.confidence > 0.7) {
@@ -914,7 +916,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
             return tests;
         }
         catch (error) {
-            console.error('[TestGenerationCoordinator] DecisionTransformer prioritization failed:', error);
+            logger.error('DecisionTransformer prioritization failed:', error instanceof Error ? error : undefined);
             return tests;
         }
     }
@@ -1009,10 +1011,10 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[TestGenerationCoordinator] Test pattern '${pattern.name}' verified by consensus`);
+                logger.info(`Test pattern '${pattern.name}' verified by consensus`);
                 return true;
             }
-            console.warn(`[TestGenerationCoordinator] Test pattern '${pattern.name}' NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Test pattern '${pattern.name}' NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed
@@ -1038,10 +1040,10 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[TestGenerationCoordinator] Mock strategy for '${strategy.target}' verified by consensus`);
+                logger.info(`Mock strategy for '${strategy.target}' verified by consensus`);
                 return true;
             }
-            console.warn(`[TestGenerationCoordinator] Mock strategy for '${strategy.target}' NOT verified`);
+            logger.warn(`Mock strategy for '${strategy.target}' NOT verified`);
             return false;
         }
         return true; // No consensus needed
@@ -1067,10 +1069,10 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[TestGenerationCoordinator] Edge case '${edgeCase.description.slice(0, 50)}...' verified by consensus`);
+                logger.info(`Edge case '${edgeCase.description.slice(0, 50)}...' verified by consensus`);
                 return true;
             }
-            console.warn(`[TestGenerationCoordinator] Edge case NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Edge case NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed

package/dist/domains/test-generation/pattern-injection/edge-case-injector.d.ts

@@ -27,11 +27,6 @@ export interface InjectionContext {
     /** Total patterns considered before filtering */
     totalConsidered: number;
 }
-/**
- * Extract searchable keywords from source code.
- * Pulls function names, class names, import identifiers, and
- * common code patterns for pattern matching.
- */
 export declare function extractKeywords(sourceCode: string): string[];
 export declare class EdgeCaseInjector {
     private readonly memory;

package/dist/domains/test-generation/pattern-injection/edge-case-injector.js

@@ -9,6 +9,7 @@
  * This creates a continuously improving test generation system where
  * patterns discovered in past testing inform future test generation.
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { generateRemediationHints } from '../../../learning/opd-remediation.js';
 export const DEFAULT_INJECTION_CONFIG = {
     topN: 3,
@@ -23,6 +24,7 @@ export const DEFAULT_INJECTION_CONFIG = {
  * Pulls function names, class names, import identifiers, and
  * common code patterns for pattern matching.
  */
+const logger = LoggerFactory.create('test-generation/edge-case-injector');
 export function extractKeywords(sourceCode) {
     const keywords = new Set();
     // Common tokens to exclude
@@ -124,7 +126,7 @@ export class EdgeCaseInjector {
         }
         catch (error) {
             // Non-blocking: injection failure should never break test generation
-            console.warn('[EdgeCaseInjector] Failed to get injection context:', error);
+            logger.warn('Failed to get injection context:');
             return emptyResult;
         }
     }

package/dist/domains/test-generation/services/code-transform-integration.d.ts

@@ -35,13 +35,6 @@ export interface CodeTransformConfig {
  * Default configuration - conservative settings for test generation
  */
 export declare const DEFAULT_TRANSFORM_CONFIG: CodeTransformConfig;
-/**
- * Check if code has patterns eligible for a specific transform
- *
- * @param code - Source code to check
- * @param type - Transform type to check eligibility for
- * @returns True if code contains patterns suitable for this transform
- */
 export declare function isEligibleForTransform(code: string, type: TransformType): boolean;
 /**
  * Detect all transforms that could be applied to code

package/dist/domains/test-generation/services/code-transform-integration.js

@@ -17,6 +17,7 @@
  *
  * @module domains/test-generation/services/code-transform-integration
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
 /**
  * Default configuration - conservative settings for test generation
@@ -48,6 +49,7 @@ const TRANSFORM_PATTERNS = {
  * @param type - Transform type to check eligibility for
  * @returns True if code contains patterns suitable for this transform
  */
+const logger = LoggerFactory.create('test-generation/code-transform');
 export function isEligibleForTransform(code, type) {
     const patterns = TRANSFORM_PATTERNS[type];
     if (!patterns)
@@ -155,7 +157,7 @@ export class CodeTransformService {
         const durationMs = Date.now() - startTime;
         this.metrics.totalTimeMs += durationMs;
         if (this.config.logMetrics) {
-            console.log(`[CodeTransformService] Applied ${appliedTransforms.length} transforms in ${durationMs}ms`);
+            logger.info(`Applied ${appliedTransforms.length} transforms in ${durationMs}ms`);
         }
         return {
             transformed: appliedTransforms.length > 0,

package/dist/domains/test-generation/services/coherence-gate-service.d.ts

@@ -114,9 +114,6 @@ export interface TestGenerationCoherenceGateConfig {
  * Default configuration
  */
 export declare const DEFAULT_COHERENCE_GATE_CONFIG: TestGenerationCoherenceGateConfig;
-/**
- * Error thrown when requirements have unresolvable contradictions
- */
 export declare class CoherenceError extends Error {
     readonly contradictions: RequirementContradiction[];
     readonly lane: ComputeLane;

package/dist/domains/test-generation/services/coherence-gate-service.js

@@ -7,6 +7,7 @@
  *
  * @module domains/test-generation/coherence-gate
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types/index.js';
 /**
  * Default configuration
@@ -21,6 +22,7 @@ export const DEFAULT_COHERENCE_GATE_CONFIG = {
 /**
  * Error thrown when requirements have unresolvable contradictions
  */
+const logger = LoggerFactory.create('test-generation/coherence-gate');
 export class CoherenceError extends Error {
     contradictions;
     lane;
@@ -123,7 +125,7 @@ export class TestGenerationCoherenceGate {
             return this.transformCoherenceResult(coherenceResult, requirements, Date.now() - startTime);
         }
         catch (error) {
-            console.error('[TestGenerationCoherenceGate] Coherence check failed:', error);
+            logger.error('Coherence check failed:', error instanceof Error ? error : undefined);
             // Return fallback result - don't block on errors
             return {
                 isCoherent: true,

package/dist/domains/test-generation/services/test-generator.d.ts

@@ -57,14 +57,6 @@ export interface TestGeneratorDependencies {
     /** ADR-051: Optional LLM router for AI-enhanced test generation */
     llmRouter?: HybridRouter;
 }
-/**
- * Test Generation Service Implementation
- * Uses Strategy Pattern generators for framework-specific test generation
- * Delegates TDD, property testing, and test data to specialized services
- *
- * ADR-XXX: Refactored to use Dependency Injection for better testability and flexibility
- * ADR-051: Added LLM enhancement for AI-powered test suggestions
- */
 export declare class TestGeneratorService implements ITestGenerationService {
     private readonly config;
     private readonly memory;

package/dist/domains/test-generation/services/test-generator.js

@@ -6,6 +6,7 @@
  * Uses TypeScript AST parser for code analysis
  * Delegates to specialized services for TDD, property tests, and test data
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -45,6 +46,7 @@ const DEFAULT_CONFIG = {
  * ADR-XXX: Refactored to use Dependency Injection for better testability and flexibility
  * ADR-051: Added LLM enhancement for AI-powered test suggestions
  */
+const logger = LoggerFactory.create('test-generation/test-generator');
 export class TestGeneratorService {
     config;
     memory;
@@ -110,7 +112,7 @@ export class TestGeneratorService {
                     }
                 }
                 catch (injectionError) {
-                    console.warn('[TestGenerator] Edge case injection failed, continuing without it:', injectionError);
+                    logger.warn('Edge case injection failed, continuing without it');
                 }
             }
             // Append KG context if available
@@ -171,7 +173,7 @@ Return ONLY the enhanced test code, no explanations.`,
             return testCode;
         }
         catch (error) {
-            console.warn('[TestGenerator] LLM enhancement failed, using original:', error);
+            logger.warn('LLM enhancement failed, using original:');
             return testCode;
         }
     }
@@ -247,7 +249,7 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
             return [];
         }
         catch (error) {
-            console.warn('[TestGenerator] LLM suggestion generation failed:', error);
+            logger.warn('LLM suggestion generation failed:');
             return [];
         }
     }

package/dist/domains/visual-accessibility/coordinator.d.ts

@@ -51,9 +51,6 @@ export interface IVisualAccessibilityCoordinatorExtended extends IVisualAccessib
  * Orchestrates visual regression, accessibility, and responsive testing workflows
  */
 type VisualAccessibilityWorkflowType = 'visual' | 'accessibility' | 'responsive' | 'combined';
-/**
- * CQ-002: Extends BaseDomainCoordinator
- */
 export declare class VisualAccessibilityCoordinator extends BaseDomainCoordinator<CoordinatorConfig, VisualAccessibilityWorkflowType> implements IVisualAccessibilityCoordinatorExtended {
     private readonly memory;
     private readonly agentCoordinator;