sonance-brand-mcp 1.3.46 → 1.3.48

package/dist/assets/api/sonance-vision-edit/route.ts

@@ -466,6 +466,8 @@ Return search/replace patches (NOT full files). The system applies your patches
 - "replace" contains your modified version
 - Include 2-4 lines of context in "search" to make it unique
 - You may ONLY edit files provided in the PAGE CONTEXT section
+- CRITICAL: NEVER invent or guess code. Your "search" string MUST be copied EXACTLY from the provided file content. If you cannot find the exact code to modify, return an empty modifications array.
+- If the file content appears truncated, only modify code that is visible in the provided content.
 
 **SONANCE BRAND COLORS:**
 - Charcoal: #333F48 (primary text)
@@ -668,10 +670,10 @@ export async function POST(request: Request) {
       }
 
       // ========== SMART CONTEXT BUDGETING ==========
-      // Total budget: 100k chars (~25k tokens, safe for Claude)
-      // Priority: Recommended file (full) > Page file (limited) > Other components (dynamic)
-      const TOTAL_CONTEXT_BUDGET = 100000;
-      const MAX_RECOMMENDED_FILE = 80000; // 80k chars max for recommended file
+      // Claude can handle 200k tokens (~800k chars), so we can safely include large files
+      // Priority: Recommended file (NEVER truncate) > Page file (limited) > Other components (dynamic)
+      const TOTAL_CONTEXT_BUDGET = 500000; // 500k chars total budget
+      const MAX_RECOMMENDED_FILE = Infinity; // NEVER truncate the target file - AI needs full context
       const MAX_PAGE_FILE = 2000; // Page file is just a wrapper
       const MAX_GLOBALS_CSS = 1500;
       const MAX_FILES = 25;
@@ -705,9 +707,8 @@ ${focusedElements.map((el) => `- ${el.name} (${el.type}) at (${el.coordinates.x}
 
       // ========== TARGET COMPONENT (RECOMMENDED FILE) - SHOWN FIRST ==========
       if (recommendedFileContent) {
-        const content = recommendedFileContent.content.length > MAX_RECOMMENDED_FILE
-          ? recommendedFileContent.content.substring(0, MAX_RECOMMENDED_FILE) + "\n// ... (file truncated at 50k chars, showing component definition and main logic)"
-          : recommendedFileContent.content;
+        // Never truncate the recommended file - AI needs full context to avoid hallucination
+        const content = recommendedFileContent.content;
         
         textContent += `═══════════════════════════════════════════════════════════════════════════════
 ⚡ TARGET COMPONENT - YOU MUST EDIT THIS FILE
@@ -818,97 +819,135 @@ CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
         text: textContent,
       });
 
-      // Call Claude Vision API
+      // Call Claude Vision API with retry mechanism
       const anthropic = new Anthropic({ apiKey });
-
-      const response = await anthropic.messages.create({
-        model: "claude-sonnet-4-20250514",
-        max_tokens: 16384,
-        messages: [
+      
+      // Build list of known file paths (for logging)
+      const knownPaths = new Set<string>();
+      if (pageContext.pageFile) {
+        knownPaths.add(pageContext.pageFile);
+      }
+      for (const comp of pageContext.componentSources) {
+        knownPaths.add(comp.path);
+      }
+      
+      // Retry loop for handling patch failures
+      const MAX_RETRIES = 1;
+      let retryCount = 0;
+      let lastPatchErrors: string[] = [];
+      let modificationsWithOriginals: VisionFileModification[] = [];
+      let finalExplanation: string | undefined;
+      let finalReasoning: string | undefined;
+      let finalAggregatedCSS: string | undefined;
+      
+      while (retryCount <= MAX_RETRIES) {
+        // Build messages for this attempt
+        const currentMessages: Anthropic.MessageCreateParams["messages"] = [
           {
             role: "user",
             content: messageContent,
           },
-        ],
-        system: VISION_SYSTEM_PROMPT,
-      });
+        ];
+        
+        // If this is a retry, add feedback about what went wrong
+        if (retryCount > 0 && lastPatchErrors.length > 0) {
+          debugLog("Retry attempt with feedback", { retryCount, errorCount: lastPatchErrors.length });
+          currentMessages.push({
+            role: "assistant",
+            content: "I'll analyze the screenshot and generate the patches now.",
+          });
+          currentMessages.push({
+            role: "user",
+            content: `PATCH APPLICATION FAILED. Your previous patches referenced code that does not exist in the file (hallucination detected).
 
-      // Extract text content from response
-      const textResponse = response.content.find((block) => block.type === "text");
-      if (!textResponse || textResponse.type !== "text") {
-        return NextResponse.json(
-          { error: "No text response from AI" },
-          { status: 500 }
-        );
-      }
+Failed patches:
+${lastPatchErrors.join("\n\n")}
 
-      // Parse AI response - now expecting patches instead of full file content
-      let aiResponse: {
-        reasoning?: string;
-        modifications: Array<{
-          filePath: string;
-          patches?: Patch[];
-          // Legacy support for modifiedContent (will be deprecated)
-          modifiedContent?: string;
-          explanation?: string;
-          previewCSS?: string;
-        }>;
-        aggregatedPreviewCSS?: string;
-        explanation?: string;
-      };
+IMPORTANT: You must copy the "search" string EXACTLY from the file content I provided. Do NOT invent or guess code.
+Look carefully at the ACTUAL file content in the TARGET COMPONENT section above and try again.
 
-      try {
-        let jsonText = textResponse.text.trim();
-        
-        // Try to extract JSON from markdown code blocks
-        const jsonMatch = jsonText.match(/```json\n([\s\S]*?)\n```/) || 
-                         jsonText.match(/```\n([\s\S]*?)\n```/);
-        
-        if (jsonMatch) {
-          jsonText = jsonMatch[1];
-        } else if (jsonText.includes("```json")) {
-            // Fallback for cases where regex might miss due to newlines
-            const start = jsonText.indexOf("```json") + 7;
-            const end = jsonText.lastIndexOf("```");
-            if (end > start) {
-                jsonText = jsonText.substring(start, end);
-            }
+If you cannot find the exact code to modify, return an empty modifications array with an explanation.`,
+          });
         }
 
-        // Clean up any remaining whitespace
-        jsonText = jsonText.trim();
-        
-        // Robust JSON extraction: find the first { and last } to extract JSON object
-        // This handles cases where the LLM includes preamble text before the JSON
-        const firstBrace = jsonText.indexOf('{');
-        const lastBrace = jsonText.lastIndexOf('}');
-        if (firstBrace !== -1 && lastBrace > firstBrace) {
-          jsonText = jsonText.substring(firstBrace, lastBrace + 1);
+        const response = await anthropic.messages.create({
+          model: "claude-sonnet-4-20250514",
+          max_tokens: 16384,
+          messages: currentMessages,
+          system: VISION_SYSTEM_PROMPT,
+        });
+
+        // Extract text content from response
+        const textResponse = response.content.find((block) => block.type === "text");
+        if (!textResponse || textResponse.type !== "text") {
+          return NextResponse.json(
+            { error: "No text response from AI" },
+            { status: 500 }
+          );
         }
-        
-        aiResponse = JSON.parse(jsonText);
-      } catch {
-        console.error("Failed to parse AI response:", textResponse.text);
-        return NextResponse.json(
-          { error: "Failed to parse AI response. Please try again." },
-          { status: 500 }
-        );
-      }
 
-      // Build list of known file paths (for logging)
-      const knownPaths = new Set<string>();
-      if (pageContext.pageFile) {
-        knownPaths.add(pageContext.pageFile);
-      }
-      for (const comp of pageContext.componentSources) {
-        knownPaths.add(comp.path);
-      }
+        // Parse AI response - now expecting patches instead of full file content
+        let aiResponse: {
+          reasoning?: string;
+          modifications: Array<{
+            filePath: string;
+            patches?: Patch[];
+            // Legacy support for modifiedContent (will be deprecated)
+            modifiedContent?: string;
+            explanation?: string;
+            previewCSS?: string;
+          }>;
+          aggregatedPreviewCSS?: string;
+          explanation?: string;
+        };
 
-      debugLog("VALIDATION: Known file paths from page context", {
-        pageFile: pageContext.pageFile,
-        knownPaths: Array.from(knownPaths),
-        aiRequestedFiles: (aiResponse.modifications || []).map(m => m.filePath)
-      });
+        try {
+          let jsonText = textResponse.text.trim();
+          
+          // Try to extract JSON from markdown code blocks
+          const jsonMatch = jsonText.match(/```json\n([\s\S]*?)\n```/) || 
+                           jsonText.match(/```\n([\s\S]*?)\n```/);
+          
+          if (jsonMatch) {
+            jsonText = jsonMatch[1];
+          } else if (jsonText.includes("```json")) {
+              // Fallback for cases where regex might miss due to newlines
+              const start = jsonText.indexOf("```json") + 7;
+              const end = jsonText.lastIndexOf("```");
+              if (end > start) {
+                  jsonText = jsonText.substring(start, end);
+              }
+          }
+
+          // Clean up any remaining whitespace
+          jsonText = jsonText.trim();
+          
+          // Robust JSON extraction: find the first { and last } to extract JSON object
+          // This handles cases where the LLM includes preamble text before the JSON
+          const firstBrace = jsonText.indexOf('{');
+          const lastBrace = jsonText.lastIndexOf('}');
+          if (firstBrace !== -1 && lastBrace > firstBrace) {
+            jsonText = jsonText.substring(firstBrace, lastBrace + 1);
+          }
+          
+          aiResponse = JSON.parse(jsonText);
+        } catch {
+          console.error("Failed to parse AI response:", textResponse.text);
+          return NextResponse.json(
+            { error: "Failed to parse AI response. Please try again." },
+            { status: 500 }
+          );
+        }
+
+        finalExplanation = aiResponse.explanation;
+        finalReasoning = aiResponse.reasoning;
+        finalAggregatedCSS = aiResponse.aggregatedPreviewCSS;
+
+        debugLog("VALIDATION: Known file paths from page context", {
+          pageFile: pageContext.pageFile,
+          knownPaths: Array.from(knownPaths),
+          aiRequestedFiles: (aiResponse.modifications || []).map(m => m.filePath)
+        });
 
       // Validate AI response - trust the LLM to identify the correct file
       // Only reject paths that are outside the project or don't exist
@@ -949,9 +988,9 @@ CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
         }
       }
 
-      // Process modifications - apply patches to get modified content
-      const modificationsWithOriginals: VisionFileModification[] = [];
-      const patchErrors: string[] = [];
+        // Process modifications - apply patches to get modified content
+        modificationsWithOriginals = [];
+        const patchErrors: string[] = [];
       
       for (const mod of aiResponse.modifications || []) {
         const fullPath = path.join(projectRoot, mod.filePath);
@@ -968,6 +1007,47 @@ CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
           // New patch-based approach
           console.log(`[Vision Mode] Applying ${mod.patches.length} patches to ${mod.filePath}`);
           
+          // PRE-VALIDATION: Check if all search strings exist in the file BEFORE applying
+          const preValidationErrors: string[] = [];
+          for (const patch of mod.patches) {
+            const normalizedSearch = patch.search.replace(/\\n/g, "\n");
+            if (!originalContent.includes(normalizedSearch)) {
+              // Try fuzzy match as fallback
+              const fuzzyMatch = findFuzzyMatch(normalizedSearch, originalContent);
+              if (!fuzzyMatch) {
+                // Find the closest matching snippet to help with debugging
+                const searchPreview = normalizedSearch.substring(0, 80).replace(/\n/g, "\\n");
+                
+                // Look for partial matches to give helpful feedback
+                const searchLines = normalizedSearch.split("\n").filter(l => l.trim().length > 10);
+                const partialMatches: string[] = [];
+                for (const line of searchLines.slice(0, 3)) {
+                  const trimmedLine = line.trim();
+                  if (trimmedLine.length > 10 && originalContent.includes(trimmedLine)) {
+                    partialMatches.push(trimmedLine.substring(0, 50));
+                  }
+                }
+                
+                let errorMsg = `Patch search string not found: "${searchPreview}..."`;
+                if (partialMatches.length > 0) {
+                  errorMsg += ` (partial matches found: ${partialMatches.join(", ")})`;
+                }
+                preValidationErrors.push(errorMsg);
+                debugLog("Pre-validation failed: search string not found", {
+                  filePath: mod.filePath,
+                  searchPreview,
+                  partialMatches
+                });
+              }
+            }
+          }
+          
+          // If pre-validation failed, add to errors and skip this file
+          if (preValidationErrors.length > 0) {
+            patchErrors.push(`${mod.filePath}: AI generated patches with non-existent code (hallucination detected):\n${preValidationErrors.join("\n")}`);
+            continue;
+          }
+          
           const patchResult = applyPatches(originalContent, mod.patches);
           
           if (!patchResult.success) {
@@ -1015,22 +1095,39 @@ CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
         });
       }
 
-      // If all modifications failed, return error
-      if (patchErrors.length > 0 && modificationsWithOriginals.length === 0) {
-        console.error("All AI patches failed:", patchErrors);
-        return NextResponse.json(
-          {
-            success: false,
-            error: `Patch application failed:\n\n${patchErrors.join("\n\n")}`,
-          } as VisionEditResponse,
-          { status: 400 }
-        );
-      }
+        // If all modifications failed, check if we should retry
+        if (patchErrors.length > 0 && modificationsWithOriginals.length === 0) {
+          if (retryCount < MAX_RETRIES) {
+            console.warn(`[Vision Mode] All patches failed, retrying (attempt ${retryCount + 1}/${MAX_RETRIES + 1})...`);
+            debugLog("Retry triggered due to patch failures", { 
+              retryCount, 
+              errorCount: patchErrors.length,
+              errors: patchErrors.slice(0, 3) // Log first 3 errors
+            });
+            lastPatchErrors = patchErrors;
+            retryCount++;
+            continue; // Retry the LLM call
+          }
+          
+          // Exhausted retries, return error
+          console.error("All AI patches failed after retries:", patchErrors);
+          return NextResponse.json(
+            {
+              success: false,
+              error: `Patch application failed (after ${retryCount} retry attempts):\n\n${patchErrors.join("\n\n")}`,
+            } as VisionEditResponse,
+            { status: 400 }
+          );
+        }
 
-      // Log patch errors as warnings if some modifications succeeded
-      if (patchErrors.length > 0) {
-        console.warn("Some patches failed:", patchErrors);
-      }
+        // Log patch errors as warnings if some modifications succeeded
+        if (patchErrors.length > 0) {
+          console.warn("Some patches failed:", patchErrors);
+        }
+        
+        // Successfully processed at least some modifications - break out of retry loop
+        break;
+      } // End of retry loop
 
       // Aggregate preview CSS
       const aggregatedCSS = modificationsWithOriginals
@@ -1041,9 +1138,9 @@ CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
       return NextResponse.json({
         success: true,
         modifications: modificationsWithOriginals,
-        aggregatedPreviewCSS: aiResponse.aggregatedPreviewCSS || aggregatedCSS,
-        explanation: aiResponse.explanation,
-        reasoning: aiResponse.reasoning,
+        aggregatedPreviewCSS: finalAggregatedCSS || aggregatedCSS,
+        explanation: finalExplanation,
+        reasoning: finalReasoning,
       } as VisionEditResponse);
     }
 
@@ -1657,32 +1754,58 @@ function searchFilesForKeywords(
 // Cache for tsconfig path aliases
 let cachedPathAliases: Map<string, string> | null = null;
 let cachedProjectRoot: string | null = null;
+let cachedTsconfigMtime: number | null = null;
+
+/**
+ * Clean tsconfig.json content to make it valid JSON
+ * tsconfig.json allows comments and trailing commas which JSON.parse doesn't support
+ */
+function cleanTsconfigContent(content: string): string {
+  return content
+    // Remove single-line comments
+    .replace(/\/\/.*$/gm, "")
+    // Remove multi-line comments
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    // Remove trailing commas before } or ]
+    .replace(/,(\s*[}\]])/g, "$1")
+    // Handle potential issues with escaped characters in strings
+    .replace(/\r\n/g, "\n")
+    // Remove any BOM
+    .replace(/^\uFEFF/, "");
+}
 
 /**
  * Read and parse tsconfig.json to get path aliases
  */
 function getPathAliases(projectRoot: string): Map<string, string> {
-  // Return cached if same project
+  const tsconfigPath = path.join(projectRoot, "tsconfig.json");
+  
+  // Check cache validity - also check file modification time
   if (cachedPathAliases && cachedProjectRoot === projectRoot) {
+    try {
+      const stat = fs.statSync(tsconfigPath);
+      if (cachedTsconfigMtime === stat.mtimeMs) {
     return cachedPathAliases;
+      }
+    } catch {
+      // File doesn't exist or can't be read, continue with fresh parse
+    }
   }
 
   const aliases = new Map<string, string>();
+  let parsedSuccessfully = false;
   
   // Try to read tsconfig.json
-  const tsconfigPath = path.join(projectRoot, "tsconfig.json");
   if (fs.existsSync(tsconfigPath)) {
     try {
       const content = fs.readFileSync(tsconfigPath, "utf-8");
-      // Remove comments (tsconfig allows them) and trailing commas (valid in tsconfig but not JSON)
-      const cleanContent = content
-        .replace(/\/\/.*$/gm, "")
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-        .replace(/,\s*([\]}])/g, "$1");
+      const cleanContent = cleanTsconfigContent(content);
+      
+      // Try to parse the cleaned content
       const tsconfig = JSON.parse(cleanContent);
+      parsedSuccessfully = true;
       
       const paths = tsconfig.compilerOptions?.paths || {};
-      const baseUrl = tsconfig.compilerOptions?.baseUrl || ".";
       
       // Parse path mappings
       for (const [alias, targets] of Object.entries(paths)) {
@@ -1695,8 +1818,30 @@ function getPathAliases(projectRoot: string): Map<string, string> {
       }
       
       debugLog("[edit] Loaded tsconfig path aliases", { aliases: Object.fromEntries(aliases) });
+      
+      // Update cache with mtime
+      try {
+        const stat = fs.statSync(tsconfigPath);
+        cachedTsconfigMtime = stat.mtimeMs;
+      } catch {
+        cachedTsconfigMtime = null;
+      }
     } catch (e) {
-      debugLog("[edit] Failed to parse tsconfig.json", { error: String(e) });
+      // Log the error with more context for debugging
+      const errorStr = String(e);
+      const posMatch = errorStr.match(/position (\d+)/);
+      let context = "";
+      if (posMatch) {
+        const pos = parseInt(posMatch[1], 10);
+        const content = fs.readFileSync(tsconfigPath, "utf-8");
+        context = `Near: "${content.substring(Math.max(0, pos - 20), pos + 20)}"`;
+      }
+      debugLog("[edit] Failed to parse tsconfig.json", { error: errorStr, context });
+      
+      // Clear cache on error so we retry next time
+      cachedPathAliases = null;
+      cachedProjectRoot = null;
+      cachedTsconfigMtime = null;
     }
   }
   
@@ -1714,8 +1859,12 @@ function getPathAliases(projectRoot: string): Map<string, string> {
     debugLog("[edit] Using default @/ alias", { alias: aliases.get("@/") });
   }
   
+  // Only cache if we parsed successfully or there's no tsconfig
+  if (parsedSuccessfully || !fs.existsSync(tsconfigPath)) {
   cachedPathAliases = aliases;
   cachedProjectRoot = projectRoot;
+  }
+  
   return aliases;
 }
 
@@ -1835,6 +1984,105 @@ interface ApplyPatchesResult {
   failedPatches: { patch: Patch; error: string }[];
 }
 
+/**
+ * Normalize whitespace in a string for comparison
+ * Collapses all whitespace runs to single spaces and trims
+ */
+function normalizeWhitespace(str: string): string {
+  return str.replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Find a fuzzy match for the search string in content
+ * Returns the actual matched substring from content, or null if not found
+ */
+function findFuzzyMatch(search: string, content: string): { start: number; end: number; matched: string } | null {
+  // Strategy 1: Try line-by-line matching with flexible indentation
+  const searchLines = search.split("\n").map(l => l.trim()).filter(l => l.length > 0);
+  if (searchLines.length === 0) return null;
+  
+  // Find the first non-empty line in content
+  const contentLines = content.split("\n");
+  const firstSearchLine = searchLines[0];
+  
+  for (let i = 0; i < contentLines.length; i++) {
+    const contentLineTrimmed = contentLines[i].trim();
+    
+    // Check if this line matches the first search line
+    if (contentLineTrimmed === firstSearchLine) {
+      // Try to match all subsequent lines
+      let matched = true;
+      let searchLineIdx = 1;
+      let contentLineIdx = i + 1;
+      
+      while (searchLineIdx < searchLines.length && contentLineIdx < contentLines.length) {
+        const searchLineTrimmed = searchLines[searchLineIdx];
+        const contentLineTrimmedNext = contentLines[contentLineIdx].trim();
+        
+        // Skip empty lines in content
+        if (contentLineTrimmedNext === "" && searchLineTrimmed !== "") {
+          contentLineIdx++;
+          continue;
+        }
+        
+        if (contentLineTrimmedNext !== searchLineTrimmed) {
+          matched = false;
+          break;
+        }
+        
+        searchLineIdx++;
+        contentLineIdx++;
+      }
+      
+      if (matched && searchLineIdx === searchLines.length) {
+        // Found a match! Calculate the actual positions
+        let start = 0;
+        for (let j = 0; j < i; j++) {
+          start += contentLines[j].length + 1; // +1 for newline
+        }
+        
+        let end = start;
+        for (let j = i; j < contentLineIdx; j++) {
+          end += contentLines[j].length + (j < contentLineIdx - 1 ? 1 : 0);
+        }
+        
+        // Include trailing newline if the search had one
+        if (search.endsWith("\n") && end < content.length && content[end] === "\n") {
+          end++;
+        }
+        
+        return {
+          start,
+          end,
+          matched: content.substring(start, end)
+        };
+      }
+    }
+  }
+  
+  // Strategy 2: Normalized whitespace comparison
+  const normalizedSearch = normalizeWhitespace(search);
+  
+  // Sliding window approach - find a substring that when normalized matches
+  for (let windowStart = 0; windowStart < content.length; windowStart++) {
+    // Find a reasonable end point (look for similar length with some tolerance)
+    for (let windowEnd = windowStart + search.length - 20; windowEnd <= Math.min(content.length, windowStart + search.length + 50); windowEnd++) {
+      if (windowEnd <= windowStart) continue;
+      
+      const candidate = content.substring(windowStart, windowEnd);
+      if (normalizeWhitespace(candidate) === normalizedSearch) {
+        return {
+          start: windowStart,
+          end: windowEnd,
+          matched: candidate
+        };
+      }
+    }
+  }
+  
+  return null;
+}
+
 /**
  * Apply search/replace patches to file content
  * This is the core of the patch-based editing system
@@ -1849,33 +2097,70 @@ function applyPatches(originalContent: string, patches: Patch[]): ApplyPatchesRe
     const normalizedSearch = patch.search.replace(/\\n/g, "\n");
     const normalizedReplace = patch.replace.replace(/\\n/g, "\n");
 
-    // Check if search string exists in content
-    if (!content.includes(normalizedSearch)) {
-      // Try with different whitespace normalization
-      const flexibleSearch = normalizedSearch.replace(/\s+/g, "\\s+");
-      const regex = new RegExp(flexibleSearch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\s\+/g, "\\s+"));
-      
-      if (!regex.test(content)) {
-        failedPatches.push({
-          patch,
-          error: `Search string not found in file. First 50 chars of search: "${normalizedSearch.substring(0, 50)}..."`,
-        });
-        continue;
-      }
-      
-      // If regex matched, use regex replace
-      content = content.replace(regex, normalizedReplace);
-      appliedPatches++;
-    } else {
-      // Exact match found - apply the replacement
-      // Only replace the first occurrence to be safe
+    // Strategy 1: Exact match
+    if (content.includes(normalizedSearch)) {
       const index = content.indexOf(normalizedSearch);
       content = 
         content.substring(0, index) + 
         normalizedReplace + 
         content.substring(index + normalizedSearch.length);
       appliedPatches++;
+      debugLog("Patch applied (exact match)", { 
+        searchPreview: normalizedSearch.substring(0, 50) 
+      });
+      continue;
     }
+
+    // Strategy 2: Fuzzy match (handles indentation differences)
+    const fuzzyMatch = findFuzzyMatch(normalizedSearch, content);
+    if (fuzzyMatch) {
+      // Apply the replacement, preserving the indentation from the original
+      const originalIndent = fuzzyMatch.matched.match(/^(\s*)/)?.[1] || "";
+      const replaceIndent = normalizedReplace.match(/^(\s*)/)?.[1] || "";
+      
+      // If indentation differs, adjust the replacement to match original
+      let adjustedReplace = normalizedReplace;
+      if (originalIndent !== replaceIndent) {
+        // Get the indentation difference
+        const originalLines = fuzzyMatch.matched.split("\n");
+        const replaceLines = normalizedReplace.split("\n");
+        
+        if (originalLines.length > 0 && replaceLines.length > 0) {
+          const baseIndent = originalLines[0].match(/^(\s*)/)?.[1] || "";
+          const searchBaseIndent = normalizedSearch.split("\n")[0].match(/^(\s*)/)?.[1] || "";
+          
+          // Adjust each line's indentation
+          adjustedReplace = replaceLines.map((line, idx) => {
+            if (idx === 0 || line.trim() === "") return line;
+            const lineIndent = line.match(/^(\s*)/)?.[1] || "";
+            const relativeIndent = lineIndent.length - (searchBaseIndent?.length || 0);
+            const newIndent = baseIndent + " ".repeat(Math.max(0, relativeIndent));
+            return newIndent + line.trim();
+          }).join("\n");
+        }
+      }
+      
+      content = 
+        content.substring(0, fuzzyMatch.start) + 
+        adjustedReplace + 
+        content.substring(fuzzyMatch.end);
+      appliedPatches++;
+      debugLog("Patch applied (fuzzy match)", { 
+        searchPreview: normalizedSearch.substring(0, 50),
+        matchedPreview: fuzzyMatch.matched.substring(0, 50)
+      });
+      continue;
+    }
+
+    // No match found
+    failedPatches.push({
+      patch,
+      error: `Search string not found in file. First 50 chars of search: "${normalizedSearch.substring(0, 50)}..."`,
+    });
+    debugLog("Patch failed - no match found", {
+      searchPreview: normalizedSearch.substring(0, 100),
+      searchLength: normalizedSearch.length
+    });
   }
 
   return {