minovative-mind-cli 2.6.4 → 2.8.0

package/dist/services/verificationService.js

@@ -299,3 +299,238 @@ export async function verifyChangedFiles(workspaceRoot, filePaths, abortSignal)
         warnings: terminalWarnings || null,
     };
 }
+/**
+ * Common mutation operators for AST/line-level diff mutation testing.
+ */
+const MUTATION_OPERATORS = [
+    {
+        name: 'EqualityReplacement',
+        pattern: /(===|!==|==|!=)/g,
+        replace: (m) => {
+            if (m === '===')
+                return '!==';
+            if (m === '!==')
+                return '===';
+            if (m === '==')
+                return '!=';
+            if (m === '!=')
+                return '==';
+            return m;
+        },
+    },
+    {
+        name: 'RelationalReplacement',
+        pattern: /(>=|<=|>|<)/g,
+        replace: (m) => {
+            if (m === '>=')
+                return '<';
+            if (m === '<=')
+                return '>';
+            if (m === '>')
+                return '<=';
+            if (m === '<')
+                return '>=';
+            return m;
+        },
+    },
+    {
+        name: 'ArithmeticReplacement',
+        pattern: /(\+|\-|\*|\/)/g,
+        replace: (m) => {
+            if (m === '+')
+                return '-';
+            if (m === '-')
+                return '+';
+            if (m === '*')
+                return '/';
+            if (m === '/')
+                return '*';
+            return m;
+        },
+    },
+    {
+        name: 'LogicalReplacement',
+        pattern: /(\&\&|\|\|)/g,
+        replace: (m) => (m === '&&' ? '||' : '&&'),
+    },
+    {
+        name: 'BooleanLiteralInversion',
+        pattern: /\b(true|false)\b/g,
+        replace: (m) => (m === 'true' ? 'false' : 'true'),
+    },
+];
+/**
+ * Generates mutants scoped specifically to modified lines of a source file.
+ */
+export function generateDiffScopedMutants(filePath, content, modifiedLines) {
+    const mutants = [];
+    const lines = content.split('\n');
+    const lineNumbers = modifiedLines && modifiedLines.length > 0
+        ? modifiedLines
+        : lines.map((_, i) => i + 1);
+    let idCounter = 1;
+    for (const lineNum of lineNumbers) {
+        if (lineNum < 1 || lineNum > lines.length)
+            continue;
+        const origLine = lines[lineNum - 1];
+        // Skip empty lines, comments, or imports/exports
+        const trimmed = origLine.trim();
+        if (!trimmed ||
+            trimmed.startsWith('//') ||
+            trimmed.startsWith('/*') ||
+            trimmed.startsWith('*') ||
+            trimmed.startsWith('import ') ||
+            trimmed.startsWith('export ') ||
+            trimmed.startsWith('#')) {
+            continue;
+        }
+        for (const op of MUTATION_OPERATORS) {
+            op.pattern.lastIndex = 0;
+            let match;
+            while ((match = op.pattern.exec(origLine)) !== null) {
+                const start = match.index;
+                const matchedText = match[0];
+                const replacement = op.replace(matchedText);
+                if (replacement === matchedText)
+                    continue;
+                const mutatedLine = origLine.substring(0, start) + replacement + origLine.substring(start + matchedText.length);
+                mutants.push({
+                    id: `mutant-${idCounter++}`,
+                    filePath,
+                    line: lineNum,
+                    originalCode: origLine,
+                    mutatedCode: mutatedLine,
+                    operator: op.name,
+                });
+            }
+        }
+    }
+    return mutants;
+}
+/**
+ * Runs diff-scoped mutation testing on modified files within the workspace.
+ * Mutates target lines in-memory/temp copy, executes workspace tests, and ensures mutants are killed.
+ */
+export async function runDiffScopedMutationTesting(workspaceRoot, filePaths, modifiedLineMap, abortSignal, options) {
+    const maxPerFile = options?.maxMutantsPerFile ?? 10;
+    const allMutants = [];
+    let totalKilled = 0;
+    for (const relPath of filePaths) {
+        if (abortSignal?.aborted)
+            break;
+        const fullPath = path.resolve(workspaceRoot, relPath);
+        let originalContent;
+        try {
+            originalContent = await fs.readFile(fullPath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const modifiedLines = modifiedLineMap ? modifiedLineMap[relPath] : undefined;
+        const mutants = generateDiffScopedMutants(relPath, originalContent, modifiedLines).slice(0, maxPerFile);
+        const lines = originalContent.split('\n');
+        for (const mutant of mutants) {
+            if (abortSignal?.aborted)
+                break;
+            // Create mutated file content
+            const mutatedLines = [...lines];
+            mutatedLines[mutant.line - 1] = mutant.mutatedCode;
+            const mutatedContent = mutatedLines.join('\n');
+            let killed = false;
+            let output = '';
+            try {
+                // Safely write mutated content with try...finally cleanup
+                await fs.writeFile(fullPath, mutatedContent, 'utf-8');
+                // Execute verification/test command
+                const testResult = await runVerification(workspaceRoot, abortSignal);
+                if (testResult && !testResult.success) {
+                    killed = true;
+                    output = testResult.errors.join('\n').substring(0, 500);
+                }
+                else if (!testResult) {
+                    // No test runner detected; default to non-kill unless error occurs
+                    killed = false;
+                }
+            }
+            catch (err) {
+                killed = true;
+                output = err.message || String(err);
+            }
+            finally {
+                // Restore original file unconditionally
+                try {
+                    await fs.writeFile(fullPath, originalContent, 'utf-8');
+                }
+                catch (restoreErr) {
+                    debugLog(`Failed to restore ${fullPath} after mutation testing: ${restoreErr}`);
+                }
+            }
+            if (killed)
+                totalKilled++;
+            allMutants.push({ ...mutant, killed, output });
+        }
+    }
+    const total = allMutants.length;
+    const score = total > 0 ? Math.round((totalKilled / total) * 100) : 100;
+    return {
+        totalMutants: total,
+        killedMutants: totalKilled,
+        survivedMutants: total - totalKilled,
+        mutationScore: score,
+        mutants: allMutants,
+    };
+}
+/**
+ * Detects whether property-based testing framework configuration or dependencies exist in workspace.
+ */
+export async function detectPropertyBasedTests(workspaceRoot) {
+    // Check package.json for fast-check or jsverify
+    try {
+        const pkgStr = await fs.readFile(path.join(workspaceRoot, 'package.json'), 'utf-8');
+        if (pkgStr.includes('fast-check'))
+            return { hasPbt: true, framework: 'fast-check' };
+        if (pkgStr.includes('jsverify'))
+            return { hasPbt: true, framework: 'jsverify' };
+    }
+    catch { }
+    // Check Python environment for hypothesis
+    try {
+        const reqStr = await fs.readFile(path.join(workspaceRoot, 'requirements.txt'), 'utf-8');
+        if (reqStr.includes('hypothesis'))
+            return { hasPbt: true, framework: 'hypothesis' };
+    }
+    catch { }
+    try {
+        const pyprojStr = await fs.readFile(path.join(workspaceRoot, 'pyproject.toml'), 'utf-8');
+        if (pyprojStr.includes('hypothesis'))
+            return { hasPbt: true, framework: 'hypothesis' };
+    }
+    catch { }
+    // Check Cargo.toml for proptest / quickcheck
+    try {
+        const cargoStr = await fs.readFile(path.join(workspaceRoot, 'Cargo.toml'), 'utf-8');
+        if (cargoStr.includes('proptest'))
+            return { hasPbt: true, framework: 'proptest' };
+        if (cargoStr.includes('quickcheck'))
+            return { hasPbt: true, framework: 'quickcheck' };
+    }
+    catch { }
+    // Check go.mod for rapid
+    try {
+        const goModStr = await fs.readFile(path.join(workspaceRoot, 'go.mod'), 'utf-8');
+        if (goModStr.includes('pgregory.net/rapid'))
+            return { hasPbt: true, framework: 'rapid' };
+    }
+    catch { }
+    return { hasPbt: false };
+}
+/**
+ * Executes workspace property-based tests if detected.
+ */
+export async function runPropertyBasedVerification(workspaceRoot, abortSignal) {
+    const pbtInfo = await detectPropertyBasedTests(workspaceRoot);
+    if (!pbtInfo.hasPbt)
+        return null;
+    debugLog(`Detected property-based testing framework: ${pbtInfo.framework}`);
+    return runVerification(workspaceRoot, abortSignal);
+}

package/dist/utils/analysisRunner.d.ts

@@ -11,6 +11,18 @@ export interface EphemeralScriptOptions {
     /** AbortSignal to cancel execution. */
     abortSignal?: AbortSignal;
 }
+export interface PropertyTestConfig {
+    numRuns?: number;
+    seed?: number;
+    shrinkTimeoutMs?: number;
+}
+export interface PropertyTestResult extends EphemeralScriptResult {
+    passed: boolean;
+    counterexample?: string;
+    shrunkInput?: string;
+    seed?: number;
+    numRunsCompleted?: number;
+}
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
@@ -50,3 +62,76 @@ export declare function runEphemeralScript(workspaceRoot: string, language: stri
  * @param options - Execution options (timeoutMs, maxOutputChars, abortSignal).
  */
 export declare function runDebugScript(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, options?: EphemeralScriptOptions): Promise<EphemeralScriptResult>;
+/**
+ * Generates an ephemeral Property-Based Testing script template tailored to the target language and properties.
+ */
+export declare function generatePBTScriptTemplate(language: string, targetFunctionOrFeature: string, properties: string[]): string;
+/**
+ * Runs an ephemeral Property-Based Test script and extracts failure counterexamples and shrink results.
+ */
+export declare function runPropertyBasedTest(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: PropertyTestConfig & EphemeralScriptOptions): Promise<PropertyTestResult>;
+export interface FuzzProbeConfig {
+    iterations?: number;
+    maxInputLength?: number;
+    seed?: number;
+    timeoutMs?: number;
+}
+export interface FuzzProbeResult extends EphemeralScriptResult {
+    passed: boolean;
+    totalFuzzRuns: number;
+    failingInputs?: string[];
+    errorSummary?: string;
+    seed?: number;
+}
+export interface HeapDeltaConfig {
+    warmupIterations?: number;
+    testIterations?: number;
+    samplingIntervalMs?: number;
+}
+export interface HeapDeltaResult extends EphemeralScriptResult {
+    initialHeapBytes: number;
+    finalHeapBytes: number;
+    deltaBytes: number;
+    leakDetected: boolean;
+    growthRateBytesPerIter?: number;
+    samples?: Array<{
+        iteration: number;
+        heapBytes: number;
+    }>;
+}
+export interface BehavioralDriftConfig {
+    tolerance?: number;
+    compareKeys?: string[];
+}
+export interface BehavioralDriftResult extends EphemeralScriptResult {
+    hasDrift: boolean;
+    baselineOutput?: string;
+    candidateOutput?: string;
+    diffSummary?: string;
+    driftDetails?: Array<{
+        field?: string;
+        baseline: any;
+        candidate: any;
+        diff?: string;
+    }>;
+}
+/**
+ * Generates an ephemeral Fuzz Probe script template tailored to the target language.
+ */
+export declare function generateFuzzScriptTemplate(language: string, targetFeature: string, config?: FuzzProbeConfig): string;
+/**
+ * Runs a fuzz probing analysis script and parses failure counterexamples and crash statistics.
+ */
+export declare function runFuzzProbe(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: FuzzProbeConfig & EphemeralScriptOptions): Promise<FuzzProbeResult>;
+/**
+ * Generates an ephemeral memory heap analysis script template tailored to the target language.
+ */
+export declare function generateHeapCheckScriptTemplate(language: string, targetCode: string, config?: HeapDeltaConfig): string;
+/**
+ * Runs a memory heap inspection script and extracts heap growth, leak indicators, and memory delta statistics.
+ */
+export declare function checkHeapDelta(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: HeapDeltaConfig & EphemeralScriptOptions): Promise<HeapDeltaResult>;
+/**
+ * Executes baseline and candidate scripts, comparing outputs and return values to detect behavioral drift.
+ */
+export declare function checkBehavioralDrift(workspaceRoot: string, baselineCode: string, candidateCode: string, language?: string | EphemeralScriptOptions, config?: BehavioralDriftConfig & EphemeralScriptOptions): Promise<BehavioralDriftResult>;