sonance-brand-mcp 1.3.60 → 1.3.61

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

@@ -2,7 +2,7 @@ import { NextResponse } from "next/server";
 import * as fs from "fs";
 import * as path from "path";
 import Anthropic from "@anthropic-ai/sdk";
-import { discoverTheme, formatThemeForPrompt } from "../sonance-vision-apply/theme-discovery";
+import { discoverTheme } from "../sonance-vision-apply/theme-discovery";
 
 /**
  * Sonance DevTools API - Vision Mode Editor
@@ -507,82 +507,20 @@ function searchFilesSmart(
   return sortedResults.map(r => ({ path: r.path, content: r.content, score: r.score }));
 }
 
-const VISION_SYSTEM_PROMPT = `You are a code editor like Cursor. Before making changes, REASON about what needs to be done.
-
-═══════════════════════════════════════════════════════════════════════════════
-STEP 1: ANALYZE (Think like Cursor)
-═══════════════════════════════════════════════════════════════════════════════
-
-Before writing any patches, analyze the screenshot and answer:
-
-1. CURRENT STATE: What do I see in the screenshot? 
-   - Is the element visible/readable right now?
-   - What colors/styles are currently applied?
-
-2. PROBLEM IDENTIFICATION: What's actually wrong?
-   - Contrast issue? (text blending with background)
-   - Hidden element? (not showing at all)
-   - Hover state issue? (only visible on interaction)
-   - Layout issue? (wrong size/position)
-   - Or is it already correct?
-
-3. FIX STRATEGY: What should I change?
-   - DEFAULT state only (element needs to look different normally)
-   - HOVER state only (element needs different hover effect)
-   - BOTH states (element needs overall visibility improvement)
-   - ASK for clarification (request is too vague)
-
-═══════════════════════════════════════════════════════════════════════════════
-STEP 2: GENERATE PATCHES (Only after reasoning)
-═══════════════════════════════════════════════════════════════════════════════
-
-CRITICAL - FILE SELECTION:
-- You MUST modify the file marked "TARGET COMPONENT" - this is the file you have FULL visibility into
-- Do NOT try to modify other files listed in context - you only see their imports/exports, not full content
-- If the TARGET COMPONENT is not the right file, return clarification_needed
-
-COPY EXACTLY from the TARGET COMPONENT section:
-- Your "search" string must match the file CHARACTER-FOR-CHARACTER
-- Include exact indentation and at least 3 lines of context
-- If the element looks FINE in the screenshot, say so
+const VISION_SYSTEM_PROMPT = `You edit code. Make ONLY the change requested.
 
 RULES:
-1. Make the SMALLEST possible change
-2. Do NOT refactor or "improve" other code
-3. NEVER invent code - COPY exact code from file
-4. NEVER change data mappings unless user provides new values
-5. If visibility issue: prefer explicit colors (text-white, text-black) over semantic tokens
+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
 
-═══════════════════════════════════════════════════════════════════════════════
-RESPONSE FORMAT
-═══════════════════════════════════════════════════════════════════════════════
-
-Return ONLY raw JSON:
+Return JSON:
 {
-  "analysis": {
-    "currentState": "what I see in the screenshot",
-    "problem": "the actual issue (or 'none - element appears correct')",
-    "fixStrategy": "default|hover|both|clarification_needed"
-  },
-  "reasoning": "my diagnosis and approach",
   "modifications": [{
-    "filePath": "path/to/file.tsx",
-    "patches": [{
-      "search": "EXACT copy from file",
-      "replace": "changed code",
-      "explanation": "what this changes and why"
-    }],
-    "previewCSS": "optional CSS for live preview"
-  }],
-  "aggregatedPreviewCSS": "combined CSS for all changes",
-  "explanation": "summary of what was changed"
-}
-
-If the element looks correct, return:
-{
-  "analysis": { "currentState": "...", "problem": "none", "fixStrategy": "clarification_needed" },
-  "modifications": [],
-  "explanation": "The element appears visible/correct in the screenshot. Please specify what needs to change."
+    "filePath": "path",
+    "patches": [{ "search": "exact code from file", "replace": "changed code" }]
+  }]
 }`;
 
 export async function POST(request: Request) {
@@ -813,172 +751,92 @@ ${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
+      // Dynamically discover theme tokens (minimal - just for logging)
       const discoveredTheme = await discoverTheme(projectRoot);
-      const themeContext = formatThemeForPrompt(discoveredTheme);
-      
-      // Check if this is a visibility-related request
-      const isVisibilityRequest = /visible|can't see|cant see|not visible|hidden|color|contrast/i.test(userPrompt);
       
       if (discoveredTheme.discoveredFiles.length > 0) {
-        // Only include detailed color guidance for visibility requests
-        if (isVisibilityRequest) {
-          // Extract available text color classes from discovered theme
-          const textColorClasses = Object.keys(discoveredTheme.cssVariables)
-            .filter(key => key.includes('foreground') || key.includes('text'))
-            .map(key => `text-${key.replace('--', '').replace(/-/g, '-')}`)
-            .slice(0, 10);
-          
-          textContent += `
-═══════════════════════════════════════════════════════════════════════════════
-COLOR FIX GUIDANCE (for visibility issues only)
-═══════════════════════════════════════════════════════════════════════════════
-
-AVAILABLE TEXT COLORS (use these for contrast fixes):
-- text-white (always visible on dark backgrounds)
-- text-black (always visible on light backgrounds)
-- text-foreground (theme default)
-- text-primary-foreground (for bg-primary)
-- text-accent-foreground (for bg-accent - CHECK IF THIS HAS GOOD CONTRAST)
-- text-destructive-foreground (for bg-destructive)
-
-SAFE BUTTON PATTERNS:
-- bg-accent text-white (cyan button, guaranteed visible)
-- bg-primary text-white (charcoal button, guaranteed visible)
-- bg-destructive text-white (red button, guaranteed visible)
-- bg-muted text-foreground (gray button, guaranteed visible)
-
-IMPORTANT: If current code has text-accent-foreground or similar semantic colors
-that result in poor contrast, REPLACE with text-white or text-black.
-
-`;
-        } else {
-          // For non-visibility requests, minimal reference
-          textContent += `
-═══════════════════════════════════════════════════════════════════════════════
-REFERENCE ONLY (do not use this to justify additional changes)
-═══════════════════════════════════════════════════════════════════════════════
-Theme discovered from: ${discoveredTheme.discoveredFiles.join(', ')}
-`;
-        }
-        
         debugLog("Theme discovery complete", {
           filesFound: discoveredTheme.discoveredFiles,
-          cssVariableCount: Object.keys(discoveredTheme.cssVariables).length,
-          tailwindColorCount: Object.keys(discoveredTheme.tailwindColors).length,
-          isVisibilityRequest,
         });
       }
 
-      // ========== 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;
+      // ========== SIMPLIFIED INSTRUCTIONS ==========
+      const targetPath = recommendedFileContent?.path || pageContext.pageFile || "unknown";
       
-      // Add recommended file first with marker
-      if (recommendedPath) {
-        validFilesList.push(`- ${recommendedPath} (*** TARGET - EDIT THIS FILE ***)`);
-      }
-      
-      // 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
+═══════════════════════════════════════════════════════════════════════════════
 
-      textContent += `VALID FILES YOU MAY EDIT:
-${validFilesList.join("\n")}
+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
 
-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. Choose which of the VALID FILES above need modifications
-4. Generate complete modified code for each file
-5. Provide previewCSS for immediate visual feedback
-6. Return as JSON in the specified format
-7. DO NOT edit the page wrapper unless the TARGET COMPONENT is unavailable
+EXAMPLE - If line 84 shows:
+   84| <div className="mb-10 md:mb-16 grid grid-cols-2">
+
+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",
@@ -1003,8 +861,6 @@ CRITICAL: Edit the TARGET COMPONENT (marked with ***), not the page wrapper.`;
       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
@@ -1054,110 +910,86 @@ 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: {
-          analysis?: {
-            currentState?: string;
-            problem?: string;
-            fixStrategy?: string;
-          };
-          reasoning?: string;
-          modifications: Array<{
-            filePath: string;
-            patches?: Patch[];
-            // Legacy support for modifiedContent (will be deprecated)
-            modifiedContent?: string;
-            explanation?: string;
-            previewCSS?: string;
-          }>;
-          aggregatedPreviewCSS?: 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```/);
-          
-          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);
-              }
-          }
+          previewCSS?: string;
+        }>;
+        explanation?: string;
+      };
 
-          // 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 }
-          );
+      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);
+            }
         }
 
-        // Log the LLM's analysis/reasoning (like Cursor showing its thought process)
-        if (aiResponse.analysis) {
-          debugLog("LLM Analysis (Step 1)", {
-            currentState: aiResponse.analysis.currentState,
-            problem: aiResponse.analysis.problem,
-            fixStrategy: aiResponse.analysis.fixStrategy,
-          });
+        // 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;
 
-        // If LLM says clarification is needed, return that to the user
-        if (aiResponse.analysis?.fixStrategy === "clarification_needed" && 
-            (!aiResponse.modifications || aiResponse.modifications.length === 0)) {
+        if (!aiResponse.modifications || aiResponse.modifications.length === 0) {
           return NextResponse.json({
             success: true,
-            needsClarification: true,
-            analysis: aiResponse.analysis,
-            explanation: aiResponse.explanation || "The element appears correct. Please specify what needs to change.",
             modifications: [],
+            explanation: aiResponse.explanation || "No changes needed.",
           });
-        }
+      }
 
-        debugLog("VALIDATION: Known file paths from page context", {
-          pageFile: pageContext.pageFile,
-          knownPaths: Array.from(knownPaths),
-          aiRequestedFiles: (aiResponse.modifications || []).map(m => m.filePath)
-        });
+      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
@@ -1198,9 +1030,9 @@ This is better than generating patches with made-up code.`,
         }
       }
 
-        // Process modifications - apply patches to get modified content
+      // Process modifications - apply patches to get modified content
         modificationsWithOriginals = [];
-        const patchErrors: string[] = [];
+      const patchErrors: string[] = [];
       
       for (const mod of aiResponse.modifications || []) {
         const fullPath = path.join(projectRoot, mod.filePath);
@@ -1278,20 +1110,9 @@ This is better than generating patches with made-up code.`,
             modifiedContent = patchResult.modifiedContent;
             console.log(`[Vision Mode] All ${mod.patches.length} patches applied successfully to ${mod.filePath}`);
           }
-        } else if (mod.modifiedContent) {
-          // Legacy: AI returned full file content
-          console.warn(`[Vision Mode] 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}`);
-            continue;
-          }
         } else {
-          // No patches and no modifiedContent - skip
-          console.warn(`[Vision Mode] No patches or modifiedContent for ${mod.filePath}`);
+          // No patches - skip
+          console.warn(`[Vision Mode] No patches for ${mod.filePath}`);
           continue;
         }
 
@@ -1306,7 +1127,7 @@ This is better than generating patches with made-up code.`,
       }
 
         // If all modifications failed, check if we should retry
-        if (patchErrors.length > 0 && modificationsWithOriginals.length === 0) {
+      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", { 
@@ -1321,19 +1142,19 @@ 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")}`,
-            } as VisionEditResponse,
-            { status: 400 }
-          );
-        }
+          } 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;
@@ -1348,9 +1169,8 @@ This is better than generating patches with made-up code.`,
       return NextResponse.json({
         success: true,
         modifications: modificationsWithOriginals,
-        aggregatedPreviewCSS: finalAggregatedCSS || aggregatedCSS,
+        aggregatedPreviewCSS: aggregatedCSS,
         explanation: finalExplanation,
-        reasoning: finalReasoning,
       } as VisionEditResponse);
     }
 
@@ -2042,13 +1862,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("[edit] Failed to parse tsconfig.json (will use defaults, logging once)", { error: errorStr, context });
         cachedParseError = errorStr;
       }
@@ -2071,14 +1891,14 @@ function getPathAliases(projectRoot: string): Map<string, string> {
     }
     // Only log default alias once (not when using cached error fallback)
     if (!cachedParseError) {
-      debugLog("[edit] Using default @/ alias", { alias: aliases.get("@/") });
+    debugLog("[edit] 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;
@@ -2386,105 +2206,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 };
-}