draftify-cli 1.0.62 → 1.0.66

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/dist/utils/api.js

@@ -250,9 +250,12 @@ new lines
 >>>>>>>
 </FILE_MODIFY>
 CRITICAL RULES FOR <FILE_MODIFY>:
-- The SEARCH block MUST PERFECTLY MATCH the existing file content. Do not use ellipses (...) or comments like "// ... existing code ..." to skip lines.
+- **MANDATORY: ALWAYS use <READ_FILE> to read the file FIRST before writing any <FILE_MODIFY> block.** Never rely on memory of what a file contains — your memory of file content degrades over conversation turns. ALWAYS re-read.
+- The SEARCH block MUST PERFECTLY MATCH the existing file content character-for-character. Do not use ellipses (...) or comments like "// ... existing code ..." to skip lines.
 - The indentation in the SEARCH block must exactly match the file.
-- Only include the minimal lines needed to uniquely identify the replacement location (usually 1-3 context lines).
+- Keep SEARCH blocks SHORT: include only 1-5 lines — the absolute minimum needed to uniquely identify the replacement location. Shorter blocks are far less likely to mismatch.
+- You can use multiple SEARCH/REPLACE blocks within a single <FILE_MODIFY> tag.
+- **LARGE CHANGES RULE: If you need to change more than ~30% of a file, do NOT use <FILE_MODIFY> with many SEARCH blocks. Instead, use <FILE_CREATE> with the complete new file content to overwrite it entirely.** This is much more reliable than multiple diffs.
 
 3. To delete a file:
 <FILE_DELETE path="relative/path/to/file.ext" />
@@ -278,6 +281,7 @@ CRITICAL RULES FOR <FILE_MODIFY>:
 
 AUTONOMOUS WORKSPACE EXPLORATION:
 If the user asks you to modify the project (e.g. "Add a game over menu", "Fix the bug in the header") but you don't know the exact file structure or contents, DO NOT ask the user to show you the files. Instead, use <LIST_DIR path="." /> and <READ_FILE path="..." /> to autonomously explore the workspace. You can read multiple files or list directories in a single response. Wait for the CLI to return the results of your exploration before you generate the code modifications. You act like an autonomous agent.
+IMPORTANT: You MUST ALWAYS <READ_FILE> any file before attempting <FILE_MODIFY> on it. This is not optional — it prevents diff mismatch failures.
 
 Always use these tags when you write code, explore files, or ask questions so the CLI can apply it automatically! Keep explanations short and outside the tags.
 

package/package.json

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