draftify-cli 1.0.62 → 1.0.64

package/dist/repl.js

@@ -668,26 +668,135 @@ async function startRepl(initialUsername) {
                             search = search.replace(/\r\n/g, '\n');
                             replace = replace.replace(/\r\n/g, '\n');
                             if (normalizedFile.includes(search)) {
+                                // === STRATEGY 1: Exact match ===
                                 fileContent = normalizedFile.replace(search, () => replace);
                                 diffApplied = true;
                             }
                             else {
-                                // Fallback 1: try stripping leading/trailing empty lines/whitespace from the search block
+                                // === STRATEGY 2: Trimmed match ===
                                 const trimmedSearch = search.trim();
                                 if (trimmedSearch && normalizedFile.includes(trimmedSearch)) {
                                     fileContent = normalizedFile.replace(trimmedSearch, () => replace.trim());
                                     diffApplied = true;
                                 }
                                 else {
-                                    // Fallback 2: Regex fuzzy matching that ignores exact whitespace differences (e.g. indentation or newlines)
+                                    // === STRATEGY 3: Whitespace-flexible regex ===
                                     const escapedSearch = trimmedSearch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+');
-                                    const regex = new RegExp(escapedSearch);
-                                    if (regex.test(normalizedFile)) {
-                                        fileContent = normalizedFile.replace(regex, () => replace.trim());
+                                    const wsRegex = new RegExp(escapedSearch);
+                                    if (wsRegex.test(normalizedFile)) {
+                                        fileContent = normalizedFile.replace(wsRegex, () => replace.trim());
                                         diffApplied = true;
                                     }
                                     else {
-                                        ui_1.ui.error(`Could not apply diff to ${filePath}: SEARCH block not exactly matched.`);
+                                        // === STRATEGY 4: Line-by-line fuzzy matching ===
+                                        // Find the region in the file that best matches the search block
+                                        const searchLines = trimmedSearch.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+                                        const fileLines = normalizedFile.split('\n');
+                                        if (searchLines.length > 0) {
+                                            let bestStartIdx = -1;
+                                            let bestEndIdx = -1;
+                                            let bestScore = 0;
+                                            // Slide a window over the file lines to find the best matching region
+                                            for (let i = 0; i <= fileLines.length - searchLines.length; i++) {
+                                                let matchedCount = 0;
+                                                let lastMatchIdx = i - 1;
+                                                for (const searchLine of searchLines) {
+                                                    // Look for this search line within a reasonable range
+                                                    for (let j = lastMatchIdx + 1; j < Math.min(i + searchLines.length + 5, fileLines.length); j++) {
+                                                        if (fileLines[j].trim() === searchLine) {
+                                                            matchedCount++;
+                                                            lastMatchIdx = j;
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                const score = matchedCount / searchLines.length;
+                                                if (score > bestScore && score >= 0.6) {
+                                                    bestScore = score;
+                                                    bestStartIdx = i;
+                                                    bestEndIdx = Math.min(lastMatchIdx, i + searchLines.length + 4);
+                                                }
+                                            }
+                                            if (bestStartIdx >= 0 && bestScore >= 0.6) {
+                                                const before = fileLines.slice(0, bestStartIdx).join('\n');
+                                                const after = fileLines.slice(bestEndIdx + 1).join('\n');
+                                                fileContent = before + (before ? '\n' : '') + replace.trim() + (after ? '\n' : '') + after;
+                                                diffApplied = true;
+                                                ui_1.ui.info(`Fuzzy matched diff for ${filePath} (${Math.round(bestScore * 100)}% confidence)`);
+                                            }
+                                            else {
+                                                // === STRATEGY 5: Anchor line matching (first + last non-empty line) ===
+                                                const firstSearchLine = searchLines[0];
+                                                const lastSearchLine = searchLines[searchLines.length - 1];
+                                                let anchorStart = -1;
+                                                let anchorEnd = -1;
+                                                for (let i = 0; i < fileLines.length; i++) {
+                                                    if (fileLines[i].trim() === firstSearchLine) {
+                                                        anchorStart = i;
+                                                        break;
+                                                    }
+                                                }
+                                                if (anchorStart >= 0) {
+                                                    for (let i = anchorStart + 1; i < fileLines.length; i++) {
+                                                        if (fileLines[i].trim() === lastSearchLine) {
+                                                            anchorEnd = i;
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                if (anchorStart >= 0 && anchorEnd >= 0 && (anchorEnd - anchorStart) <= searchLines.length * 2) {
+                                                    const before = fileLines.slice(0, anchorStart).join('\n');
+                                                    const after = fileLines.slice(anchorEnd + 1).join('\n');
+                                                    fileContent = before + (before ? '\n' : '') + replace.trim() + (after ? '\n' : '') + after;
+                                                    diffApplied = true;
+                                                    ui_1.ui.info(`Anchor-matched diff for ${filePath} (first/last line anchors)`);
+                                                }
+                                                else {
+                                                    // === STRATEGY 6: Partial content - find longest unique line sequence ===
+                                                    // Use the 3 longest unique lines from the search as anchors
+                                                    const uniqueSearchLines = searchLines
+                                                        .filter(l => l.length > 10)
+                                                        .sort((a, b) => b.length - a.length)
+                                                        .slice(0, 3);
+                                                    if (uniqueSearchLines.length >= 2) {
+                                                        const firstUnique = uniqueSearchLines[0];
+                                                        const secondUnique = uniqueSearchLines[1];
+                                                        let uStart = -1, uEnd = -1;
+                                                        for (let i = 0; i < fileLines.length; i++) {
+                                                            if (fileLines[i].trim().includes(firstUnique) || firstUnique.includes(fileLines[i].trim())) {
+                                                                if (uStart < 0)
+                                                                    uStart = i;
+                                                                uEnd = i;
+                                                            }
+                                                            if (fileLines[i].trim().includes(secondUnique) || secondUnique.includes(fileLines[i].trim())) {
+                                                                if (uStart < 0)
+                                                                    uStart = i;
+                                                                uEnd = i;
+                                                            }
+                                                        }
+                                                        if (uStart >= 0 && uEnd >= uStart) {
+                                                            // Expand slightly to capture the full block
+                                                            const expandedStart = Math.max(0, uStart - 1);
+                                                            const expandedEnd = Math.min(fileLines.length - 1, uEnd + 1);
+                                                            const before = fileLines.slice(0, expandedStart).join('\n');
+                                                            const after = fileLines.slice(expandedEnd + 1).join('\n');
+                                                            fileContent = before + (before ? '\n' : '') + replace.trim() + (after ? '\n' : '') + after;
+                                                            diffApplied = true;
+                                                            ui_1.ui.info(`Partial-matched diff for ${filePath} (unique line anchors)`);
+                                                        }
+                                                        else {
+                                                            ui_1.ui.error(`Could not apply diff to ${filePath}: SEARCH block not matched (all 6 strategies failed).`);
+                                                        }
+                                                    }
+                                                    else {
+                                                        ui_1.ui.error(`Could not apply diff to ${filePath}: SEARCH block not matched (all strategies failed).`);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            ui_1.ui.error(`Could not apply diff to ${filePath}: SEARCH block is empty.`);
+                                        }
                                     }
                                 }
                             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "draftify-cli",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "description": "Draftify AI CLI tool",
   "main": "dist/index.js",
   "bin": {