deepdebug-local-agent 0.3.1

package/src/patch.js

@@ -0,0 +1,607 @@
+import path from "path";
+import { writeFile, readFile } from "./fs-utils.js";
+import pkg from "unidiff";
+
+const { parsePatch, applyPatch } = pkg;
+
+/**
+ * Apply unified diff with smart fallback strategies
+ *
+ * 🆕 FIX v2:
+ * - Completely removed any fallback that might append patch as comment
+ * - Added validation to ensure file wasn't corrupted
+ * - Added Strategy 4: Intelligent line-by-line matching
+ *
+ * Strategies (in order):
+ * 1. Exact match (standard applyPatch)
+ * 2. Fuzzy match (try different line offsets)
+ * 3. Content match (find best matching context)
+ * 4. Intelligent match (find lines by content, ignore line numbers)
+ */
+export async function applyUnifiedDiff(root, diffText) {
+    console.log("🔧 [SMART PATCH v2] Starting patch application...");
+
+    let patches = parsePatch(diffText);
+    if (!patches.length) throw new Error("No patches found in diff");
+    let p = patches[0];
+
+    // Discover target path from patch
+    const targetRel =
+        p?.newFileName?.replace(/^b\//, "") ||
+        p?.oldFileName?.replace(/^a\//, "");
+    if (!targetRel) throw new Error("Could not infer target file from diff");
+
+    console.log("🎯 Target:", targetRel);
+    const full = path.join(root, targetRel);
+
+    let original;
+    try {
+        original = await readFile(full, "utf8");
+    } catch (err) {
+        throw new Error(`Target file not found: ${targetRel}`);
+    }
+
+    // Normalize invisible characters in both file content and diff
+    // This fixes encoding mismatches between AI-generated diffs and actual files
+    const rawOriginal = original;
+    original = stripInvisibleChars(original);
+    diffText = stripInvisibleChars(diffText);
+
+    if (rawOriginal !== original) {
+        console.log("⚡ Original file had invisible characters - normalized");
+    }
+
+    // Re-parse the normalized diff
+    const normalizedPatches = parsePatch(diffText);
+    if (normalizedPatches.length > 0) {
+        p = normalizedPatches[0];
+    }
+
+    const originalLines = original.split('\n');
+    const originalLength = original.length;
+    console.log("📖 Original file:", originalLines.length, "lines,", originalLength, "chars");
+
+    // Log patch info
+    if (p.hunks && p.hunks.length > 0) {
+        const hunk = p.hunks[0];
+        console.log("📋 Patch hunk:");
+        console.log("  Old start:", hunk.oldStart);
+        console.log("  Old lines:", hunk.oldLines);
+        console.log("  New start:", hunk.newStart);
+        console.log("  New lines:", hunk.newLines);
+        console.log("  Context lines:", hunk.lines.filter(l => l.startsWith(' ')).length);
+        console.log("  Additions:", hunk.lines.filter(l => l.startsWith('+')).length);
+        console.log("  Deletions:", hunk.lines.filter(l => l.startsWith('-')).length);
+    }
+
+    // STRATEGY 1: Try exact match first
+    console.log("\n🎯 STRATEGY 1: Exact match");
+    let result = applyPatch(original, p);
+
+    if (result !== false && isValidResult(result, diffText)) {
+        console.log("✅ Exact match succeeded!");
+        await writeFile(full, result, "utf8");
+        return {
+            ok: true,
+            target: targetRel,
+            bytes: Buffer.byteLength(result, "utf8"),
+            strategy: "exact",
+            filesModified: 1,
+            patchedFiles: [targetRel]
+        };
+    }
+    console.log("❌ Exact match failed");
+
+    // STRATEGY 2: Try fuzzy match with line offsets
+    console.log("\n🔍 STRATEGY 2: Fuzzy match with offsets");
+    const offsets = [1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6, 7, -7, 8, -8, 9, -9, 10, -10,
+        15, -15, 20, -20, 25, -25, 30, -30, 40, -40, 50, -50, 75, -75, 100, -100];
+
+    for (const offset of offsets) {
+        const adjustedPatch = adjustPatchLineNumbers(p, offset);
+        result = applyPatch(original, adjustedPatch);
+
+        if (result !== false && isValidResult(result, diffText)) {
+            console.log(`✅ Fuzzy match succeeded with offset: ${offset}`);
+            await writeFile(full, result, "utf8");
+            return {
+                ok: true,
+                target: targetRel,
+                bytes: Buffer.byteLength(result, "utf8"),
+                strategy: "fuzzy",
+                offset: offset,
+                filesModified: 1,
+                patchedFiles: [targetRel]
+            };
+        }
+    }
+    console.log("❌ Fuzzy match failed (tried all offsets)");
+
+    // STRATEGY 3: Try content-based match
+    console.log("\n🧠 STRATEGY 3: Content-based matching");
+    result = await tryContentMatch(original, p);
+
+    if (result !== null && isValidResult(result, diffText)) {
+        console.log("✅ Content match succeeded!");
+        await writeFile(full, result, "utf8");
+        return {
+            ok: true,
+            target: targetRel,
+            bytes: Buffer.byteLength(result, "utf8"),
+            strategy: "content",
+            filesModified: 1,
+            patchedFiles: [targetRel]
+        };
+    }
+    console.log("❌ Content match failed");
+
+    // STRATEGY 4: Try intelligent line-by-line match
+    console.log("\n🔬 STRATEGY 4: Intelligent line-by-line matching");
+    result = await tryIntelligentMatch(original, p);
+
+    if (result !== null && isValidResult(result, diffText)) {
+        console.log("✅ Intelligent match succeeded!");
+        await writeFile(full, result, "utf8");
+        return {
+            ok: true,
+            target: targetRel,
+            bytes: Buffer.byteLength(result, "utf8"),
+            strategy: "intelligent",
+            filesModified: 1,
+            patchedFiles: [targetRel]
+        };
+    }
+    console.log("❌ Intelligent match failed");
+
+    // ❌ ALL STRATEGIES FAILED - THROW ERROR
+    console.error("\n❌ ALL STRATEGIES EXHAUSTED - PATCH CANNOT BE APPLIED");
+
+    // Provide detailed error info
+    const errorDetails = buildErrorDetails(originalLines, p);
+
+    const error = new Error(`Patch failed: ${errorDetails}`);
+    error.code = "PATCH_FAILED";
+    error.file = targetRel;
+    error.suggestion = "The file may have been modified. Try re-analyzing the error.";
+
+    throw error;
+}
+
+/**
+ * 🆕 VALIDATION: Ensure the result is valid and wasn't corrupted
+ * Checks that the patch wasn't appended as a comment
+ */
+function isValidResult(result, diffText) {
+    if (!result || typeof result !== 'string') {
+        return false;
+    }
+
+    // Check if the diff was appended as a comment (BUG we're fixing)
+    if (result.includes("PATCH COULD NOT BE APPLIED") ||
+        result.includes("fuzz 0-3 failed") ||
+        result.includes("--- a/") && result.includes("+++ b/") && result.endsWith(diffText.trim())) {
+        console.warn("⚠️ Detected corrupted result (patch appended as comment)");
+        return false;
+    }
+
+    // Check if the diff text was literally appended to the file
+    const diffLines = diffText.split('\n').slice(0, 5).join('\n');
+    if (result.includes(diffLines) && result.indexOf(diffLines) > result.length - diffText.length - 100) {
+        console.warn("⚠️ Detected diff appended to end of file");
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * 🆕 STRATEGY 4: Intelligent line-by-line matching
+ * Finds the exact lines to modify by content, completely ignoring line numbers
+ */
+async function tryIntelligentMatch(original, patch) {
+    const originalLines = original.split('\n');
+
+    if (!patch.hunks || !patch.hunks.length) return null;
+
+    let resultLines = [...originalLines];
+    let totalOffset = 0;
+
+    for (const hunk of patch.hunks) {
+        // Extract lines to remove and add
+        const linesToRemove = [];
+        const linesToAdd = [];
+        const contextBefore = [];
+        const contextAfter = [];
+        let foundFirstChange = false;
+
+        for (const line of hunk.lines) {
+            if (line.startsWith('-')) {
+                linesToRemove.push(line.substring(1));
+                foundFirstChange = true;
+            } else if (line.startsWith('+')) {
+                linesToAdd.push(line.substring(1));
+                foundFirstChange = true;
+            } else if (line.startsWith(' ')) {
+                if (!foundFirstChange) {
+                    contextBefore.push(line.substring(1));
+                } else {
+                    contextAfter.push(line.substring(1));
+                }
+            }
+        }
+
+        console.log(`  Lines to remove: ${linesToRemove.length}, to add: ${linesToAdd.length}`);
+        console.log(`  Context before: ${contextBefore.length}, after: ${contextAfter.length}`);
+
+        if (linesToRemove.length === 0 && linesToAdd.length > 0) {
+            // Pure addition - find insertion point using context
+            const insertIndex = findInsertionPoint(resultLines, contextBefore, contextAfter, totalOffset);
+            if (insertIndex !== -1) {
+                console.log(`  ✅ Found insertion point at line ${insertIndex + 1}`);
+                resultLines.splice(insertIndex, 0, ...linesToAdd);
+                totalOffset += linesToAdd.length;
+                continue;
+            }
+            console.log("  ❌ Could not find insertion point");
+            return null;
+        }
+
+        // Find where the lines to remove actually are
+        const foundIndex = findLinesInFile(resultLines, linesToRemove, contextBefore);
+
+        if (foundIndex === -1) {
+            console.log("  ❌ Could not find lines to remove in file");
+            return null;
+        }
+
+        console.log(`  ✅ Found matching lines at index ${foundIndex + 1}`);
+
+        // Replace the found lines with the new lines
+        resultLines.splice(foundIndex, linesToRemove.length, ...linesToAdd);
+        totalOffset += linesToAdd.length - linesToRemove.length;
+    }
+
+    return resultLines.join('\n');
+}
+
+/**
+ * Find a sequence of lines in the file using content matching
+ */
+function findLinesInFile(fileLines, searchLines, contextBefore = []) {
+    if (searchLines.length === 0) return -1;
+
+    const searchStart = contextBefore.length > 0 ? contextBefore[contextBefore.length - 1] : null;
+
+    for (let i = 0; i <= fileLines.length - searchLines.length; i++) {
+        // If we have context, check if it matches first
+        if (searchStart && contextBefore.length > 0) {
+            let contextMatches = true;
+            const contextStartIndex = i - contextBefore.length;
+
+            if (contextStartIndex >= 0) {
+                for (let c = 0; c < contextBefore.length; c++) {
+                    if (normalize(fileLines[contextStartIndex + c]) !== normalize(contextBefore[c])) {
+                        contextMatches = false;
+                        break;
+                    }
+                }
+
+                if (!contextMatches) continue;
+            }
+        }
+
+        // Check if search lines match
+        let match = true;
+        for (let j = 0; j < searchLines.length; j++) {
+            if (normalize(fileLines[i + j]) !== normalize(searchLines[j])) {
+                match = false;
+                break;
+            }
+        }
+
+        if (match) {
+            return i;
+        }
+    }
+
+    // Fallback: try partial matching (80% threshold)
+    for (let i = 0; i <= fileLines.length - searchLines.length; i++) {
+        let matchCount = 0;
+
+        for (let j = 0; j < searchLines.length; j++) {
+            const fileLine = normalize(fileLines[i + j]);
+            const searchLine = normalize(searchLines[j]);
+
+            if (fileLine === searchLine) {
+                matchCount++;
+            } else if (fileLine.includes(searchLine) || searchLine.includes(fileLine)) {
+                matchCount += 0.5;
+            }
+        }
+
+        if (matchCount / searchLines.length >= 0.8) {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+/**
+ * Find best insertion point for pure additions using context
+ */
+function findInsertionPoint(fileLines, contextBefore, contextAfter, offset) {
+    // Strategy 1: Find context before
+    if (contextBefore.length > 0) {
+        for (let i = 0; i <= fileLines.length - contextBefore.length; i++) {
+            let match = true;
+            for (let j = 0; j < contextBefore.length; j++) {
+                if (normalize(fileLines[i + j]) !== normalize(contextBefore[j])) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                return i + contextBefore.length;
+            }
+        }
+    }
+
+    // Strategy 2: Find context after and insert before it
+    if (contextAfter.length > 0) {
+        for (let i = 0; i <= fileLines.length - contextAfter.length; i++) {
+            let match = true;
+            for (let j = 0; j < contextAfter.length; j++) {
+                if (normalize(fileLines[i + j]) !== normalize(contextAfter[j])) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                return i;
+            }
+        }
+    }
+
+    return -1;
+}
+
+/**
+ * Normalize a line for comparison (trim whitespace)
+ */
+/**
+ * Strip invisible characters from text to normalize encoding differences
+ * between AI-generated diffs and actual file content
+ */
+function stripInvisibleChars(text) {
+    if (!text) return text;
+    return text
+        // Remove BOM
+        .replace(/^\uFEFF/, '')
+        // Remove zero-width chars
+        .replace(/[\u200B\u200C\u200D\u200E\u200F]/g, '')
+        // Replace non-breaking spaces with regular spaces
+        .replace(/\u00A0/g, ' ')
+        // Normalize unicode
+        .normalize('NFC');
+}
+
+function normalize(line) {
+    return (line || '')
+        // Remove BOM
+        .replace(/^\uFEFF/, '')
+        // Remove zero-width spaces and other invisible unicode
+        .replace(/[\u200B\u200C\u200D\u200E\u200F\uFEFF\u00A0]/g, '')
+        // Normalize unicode (NFC form)
+        .normalize('NFC')
+        // Normalize whitespace (tabs to spaces, multiple spaces to single)
+        .replace(/\t/g, '    ')
+        .trim();
+}
+
+/**
+ * Build detailed error message
+ */
+function buildErrorDetails(originalLines, patch) {
+    if (!patch.hunks || patch.hunks.length === 0) {
+        return "Patch has no hunks.";
+    }
+
+    const hunk = patch.hunks[0];
+    const expectedStart = hunk.oldStart;
+
+    // Get expected content from patch
+    const expectedLines = hunk.lines
+        .filter(l => l.startsWith(' ') || l.startsWith('-'))
+        .slice(0, 2)
+        .map(l => l.substring(1).trim());
+
+    // Get actual content at that location
+    const actualLines = originalLines
+        .slice(Math.max(0, expectedStart - 1), expectedStart + 1)
+        .map(l => l.trim());
+
+    return `At line ${expectedStart}: expected "${expectedLines[0] || 'N/A'}" ` +
+        `but found "${actualLines[0] || 'N/A'}". Context mismatch.`;
+}
+
+/**
+ * Adjust line numbers in a patch by an offset
+ */
+function adjustPatchLineNumbers(patch, offset) {
+    const adjusted = JSON.parse(JSON.stringify(patch));
+
+    if (adjusted.hunks) {
+        adjusted.hunks = adjusted.hunks.map(hunk => ({
+            ...hunk,
+            oldStart: Math.max(1, hunk.oldStart + offset),
+            newStart: Math.max(1, hunk.newStart + offset)
+        }));
+    }
+
+    return adjusted;
+}
+
+/**
+ * STRATEGY 3: Content-based matching
+ */
+async function tryContentMatch(original, patch) {
+    const originalLines = original.split('\n');
+
+    if (!patch.hunks || !patch.hunks.length) return null;
+
+    let resultLines = [...originalLines];
+    let totalOffset = 0;
+
+    for (const hunk of patch.hunks) {
+        const contextLines = [];
+        const additions = [];
+        const deletions = [];
+
+        for (const line of hunk.lines) {
+            if (line.startsWith(' ')) {
+                contextLines.push(line.substring(1));
+            } else if (line.startsWith('+')) {
+                additions.push(line.substring(1));
+            } else if (line.startsWith('-')) {
+                deletions.push(line.substring(1));
+            }
+        }
+
+        console.log("  Context:", contextLines.length, "Add:", additions.length, "Del:", deletions.length);
+
+        const matchIndex = findBestContextMatch(resultLines, contextLines);
+
+        if (matchIndex !== -1) {
+            console.log(`  ✅ Found context at line ${matchIndex + 1}`);
+
+            const newResult = applyChangesAtLocation(
+                resultLines,
+                matchIndex,
+                deletions,
+                additions,
+                contextLines
+            );
+
+            if (newResult) {
+                resultLines = newResult;
+                totalOffset += additions.length - deletions.length;
+            } else {
+                return null;
+            }
+        } else {
+            console.log("  ❌ No context match found");
+            return null;
+        }
+    }
+
+    return resultLines.join('\n');
+}
+
+/**
+ * Find the best matching context in the file (60% threshold)
+ */
+function findBestContextMatch(fileLines, contextLines) {
+    if (contextLines.length === 0) return -1;
+
+    let bestMatch = -1;
+    let bestScore = 0;
+
+    for (let i = 0; i <= fileLines.length - contextLines.length; i++) {
+        let score = 0;
+
+        for (let j = 0; j < contextLines.length; j++) {
+            const fileLine = normalize(fileLines[i + j]);
+            const contextLine = normalize(contextLines[j]);
+
+            if (fileLine === contextLine) {
+                score++;
+            } else if (fileLine && contextLine &&
+                (fileLine.includes(contextLine) || contextLine.includes(fileLine))) {
+                score += 0.5;
+            }
+        }
+
+        const matchPercentage = score / contextLines.length;
+        if (matchPercentage > bestScore && matchPercentage >= 0.6) {
+            bestScore = matchPercentage;
+            bestMatch = i;
+        }
+    }
+
+    return bestMatch;
+}
+
+/**
+ * Apply changes at a specific location
+ */
+function applyChangesAtLocation(fileLines, startIndex, deletions, additions, contextLines) {
+    const result = [...fileLines];
+
+    // Find where deletions actually are
+    let deleteStartIndex = startIndex;
+
+    if (deletions.length > 0) {
+        for (let i = startIndex; i < Math.min(result.length, startIndex + contextLines.length + 10); i++) {
+            if (normalize(result[i]) === normalize(deletions[0])) {
+                deleteStartIndex = i;
+                break;
+            }
+        }
+    }
+
+    // Remove deletion lines
+    for (let i = 0; i < deletions.length; i++) {
+        const deletionNorm = normalize(deletions[i]);
+
+        for (let j = deleteStartIndex; j < Math.min(result.length, deleteStartIndex + 10); j++) {
+            if (normalize(result[j]) === deletionNorm) {
+                result.splice(j, 1);
+                break;
+            }
+        }
+    }
+
+    // Add new lines
+    result.splice(deleteStartIndex, 0, ...additions);
+
+    return result;
+}
+
+/**
+ * Validate that a patch can be applied
+ */
+export async function validateDiff(root, diffText) {
+    try {
+        const patches = parsePatch(diffText);
+
+        if (!patches || patches.length === 0) {
+            return {
+                valid: false,
+                errors: ["No patches found in diff"]
+            };
+        }
+
+        const errors = [];
+
+        for (const patch of patches) {
+            if (!patch.oldFileName && !patch.newFileName) {
+                errors.push("Patch missing file names");
+            }
+
+            if (!patch.hunks || patch.hunks.length === 0) {
+                errors.push("Patch has no hunks");
+            }
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    } catch (error) {
+        return {
+            valid: false,
+            errors: [error.message]
+        };
+    }
+}