sonance-brand-mcp 1.3.59 → 1.3.61

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

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import * as path from "path";
 import Anthropic from "@anthropic-ai/sdk";
 import { randomUUID } from "crypto";
-import { discoverTheme, formatThemeForPrompt } from "./theme-discovery";
+import { discoverTheme } from "./theme-discovery";
 
 /**
  * Sonance DevTools API - Apply-First Vision Mode
@@ -511,48 +511,21 @@ function searchFilesSmart(
   return sortedResults.map(r => ({ path: r.path, content: r.content, score: r.score }));
 }
 
-const VISION_SYSTEM_PROMPT = `You are a code editor. Make ONLY the change the user requested.
+const VISION_SYSTEM_PROMPT = `You edit code. Make ONLY the change requested.
 
 RULES:
-1. Make the SMALLEST possible change to accomplish the request
-2. Do NOT refactor, rebrand, or "improve" anything else
-3. Do NOT change import statements unless explicitly required
-4. Do NOT change component libraries (e.g., heroui to shadcn)
-5. If fixing a color/visibility issue, change ONLY that element's classes
-6. Your patch should typically be 1-5 lines, not 50+
-7. NEVER invent or guess code - your "search" string MUST match the file EXACTLY
-8. NEVER change data mappings (icon names, keys, enum values) unless user explicitly provides the new values
-9. If you don't know what values exist in a database or data source, DO NOT guess - ask for clarification
-
-CRITICAL - ELEMENT VERIFICATION:
-- When a focused element is mentioned, SEARCH the provided file content for that EXACT element
-- Look for the actual JSX/HTML code: <button, <Button, <div, className, onClick, etc.
-- If you cannot find the element in the TARGET COMPONENT section, it may be in a child component
-- NEVER guess what element code looks like - find it in the file or report "element not found"
-- If the element is not in the provided file, return: {"modifications": [], "explanation": "The focused element appears to be in a child component, not in [filename]"}
-
-CRITICAL - DATA INTEGRITY:
-- If code references database values (like icon_name, type, status), DO NOT change the mapping keys
-- You cannot see database content - only change STRUCTURE, not DATA MAPPINGS
-- Example: If you see iconMap["EyeOff"] = SomeIcon, do NOT change "EyeOff" to something else
-- If user wants different icons, they must tell you the EXACT icon names they want
-
-PATCH FORMAT:
-Return ONLY raw JSON (no markdown, no preamble):
+1. Copy code EXACTLY from the file - character for character
+2. Make the SMALLEST possible change
+3. For color changes, just change the className
+4. Do not restructure or reorganize code
+
+Return JSON:
 {
-  "reasoning": "brief explanation",
   "modifications": [{
-    "filePath": "path/to/file.tsx",
-    "patches": [{
-      "search": "exact original code (copy from provided file)",
-      "replace": "minimal change",
-      "explanation": "what this does"
-    }]
-  }],
-  "explanation": "summary"
-}
-
-If you cannot find the exact code to modify, OR if you would need to guess data values, return empty modifications array with explanation.`;
+    "filePath": "path",
+    "patches": [{ "search": "exact code from file", "replace": "changed code" }]
+  }]
+}`;
 
 export async function POST(request: Request) {
   // Only allow in development
@@ -809,143 +782,93 @@ ${focusedElements.map((el) => `- ${el.name} (${el.type}) at (${el.coordinates.x}
 `;
       }
 
-      // ========== TARGET COMPONENT (RECOMMENDED FILE) - SHOWN FIRST ==========
+      // ========== TARGET COMPONENT ONLY (with line numbers) ==========
+      // CRITICAL: Only include the TARGET file to avoid overwhelming the LLM with noise
       if (recommendedFileContent) {
-        // Never truncate the recommended file - AI needs full context to avoid hallucination
         const content = recommendedFileContent.content;
         
+        // Add line numbers to make it easy for LLM to reference exact code
+        const linesWithNumbers = content.split('\n').map((line, i) => 
+          `${String(i + 1).padStart(4, ' ')}| ${line}`
+        ).join('\n');
+        
         textContent += `═══════════════════════════════════════════════════════════════════════════════
-⚡ TARGET COMPONENT - YOU MUST EDIT THIS FILE
+FILE TO EDIT: ${recommendedFileContent.path}
 ═══════════════════════════════════════════════════════════════════════════════
 
-This is the component that renders the UI you see in the screenshot.
-File: ${recommendedFileContent.path}
+IMPORTANT: Copy code EXACTLY as shown below (including line numbers for reference).
+Your "search" string must match the code CHARACTER FOR CHARACTER.
 
 \`\`\`tsx
-${content}
+${linesWithNumbers}
 \`\`\`
 
 `;
         usedContext += content.length;
-        debugLog("Added TARGET COMPONENT to context", { 
+        debugLog("Added TARGET COMPONENT with line numbers", { 
           path: recommendedFileContent.path, 
-          originalSize: recommendedFileContent.content.length,
-          includedSize: content.length 
+          lines: content.split('\n').length,
+          size: content.length 
         });
-      }
-
-      // ========== PAGE CONTEXT (wrapper - de-emphasized) ==========
-      const pageContentTruncated = pageContext.pageContent.substring(0, MAX_PAGE_FILE);
-      const pageWasTruncated = pageContext.pageContent.length > MAX_PAGE_FILE;
-      
-      textContent += `PAGE CONTEXT (wrapper only${recommendedFileContent ? " - DO NOT edit this, edit the TARGET COMPONENT above" : ""}):
-
-Page File: ${pageContext.pageFile || "Not found"}
-${pageContext.pageContent ? `\`\`\`tsx\n${pageContentTruncated}${pageWasTruncated ? "\n// ... (wrapper truncated)" : ""}\n\`\`\`` : ""}
-
-`;
-      usedContext += pageContentTruncated.length;
-
-      // ========== SUPPORTING COMPONENTS (dynamic budget) ==========
-      if (pageContext.componentSources.length > 0) {
-        const remainingBudget = TOTAL_CONTEXT_BUDGET - usedContext - MAX_GLOBALS_CSS - 5000; // Reserve 5k for instructions
-        const filesToInclude = pageContext.componentSources.slice(0, MAX_FILES);
-        const perFileLimit = Math.max(1000, Math.floor(remainingBudget / Math.max(filesToInclude.length, 1)));
-        
-        textContent += `SUPPORTING COMPONENTS (${filesToInclude.length} files, ~${Math.round(perFileLimit/1000)}k chars each):\n`;
+      } else if (pageContext.pageContent) {
+        // Fallback: use page file if no recommended file
+        const content = pageContext.pageContent;
+        const linesWithNumbers = content.split('\n').map((line, i) => 
+          `${String(i + 1).padStart(4, ' ')}| ${line}`
+        ).join('\n');
         
-        for (const comp of filesToInclude) {
-          if (usedContext > TOTAL_CONTEXT_BUDGET - 10000) {
-            textContent += `\n// ... (remaining files omitted to stay within context limits)\n`;
-            break;
-          }
-          
-          const truncatedContent = comp.content.substring(0, perFileLimit);
-          const wasTruncated = comp.content.length > perFileLimit;
-          
-          textContent += `
-File: ${comp.path}
+        textContent += `═══════════════════════════════════════════════════════════════════════════════
+FILE TO EDIT: ${pageContext.pageFile}
+═══════════════════════════════════════════════════════════════════════════════
+
 \`\`\`tsx
-${truncatedContent}${wasTruncated ? "\n// ... (truncated)" : ""}
+${linesWithNumbers}
 \`\`\`
+
 `;
-          usedContext += truncatedContent.length;
-        }
+        usedContext += content.length;
       }
+      
+      // NOTE: We intentionally skip SUPPORTING COMPONENTS to reduce noise
+      // The LLM only needs the TARGET file to make accurate edits
 
       // ========== THEME DISCOVERY (REFERENCE ONLY) ==========
-      // Dynamically discover theme tokens from the target codebase
-      // This is marked as REFERENCE ONLY so the LLM doesn't use it to justify extra changes
+      // Dynamically discover theme tokens (minimal - just for logging)
       const discoveredTheme = await discoverTheme(projectRoot);
-      const themeContext = formatThemeForPrompt(discoveredTheme);
       
       if (discoveredTheme.discoveredFiles.length > 0) {
-        textContent += `
-═══════════════════════════════════════════════════════════════════════════════
-REFERENCE ONLY (do not use this to justify additional changes)
-═══════════════════════════════════════════════════════════════════════════════
-
-If you need to pick a color for a VISIBILITY fix, these are safe choices:
-- bg-accent text-white (cyan button with white text)
-- bg-primary text-white (charcoal button with white text)
-- bg-success text-white (green button with white text)
-- bg-destructive text-white (red button with white text)
-
-But ONLY use these if the user is asking for a color/visibility change.
-Do NOT rebrand or change other elements to match.
-
-`;
         debugLog("Theme discovery complete", {
           filesFound: discoveredTheme.discoveredFiles,
-          cssVariableCount: Object.keys(discoveredTheme.cssVariables).length,
-          tailwindColorCount: Object.keys(discoveredTheme.tailwindColors).length,
         });
       }
 
-      // ========== GLOBALS CSS ==========
-      const globalsTruncated = pageContext.globalsCSS.substring(0, MAX_GLOBALS_CSS);
-      textContent += `
-GLOBALS.CSS (theme variables):
-\`\`\`css
-${globalsTruncated}${pageContext.globalsCSS.length > MAX_GLOBALS_CSS ? "\n/* ... (truncated) */" : ""}
-\`\`\`
-
-`;
-
-      // ========== VALID FILES LIST ==========
-      const validFilesList: string[] = [];
-      const recommendedPath = recommendedFile?.path;
-      
-      // Add recommended file first with marker
-      if (recommendedPath) {
-        validFilesList.push(`- ${recommendedPath} (*** TARGET - EDIT THIS FILE ***)`);
-      }
+      // ========== SIMPLIFIED INSTRUCTIONS ==========
+      const targetPath = recommendedFileContent?.path || pageContext.pageFile || "unknown";
       
-      // Add page file (if not the recommended file)
-      if (pageContext.pageFile && pageContext.pageFile !== recommendedPath) {
-        validFilesList.push(`- ${pageContext.pageFile} (wrapper only)`);
-      }
-      
-      // Add other component sources (excluding recommended file)
-      for (const comp of pageContext.componentSources) {
-        if (comp.path !== recommendedPath) {
-          validFilesList.push(`- ${comp.path}`);
-        }
-      }
+      textContent += `═══════════════════════════════════════════════════════════════════════════════
+HOW TO MAKE YOUR EDIT
+═══════════════════════════════════════════════════════════════════════════════
+
+1. Find the EXACT code in the file above that needs to change
+2. COPY that code CHARACTER FOR CHARACTER (use the line numbers as reference)
+3. Make your change to the copied code
+4. Return a patch with the exact "search" and "replace" strings
 
-      textContent += `VALID FILES YOU MAY EDIT:
-${validFilesList.join("\n")}
+EXAMPLE - If line 84 shows:
+   84| <div className="mb-10 md:mb-16 grid grid-cols-2">
 
-INSTRUCTIONS:
-1. Look at the screenshot and identify elements mentioned in the user's request
-2. The TARGET COMPONENT shown first contains the UI - EDIT THAT FILE
-3. Make SURGICAL EDITS - change only the specific lines needed
-4. PRESERVE all existing logic, hooks, API calls, and error handling
-5. Return patches in the specified format (search/replace)
-6. Only use file paths from the VALID FILES list above
-7. DO NOT edit the page wrapper unless the TARGET COMPONENT is unavailable
+Your patch should be:
+{
+  "modifications": [{
+    "filePath": "${targetPath}",
+    "patches": [{
+      "search": "<div className=\\"mb-10 md:mb-16 grid grid-cols-2\\">",
+      "replace": "<div className=\\"mb-10 md:mb-16 grid grid-cols-2 bg-accent\\">"
+    }]
+  }]
+}
 
-CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
+CRITICAL: Your "search" string MUST exist in the file. If you can't find the exact code, return empty modifications.`;
 
       messageContent.push({
         type: "text",
@@ -975,7 +898,6 @@ CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
       let lastPatchErrors: string[] = [];
       let modifications: VisionFileModification[] = [];
       let finalExplanation: string | undefined;
-      let finalReasoning: string | undefined;
       
       while (retryCount <= MAX_RETRIES) {
         // Build messages for this attempt
@@ -1025,93 +947,88 @@ This is better than generating patches with made-up code.`,
           });
         }
 
-        const response = await anthropic.messages.create({
-          model: "claude-sonnet-4-20250514",
-          max_tokens: 16384,
+      const response = await anthropic.messages.create({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 16384,
           messages: currentMessages,
-          system: VISION_SYSTEM_PROMPT,
-        });
+        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 }
-          );
-        }
+      // 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 }
+        );
+      }
 
-        // 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;
-          }>;
+        // Parse AI response - expecting modifications array
+      let aiResponse: {
+        modifications: Array<{
+          filePath: string;
+          patches?: Patch[];
           explanation?: string;
-        };
-
-        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```/);
+        }>;
+        explanation?: string;
+      };
 
-          if (jsonMatch) {
-            jsonText = jsonMatch[1];
-          } else if (jsonText.includes("```json")) {
-            const start = jsonText.indexOf("```json") + 7;
-            const end = jsonText.lastIndexOf("```");
-            if (end > start) {
-              jsonText = jsonText.substring(start, end);
-            }
+      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")) {
+          const start = jsonText.indexOf("```json") + 7;
+          const end = jsonText.lastIndexOf("```");
+          if (end > start) {
+            jsonText = jsonText.substring(start, end);
           }
+        }
 
-          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 }
-          );
+        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;
-
-        if (!aiResponse.modifications || aiResponse.modifications.length === 0) {
-          return NextResponse.json({
-            success: true,
-            sessionId: newSessionId,
-            modifications: [],
-            explanation: aiResponse.explanation || "No changes needed.",
-            reasoning: aiResponse.reasoning,
+
+      if (!aiResponse.modifications || aiResponse.modifications.length === 0) {
+        return NextResponse.json({
+          success: true,
+          sessionId: newSessionId,
+          modifications: [],
+          explanation: aiResponse.explanation || "No changes needed.",
           });
         }
       
-        debugLog("VALIDATION: Valid file paths from page context", { 
-          pageFile: pageContext.pageFile,
-          validFilePaths: Array.from(validFilePaths),
-          aiRequestedFiles: aiResponse.modifications.map(m => m.filePath)
-        });
+      debugLog("VALIDATION: Valid file paths from page context", { 
+        pageFile: pageContext.pageFile,
+        validFilePaths: Array.from(validFilePaths),
+        aiRequestedFiles: aiResponse.modifications.map(m => m.filePath)
+      });
       
-        // Process modifications - apply patches to get modified content
+      // Process modifications - apply patches to get modified content
         modifications = [];
-        const patchErrors: string[] = [];
+      const patchErrors: string[] = [];
       
       for (const mod of aiResponse.modifications) {
         // Validate that the file path is in the page context
@@ -1131,6 +1048,19 @@ This is better than generating patches with made-up code.`,
           continue;
         }
         
+        // CRITICAL: Warn if LLM is trying to modify a file OTHER than the TARGET COMPONENT
+        // This usually means the LLM is trying to modify a file it doesn't have full visibility into
+        const targetComponentPath = recommendedFileContent?.path;
+        if (targetComponentPath && mod.filePath !== targetComponentPath) {
+          debugLog("WARNING: LLM trying to modify non-target file", {
+            targetComponent: targetComponentPath,
+            attemptedFile: mod.filePath,
+            warning: "LLM may be hallucinating code since it only has full content of the TARGET COMPONENT"
+          });
+          console.warn(`[Apply-First] ⚠️ LLM is modifying ${mod.filePath} but TARGET COMPONENT is ${targetComponentPath}`);
+          console.warn(`[Apply-First] ⚠️ This may cause hallucination since LLM only has full visibility into the TARGET COMPONENT`);
+        }
+        
         const fullPath = path.join(projectRoot, mod.filePath);
         let originalContent = "";
         if (fs.existsSync(fullPath)) {
@@ -1206,20 +1136,37 @@ This is better than generating patches with made-up code.`,
             modifiedContent = patchResult.modifiedContent;
             console.log(`[Apply-First] All ${mod.patches.length} patches applied successfully to ${mod.filePath}`);
           }
-        } else if (mod.modifiedContent) {
-          // Legacy: AI returned full file content
-          console.warn(`[Apply-First] Legacy modifiedContent received for ${mod.filePath} - patch-based format preferred`);
-          modifiedContent = mod.modifiedContent;
           
-          // Validate the modification using legacy validation
-          const validation = validateModification(originalContent, modifiedContent, mod.filePath);
-          if (!validation.valid) {
-            patchErrors.push(`${mod.filePath}: ${validation.error}`);
+          // SYNTAX VALIDATION: Check for common JSX/HTML tag mismatches
+          // This catches cases where the LLM changes opening tags but not closing tags
+          if (mod.filePath.endsWith('.tsx') || mod.filePath.endsWith('.jsx')) {
+            const openDivs = (modifiedContent.match(/<div[\s>]/g) || []).length;
+            const closeDivs = (modifiedContent.match(/<\/div>/g) || []).length;
+            const openSpans = (modifiedContent.match(/<span[\s>]/g) || []).length;
+            const closeSpans = (modifiedContent.match(/<\/span>/g) || []).length;
+            
+            if (openDivs !== closeDivs || openSpans !== closeSpans) {
+              debugLog("SYNTAX WARNING: Tag mismatch detected", {
+                filePath: mod.filePath,
+                divs: { open: openDivs, close: closeDivs },
+                spans: { open: openSpans, close: closeSpans },
+              });
+              console.warn(`[Apply-First] ⚠️ SYNTAX WARNING: Tag mismatch in ${mod.filePath}`);
+              console.warn(`[Apply-First]   divs: ${openDivs} open, ${closeDivs} close`);
+              console.warn(`[Apply-First]   spans: ${openSpans} open, ${closeSpans} close`);
+              
+              // If there's a significant mismatch, reject the change
+              const divDiff = Math.abs(openDivs - closeDivs);
+              const spanDiff = Math.abs(openSpans - closeSpans);
+              if (divDiff > 0 || spanDiff > 0) {
+                patchErrors.push(`${mod.filePath}: LLM introduced syntax error - tag mismatch detected (${divDiff} div, ${spanDiff} span). Change rejected.`);
             continue;
+              }
+            }
           }
         } else {
-          // No patches and no modifiedContent - skip
-          console.warn(`[Apply-First] No patches or modifiedContent for ${mod.filePath}`);
+          // No patches - skip
+          console.warn(`[Apply-First] No patches for ${mod.filePath}`);
           continue;
         }
 
@@ -1233,7 +1180,7 @@ This is better than generating patches with made-up code.`,
       }
 
         // If all modifications failed, check if we should retry
-        if (patchErrors.length > 0 && modifications.length === 0) {
+      if (patchErrors.length > 0 && modifications.length === 0) {
           if (retryCount < MAX_RETRIES) {
             console.warn(`[Apply-First] All patches failed, retrying (attempt ${retryCount + 1}/${MAX_RETRIES + 1})...`);
             debugLog("Retry triggered due to patch failures", { 
@@ -1248,20 +1195,20 @@ This is better than generating patches with made-up code.`,
           
           // Exhausted retries, return error
           console.error("All AI patches failed after retries:", patchErrors);
-          return NextResponse.json(
-            {
-              success: false,
+        return NextResponse.json(
+          {
+            success: false,
               error: `Patch application failed (after ${retryCount} retry attempts):\n\n${patchErrors.join("\n\n")}`,
-            },
-            { status: 400 }
-          );
-        }
+          },
+          { 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
@@ -1278,7 +1225,6 @@ This is better than generating patches with made-up code.`,
           preview: true,
           modifications,
           explanation: finalExplanation,
-          reasoning: finalReasoning,
         });
       }
 
@@ -1302,7 +1248,6 @@ This is better than generating patches with made-up code.`,
         modifications,
         backupPaths: applyResult.backupPaths,
         explanation: finalExplanation,
-        reasoning: finalReasoning,
       });
     }
 
@@ -2114,13 +2059,13 @@ function getPathAliases(projectRoot: string): Map<string, string> {
       
       // Only log parse error once to avoid log spam
       if (!cachedParseError) {
-        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)}"`;
-        }
+      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("[apply] Failed to parse tsconfig.json (will use defaults, logging once)", { error: errorStr, context });
         cachedParseError = errorStr;
       }
@@ -2143,14 +2088,14 @@ function getPathAliases(projectRoot: string): Map<string, string> {
     }
     // Only log default alias once (not when using cached error fallback)
     if (!cachedParseError) {
-      debugLog("[apply] Using default @/ alias", { alias: aliases.get("@/") });
+    debugLog("[apply] Using default @/ alias", { alias: aliases.get("@/") });
     }
   }
   
   // Cache aliases if parsed successfully, no tsconfig exists, OR we have a parse error (cache fallback)
   if (parsedSuccessfully || !fs.existsSync(tsconfigPath) || cachedParseError) {
-    cachedPathAliases = aliases;
-    cachedProjectRoot = projectRoot;
+  cachedPathAliases = aliases;
+  cachedProjectRoot = projectRoot;
   }
   
   return aliases;
@@ -2452,105 +2397,3 @@ function applyPatches(originalContent: string, patches: Patch[]): ApplyPatchesRe
     failedPatches,
   };
 }
-
-/**
- * Validate that AI modifications are surgical edits, not complete rewrites
- */
-interface ValidationResult {
-  valid: boolean;
-  error?: string;
-  warnings: string[];
-}
-
-function validateModification(
-  originalContent: string,
-  modifiedContent: string,
-  filePath: string
-): ValidationResult {
-  const warnings: string[] = [];
-  
-  // Skip validation for new files (no original content)
-  if (!originalContent || originalContent.trim() === "") {
-    return { valid: true, warnings: ["New file - no original to compare"] };
-  }
-
-  const originalLines = originalContent.split("\n");
-  const modifiedLines = modifiedContent.split("\n");
-  
-  // Check 1: Truncation detection - look for placeholder comments
-  const truncationPatterns = [
-    /\/\/\s*\.\.\.\s*existing/i,
-    /\/\/\s*\.\.\.\s*rest\s*of/i,
-    /\/\/\s*\.\.\.\s*more\s*code/i,
-    /\/\*\s*\.\.\.\s*\*\//,
-    /\/\/\s*\.\.\./,
-  ];
-  
-  for (const pattern of truncationPatterns) {
-    if (pattern.test(modifiedContent)) {
-      return {
-        valid: false,
-        error: `File ${filePath} contains truncation placeholder (e.g., "// ... existing code"). The AI must return the complete file content. Please try again.`,
-        warnings,
-      };
-    }
-  }
-  
-  // Check 2: Line count shrinkage - reject if file shrinks by more than 30%
-  const lineDelta = modifiedLines.length - originalLines.length;
-  const shrinkagePercent = (lineDelta / originalLines.length) * 100;
-  
-  if (shrinkagePercent < -30) {
-    return {
-      valid: false,
-      error: `File ${filePath} shrank from ${originalLines.length} to ${modifiedLines.length} lines (${Math.abs(shrinkagePercent).toFixed(0)}% reduction). This suggests the AI rewrote the file instead of making surgical edits. Please try a more specific request.`,
-      warnings,
-    };
-  }
-  
-  if (shrinkagePercent < -15) {
-    warnings.push(`File shrank by ${Math.abs(shrinkagePercent).toFixed(0)}% - review carefully`);
-  }
-  
-  // Check 3: Change percentage - warn if too many lines are different
-  let changedLines = 0;
-  const minLines = Math.min(originalLines.length, modifiedLines.length);
-  
-  for (let i = 0; i < minLines; i++) {
-    if (originalLines[i] !== modifiedLines[i]) {
-      changedLines++;
-    }
-  }
-  
-  // Add lines that were added or removed
-  changedLines += Math.abs(originalLines.length - modifiedLines.length);
-  
-  const changePercent = (changedLines / originalLines.length) * 100;
-  
-  if (changePercent > 50) {
-    return {
-      valid: false,
-      error: `File ${filePath} has ${changePercent.toFixed(0)}% of lines changed. This suggests the AI rewrote the file instead of making surgical edits. For safety, this change has been rejected. Please try a more specific request.`,
-      warnings,
-    };
-  }
-  
-  if (changePercent > 30) {
-    warnings.push(`${changePercent.toFixed(0)}% of lines changed - larger than expected for a surgical edit`);
-  }
-  
-  // Check 4: Import preservation - ensure imports aren't removed
-  const importRegex = /^import\s+/gm;
-  const originalImports = (originalContent.match(importRegex) || []).length;
-  const modifiedImports = (modifiedContent.match(importRegex) || []).length;
-  
-  if (modifiedImports < originalImports * 0.5 && originalImports > 2) {
-    return {
-      valid: false,
-      error: `File ${filePath} went from ${originalImports} imports to ${modifiedImports}. Imports should not be removed. Please try again.`,
-      warnings,
-    };
-  }
-  
-  return { valid: true, warnings };
-}