proffesor-for-testing__agentic-qe/v2/scripts/store-coverage-improvement.ts

#!/usr/bin/env ts-node
/**
 * Store coverage improvement progress in SwarmMemoryManager
 */

import { SwarmMemoryManager } from '../src/core/memory/SwarmMemoryManager';
import * as path from 'path';
import * as fs from 'fs-extra';

async function storeCoverageProgress() {
  const dbPath = path.join(process.cwd(), '.swarm/memory.db');
  const memoryStore = new SwarmMemoryManager(dbPath);

  try {
    await memoryStore.initialize();

    // Read current coverage
    const coveragePath = path.join(process.cwd(), 'coverage/coverage-summary.json');

    let currentCoverage = {
      lines: { pct: 0 },
      statements: { pct: 0 },
      functions: { pct: 0 },
      branches: { pct: 0 }
    };

    if (await fs.pathExists(coveragePath)) {
      const coverageData = await fs.readJson(coveragePath);
      currentCoverage = coverageData.total;
    }

    // Store Phase 1 progress
    const phase1Progress = {
      timestamp: Date.now(),
      agent: 'coverage-improvement-agent',
      phase: 1,
      description: 'Core module tests added (RollbackManager, Config, OODACoordination, SwarmIntegration)',
      previousCoverage: {
        lines: 0.95,
        statements: 0.91,
        functions: 0.98,
        branches: 0.25
      },
      currentCoverage: {
        lines: currentCoverage.lines.pct,
        statements: currentCoverage.statements.pct,
        functions: currentCoverage.functions.pct,
        branches: currentCoverage.branches.pct
      },
      coverageGain: {
        lines: currentCoverage.lines.pct - 0.95,
        statements: currentCoverage.statements.pct - 0.91,
        functions: currentCoverage.functions.pct - 0.98,
        branches: currentCoverage.branches.pct - 0.25
      },
      testsAdded: 145,
      filesCreated: [
        'tests/unit/core/RollbackManager.comprehensive.test.ts',
        'tests/unit/utils/Config.comprehensive.test.ts',
        'tests/unit/core/OODACoordination.comprehensive.test.ts',
        'tests/unit/learning/SwarmIntegration.comprehensive.test.ts'
      ],
      testCounts: {
        RollbackManager: 36,
        Config: 34,
        OODACoordination: 45,
        SwarmIntegration: 30
      }
    };

    await memoryStore.store('aqe/coverage/phase-1-complete', phase1Progress, {
      partition: 'coordination',
      ttl: 604800 // 7 days
    });

    console.log('\n✅ Phase 1 Coverage Progress Stored:');
    console.log(`   Previous Coverage: ${phase1Progress.previousCoverage.lines}%`);
    console.log(`   Current Coverage:  ${phase1Progress.currentCoverage.lines}%`);
    console.log(`   Coverage Gain:     ${phase1Progress.coverageGain.lines.toFixed(2)}%`);
    console.log(`   Tests Added:       ${phase1Progress.testsAdded}`);
    console.log(`   Files Created:     ${phase1Progress.filesCreated.length}`);

    // Store patterns for test creation strategies
    const testPatterns = {
      timestamp: Date.now(),
      agent: 'coverage-improvement-agent',
      patterns: [
        {
          name: 'Comprehensive Module Testing',
          description: 'Create 30+ tests per module covering happy path, error cases, edge cases, and integration',
          effectiveness: 'high',
          coverage_gain_per_file: '0.1-0.2%'
        },
        {
          name: 'Core Module Priority',
          description: 'Prioritize core modules (hooks, coordination, memory) for maximum impact',
          effectiveness: 'high',
          coverage_gain_per_file: '0.15-0.3%'
        },
        {
          name: 'Mock-based Unit Testing',
          description: 'Use mocks for external dependencies to ensure isolated unit tests',
          effectiveness: 'medium',
          test_stability: 'high'
        },
        {
          name: 'Lifecycle Hook Testing',
          description: 'Test all lifecycle hooks (creation, execution, error handling, cleanup)',
          effectiveness: 'high',
          coverage_categories: ['statements', 'branches', 'functions']
        }
      ]
    };

    await memoryStore.store('aqe/patterns/test-creation-strategies', testPatterns, {
      partition: 'coordination',
      ttl: 604800
    });

    console.log('\n✅ Test Creation Patterns Stored');

    // Store improvement roadmap
    const roadmap = {
      timestamp: Date.now(),
      agent: 'coverage-improvement-agent',
      targetCoverage: 20,
      phases: [
        {
          phase: 1,
          status: 'completed',
          target: '5% gain',
          actual: `${phase1Progress.coverageGain.lines.toFixed(2)}% gain`,
          modules: ['RollbackManager', 'Config', 'OODACoordination', 'SwarmIntegration']
        },
        {
          phase: 2,
          status: 'pending',
          target: '5% gain',
          modules: ['Agents', 'Coordination', 'Routing']
        },
        {
          phase: 3,
          status: 'pending',
          target: '5% gain',
          modules: ['Learning', 'FlakyDetection', 'StatisticalAnalysis']
        },
        {
          phase: 4,
          status: 'pending',
          target: '5% gain',
          modules: ['Utils', 'Logger', 'Validators', 'CLI']
        }
      ]
    };

    await memoryStore.store('aqe/coverage/improvement-roadmap', roadmap, {
      partition: 'coordination',
      ttl: 604800
    });

    console.log('\n✅ Coverage Improvement Roadmap Stored');
    console.log(`   Target: ${roadmap.targetCoverage}% coverage`);
    console.log(`   Phases: ${roadmap.phases.length}`);
    console.log(`   Phase 1: ${roadmap.phases[0].status}`);

  } catch (error) {
    console.error('Error storing coverage progress:', error);
    throw error;
  } finally {
    await memoryStore.close();
  }
}

storeCoverageProgress().catch(console.error);