minovative-mind-cli 2.6.4 → 2.7.0

package/README.md

@@ -7,7 +7,7 @@ and hope for the best.
 
 This CLI does the opposite — it uses a custom built agentic system called,
 **Precision-Context Verification (PCV)** engine to feed lightweight Flash models
-exactly the right context, execute code, verify the output compiles, and self-correct (if it even needs to), until
+exactly the right context, execute code, verify compilation, execute Property-Based Testing (PBT) suites and diff-scoped mutation audits, and self-correct (if it even needs to), until
 the build/performance metrics are green.
 
 > The result: **Genuine Pro reasoning accuracy at Flash-level speed and efficiency.**
@@ -142,7 +142,7 @@ By prefixing file paths with `@alias/` (e.g., `@backend/src/api.ts` and `@fronte
 
 Minovative Mind CLI fundamentally supports **ALL programming languages** for chat, code generation, planning, and execution, as it relies on Gemini's vast training data.
 
-However, the PCV engine features deep, context-aware analysis across **12 major programming language families**. Our core advanced engines—**Smart Dependency Tracing**, **Performance Auditing** (across 9 language families), and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
+However, the PCV engine features deep, context-aware analysis across **12 major programming language families**. Our core advanced engines—**Smart Dependency Tracing**, **Property-Based & Mutation Verification**, **Performance Auditing** (across 9 language families), and **Ephemeral Analysis Scripts**—provide tailored support depending on the language's syntax and runtime model:
 
 | Language Family              | Supported Extensions                         | Dependency Tracing | Performance Auditing | Ephemeral Analysis |
 | :--------------------------- | :------------------------------------------- | :----------------: | :------------------: | :----------------: |
@@ -165,7 +165,7 @@ _⚠️\*Support is limited or requires custom local system tooling/environment
 
 1. **Dependency Tracing:** Fully supported across language families. It uses lightning-fast static regex pattern matching to resolve local import structures and determine the "blast radius" of code changes without requiring local compilations.
 2. **Performance Auditing:** Executed natively across 9 major language families (JavaScript/TypeScript, Python, Go, Rust, PHP, C#, Java, C/C++, and Ruby). It uses zero-dependency, ultra-fast (<50ms) language-aware regex heuristics with comment/string stripping and line-preserving offset tracking to detect severe runtime anti-patterns (such as unbounded loops, synchronous I/O, chained array allocations, unnecessary allocations, and unclosed resources).
-3. **Ephemeral Analysis Scripts:** Runs temporary files in sandbox directories to parse and extract local symbols. Also used for infrastructure probing (detecting available runtimes, checking ports, identifying project type), post-change validation (importing modified modules and asserting expected behavior), and lightweight ML-powered analysis (e.g., TF-IDF file ranking, anomaly detection, Big-O estimation). Defaults to Node.js as a safe baseline, but natively leverages host-installed runtimes (Python, Rust, Go compilers) and standard libraries whenever available in the workspace.
+3. **Ephemeral Analysis & Property-Based Probing:** Runs temporary files in sandbox directories to parse and extract local symbols, execute ephemeral Property-Based Testing (PBT) probes to discover and shrink counterexamples, perform infrastructure probing (detecting available runtimes, checking ports, identifying project type), post-change validation (importing modified modules and asserting expected behavior), and lightweight ML-powered analysis (e.g., TF-IDF file ranking, anomaly detection, Big-O estimation). Defaults to Node.js as a safe baseline, but natively leverages host-installed runtimes (Python, Rust, Go compilers) and standard libraries whenever available in the workspace.
 
 ---
 

package/dist/services/orchestration/messageBus.d.ts

@@ -83,6 +83,7 @@ export declare class MessageBus {
     private signals;
     private activityCursors;
     private signalCursors;
+    private persistQueue;
     private readonly persistPath;
     private readonly workspaceRoot;
     /** Maximum semantic signals any single agent can post */

package/dist/services/orchestration/messageBus.js

@@ -35,6 +35,7 @@ export class MessageBus {
     signals = [];
     activityCursors = new Map();
     signalCursors = new Map();
+    persistQueue = Promise.resolve();
     persistPath;
     workspaceRoot;
     /** Maximum semantic signals any single agent can post */
@@ -172,8 +173,10 @@ export class MessageBus {
             activityCursors: Object.fromEntries(this.activityCursors),
             signalCursors: Object.fromEntries(this.signalCursors),
         };
-        // Fire-and-forget — don't block the calling agent's tool loop
-        atomicWriteFile(this.persistPath, JSON.stringify(snapshot)).catch((err) => {
+        // Fire-and-forget — don't block the calling agent's tool loop, but serialize writes sequentially
+        this.persistQueue = this.persistQueue
+            .then(() => atomicWriteFile(this.persistPath, JSON.stringify(snapshot)))
+            .catch((err) => {
             debugLog(`MessageBus: Failed to persist to disk: ${err}`);
         });
     }

package/dist/services/verificationService.d.ts

@@ -5,11 +5,53 @@ export interface VerificationResult {
     errors: string[];
     aborted?: boolean;
 }
+export interface Mutant {
+    id: string;
+    filePath: string;
+    line: number;
+    originalCode: string;
+    mutatedCode: string;
+    operator: string;
+}
+export interface MutationTestResult {
+    totalMutants: number;
+    killedMutants: number;
+    survivedMutants: number;
+    mutationScore: number;
+    mutants: Array<Mutant & {
+        killed: boolean;
+        output?: string;
+    }>;
+}
 export declare function detectVerificationCommand(workspaceRoot: string): Promise<string | null>;
 export declare function runVerification(workspaceRoot: string, abortSignal?: AbortSignal): Promise<VerificationResult | null>;
 export declare function formatVerificationForModel(result: VerificationResult): string;
 export interface FullVerificationResult {
     errors: string | null;
     warnings: string | null;
+    mutationResult?: MutationTestResult | null;
 }
 export declare function verifyChangedFiles(workspaceRoot: string, filePaths: string[], abortSignal?: AbortSignal): Promise<FullVerificationResult | '[Verification Aborted]'>;
+/**
+ * Generates mutants scoped specifically to modified lines of a source file.
+ */
+export declare function generateDiffScopedMutants(filePath: string, content: string, modifiedLines?: number[]): Mutant[];
+/**
+ * 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 declare function runDiffScopedMutationTesting(workspaceRoot: string, filePaths: string[], modifiedLineMap?: Record<string, number[]>, abortSignal?: AbortSignal, options?: {
+    maxMutantsPerFile?: number;
+    timeoutMs?: number;
+}): Promise<MutationTestResult>;
+/**
+ * Detects whether property-based testing framework configuration or dependencies exist in workspace.
+ */
+export declare function detectPropertyBasedTests(workspaceRoot: string): Promise<{
+    hasPbt: boolean;
+    framework?: string;
+}>;
+/**
+ * Executes workspace property-based tests if detected.
+ */
+export declare function runPropertyBasedVerification(workspaceRoot: string, abortSignal?: AbortSignal): Promise<VerificationResult | null>;

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,11 @@ 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>;

package/dist/utils/analysisRunner.js

@@ -207,3 +207,120 @@ export async function runDebugScript(workspaceRoot, code, language = 'node', opt
     }
     return runEphemeralScript(workspaceRoot, lang, code, opts);
 }
+/**
+ * Generates an ephemeral Property-Based Testing script template tailored to the target language and properties.
+ */
+export function generatePBTScriptTemplate(language, targetFunctionOrFeature, properties) {
+    const normLang = normalizeLanguage(language);
+    if (normLang === 'python') {
+        return `import sys, random
+
+# Target: ${targetFunctionOrFeature}
+# Properties to verify:
+${properties.map((p) => `# - ${p}`).join('\n')}
+
+def property_test():
+    runs = 100
+    for i in range(runs):
+        # Generate random inputs
+        val_int = random.randint(-10000, 10000)
+        val_str = "".join(random.choices("abcdefghijklmnopqrstuvwxyz0123456789", k=random.randint(0, 50)))
+        
+        # Test property invariants
+        try:
+            # Assertion placeholder
+            assert isinstance(val_int, int)
+        except AssertionError as e:
+            print(f"[PBT FAILED] Seed/Iteration: {i}")
+            print(f"Counterexample: val_int={val_int}, val_str={val_str!r}")
+            sys.exit(1)
+            
+    print(f"[PBT PASSED] Completed {runs} runs successfully.")
+
+if __name__ == "__main__":
+    property_test()
+`;
+    }
+    // Default Node / TypeScript / JS template
+    return `// Target: ${targetFunctionOrFeature}
+// Properties to verify:
+${properties.map((p) => `// - ${p}`).join('\n')}
+
+async function runPBT() {
+  const numRuns = 100;
+  let passed = 0;
+
+  for (let i = 0; i < numRuns; i++) {
+    // Generate pseudo-random inputs
+    const randInt = Math.floor(Math.random() * 20000) - 10000;
+    const randStr = Math.random().toString(36).substring(2);
+    
+    try {
+      // Test property invariant
+      if (typeof randInt !== 'number' || isNaN(randInt)) {
+        throw new Error('Type invariant failed');
+      }
+      passed++;
+    } catch (err) {
+      console.log(\`[PBT FAILED] Iteration: \${i}\`);
+      console.log(\`Counterexample: randInt=\${randInt}, randStr="\${randStr}"\`);
+      console.log(\`Error: \${err.message}\`);
+      process.exit(1);
+    }
+  }
+
+  console.log(\`[PBT PASSED] Completed \${passed} runs successfully.\`);
+}
+
+runPBT();
+`;
+}
+/**
+ * Runs an ephemeral Property-Based Test script and extracts failure counterexamples and shrink results.
+ */
+export async function runPropertyBasedTest(workspaceRoot, code, language = 'node', config) {
+    let lang = 'node';
+    let opts;
+    if (typeof language === 'string') {
+        lang = language;
+        opts = config;
+    }
+    else if (typeof language === 'object' && language !== null) {
+        opts = language;
+    }
+    const scriptResult = await runEphemeralScript(workspaceRoot, lang, code, opts);
+    const combinedOutput = `${scriptResult.stdout}\n${scriptResult.stderr}`;
+    const isPassed = combinedOutput.includes('[PBT PASSED]') || (scriptResult.exitCode === 0 && !combinedOutput.includes('[PBT FAILED]'));
+    let counterexample;
+    let shrunkInput;
+    let seed;
+    let numRunsCompleted;
+    // Extract counterexample
+    const counterMatch = combinedOutput.match(/Counterexample:\s*([^\n]+)/i);
+    if (counterMatch) {
+        counterexample = counterMatch[1].trim();
+    }
+    // Extract shrunk input
+    const shrinkMatch = combinedOutput.match(/(?:Shrunk Input|Shrunk|Minimal):\s*([^\n]+)/i);
+    if (shrinkMatch) {
+        shrunkInput = shrinkMatch[1].trim();
+    }
+    // Extract seed
+    const seedMatch = combinedOutput.match(/Seed(?:|\/Iteration):\s*(\d+)/i);
+    if (seedMatch) {
+        seed = parseInt(seedMatch[1], 10);
+    }
+    // Extract completed runs
+    const runsMatch = combinedOutput.match(/Completed\s+(\d+)\s+runs/i);
+    if (runsMatch) {
+        numRunsCompleted = parseInt(runsMatch[1], 10);
+    }
+    return {
+        ...scriptResult,
+        passed: isPassed,
+        counterexample,
+        shrunkInput,
+        seed,
+        numRunsCompleted,
+    };
+}

package/dist/utils/atomicWrite.js

@@ -7,7 +7,8 @@ import path from 'node:path';
  */
 export async function atomicWriteFile(targetPath, data, encoding = 'utf-8') {
     const dir = path.dirname(targetPath);
-    const tempPath = path.join(dir, `.${path.basename(targetPath)}.${Date.now()}.tmp`);
+    const randomSuffix = Math.random().toString(36).slice(2, 8);
+    const tempPath = path.join(dir, `.${path.basename(targetPath)}.${Date.now()}.${randomSuffix}.tmp`);
     try {
         // Ensure the directory exists
         await fs.mkdir(dir, { recursive: true });

package/oclif.manifest.json

@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "2.6.4"
+  "version": "2.7.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minovative-mind-cli",
   "description": "An automated AI agent powered by Vertex AI that helps you write software",
-  "version": "2.6.4",
+  "version": "2.7.0",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"