agentic-qe 1.3.3 → 1.3.4

package/dist/learning/FixRecommendationEngine.js

@@ -0,0 +1,500 @@
+"use strict";
+/**
+ * FixRecommendationEngine - Automated fix recommendations for flaky tests
+ *
+ * Generates actionable fix recommendations with code examples based on root cause analysis
+ *
+ * @module learning/FixRecommendationEngine
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixRecommendationEngine = void 0;
+/**
+ * FixRecommendationEngine for generating automated fix recommendations
+ */
+class FixRecommendationEngine {
+    /**
+     * Generate fix recommendations based on root cause
+     *
+     * @param rootCause - Root cause analysis result
+     * @returns Array of fix recommendations with code examples
+     */
+    generateRecommendations(rootCause) {
+        switch (rootCause.cause) {
+            case 'timing':
+                return this.timingFixes(rootCause);
+            case 'race_condition':
+                return this.raceFixes(rootCause);
+            case 'dependency':
+                return this.dependencyFixes(rootCause);
+            case 'isolation':
+                return this.isolationFixes(rootCause);
+            case 'environment':
+                return this.environmentFixes(rootCause);
+            default:
+                return this.genericFixes(rootCause);
+        }
+    }
+    /**
+     * Timing-related fixes
+     */
+    timingFixes(rootCause) {
+        const fixes = [];
+        // Fix 1: Add explicit wait with retry logic
+        fixes.push({
+            priority: 'high',
+            category: 'timing',
+            recommendation: 'Add explicit wait with retry logic to handle asynchronous operations',
+            codeExample: `// Before
+expect(element).toBeVisible();
+
+// After - Using waitFor with retry
+import { waitFor } from '@testing-library/react';
+
+await waitFor(
+  () => expect(element).toBeVisible(),
+  {
+    timeout: 5000,
+    interval: 100
+  }
+);
+
+// Or with retry wrapper
+async function withRetry(fn: () => void, retries = 3) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      await fn();
+      return;
+    } catch (error) {
+      if (i === retries - 1) throw error;
+      await new Promise(resolve => setTimeout(resolve, 100 * (i + 1)));
+    }
+  }
+}
+
+await withRetry(() => expect(element).toBeVisible());`,
+            estimatedEffort: 'low'
+        });
+        // Fix 2: Use proper async/await patterns
+        fixes.push({
+            priority: 'high',
+            category: 'timing',
+            recommendation: 'Ensure proper async/await usage for asynchronous operations',
+            codeExample: `// Before - Missing await
+it('should fetch data', () => {
+  const data = fetchData(); // Returns Promise
+  expect(data).toEqual({ id: 1 });
+});
+
+// After - Proper async/await
+it('should fetch data', async () => {
+  const data = await fetchData();
+  expect(data).toEqual({ id: 1 });
+});
+
+// Or with .resolves
+it('should fetch data', () => {
+  return expect(fetchData()).resolves.toEqual({ id: 1 });
+});`,
+            estimatedEffort: 'low'
+        });
+        // Fix 3: Add timeout configuration
+        fixes.push({
+            priority: 'medium',
+            category: 'timing',
+            recommendation: 'Configure appropriate timeouts for slow operations',
+            codeExample: `// Test-specific timeout
+it('should handle slow operation', async () => {
+  await slowOperation();
+  expect(result).toBeDefined();
+}, 10000); // 10 second timeout
+
+// Or using Jest setTimeout
+beforeEach(() => {
+  jest.setTimeout(10000);
+});`,
+            estimatedEffort: 'low'
+        });
+        return fixes;
+    }
+    /**
+     * Race condition fixes
+     */
+    raceFixes(rootCause) {
+        const fixes = [];
+        // Fix 1: Add proper synchronization
+        fixes.push({
+            priority: 'critical',
+            category: 'concurrency',
+            recommendation: 'Add synchronization mechanisms to prevent race conditions',
+            codeExample: `// Before - Race condition
+let sharedState = 0;
+Promise.all([
+  updateState(),
+  checkState()
+]);
+
+// After - Using mutex/lock pattern
+import { Mutex } from 'async-mutex';
+
+const mutex = new Mutex();
+let sharedState = 0;
+
+async function updateState() {
+  const release = await mutex.acquire();
+  try {
+    sharedState++;
+  } finally {
+    release();
+  }
+}
+
+// Or using atomic operations
+import { Atomics } from 'atomics';
+
+const sharedBuffer = new SharedArrayBuffer(4);
+const sharedArray = new Int32Array(sharedBuffer);
+Atomics.add(sharedArray, 0, 1); // Atomic increment`,
+            estimatedEffort: 'medium'
+        });
+        // Fix 2: Use test isolation
+        fixes.push({
+            priority: 'high',
+            category: 'concurrency',
+            recommendation: 'Isolate concurrent tests using proper setup/teardown',
+            codeExample: `// Before - Shared state across tests
+let counter = 0;
+
+it('test 1', () => {
+  counter++;
+  expect(counter).toBe(1);
+});
+
+it('test 2', () => {
+  counter++;
+  expect(counter).toBe(1); // Fails due to shared state
+});
+
+// After - Isolated state
+describe('Counter tests', () => {
+  let counter: number;
+
+  beforeEach(() => {
+    counter = 0; // Reset for each test
+  });
+
+  it('test 1', () => {
+    counter++;
+    expect(counter).toBe(1);
+  });
+
+  it('test 2', () => {
+    counter++;
+    expect(counter).toBe(1); // Now passes
+  });
+});`,
+            estimatedEffort: 'low'
+        });
+        return fixes;
+    }
+    /**
+     * Dependency-related fixes
+     */
+    dependencyFixes(rootCause) {
+        const fixes = [];
+        // Fix 1: Mock external dependencies
+        fixes.push({
+            priority: 'high',
+            category: 'external',
+            recommendation: 'Mock external dependencies to eliminate external variability',
+            codeExample: `// Before - Real API calls
+it('should fetch user data', async () => {
+  const user = await api.getUser(123);
+  expect(user.name).toBe('John');
+});
+
+// After - Mocked dependencies
+import { jest } from '@jest/globals';
+
+jest.mock('./api', () => ({
+  getUser: jest.fn().mockResolvedValue({
+    id: 123,
+    name: 'John'
+  })
+}));
+
+it('should fetch user data', async () => {
+  const user = await api.getUser(123);
+  expect(user.name).toBe('John');
+});
+
+// With MSW for HTTP mocking
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
+
+const server = setupServer(
+  rest.get('/api/user/:id', (req, res, ctx) => {
+    return res(ctx.json({ id: 123, name: 'John' }));
+  })
+);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());`,
+            estimatedEffort: 'medium'
+        });
+        // Fix 2: Stub time-dependent functions
+        fixes.push({
+            priority: 'medium',
+            category: 'external',
+            recommendation: 'Stub time-dependent functions for deterministic results',
+            codeExample: `// Before - Real date/time
+it('should check expiry', () => {
+  const token = { expiresAt: Date.now() + 1000 };
+  expect(isExpired(token)).toBe(false);
+});
+
+// After - Mocked time
+jest.useFakeTimers();
+jest.setSystemTime(new Date('2024-01-01'));
+
+it('should check expiry', () => {
+  const token = { expiresAt: new Date('2024-01-02').getTime() };
+  expect(isExpired(token)).toBe(false);
+
+  // Advance time
+  jest.advanceTimersByTime(24 * 60 * 60 * 1000);
+  expect(isExpired(token)).toBe(true);
+});
+
+jest.useRealTimers(); // Cleanup`,
+            estimatedEffort: 'low'
+        });
+        return fixes;
+    }
+    /**
+     * Isolation-related fixes
+     */
+    isolationFixes(rootCause) {
+        const fixes = [];
+        // Fix 1: Proper test cleanup
+        fixes.push({
+            priority: 'high',
+            category: 'data',
+            recommendation: 'Add proper cleanup in afterEach to ensure test isolation',
+            codeExample: `// Before - No cleanup
+it('test 1', () => {
+  localStorage.setItem('key', 'value1');
+  // ... test logic
+});
+
+it('test 2', () => {
+  // Fails due to leftover state
+  expect(localStorage.getItem('key')).toBeNull();
+});
+
+// After - Proper cleanup
+describe('LocalStorage tests', () => {
+  afterEach(() => {
+    localStorage.clear();
+    jest.clearAllMocks();
+    jest.clearAllTimers();
+  });
+
+  it('test 1', () => {
+    localStorage.setItem('key', 'value1');
+    expect(localStorage.getItem('key')).toBe('value1');
+  });
+
+  it('test 2', () => {
+    expect(localStorage.getItem('key')).toBeNull();
+  });
+});`,
+            estimatedEffort: 'low'
+        });
+        // Fix 2: Reset global state
+        fixes.push({
+            priority: 'high',
+            category: 'data',
+            recommendation: 'Reset global state and singletons between tests',
+            codeExample: `// Before - Singleton with state
+class ConfigManager {
+  private static instance: ConfigManager;
+  private config: any = {};
+
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new ConfigManager();
+    }
+    return this.instance;
+  }
+}
+
+// After - Add reset method
+class ConfigManager {
+  private static instance: ConfigManager;
+  private config: any = {};
+
+  static getInstance() {
+    if (!this.instance) {
+      this.instance = new ConfigManager();
+    }
+    return this.instance;
+  }
+
+  static resetInstance() {
+    this.instance = null as any;
+  }
+}
+
+// In tests
+afterEach(() => {
+  ConfigManager.resetInstance();
+});`,
+            estimatedEffort: 'medium'
+        });
+        return fixes;
+    }
+    /**
+     * Environment-related fixes
+     */
+    environmentFixes(rootCause) {
+        const fixes = [];
+        // Fix 1: Use test doubles for environment
+        fixes.push({
+            priority: 'medium',
+            category: 'environmental',
+            recommendation: 'Use test doubles to eliminate environment variability',
+            codeExample: `// Before - Relying on environment
+it('should use correct API URL', () => {
+  const url = process.env.API_URL;
+  expect(url).toBeDefined();
+});
+
+// After - Mock environment
+const originalEnv = process.env;
+
+beforeEach(() => {
+  jest.resetModules();
+  process.env = {
+    ...originalEnv,
+    API_URL: 'https://test.api.com',
+    NODE_ENV: 'test'
+  };
+});
+
+afterEach(() => {
+  process.env = originalEnv;
+});
+
+it('should use correct API URL', () => {
+  const url = process.env.API_URL;
+  expect(url).toBe('https://test.api.com');
+});`,
+            estimatedEffort: 'low'
+        });
+        // Fix 2: Use test containers
+        fixes.push({
+            priority: 'medium',
+            category: 'environmental',
+            recommendation: 'Use test containers for consistent database/service environments',
+            codeExample: `// Using Testcontainers
+import { GenericContainer } from 'testcontainers';
+
+describe('Database tests', () => {
+  let container: any;
+  let database: any;
+
+  beforeAll(async () => {
+    container = await new GenericContainer('postgres:14')
+      .withExposedPorts(5432)
+      .withEnv('POSTGRES_PASSWORD', 'test')
+      .start();
+
+    const port = container.getMappedPort(5432);
+    database = await connectToDatabase({
+      host: 'localhost',
+      port,
+      password: 'test'
+    });
+  });
+
+  afterAll(async () => {
+    await database.close();
+    await container.stop();
+  });
+
+  it('should query database', async () => {
+    const result = await database.query('SELECT 1');
+    expect(result).toBeDefined();
+  });
+});`,
+            estimatedEffort: 'high'
+        });
+        return fixes;
+    }
+    /**
+     * Generic fixes for unknown root causes
+     */
+    genericFixes(rootCause) {
+        return [{
+                priority: 'medium',
+                category: 'data',
+                recommendation: 'Add retry logic and better error handling',
+                codeExample: `// Generic retry wrapper
+async function retryTest(testFn: () => Promise<void>, maxRetries = 3) {
+  let lastError: Error;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      await testFn();
+      return; // Success
+    } catch (error) {
+      lastError = error as Error;
+      await new Promise(resolve => setTimeout(resolve, 100 * (i + 1)));
+    }
+  }
+
+  throw lastError!;
+}
+
+// Usage
+it('flaky test', async () => {
+  await retryTest(async () => {
+    // Test logic here
+    expect(await someAsyncOperation()).toBe(expected);
+  });
+});`,
+                estimatedEffort: 'low'
+            }];
+    }
+    /**
+     * Get priority order for recommendations
+     */
+    getPriorityOrder(recommendations) {
+        const priorityMap = {
+            critical: 4,
+            high: 3,
+            medium: 2,
+            low: 1
+        };
+        return recommendations.sort((a, b) => {
+            return priorityMap[b.priority] - priorityMap[a.priority];
+        });
+    }
+    /**
+     * Filter recommendations by effort
+     */
+    filterByEffort(recommendations, maxEffort) {
+        const effortMap = {
+            low: 1,
+            medium: 2,
+            high: 3
+        };
+        const threshold = effortMap[maxEffort];
+        return recommendations.filter(rec => effortMap[rec.estimatedEffort] <= threshold);
+    }
+}
+exports.FixRecommendationEngine = FixRecommendationEngine;
+exports.default = FixRecommendationEngine;
+//# sourceMappingURL=FixRecommendationEngine.js.map

package/dist/learning/FixRecommendationEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FixRecommendationEngine.js","sourceRoot":"","sources":["../../src/learning/FixRecommendationEngine.ts"],"names":[],"mappings":"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"}

package/dist/learning/FlakyTestDetector.d.ts

@@ -3,6 +3,7 @@
  * Achieves 90% accuracy in identifying flaky tests
  */
 import { TestResult, FlakyTest } from './types';
+import { RootCauseAnalysis } from './FixRecommendationEngine';
 export interface FlakyDetectionOptions {
     minRuns?: number;
     passRateThreshold?: number;
@@ -21,6 +22,7 @@ export interface ResolvedFlakyDetectionOptions {
 }
 export declare class FlakyTestDetector {
     private model;
+    private fixEngine;
     private options;
     constructor(options?: FlakyDetectionOptions);
     /**
@@ -51,5 +53,22 @@ export declare class FlakyTestDetector {
     private identifyFailurePattern;
     private calculateEnvironmentVariability;
     private calculateSeverity;
+    /**
+     * Analyze root cause of flakiness using ML patterns
+     *
+     * @param testName - Name of the flaky test
+     * @param results - Test execution results
+     * @param failurePattern - Identified failure pattern
+     * @returns Root cause analysis with ML confidence
+     */
+    analyzeRootCause(testName: string, results: TestResult[], failurePattern: 'intermittent' | 'environmental' | 'timing' | 'resource'): RootCauseAnalysis;
+    /**
+     * Check if failures occur sequentially (race condition indicator)
+     */
+    private areFailuresSequential;
+    /**
+     * Map failure pattern to root cause
+     */
+    private mapFailurePatternToRootCause;
 }
 //# sourceMappingURL=FlakyTestDetector.d.ts.map

package/dist/learning/FlakyTestDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FlakyTestDetector.d.ts","sourceRoot":"","sources":["../../src/learning/FlakyTestDetector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAKhD,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,OAAO,CAAgC;gBAEnC,OAAO,GAAE,qBAA0B;IAY/C;;;OAGG;IACG,gBAAgB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAoEnE;;OAEG;IACG,UAAU,CACd,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,EACvC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,OAAO,CAAC,IAAI,CAAC;IAmBhB;;OAEG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAsDrF;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG;QACtC,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;KACvB;IAsBD,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,sBAAsB;IA4B9B,OAAO,CAAC,+BAA+B;IAgBvC,OAAO,CAAC,iBAAiB;CAS1B"}
+{"version":3,"file":"FlakyTestDetector.d.ts","sourceRoot":"","sources":["../../src/learning/FlakyTestDetector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,SAAS,EAA0B,MAAM,SAAS,CAAC;AAIxE,OAAO,EAA2B,iBAAiB,EAAa,MAAM,2BAA2B,CAAC;AAElG,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,OAAO,CAAgC;gBAEnC,OAAO,GAAE,qBAA0B;IAa/C;;;OAGG;IACG,gBAAgB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IA4EnE;;OAEG;IACG,UAAU,CACd,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,EACvC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,OAAO,CAAC,IAAI,CAAC;IAmBhB;;OAEG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAsDrF;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG;QACtC,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;KACvB;IAsBD,OAAO,CAAC,WAAW;IAanB,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,sBAAsB;IA4B9B,OAAO,CAAC,+BAA+B;IAgBvC,OAAO,CAAC,iBAAiB;IAUzB;;;;;;;OAOG;IACH,gBAAgB,CACd,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,UAAU,EAAE,EACrB,cAAc,EAAE,cAAc,GAAG,eAAe,GAAG,QAAQ,GAAG,UAAU,GACvE,iBAAiB;IA+EpB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;OAEG;IACH,OAAO,CAAC,4BAA4B;CAYrC"}