sonance-brand-mcp 1.3.46 → 1.3.47

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

@@ -1753,32 +1753,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)) {
@@ -1791,8 +1817,30 @@ function getPathAliases(projectRoot: string): Map<string, string> {
       }
       
       debugLog("[apply] 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("[apply] 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("[apply] Failed to parse tsconfig.json", { error: errorStr, context });
+      
+      // Clear cache on error so we retry next time
+      cachedPathAliases = null;
+      cachedProjectRoot = null;
+      cachedTsconfigMtime = null;
     }
   }
   
@@ -1810,8 +1858,12 @@ function getPathAliases(projectRoot: string): Map<string, string> {
     debugLog("[apply] 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;
 }
 
@@ -1925,6 +1977,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
@@ -1939,33 +2090,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 {

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

@@ -1657,32 +1657,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 +1721,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 +1762,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 +1887,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 +2000,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonance-brand-mcp",
-  "version": "1.3.46",
+  "version": "1.3.47",
   "description": "MCP Server for Sonance Brand Guidelines and Component Library - gives Claude instant access to brand colors, typography, and UI components.",
   "main": "dist/index.js",
   "type": "module",