ai-debug-local-mcp/dist/tdd-debug-engine.d.ts

🎯 ENHANCED AI GUIDANCE v4.1.2: Dramatically improved tool descriptions help AI users choose the right tools instead of 'close enough' options. Ultra-fast keyboard automation (10x speed), universal recording, multi-ecosystem debugging support, and compreh

/**
 * TDD Debug Engine - Revolutionary Test-Runtime Bridging
 *
 * Implements Cycle 30 #1 priority: TDD automation with systematic debugging integration
 * Building on proven MCP integration success (Memory MCP + Sequential Thinking MCP)
 */
import { EventEmitter } from 'events';
import { MemoryAwareSessionManager } from './utils/memory-aware-session-manager.js';
import StartupAwareMemoryManager from './utils/startup-aware-memory-manager.js';
import { ToolExecutionSafetyWrapper } from './utils/tool-execution-safety.js';
export interface TDDSession {
    sessionId: string;
    testFile: string;
    implementationFile?: string;
    framework: 'jest' | 'flutter' | 'exunit' | 'pytest' | 'unknown';
    coverageBaseline?: CoverageData;
    testBaseline?: TestResults;
    redGreenRefactorState: 'red' | 'green' | 'refactor';
    startTime: number;
    lastResults?: TestExecutionResults;
    eventEmitter?: EventEmitter;
}
export interface TestExecutionResults {
    success: boolean;
    testResults: TestResults;
    coverageData?: CoverageData;
    runtimeBehavior?: RuntimeBehaviorData;
    regressionAnalysis?: RegressionAnalysis;
    timestamp: number;
    executionTime: number;
}
export interface TestResults {
    totalTests: number;
    passedTests: number;
    failedTests: number;
    skippedTests: number;
    testSuites: TestSuite[];
    failureDetails?: FailureDetail[];
}
export interface TestSuite {
    name: string;
    tests: Test[];
    passed: number;
    failed: number;
    duration: number;
}
export interface Test {
    name: string;
    status: 'passed' | 'failed' | 'skipped';
    duration: number;
    error?: string;
    assertions?: AssertionResult[];
}
export interface AssertionResult {
    description: string;
    expected: any;
    actual: any;
    passed: boolean;
    runtimeValidation?: {
        behaviorMatched: boolean;
        actualRuntimeValue: any;
        discrepancyReason?: string;
    };
}
export interface CoverageData {
    linesCovered: number;
    totalLines: number;
    percentage: number;
    branchesCovered: number;
    totalBranches: number;
    branchPercentage: number;
    filesCovered: {
        [filename: string]: FileCoverage;
    };
}
export interface FileCoverage {
    lines: {
        [lineNumber: number]: number;
    };
    branches: {
        [branchId: string]: number;
    };
    functions: {
        [functionName: string]: number;
    };
}
export interface RuntimeBehaviorData {
    functionCalls: FunctionCall[];
    stateChanges: StateChange[];
    networkRequests: NetworkRequest[];
    performanceMetrics: PerformanceMetrics;
    memoryUsage: MemoryMetrics;
}
export interface FunctionCall {
    functionName: string;
    parameters: any[];
    returnValue: any;
    executionTime: number;
    stackTrace?: string[];
}
export interface StateChange {
    componentName: string;
    propertyName: string;
    oldValue: any;
    newValue: any;
    timestamp: number;
}
export interface NetworkRequest {
    url: string;
    method: string;
    status: number;
    duration: number;
    requestBody?: any;
    responseBody?: any;
}
export interface PerformanceMetrics {
    renderTime?: number;
    interactionLatency?: number;
    memoryDelta: number;
    cpuUsage?: number;
}
export interface MemoryMetrics {
    heapUsed: number;
    heapTotal: number;
    external: number;
    arrayBuffers: number;
}
export interface RegressionAnalysis {
    hasRegression: boolean;
    performanceRegression?: {
        metric: string;
        baselineValue: number;
        currentValue: number;
        percentageChange: number;
    };
    coverageRegression?: {
        baselineCoverage: number;
        currentCoverage: number;
        coverageDelta: number;
    };
    testRegression?: {
        previouslyPassingTests: string[];
        newFailures: FailureDetail[];
    };
    recommendations: string[];
}
export interface FailureDetail {
    testName: string;
    suiteName: string;
    error: string;
    stackTrace?: string;
    expectedVsActual?: {
        expected: any;
        actual: any;
        diff?: string;
    };
    runtimeDiscrepancy?: {
        testAssertion: string;
        runtimeBehavior: string;
        explanation: string;
    };
}
export interface TDDDebugOptions {
    testFile: string;
    implementationFile?: string;
    autoValidate?: boolean;
    trackRedGreenRefactor?: boolean;
    enableCoverage?: boolean;
    enableRuntimeBridging?: boolean;
    regressionDetection?: boolean;
    frameworkHint?: 'jest' | 'flutter' | 'exunit' | 'pytest';
    enableStreaming?: boolean;
}
export declare class TDDDebugEngine {
    private sessionManager;
    private memoryManager;
    private toolSafety;
    private tddSessions;
    private runningTests;
    constructor(sessionManager: MemoryAwareSessionManager, memoryManager: StartupAwareMemoryManager, toolSafety: ToolExecutionSafetyWrapper);
    /**
     * Enable TDD Mode - Revolutionary Test-Runtime Bridging
     */
    enableTDDMode(options: TDDDebugOptions): Promise<TDDSession>;
    /**
     * Run Tests with Coverage - Core TDD automation tool
     */
    runTestsWithCoverage(sessionId: string, options?: {
        testPattern?: string;
        generateBaseline?: boolean;
        enableRuntimeBridging?: boolean;
    }): Promise<TestExecutionResults>;
    /**
     * Test Impact Analysis - Detect refactoring breakage
     */
    testImpactAnalysis(sessionId: string, changes: {
        modifiedFiles: string[];
        testScope?: 'affected' | 'all' | 'smart';
    }): Promise<{
        impactedTests: string[];
        riskAssessment: 'low' | 'medium' | 'high';
        recommendedTestScope: string[];
        executionStrategy: string;
    }>;
    /**
     * Regression Detection - Automated regression analysis
     */
    regressionDetection(sessionId: string): Promise<RegressionAnalysis>;
    /**
     * Private implementation methods
     */
    private detectTestFramework;
    private findFlutterProjectRoot;
    private executeTests;
    private executeJestTests;
    private executeFlutterTests;
    private executeExUnitTests;
    private parseExUnitResults;
    private executePytestTests;
    private parseJestResults;
    private parseJestTextOutput;
    private parseFlutterTestOutput;
    private parseFlutterJsonResults;
    private analyzeCoverage;
    private analyzeJestCoverage;
    private analyzeFlutterCoverage;
    private captureRuntimeBehavior;
    private updateTDDState;
    private analyzeTestImpact;
    private assessChangeRisk;
    private recommendTestScope;
    private generateExecutionStrategy;
    private analyzeTestRegression;
    private analyzeCoverageRegression;
    private analyzePerformanceRegression;
    private generateRegressionRecommendations;
    /**
     * Clean up TDD session and free resources
     */
    closeTDDSession(sessionId: string): Promise<void>;
    /**
     * Get TDD session status and metrics
     */
    getTDDSessionStatus(sessionId: string): TDDSession | undefined;
    /**
     * List all active TDD sessions
     */
    getActiveTDDSessions(): TDDSession[];
}
//# sourceMappingURL=tdd-debug-engine.d.ts.map