minovative-mind-cli 2.5.1 → 2.6.0

package/dist/utils/fuzzyMatch.js

@@ -1,4 +1,5 @@
 import { distance } from 'fastest-levenshtein';
+import { localValidate } from './localSyntaxValidator.js';
 /**
  * Trims each line, collapses multiple spaces/tabs to single space,
  * and normalizes line endings.
@@ -24,32 +25,50 @@ export function levenshteinSimilarity(a, b) {
 /**
  * Finds the best match for `searchContent` inside `fileContent`.
  * Uses a pipeline of strategies: Exact -> Whitespace-normalized -> Levenshtein.
+ * Enforces uniqueness and higher confidence thresholds for non-unique search snippets across repetitive files.
  */
 export function findBestMatch(fileContent, searchContent) {
-    if (!fileContent || !searchContent)
+    if (fileContent === undefined || searchContent === undefined)
         return null;
-    // Strategy 1: Exact Match
-    const exactIndex = fileContent.indexOf(searchContent);
-    if (exactIndex !== -1) {
+    // Special case: empty search content
+    if (searchContent === '') {
         return {
-            start: exactIndex,
-            end: exactIndex + searchContent.length,
+            start: 0,
+            end: 0,
             strategy: 'Exact Match',
         };
     }
-    // Strategy 2: Whitespace-normalized Match
+    if (!fileContent)
+        return null;
+    // Strategy 1: Exact Match (with Uniqueness check)
+    let firstExactIndex = -1;
+    let exactMatchCount = 0;
+    let pos = fileContent.indexOf(searchContent);
+    while (pos !== -1) {
+        exactMatchCount++;
+        if (firstExactIndex === -1)
+            firstExactIndex = pos;
+        pos = fileContent.indexOf(searchContent, pos + 1);
+    }
+    if (exactMatchCount === 1) {
+        return {
+            start: firstExactIndex,
+            end: firstExactIndex + searchContent.length,
+            strategy: 'Exact Match',
+        };
+    }
+    else if (exactMatchCount > 1) {
+        // Non-unique exact match across repetitive file content!
+        return null;
+    }
+    // Strategy 2: Whitespace-normalized Match (with Uniqueness check)
     const normFileLines = fileContent.split(/\r?\n/);
-    const normSearchContent = normalizeWhitespace(searchContent);
-    // Fast check: does the normalized file content contain the normalized search content at all?
-    // Since newlines are preserved by normalizeWhitespace (it only trims lines), we can do this:
-    const normFileContent = normalizeWhitespace(fileContent);
-    // To map back to original lines, we try matching line by line.
     const searchLines = searchContent.split(/\r?\n/);
     const numSearchLines = searchLines.length;
+    const normalizedMatches = [];
     if (numSearchLines > 0 && numSearchLines <= normFileLines.length) {
         for (let i = 0; i <= normFileLines.length - numSearchLines; i++) {
             let isMatch = true;
-            let charMatchCount = 0;
             for (let j = 0; j < numSearchLines; j++) {
                 const fileLineNorm = normalizeWhitespace(normFileLines[i + j]);
                 const searchLineNorm = normalizeWhitespace(searchLines[j]);
@@ -64,45 +83,100 @@ export function findBestMatch(fileContent, searchContent) {
                 const endLineOffset = getByteOffsetOfLine(fileContent, i + numSearchLines - 1);
                 const originalEndLine = normFileLines[i + numSearchLines - 1];
                 const end = endLineOffset + originalEndLine.length;
-                return {
+                normalizedMatches.push({
                     start,
                     end,
                     strategy: 'Whitespace-Normalized Match',
-                };
+                });
             }
         }
     }
-    // Strategy 3: Levenshtein Similarity
-    // We use a sliding window of size `numSearchLines`, `+ 1`, and `- 1` to handle line hallucinations.
-    const THRESHOLD = 0.8;
-    let bestSim = 0;
-    let bestMatch = null;
+    if (normalizedMatches.length === 1) {
+        return normalizedMatches[0];
+    }
+    else if (normalizedMatches.length > 1) {
+        // Non-unique whitespace-normalized match across repetitive code blocks!
+        return null;
+    }
+    // Strategy 3: Levenshtein Similarity (with Confidence Threshold & Region Uniqueness)
+    // We use higher confidence thresholds and check for competing candidate regions in repetitive files.
+    const trimmedSearchLen = searchContent.trim().length;
+    // Require higher threshold (0.92) for short search content or single-line snippets, and 0.88 for longer content.
+    const confidenceThreshold = (numSearchLines < 3 || trimmedSearchLen < 40) ? 0.92 : 0.88;
+    const rawCandidates = [];
     if (numSearchLines > 0) {
         for (let i = 0; i < normFileLines.length; i++) {
             for (const windowSize of [numSearchLines, numSearchLines + 1, numSearchLines - 1]) {
                 if (windowSize <= 0 || i + windowSize > normFileLines.length)
                     continue;
                 const windowLines = normFileLines.slice(i, i + windowSize);
-                // Normalize both strings before comparing to ignore indentation/whitespace differences
                 const windowStr = normalizeWhitespace(windowLines.join('\n'));
                 const targetStr = normalizeWhitespace(searchLines.join('\n'));
                 const sim = levenshteinSimilarity(windowStr, targetStr);
-                if (sim >= THRESHOLD && sim > bestSim) {
-                    bestSim = sim;
+                if (sim >= confidenceThreshold) {
                     const start = getByteOffsetOfLine(fileContent, i);
                     const endLineOffset = getByteOffsetOfLine(fileContent, i + windowSize - 1);
                     const originalEndLine = normFileLines[i + windowSize - 1];
                     const end = endLineOffset + originalEndLine.length;
-                    bestMatch = {
+                    rawCandidates.push({
+                        lineIndex: i,
+                        windowSize,
+                        sim,
                         start,
                         end,
-                        strategy: `Levenshtein Match (${(sim * 100).toFixed(1)}%) [Window: ${windowSize}]`,
-                    };
+                    });
                 }
             }
         }
     }
-    return bestMatch;
+    if (rawCandidates.length === 0)
+        return null;
+    // Group raw candidate windows into distinct file regions
+    // Candidates within `minRegionGap` lines of each other belong to the same region.
+    const minRegionGap = Math.max(2, Math.floor(numSearchLines / 2));
+    // Sort candidates by lineIndex
+    rawCandidates.sort((a, b) => a.lineIndex - b.lineIndex);
+    const distinctRegions = [];
+    for (const cand of rawCandidates) {
+        if (distinctRegions.length === 0) {
+            distinctRegions.push(cand);
+        }
+        else {
+            const lastRegion = distinctRegions[distinctRegions.length - 1];
+            if (Math.abs(cand.lineIndex - lastRegion.lineIndex) <= minRegionGap) {
+                // Same region: keep the candidate with higher similarity score
+                if (cand.sim > lastRegion.sim) {
+                    distinctRegions[distinctRegions.length - 1] = cand;
+                }
+            }
+            else {
+                distinctRegions.push(cand);
+            }
+        }
+    }
+    // Sort distinct regions by similarity score descending
+    distinctRegions.sort((a, b) => b.sim - a.sim);
+    if (distinctRegions.length === 1) {
+        const best = distinctRegions[0];
+        return {
+            start: best.start,
+            end: best.end,
+            strategy: `Levenshtein Match (${(best.sim * 100).toFixed(1)}%) [Window: ${best.windowSize}]`,
+        };
+    }
+    // Multiple distinct regions matched with high similarity across repetitive files.
+    // Check if top match significantly outperforms second best match.
+    const topCandidate = distinctRegions[0];
+    const secondCandidate = distinctRegions[1];
+    if (topCandidate.sim - secondCandidate.sim >= 0.08 && secondCandidate.sim < 0.85) {
+        return {
+            start: topCandidate.start,
+            end: topCandidate.end,
+            strategy: `Levenshtein Match (${(topCandidate.sim * 100).toFixed(1)}%) [Window: ${topCandidate.windowSize}]`,
+        };
+    }
+    // Search snippet is non-unique / ambiguous across repetitive code regions in the file.
+    return null;
 }
 export function applyMatch(fileContent, match, replaceContent) {
     return fileContent.slice(0, match.start) + replaceContent + fileContent.slice(match.end);
@@ -119,3 +193,117 @@ function getByteOffsetOfLine(text, lineIndex) {
     }
     return offset;
 }
+/**
+ * Parses differential patch block string into structured PatchBlock objects.
+ * Supports blocks formatted as:
+ * <<<<< SEARCH
+ * search content
+ * =====
+ * replace content
+ * >>>>> REPLACE
+ */
+export function parsePatchBlocks(patchText) {
+    if (!patchText || typeof patchText !== 'string')
+        return [];
+    const blocks = [];
+    const lines = patchText.split(/\r?\n/);
+    let state = 'IDLE';
+    let currentSearchLines = [];
+    let currentReplaceLines = [];
+    const searchMarkerRegex = /^<{5,}\s*SEARCH\b/i;
+    const dividerMarkerRegex = /^={5,}\s*$/;
+    const replaceMarkerRegex = /^>{5,}\s*REPLACE\b/i;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (state === 'IDLE') {
+            if (searchMarkerRegex.test(line)) {
+                state = 'SEARCH';
+                currentSearchLines = [];
+                currentReplaceLines = [];
+            }
+        }
+        else if (state === 'SEARCH') {
+            if (dividerMarkerRegex.test(line)) {
+                state = 'REPLACE';
+            }
+            else if (searchMarkerRegex.test(line)) {
+                currentSearchLines = [];
+            }
+            else {
+                currentSearchLines.push(line);
+            }
+        }
+        else if (state === 'REPLACE') {
+            if (replaceMarkerRegex.test(line)) {
+                blocks.push({
+                    search: currentSearchLines.join('\n'),
+                    replace: currentReplaceLines.join('\n'),
+                });
+                state = 'IDLE';
+                currentSearchLines = [];
+                currentReplaceLines = [];
+            }
+            else if (searchMarkerRegex.test(line)) {
+                state = 'SEARCH';
+                currentSearchLines = [];
+                currentReplaceLines = [];
+            }
+            else {
+                currentReplaceLines.push(line);
+            }
+        }
+    }
+    return blocks;
+}
+/**
+ * Applies a sequence of search/replace patch blocks to file content
+ * using fuzzy matching, and validates local syntax on the result.
+ */
+export function applyPatch(fileContent, patchTextOrBlocks, filePath, options) {
+    const blocks = typeof patchTextOrBlocks === 'string'
+        ? parsePatchBlocks(patchTextOrBlocks)
+        : patchTextOrBlocks;
+    if (!blocks || blocks.length === 0) {
+        return {
+            success: false,
+            content: fileContent,
+            appliedBlocks: 0,
+            failedBlocks: 0,
+            errors: ['No patch blocks found in input'],
+        };
+    }
+    let currentContent = fileContent;
+    let appliedBlocks = 0;
+    let failedBlocks = 0;
+    const errors = [];
+    for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        const match = findBestMatch(currentContent, block.search);
+        if (match) {
+            currentContent = applyMatch(currentContent, match, block.replace);
+            appliedBlocks++;
+        }
+        else {
+            failedBlocks++;
+            const preview = block.search.length > 80 ? block.search.slice(0, 80) + '...' : block.search;
+            errors.push(`Failed to locate match for search block ${i + 1}: "${preview}"`);
+        }
+    }
+    let syntaxValidation;
+    const shouldValidate = options?.validateSyntax !== false;
+    if (shouldValidate && filePath) {
+        syntaxValidation = localValidate(filePath, currentContent);
+        if (!syntaxValidation.isValid) {
+            errors.push(`Syntax validation failed: ${syntaxValidation.error}`);
+        }
+    }
+    const success = failedBlocks === 0 && appliedBlocks > 0 && (!syntaxValidation || syntaxValidation.isValid);
+    return {
+        success,
+        content: currentContent,
+        appliedBlocks,
+        failedBlocks,
+        errors,
+        syntaxValidation,
+    };
+}

package/dist/utils/localSyntaxValidator.d.ts

@@ -1,6 +1,6 @@
 /**
- * Performs fast, local syntax validation using regex-based checks.
- * This is intended as a first-pass filter before calling more expensive AI-based validation.
+ * Performs fast, local syntax validation using bracket-matching state machine and native parsers.
+ * Acts as a first-pass filter before AI-based validation.
  */
 export interface ValidationResult {
     isValid: boolean;