T17 — Fuzzy edit matching 3-tier

{`
const REPLACERS = [
  SimpleReplacer,       // Tier 1: exact
  LineTrimmedReplacer,  // Tier 2: trim whitespace per line
  BlockAnchorReplacer,  // Tier 3: anchor + Levenshtein
] as const

export async function applyEdit(
  content: string,
  oldStr: string,
  newStr: string,
) {
  for (const Replacer of REPLACERS) {
    const match = Replacer.findMatch(content, oldStr)
    if (match) {
      return Replacer.replace(content, match, newStr)
    }
  }
  throw new NoMatchError(
    "old_string not found in file. Re-read the file and try again with exact content."
  )
}
`}

{`
class BlockAnchorReplacer {
  static findMatch(content: string, oldStr: string) {
    const oldLines = oldStr.split("\n")
    // Chỉ áp dụng cho block >= 3 dòng
    if (oldLines.length < 3) return null

    const first = oldLines[0].trim()
    const last  = oldLines[oldLines.length - 1].trim()

    // Tìm tất cả cặp (first, last) trong content
    const candidates = findAllAnchorPairs(content, first, last)

    // Score mỗi candidate bằng Levenshtein ratio
    const scored = candidates.map((c) => ({
      ...c,
      score: levenshteinRatio(oldStr, content.slice(c.start, c.end)),
    }))
    scored.sort((a, b) => b.score - a.score)

    // Adaptive threshold: 0.0 khi 1 candidate, 0.3 khi nhiều
    const threshold = scored.length > 1 ? 0.3 : 0.0

    return scored[0]?.score >= threshold ? scored[0] : null
  }
}

// levenshteinRatio = 1.0 - (editDistance / maxLen)
// 1.0 = perfect match, 0.0 = hoàn toàn khác
`}

{`
function replaceFlex(content: string, oldStr: string, newStr: string): string {
  const replacers = [exactMatch, trimmedMatch, anchorMatch]

  for (const r of replacers) {
    const m = r.find(content, oldStr)
    if (m) return content.slice(0, m.start) + newStr + content.slice(m.end)
  }

  throw new Error(
    "No match found after 3-tier search. Re-read the file and retry with exact content."
  )
}

function anchorMatch(content: string, oldStr: string) {
  const lines = oldStr.split("\n")
  if (lines.length < 3) return null

  const first = lines[0].trim()
  const last  = lines[lines.length - 1].trim()

  // Find all positions where first and last line anchor match
  const candidates = findAnchorPairs(content, first, last)

  // Score by Levenshtein, return best above threshold
  return bestMatch(candidates, oldStr, content, candidates.length > 1 ? 0.3 : 0.0)
}
`}

{`
// Levenshtein distance (simple implementation)
function levenshtein(a: string, b: string): number {
  const m = a.length, n = b.length
  const dp: number[][] = Array.from({ length: m + 1 }, (_, i) =>
    Array.from({ length: n + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0)
  )
  for (let i = 1; i <= m; i++) {
    for (let j = 1; j <= n; j++) {
      dp[i][j] = a[i-1] === b[j-1]
        ? dp[i-1][j-1]
        : 1 + Math.min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
    }
  }
  return dp[m][n]
}

function levenshteinRatio(a: string, b: string): number {
  const dist = levenshtein(a, b)
  return 1 - dist / Math.max(a.length, b.length, 1)
}

// 3-tier applyEdit
export function applyEdit(content: string, old: string, next: string): string {
  // Tier 1: exact
  const idx1 = content.indexOf(old)
  if (idx1 !== -1) return content.slice(0, idx1) + next + content.slice(idx1 + old.length)

  // Tier 2: line-trimmed
  const trimmedContent = content.split("\n").map(l => l.trim()).join("\n")
  const trimmedOld     = old.split("\n").map(l => l.trim()).join("\n")
  const idx2 = trimmedContent.indexOf(trimmedOld)
  if (idx2 !== -1) {
    // Map back to original content positions
    const start = mapTrimmedIndex(content, idx2)
    const end   = mapTrimmedIndex(content, idx2 + trimmedOld.length)
    return content.slice(0, start) + next + content.slice(end)
  }

  // Tier 3: block anchor + Levenshtein
  const oldLines = old.split("\n")
  if (oldLines.length >= 3) {
    const first = oldLines[0].trim()
    const last  = oldLines[oldLines.length - 1].trim()
    const candidates = findAnchorPairs(content, first, last)
    const scored = candidates
      .map(c => ({ ...c, score: levenshteinRatio(old, content.slice(c.start, c.end)) }))
      .sort((a, b) => b.score - a.score)
    const threshold = scored.length > 1 ? 0.3 : 0.0
    const best = scored[0]
    if (best && best.score >= threshold) {
      return content.slice(0, best.start) + next + content.slice(best.end)
    }
  }

  throw new Error("old_string not found. Re-read the file and retry.")
}
`}