@hapico/cli 0.0.29 → 0.0.31

package/tools/vibe/patch.utils.ts

@@ -0,0 +1,273 @@
+import { diff_match_patch } from "diff-match-patch";
+
+/**
+ * ------------------------------------------------------------------
+ * TYPES
+ * ------------------------------------------------------------------
+ */
+export interface PatchBlock {
+  search: string;
+  replace: string;
+}
+
+/**
+ * ------------------------------------------------------------------
+ * HELPER: STRING SIMILARITY (Levenshtein based)
+ * Tính độ giống nhau giữa 2 chuỗi (0 -> 1)
+ * ------------------------------------------------------------------
+ */
+const calculateSimilarity = (s1: string, s2: string): number => {
+  const longer = s1.length > s2.length ? s1 : s2;
+  const shorter = s1.length > s2.length ? s2 : s1;
+  const longerLength = longer.length;
+  if (longerLength === 0) {
+    return 1.0;
+  }
+  
+  // Sử dụng dmp để tính Levenshtein distance cho chính xác và nhanh
+  const dmp = new diff_match_patch();
+  const diffs = dmp.diff_main(longer, shorter);
+  const levenshtein = dmp.diff_levenshtein(diffs);
+  
+  return (longerLength - levenshtein) / longerLength;
+};
+
+/**
+ * ------------------------------------------------------------------
+ * HELPER: FUZZY LINE MATCHING
+ * Tìm đoạn code khớp nhất trong file gốc dựa trên điểm số (Confidence)
+ * ------------------------------------------------------------------
+ */
+const applyFuzzyLineMatch = (
+  original: string,
+  search: string,
+  replace: string,
+  threshold: number = 0.85 // Ngưỡng chấp nhận (85% giống nhau)
+): { result: string | null; confidence: number } => {
+  const originalLines = original.split(/\r?\n/);
+  const searchLines = search.split(/\r?\n/);
+  
+  // Lọc bỏ dòng trống ở đầu/cuối search block để match chính xác hơn
+  while (searchLines.length > 0 && searchLines[0].trim() === "") searchLines.shift();
+  while (searchLines.length > 0 && searchLines[searchLines.length - 1].trim() === "") searchLines.pop();
+
+  if (searchLines.length === 0) return { result: null, confidence: 0 };
+
+  let bestMatchIndex = -1;
+  let bestMatchScore = 0;
+
+  // Duyệt qua file gốc (Sliding Window)
+  // Chỉ cần duyệt đến vị trí mà số dòng còn lại đủ để chứa searchLines
+  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+    let currentScoreTotal = 0;
+    let possible = true;
+
+    for (let j = 0; j < searchLines.length; j++) {
+      const originalLine = originalLines[i + j].trim();
+      const searchLine = searchLines[j].trim();
+
+      // So sánh nhanh: Nếu giống hệt nhau
+      if (originalLine === searchLine) {
+        currentScoreTotal += 1;
+        continue;
+      }
+
+      // So sánh chậm: Tính độ tương đồng
+      const similarity = calculateSimilarity(originalLine, searchLine);
+      
+      // Nếu một dòng quá khác biệt (< 60%), coi như block này không khớp
+      // (Giúp tối ưu hiệu năng, cắt nhánh sớm)
+      if (similarity < 0.6) {
+        possible = false;
+        break;
+      }
+      currentScoreTotal += similarity;
+    }
+
+    if (possible) {
+      const avgScore = currentScoreTotal / searchLines.length;
+      if (avgScore > bestMatchScore) {
+        bestMatchScore = avgScore;
+        bestMatchIndex = i;
+      }
+    }
+  }
+
+  // LOG CONFIDENCE ĐỂ DEBUG
+  if (bestMatchScore > 0) {
+    console.log(`[FuzzyMatch] Best match score: ${(bestMatchScore * 100).toFixed(2)}% at line ${bestMatchIndex + 1}`);
+  }
+
+  // Nếu tìm thấy vị trí có độ tin cậy cao hơn ngưỡng
+  if (bestMatchIndex !== -1 && bestMatchScore >= threshold) {
+    const before = originalLines.slice(0, bestMatchIndex);
+    // Lưu ý: Đoạn replace thay thế đúng số lượng dòng của searchLines
+    // (Giả định search và match trong original có cùng số dòng hiển thị)
+    const after = originalLines.slice(bestMatchIndex + searchLines.length);
+    
+    return {
+      result: [...before, replace, ...after].join("\n"),
+      confidence: bestMatchScore
+    };
+  }
+
+  return { result: null, confidence: bestMatchScore };
+};
+
+/**
+ * ------------------------------------------------------------------
+ * 1. STATE MACHINE PARSER (GIỮ NGUYÊN)
+ * ------------------------------------------------------------------
+ */
+export const parseLLMPatch = (patchContent: string): PatchBlock[] => {
+  // ... (Code parse giữ nguyên như cũ của bạn)
+  const lines = patchContent.split(/\r?\n/);
+  const patches: PatchBlock[] = [];
+  let inSearch = false;
+  let inReplace = false;
+  let searchLines: string[] = [];
+  let replaceLines: string[] = [];
+  const isSearchMarker = (line: string) => /^\s*<{7,}\s*SEARCH\s*$/.test(line);
+  const isDividerMarker = (line: string) => /^\s*={7,}\s*$/.test(line);
+  const isEndMarker = (line: string) => /^\s*>{7,}\s*REPLACE\s*$/.test(line);
+
+  for (const line of lines) {
+    if (isSearchMarker(line)) {
+      inSearch = true;
+      inReplace = false;
+      searchLines = [];
+      replaceLines = [];
+      continue;
+    }
+    if (isDividerMarker(line)) {
+      if (inSearch) { inSearch = false; inReplace = true; }
+      continue;
+    }
+    if (isEndMarker(line)) {
+      if (inReplace || inSearch) {
+        // CẬP NHẬT: Cho phép lưu patch nếu có search HOẶC có replace
+        // (Trường hợp Search rỗng nhưng Replace có nội dung = Insert/Append)
+        if (searchLines.length > 0 || replaceLines.length > 0) {
+          patches.push({ search: searchLines.join("\n"), replace: replaceLines.join("\n") });
+        }
+      }
+      inSearch = false; inReplace = false; searchLines = []; replaceLines = [];
+      continue;
+    }
+    if (inSearch) searchLines.push(line);
+    else if (inReplace) replaceLines.push(line);
+  }
+  return patches;
+};
+
+/**
+ * ------------------------------------------------------------------
+ * 2. APPLY PATCH (UPDATED)
+ * ------------------------------------------------------------------
+ */
+export const applyPatch = (
+  originalContent: string,
+  patchContent: string | PatchBlock[]
+): string => {
+  
+  let patches: PatchBlock[];
+  if (typeof patchContent === 'string') {
+    if (!patchContent || !patchContent.includes("<<<<<<< SEARCH")) {
+      return patchContent || originalContent;
+    }
+    patches = parseLLMPatch(patchContent);
+  } else {
+    patches = patchContent;
+  }
+
+  if (!patches || patches.length === 0) return originalContent;
+
+  let result = originalContent;
+
+  for (const patch of patches) {
+    const { search, replace } = patch;
+
+    // Strategy 0: Full File Replacement (Overwrite)
+    if (search === "__FULL_FILE_REPLACEMENT__") {
+      console.log(`[ApplyPatch] Overwriting file with full content.`);
+      result = replace;
+      continue;
+    }
+
+    // Nếu search và replace giống hệt nhau, bỏ qua
+    if (search === replace) {
+      console.log(`[ApplyPatch] Search and replace are identical. Skipping.`);
+      continue;
+    }
+
+    // NẾU SEARCH RỖNG (INSERT/APPEND hoặc TẠO FILE MỚI)
+    if (search.trim() === "") {
+      console.log(`[ApplyPatch] Inserting/appending block.`);
+      if (result.trim() === "") {
+        // Nếu file hiện tại rỗng hoặc chỉ có khoảng trắng, gán luôn bằng nội dung replace (Hỗ trợ tạo file mới)
+        result = replace;
+      } else {
+        // Nếu file đã có nội dung, append vào cuối. Đảm bảo có ít nhất một dấu xuống dòng phân tách.
+        const separator = result.endsWith("\n") ? "" : "\n";
+        result += separator + replace;
+      }
+      continue;
+    }
+
+    // --- STRATEGY 1: EXACT MATCH ---
+    if (result.includes(search)) {
+      console.log(`[ApplyPatch] Exact match found.`);
+      result = result.replace(search, replace);
+      continue;
+    }
+
+    // --- STRATEGY 2: NORMALIZED MATCH (Trim) ---
+    const trimmedSearch = search.trim();
+    if (result.includes(trimmedSearch)) {
+      console.log(`[ApplyPatch] Trimmed match found.`);
+      result = result.replace(trimmedSearch, replace.trim());
+      continue;
+    }
+    
+    // --- STRATEGY 3: FUZZY LINE MATCH (BEST FOR CODE) ---
+    // Tìm vị trí tốt nhất dựa trên similarity score của từng dòng
+    const fuzzyMatch = applyFuzzyLineMatch(result, search, replace, 0.80); // 80% confidence
+    if (fuzzyMatch.result !== null) {
+        console.log(`[ApplyPatch] Fuzzy line match applied (Confidence: ${(fuzzyMatch.confidence * 100).toFixed(0)}%)`);
+        result = fuzzyMatch.result;
+        continue;
+    } else {
+        console.warn(`[ApplyPatch] Failed to match block. Max confidence was: ${(fuzzyMatch.confidence * 100).toFixed(0)}%`);
+    }
+
+    // --- STRATEGY 4: DMP FALLBACK (LAST RESORT) ---
+    // Nếu cả fuzzy line match cũng tạch (ví dụ do search block quá ngắn hoặc cấu trúc quá nát)
+    // thì mới dùng DMP patch_apply.
+    try {
+      const dmp = new diff_match_patch();
+      dmp.Match_Threshold = 0.5;
+      dmp.Match_Distance = 1000;
+      
+      const dmpPatches = dmp.patch_make(search, replace);
+      const [newText, applyResults] = dmp.patch_apply(dmpPatches, result);
+      
+      // Kiểm tra xem có apply được hết các hunk không
+      const successCount = applyResults.filter(Boolean).length;
+      const successRate = successCount / applyResults.length;
+
+      if (successRate === 1 && newText !== result) {
+         console.log(`[ApplyPatch] DMP Patch applied via fuzzy logic.`);
+         result = newText;
+      } else {
+         console.error(`[ApplyPatch] All strategies failed for block starting with: ${search.substring(0, 30)}...`);
+         console.log(`[ApplyPatch DATA]`, { search, replace, result });
+         // Tuỳ chọn: Throw error để báo cho LLM biết là apply thất bại
+         // throw new Error("Could not apply patch block");
+      }
+    } catch (e) {
+      console.error(`[ApplyPatch] DMP error:`, e);
+    }
+  }
+
+  return result;
+};