Initial open-source release

packages/context/src/tools/sql-edit-replacer.ts

@@ -0,0 +1,229 @@
+export interface SqlEdit {
+  oldText: string;
+  newText: string;
+  reason?: string;
+}
+
+interface SqlEditResult {
+  success: boolean;
+  sql: string;
+  appliedEdits: number;
+  errors: string[];
+}
+
+type ReplacerResult = { sql: string; note?: string } | { error: string } | null;
+
+function exactReplacer(sql: string, oldText: string, newText: string): ReplacerResult {
+  if (oldText.length === 0) {
+    return null;
+  }
+
+  let count = 0;
+  let idx = -1;
+  let searchFrom = 0;
+
+  while (true) {
+    const found = sql.indexOf(oldText, searchFrom);
+    if (found === -1) {
+      break;
+    }
+    count++;
+    idx = found;
+    searchFrom = found + 1;
+  }
+
+  if (count === 0) {
+    return null;
+  }
+  if (count > 1) {
+    return { error: `Found ${count} matches for text, expected 1. Add more surrounding context.` };
+  }
+
+  return { sql: sql.slice(0, idx) + newText + sql.slice(idx + oldText.length) };
+}
+
+function buildCharacterMap(original: string): number[] {
+  const map: number[] = [];
+  for (let i = 0; i < original.length; i++) {
+    if (/\s/.test(original[i])) {
+      if (map.length === 0 || !/\s/.test(original[i - 1])) {
+        map.push(i);
+      }
+    } else {
+      map.push(i);
+    }
+  }
+  return map;
+}
+
+function whitespaceNormalizedReplacer(sql: string, oldText: string, newText: string): ReplacerResult {
+  const normalizedSql = sql.replace(/\s+/g, ' ');
+  const normalizedOldText = oldText.replace(/\s+/g, ' ');
+
+  if (normalizedOldText.length === 0) {
+    return null;
+  }
+
+  let count = 0;
+  let matchIdx = -1;
+  let searchFrom = 0;
+
+  while (true) {
+    const found = normalizedSql.indexOf(normalizedOldText, searchFrom);
+    if (found === -1) {
+      break;
+    }
+    count++;
+    matchIdx = found;
+    searchFrom = found + 1;
+  }
+
+  if (count === 0) {
+    return null;
+  }
+  if (count > 1) {
+    return null;
+  }
+
+  const charMap = buildCharacterMap(sql);
+
+  const originalStart = charMap[matchIdx];
+  const normalizedEnd = matchIdx + normalizedOldText.length;
+
+  let originalEnd: number;
+  if (normalizedEnd >= charMap.length) {
+    originalEnd = sql.length;
+  } else {
+    originalEnd = charMap[normalizedEnd];
+  }
+
+  return { sql: sql.slice(0, originalStart) + newText + sql.slice(originalEnd) };
+}
+
+function levenshteinDistance(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+
+  if (m === 0) {
+    return n;
+  }
+  if (n === 0) {
+    return m;
+  }
+
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+  for (let i = 0; i <= m; i++) {
+    dp[i][0] = i;
+  }
+  for (let j = 0; j <= n; j++) {
+    dp[0][j] = j;
+  }
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+
+  return dp[m][n];
+}
+
+function fuzzyReplacer(sql: string, oldText: string, newText: string): ReplacerResult {
+  if (oldText.length === 0) {
+    return null;
+  }
+
+  const targetLen = oldText.length;
+  const minWindow = Math.max(1, Math.floor(targetLen * 0.85));
+  const maxWindow = Math.ceil(targetLen * 1.15);
+
+  let bestDistance = Infinity;
+  let bestStart = -1;
+  let bestEnd = -1;
+
+  for (let windowLen = minWindow; windowLen <= maxWindow; windowLen++) {
+    if (windowLen > sql.length) {
+      break;
+    }
+
+    for (let start = 0; start <= sql.length - windowLen; start++) {
+      const candidate = sql.slice(start, start + windowLen);
+      const distance = levenshteinDistance(candidate, oldText);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestStart = start;
+        bestEnd = start + windowLen;
+      }
+    }
+  }
+
+  if (bestStart === -1) {
+    return null;
+  }
+
+  const maxLen = Math.max(oldText.length, bestEnd - bestStart);
+  const similarity = 1 - bestDistance / maxLen;
+
+  if (similarity < 0.85) {
+    return null;
+  }
+
+  const matchedText = sql.slice(bestStart, bestEnd);
+  return {
+    sql: sql.slice(0, bestStart) + newText + sql.slice(bestEnd),
+    note: `Fuzzy match used (similarity: ${(similarity * 100).toFixed(1)}%, matched: "${matchedText}")`,
+  };
+}
+
+interface ApplySqlEditsOptions {
+  exactOnly?: boolean;
+}
+
+export function applySqlEdits(sql: string, edits: SqlEdit[], options?: ApplySqlEditsOptions): SqlEditResult {
+  let currentSql = sql;
+  let appliedEdits = 0;
+  const errors: string[] = [];
+
+  for (const edit of edits) {
+    const replacers = options?.exactOnly
+      ? [exactReplacer]
+      : [exactReplacer, whitespaceNormalizedReplacer, fuzzyReplacer];
+    let applied = false;
+
+    for (const replacer of replacers) {
+      const result = replacer(currentSql, edit.oldText, edit.newText);
+
+      if (result === null) {
+        continue;
+      }
+
+      if ('error' in result) {
+        const context = edit.reason ? ` (reason: ${edit.reason})` : '';
+        errors.push(`${result.error}${context}`);
+        applied = true;
+        break;
+      }
+
+      currentSql = result.sql;
+      appliedEdits++;
+      applied = true;
+      break;
+    }
+
+    if (!applied) {
+      const context = edit.reason ? ` (reason: ${edit.reason})` : '';
+      errors.push(
+        `No match found for edit${context}: "${edit.oldText.slice(0, 80)}${edit.oldText.length > 80 ? '...' : ''}"`,
+      );
+    }
+  }
+
+  return {
+    success: errors.length === 0,
+    sql: currentSql,
+    appliedEdits,
+    errors,
+  };
+}