minovative-mind-cli 2.6.3 → 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/agent-tools.js

@@ -1413,12 +1413,23 @@ const currentTasksByAgent = new Map();
  * @returns A promise resolving to a {@link ToolResult}.
  */
 export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
+    // Normalize common LLM tool alias hallucinations to registered tool names
+    let normalizedToolName = toolName;
+    if (normalizedToolName === 'search' || normalizedToolName === 'web_search') {
+        normalizedToolName = (args.query || args.searchQuery || args.url) ? 'perform_web_search' : 'grep_search';
+    }
+    else if (normalizedToolName === 'grep' || normalizedToolName === 'search_codebase') {
+        normalizedToolName = 'grep_search';
+    }
+    else if (normalizedToolName === 'finish_investigation') {
+        normalizedToolName = 'finish_task';
+    }
     // ─── Multi-Workspace Path Resolution ─────────────────────────────
     // Intercept @alias/ prefixed paths and swap workspaceRoot + relative path
     // before dispatching to the underlying tool functions (which remain unchanged).
-    const { effectiveRoot, resolvedArgs } = resolveWorkspaceArgs(workspaceRoot, toolName, args);
+    const { effectiveRoot, resolvedArgs } = resolveWorkspaceArgs(workspaceRoot, normalizedToolName, args);
     let result;
-    switch (toolName) {
+    switch (normalizedToolName) {
         case 'perform_web_search': {
             const { createWebSearchAgentSession } = await import('./ai.js');
             const webSession = createWebSearchAgentSession();

package/dist/services/agent.d.ts

@@ -112,24 +112,14 @@ export declare function executeSingleTurn(workspaceRoot: string, userInput: stri
 } | void>;
 /**
  * Raw chat history entry count threshold to trigger chat history summarization.
- * 12 entries = 6 conversational user/model turns.
- */
-export declare const HISTORY_SUMMARIZATION_THRESHOLD = 12;
-/**
- * Checks and summarizes older chat history entries if the active session's history
- * exceeds HISTORY_SUMMARIZATION_THRESHOLD entries.
- *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
- * replacing all preceding turns with a single summarized pair in the chat history.
- *
- * @param chat - The active ProxyChatSession instance.
- * @returns True if history was summarized and updated; false otherwise.
+ * 50 entries = 25 conversational user/model turns.
  */
+export declare const HISTORY_SUMMARIZATION_THRESHOLD = 50;
 /**
  * Summarizes older chat history entries if the active session's history
  * exceeds {@link HISTORY_SUMMARIZATION_THRESHOLD} entries.
  *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
+ * Preserves the most recent 20 entries (10 turns) intact for conversational continuity,
  * replacing all preceding turns with a single summarized pair in the chat history.
  *
  * @param chat - The active ProxyChatSession instance.

package/dist/services/agent.js

@@ -152,7 +152,7 @@ export async function startAgentLoop(workspaceRoot, version) {
     process.stdout.write('\n\n\n\x1b[3A');
     console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
     while (true) {
-        if (chat.getRawHistory().length === 0 && chatSessionState.title !== '') {
+        if (chat.getFullHistory().length === 0 && chatSessionState.title !== '') {
             chatSessionState.id = crypto.randomUUID();
             chatSessionState.title = '';
             chatSessionState.totalTokens = 0;
@@ -466,19 +466,47 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 const orchestrator = new Orchestrator(workspaceRoot, chatSessionState.id, inputHandler);
                 const handledByOrchestrator = await orchestrator.runOrchestration(finalInput, dynamicSystemInstruction, ac.signal);
                 if (typeof handledByOrchestrator === 'string') {
-                    // The orchestrator successfully decomposed and ran the task.
-                    // Inject the task context into the main proxy chat session so the agent remembers what happened
-                    // and so the history state gets saved properly on disk.
-                    chat.getRawHistory().push({
-                        role: 'user',
-                        parts: [{ text: userInput }],
-                    });
-                    chat.getRawHistory().push({
-                        role: 'model',
-                        parts: [{ text: handledByOrchestrator }],
-                    });
-                    // Print the summary text just like single-agent mode
-                    if (handledByOrchestrator !== '[Generation stopped.]') {
+                    const isStopped = handledByOrchestrator.includes('Generation stopped') ||
+                        handledByOrchestrator.includes('[Generation stopped');
+                    if (isStopped) {
+                        const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+                        const modifiedFiles = currentChanges
+                            .filter((c) => c.action === 'modify' || c.action === 'create' || c.action === 'delete')
+                            .map((c) => `${c.action}: ${path.relative(workspaceRoot, c.filePath)}`);
+                        let summaryMsg = '';
+                        if (modifiedFiles.length > 0) {
+                            summaryMsg = `Generation was stopped by the user before completion. Partial code changes made before stopping:\n- ${modifiedFiles.join('\n- ')}`;
+                            p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion.'));
+                            p.log.info(pc.cyan('Partial code changes created/modified before stopping:'));
+                            modifiedFiles.forEach((file) => p.log.message(`  ${pc.dim('•')} ${file}`));
+                        }
+                        else {
+                            summaryMsg = 'Generation was stopped by the user before completion. No code files were modified before stopping.';
+                            p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion (no files were modified).'));
+                        }
+                        chat.addTurn({
+                            role: 'user',
+                            parts: [{ text: `[USER INTERRUPT] User issued a "stop" command during execution: "${userInput}"` }],
+                        }, {
+                            role: 'model',
+                            parts: [
+                                {
+                                    text: `[GENERATION INTERRUPTED BY USER] I acknowledge that generation was manually stopped by the user before task completion.\n${summaryMsg}`,
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        // Inject the task context into the main proxy chat session so the agent remembers what happened
+                        // and so the full history state gets saved properly on disk.
+                        chat.addTurn({
+                            role: 'user',
+                            parts: [{ text: userInput }],
+                        }, {
+                            role: 'model',
+                            parts: [{ text: handledByOrchestrator }],
+                        });
+                        // Print the summary text just like single-agent mode
                         console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(Orchestrator)`)}\n`);
                         const cleanText = handledByOrchestrator.replace(/\n([ \t]*\n){2,}/g, '\n\n');
                         console.log(marked.parse(cleanText));
@@ -519,7 +547,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     changeLogger.markComplete();
                     changeLogger.commitChangeSet();
                     // Auto-save chat history for the orchestrator turn
-                    const history = chat.getRawHistory();
+                    const history = chat.getFullHistory();
                     if (history.length > 0) {
                         if (!chatSessionState.title) {
                             chatSessionState.title = 'Generating title...';
@@ -628,8 +656,38 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             const turnEndTime = Date.now();
             const turnDuration = ((turnEndTime - turnStartTime) / 1000).toFixed(1);
             p.log.info(`${pc.dim('Generated in')} ${pc.cyan(turnDuration + 's')}`);
-            // If we reach this point without throwing or breaking early, and the generation wasn't stopped, the turn finished completely.
-            if (finalText !== '[Generation stopped.]') {
+            // Check if generation was stopped by user
+            const isStopped = finalText.includes('Generation stopped') ||
+                finalText.includes('[Generation stopped');
+            if (isStopped) {
+                const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+                const modifiedFiles = currentChanges
+                    .filter((c) => c.action === 'modify' || c.action === 'create' || c.action === 'delete')
+                    .map((c) => `${c.action}: ${path.relative(workspaceRoot, c.filePath)}`);
+                let summaryMsg = '';
+                if (modifiedFiles.length > 0) {
+                    summaryMsg = `Generation was stopped by the user before completion. Partial code changes made before stopping:\n- ${modifiedFiles.join('\n- ')}`;
+                    p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion.'));
+                    p.log.info(pc.cyan('Partial code changes created/modified before stopping:'));
+                    modifiedFiles.forEach((file) => p.log.message(`  ${pc.dim('•')} ${file}`));
+                }
+                else {
+                    summaryMsg = 'Generation was stopped by the user before completion. No code files were modified before stopping.';
+                    p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion (no files were modified).'));
+                }
+                chat.addTurn({
+                    role: 'user',
+                    parts: [{ text: `[USER INTERRUPT] User issued a "stop" command during execution: "${userInput}"` }],
+                }, {
+                    role: 'model',
+                    parts: [
+                        {
+                            text: `[GENERATION INTERRUPTED BY USER] I acknowledge that generation was manually stopped by the user before task completion.\n${summaryMsg}`,
+                        },
+                    ],
+                });
+            }
+            else {
                 changeLogger.markComplete();
             }
             if (usage) {
@@ -647,7 +705,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 chatSessionState.totalCreditsUsed += usage.creditsUsed || 0;
             }
             // Auto-save chat history
-            const history = chat.getRawHistory();
+            const history = chat.getFullHistory();
             if (history.length > 0) {
                 if (!chatSessionState.title) {
                     chatSessionState.title = 'Generating title...';
@@ -884,24 +942,14 @@ async function compressContextFiles(workspaceRoot, contextResult) {
 }
 /**
  * Raw chat history entry count threshold to trigger chat history summarization.
- * 12 entries = 6 conversational user/model turns.
- */
-export const HISTORY_SUMMARIZATION_THRESHOLD = 12;
-/**
- * Checks and summarizes older chat history entries if the active session's history
- * exceeds HISTORY_SUMMARIZATION_THRESHOLD entries.
- *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
- * replacing all preceding turns with a single summarized pair in the chat history.
- *
- * @param chat - The active ProxyChatSession instance.
- * @returns True if history was summarized and updated; false otherwise.
+ * 50 entries = 25 conversational user/model turns.
  */
+export const HISTORY_SUMMARIZATION_THRESHOLD = 50;
 /**
  * Summarizes older chat history entries if the active session's history
  * exceeds {@link HISTORY_SUMMARIZATION_THRESHOLD} entries.
  *
- * Preserves the most recent 4 entries (2 turns) intact for conversational continuity,
+ * Preserves the most recent 20 entries (10 turns) intact for conversational continuity,
  * replacing all preceding turns with a single summarized pair in the chat history.
  *
  * @param chat - The active ProxyChatSession instance.
@@ -913,8 +961,8 @@ export async function summarizeHistoryIfNeeded(chat) {
         return false;
     }
     try {
-        // Keep the most recent 4 entries (2 full user/model turns) intact
-        const recentCount = 4;
+        // Keep the most recent 20 entries (10 full user/model turns) intact
+        const recentCount = 20;
         const olderHistory = history.slice(0, history.length - recentCount);
         const recentHistory = history.slice(history.length - recentCount);
         debugLog(`Summarizing ${olderHistory.length} older chat history entries...`);
@@ -930,7 +978,7 @@ export async function summarizeHistoryIfNeeded(chat) {
                     parts: [{ text: 'Understood. I have reviewed and absorbed the summary of our preceding conversation.' }],
                 },
             ];
-            chat.loadRawHistory([...summaryContent, ...recentHistory]);
+            chat.loadCompressedHistory([...summaryContent, ...recentHistory]);
             debugLog(`Chat history compressed successfully from ${history.length} to ${summaryContent.length + recentHistory.length} entries.`);
             return true;
         }

package/dist/services/ai.d.ts

@@ -5,6 +5,7 @@ export declare function setGlobalActiveModel(model: string): void;
 export declare function getGlobalActiveModel(): string;
 export declare class ProxyChatSession {
     private history;
+    private fullHistory;
     private modelName;
     private systemInstruction;
     private tools;
@@ -17,7 +18,10 @@ export declare class ProxyChatSession {
     getModel(): string;
     clearHistory(): void;
     getRawHistory(): Content[];
+    getFullHistory(): Content[];
     loadRawHistory(history: Content[]): void;
+    loadCompressedHistory(history: Content[]): void;
+    addTurn(userContent: Content, modelContent: Content): void;
     /**
      * Retrieves the most recent conversation history as a formatted string.
      * Useful for passing conversation context to stateless background agents.

package/dist/services/ai.js

@@ -69,6 +69,7 @@ function truncatePartText(text) {
 }
 export class ProxyChatSession {
     history = [];
+    fullHistory = [];
     modelName;
     systemInstruction;
     tools;
@@ -95,25 +96,37 @@ export class ProxyChatSession {
     }
     clearHistory() {
         this.history = [];
+        this.fullHistory = [];
     }
     getRawHistory() {
         return this.history;
     }
+    getFullHistory() {
+        return this.fullHistory;
+    }
     loadRawHistory(history) {
+        this.history = [...history];
+        this.fullHistory = JSON.parse(JSON.stringify(history));
+    }
+    loadCompressedHistory(history) {
         this.history = history;
     }
+    addTurn(userContent, modelContent) {
+        this.history.push(userContent);
+        this.history.push(modelContent);
+        this.fullHistory.push(JSON.parse(JSON.stringify(userContent)));
+        this.fullHistory.push(JSON.parse(JSON.stringify(modelContent)));
+    }
     /**
      * Retrieves the most recent conversation history as a formatted string.
      * Useful for passing conversation context to stateless background agents.
      * @param turns Number of back-and-forth turns (user + model pair = 1 turn) to retrieve.
      */
     getRecentHistory(turns = 2) {
-        if (this.history.length === 0)
+        if (this.fullHistory.length === 0 && this.history.length === 0)
             return '';
-        // History is an array of Content { role: 'user' | 'model', parts: Part[] }
-        // A single turn is generally 2 items (user, then model). Sometimes tools are interspersed.
-        // We'll just grab the last N * 2 items.
-        const recentItems = this.history.slice(-(turns * 2));
+        const sourceHistory = this.fullHistory.length > 0 ? this.fullHistory : this.history;
+        const recentItems = sourceHistory.slice(-(turns * 2));
         let formattedHistory = '';
         for (const item of recentItems) {
             const role = item.role === 'user' ? 'User' : 'Assistant';
@@ -134,6 +147,10 @@ export class ProxyChatSession {
             this.history.pop();
             this.history.pop();
         }
+        if (this.fullHistory.length >= 2) {
+            this.fullHistory.pop();
+            this.fullHistory.pop();
+        }
     }
     sessionId;
     workspaceRoot;
@@ -148,12 +165,15 @@ export class ProxyChatSession {
      */
     async pruneHistory() {
         if (this.history.length > MAX_HISTORY_ENTRIES) {
-            // Always keep pairs aligned (user/model), so trim from the front
             const excess = this.history.length - MAX_HISTORY_ENTRIES;
-            // Round up to the nearest even number to keep user/model pairs intact
             const trimCount = excess % 2 === 0 ? excess : excess + 1;
-            const pruned = this.history.slice(0, trimCount);
             this.history = this.history.slice(trimCount);
+        }
+        if (this.fullHistory.length > MAX_HISTORY_ENTRIES) {
+            const excess = this.fullHistory.length - MAX_HISTORY_ENTRIES;
+            const trimCount = excess % 2 === 0 ? excess : excess + 1;
+            const pruned = this.fullHistory.slice(0, trimCount);
+            this.fullHistory = this.fullHistory.slice(trimCount);
             if (this.sessionId && this.workspaceRoot) {
                 const archiveFile = `archives/archived_history_${this.sessionId}.json`;
                 const existingArchive = readCache(this.workspaceRoot, archiveFile) || [];
@@ -199,10 +219,12 @@ export class ProxyChatSession {
         if (additionalText) {
             newParts.push({ text: truncatePartText(additionalText) });
         }
-        this.history.push({
+        const userEntry = {
             role: 'user',
             parts: newParts,
-        });
+        };
+        this.history.push(userEntry);
+        this.fullHistory.push(JSON.parse(JSON.stringify(userEntry)));
         // Prune old history before sending to keep payload bounded
         await this.pruneHistory();
         const effectiveGenerationConfig = { ...this.generationConfig };
@@ -286,10 +308,12 @@ export class ProxyChatSession {
             });
         }
         if (modelParts.length > 0) {
-            this.history.push({
+            const modelEntry = {
                 role: 'model',
                 parts: modelParts,
-            });
+            };
+            this.history.push(modelEntry);
+            this.fullHistory.push(JSON.parse(JSON.stringify(modelEntry)));
             // We must prune again if we just pushed new history
             await this.pruneHistory();
         }

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.3"
+  "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.3",
+  "version": "2.7.0",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"