patchling 0.2.0 → 0.2.1

package/src/applydiff.js

@@ -402,3 +402,785 @@ export function applyDiff(files, diffText) {
   }
   return { changed: true, files: working };
 }
+
+/**
+ * Parse the hunks of a single-file patch.
+ *
+ * Returns null when a body line is ambiguous (`++`, which is either a doubled
+ * add marker or a literal line that starts with `+`). A non-standard hunk
+ * header with no line numbers is kept and anchored at the start of the file.
+ * {@link applyPatchToFile} refuses that header instead; this parser exists so
+ * a later intent check can still see the `+`/`-` lines.
+ *
+ * @param {string} patch
+ * @returns {Array<{ hint: number, ops: Array<{ kind: string, text: string }> }> | null}
+ */
+export function parsePatchHunks(patch) {
+  const patchLines = splitLines(patch || '');
+  /** @type {Array<{ hint: number, ops: Array<{ kind: string, text: string }> }>} */
+  const hunks = [];
+  let i = 0;
+  while (i < patchLines.length) {
+    const line = patchLines[i];
+    if (!line.replace(/^\s+/, '').startsWith('@@')) {
+      i += 1;
+      continue;
+    }
+    let origStart = 1;
+    const trimmed = line.trim();
+    if (trimmed !== '@@') {
+      const m = trimmed.match(HUNK_HEADER_RE);
+      if (m && m[1] !== undefined) origStart = parseInt(m[1], 10);
+    }
+    /** @type {Array<{ kind: string, text: string }>} */
+    const ops = [];
+    i += 1;
+    while (i < patchLines.length && !patchLines[i].replace(/^\s+/, '').startsWith('@@')) {
+      const pline = patchLines[i];
+      i += 1;
+      if (pline.startsWith('\\')) continue;
+      if (pline.startsWith('++') && !pline.startsWith('+++')) return null;
+      if (pline.startsWith('-')) ops.push({ kind: 'del', text: pline.slice(1) });
+      else if (pline.startsWith('+')) ops.push({ kind: 'add', text: pline.slice(1) });
+      else if (pline.startsWith(' ')) ops.push({ kind: 'context', text: pline.slice(1) });
+      else ops.push({ kind: 'context', text: pline });
+    }
+    hunks.push({ hint: Math.max(origStart - 1, 0), ops });
+  }
+  return hunks;
+}
+
+/**
+ * @param {string[]} lines
+ * @returns {Map<string, number>}
+ */
+function lineCounts(lines) {
+  /** @type {Map<string, number>} */
+  const counts = new Map();
+  for (const line of lines) counts.set(line, (counts.get(line) || 0) + 1);
+  return counts;
+}
+
+/**
+ * @param {Map<string, number>} budget
+ * @param {string} text
+ * @returns {boolean}
+ */
+function takeOne(budget, text) {
+  const n = budget.get(text) || 0;
+  if (n <= 0) return false;
+  if (n === 1) budget.delete(text);
+  else budget.set(text, n - 1);
+  return true;
+}
+
+/**
+ * True when `updatedLines` is `originalLines` with only the budgeted `-`
+ * lines removed and the budgeted `+` lines inserted, in an order that keeps
+ * every surviving line in its original relative order.
+ *
+ * @param {string[]} originalLines
+ * @param {string[]} updatedLines
+ * @param {Map<string, number>} delCounts
+ * @param {Map<string, number>} addCounts
+ * @returns {boolean}
+ */
+function isPlusMinusEdit(originalLines, updatedLines, delCounts, addCounts) {
+  const delLeft = new Map(delCounts);
+  const addLeft = new Map(addCounts);
+  let i = 0;
+  let j = 0;
+  while (i < originalLines.length && j < updatedLines.length) {
+    if (originalLines[i] === updatedLines[j]) {
+      i += 1;
+      j += 1;
+      continue;
+    }
+    if (takeOne(addLeft, updatedLines[j])) {
+      j += 1;
+      continue;
+    }
+    if (takeOne(delLeft, originalLines[i])) {
+      i += 1;
+      continue;
+    }
+    return false;
+  }
+  while (i < originalLines.length) {
+    if (!takeOne(delLeft, originalLines[i])) return false;
+    i += 1;
+  }
+  while (j < updatedLines.length) {
+    if (!takeOne(addLeft, updatedLines[j])) return false;
+    j += 1;
+  }
+  return true;
+}
+
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+function leadingWhitespace(text) {
+  const m = /^[ \t]*/.exec(text);
+  return m ? m[0] : '';
+}
+
+/**
+ * Move `text` by `delta` leading spaces. A negative delta only strips spaces,
+ * never tabs. Returns null when the line is not indented far enough.
+ *
+ * @param {string} text
+ * @param {number} delta
+ * @returns {string | null}
+ */
+function shiftIndent(text, delta) {
+  if (!delta) return text;
+  if (delta > 0) return `${' '.repeat(delta)}${text}`;
+  const remove = -delta;
+  const ws = leadingWhitespace(text);
+  if (ws.length < remove || ws.slice(0, remove).includes('\t')) return null;
+  return text.slice(remove);
+}
+
+/**
+ * Indent deltas at which a context or deletion line equals some file line.
+ * `0` is always included so an exact hunk keeps its current anchor.
+ *
+ * @param {Array<{ kind: string, text: string }>} ops
+ * @param {string[]} fileLines
+ * @returns {number[]}
+ */
+function candidateDeltas(ops, fileLines) {
+  /** @type {Set<number>} */
+  const deltas = new Set([0]);
+  /** @type {Map<string, string[]>} */
+  const linesByBody = new Map();
+  for (const line of fileLines) {
+    const body = line.replace(/^[ \t]*/, '');
+    if (!linesByBody.has(body)) linesByBody.set(body, []);
+    linesByBody.get(body).push(line);
+  }
+  for (const op of ops) {
+    if (op.kind === 'add') continue;
+    const body = op.text.replace(/^[ \t]*/, '');
+    const lines = linesByBody.get(body);
+    if (!lines) continue;
+    const opWs = leadingWhitespace(op.text).length;
+    for (const line of lines) {
+      const delta = leadingWhitespace(line).length - opWs;
+      if (shiftIndent(op.text, delta) === line) deltas.add(delta);
+    }
+  }
+  return [...deltas];
+}
+
+/**
+ * @param {string} content
+ * @returns {boolean}
+ */
+function isBlank(content) {
+  return !/\S/.test(content || '');
+}
+
+const IDENT_PAIR_MIN = 0.55;
+
+/**
+ * @param {string} text
+ * @returns {boolean}
+ */
+function isEllipsis(text) {
+  const trimmed = String(text || '').trim();
+  return trimmed === '...' || trimmed === '…' || trimmed === '....' || trimmed === '..';
+}
+
+/**
+ * Identity ignoring whitespace and trailing semicolons. Case-sensitive, so
+ * `False` and `false` stay different.
+ *
+ * @param {string} line
+ * @returns {string}
+ */
+function trivialKey(line) {
+  let collapsed = String(line || '').replace(/\s+/g, '');
+  while (collapsed.endsWith(';')) collapsed = collapsed.slice(0, -1);
+  return collapsed;
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+function sameTrivial(a, b) {
+  return a === b || trivialKey(a) === trivialKey(b);
+}
+
+/**
+ * Ratcliff/Obershelp match size, the same ratio basis as Python's
+ * difflib.SequenceMatcher for short lines (no autojunk).
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function matchingSize(a, b) {
+  if (!a.length || !b.length) return 0;
+  let bestLen = 0;
+  let bestI = 0;
+  let bestJ = 0;
+  const cols = b.length;
+  let prev = new Uint32Array(cols + 1);
+  let cur = new Uint32Array(cols + 1);
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= cols; j++) {
+      if (a.charCodeAt(i - 1) === b.charCodeAt(j - 1)) {
+        const len = prev[j - 1] + 1;
+        cur[j] = len;
+        if (len > bestLen) {
+          bestLen = len;
+          bestI = i - len;
+          bestJ = j - len;
+        }
+      } else {
+        cur[j] = 0;
+      }
+    }
+    const swap = prev;
+    prev = cur;
+    cur = swap;
+    cur.fill(0);
+  }
+  if (bestLen === 0) return 0;
+  return bestLen
+    + matchingSize(a.slice(0, bestI), b.slice(0, bestJ))
+    + matchingSize(a.slice(bestI + bestLen), b.slice(bestJ + bestLen));
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function sequenceRatio(a, b) {
+  const total = a.length + b.length;
+  if (total === 0) return 1;
+  return (2 * matchingSize(a, b)) / total;
+}
+
+/**
+ * @param {string} diffLine
+ * @param {string} fileLine
+ * @returns {number}
+ */
+function contextAnchorScore(diffLine, fileLine) {
+  if (sameTrivial(diffLine, fileLine)) return 1;
+  const left = trivialKey(diffLine);
+  const right = trivialKey(fileLine);
+  if (left.length < 4 || right.length < 4) return 0;
+  return sequenceRatio(left, right);
+}
+
+/**
+ * @param {string} text
+ * @returns {string[]}
+ */
+function identifiers(text) {
+  return String(text || '').match(/[A-Za-z_][A-Za-z0-9_]*/g) || [];
+}
+
+/**
+ * Map drifted diff identifiers onto the names the file actually uses.
+ *
+ * A context line pairs with a file line only when they are the best match
+ * near the edit and contain the same number of identifiers, so
+ * `database.get(user_id)` can teach `user_id` → `uid` without rewriting
+ * unrelated lines. Conflicting mappings are dropped.
+ *
+ * @param {string[]} lines
+ * @param {string[]} contexts
+ * @param {number} [start]
+ * @param {number} [end]
+ * @returns {Map<string, string>}
+ */
+function identMapForLines(lines, contexts, start = 0, end = lines.length) {
+  const from = Math.max(0, start);
+  const to = Math.min(lines.length, end);
+  /** @type {Map<string, string>} */
+  const mapping = new Map();
+  /** @type {Set<string>} */
+  const conflicts = new Set();
+  for (const text of contexts) {
+    if (isEllipsis(text)) continue;
+    let bestI = -1;
+    let bestS = IDENT_PAIR_MIN;
+    for (let i = from; i < to; i++) {
+      const score = contextAnchorScore(text, lines[i]);
+      if (score > bestS) {
+        bestS = score;
+        bestI = i;
+      }
+    }
+    if (bestI < 0) continue;
+    const diffIds = identifiers(text);
+    const fileIds = identifiers(lines[bestI]);
+    if (diffIds.length !== fileIds.length) continue;
+    for (let k = 0; k < diffIds.length; k++) {
+      const src = diffIds[k];
+      const dst = fileIds[k];
+      if (src === dst) continue;
+      const prev = mapping.get(src);
+      if (prev === undefined) mapping.set(src, dst);
+      else if (prev !== dst) conflicts.add(src);
+    }
+  }
+  for (const src of conflicts) mapping.delete(src);
+  return mapping;
+}
+
+/**
+ * @param {string} text
+ * @param {Map<string, string>} mapping
+ * @returns {string}
+ */
+function applyIdentMap(text, mapping) {
+  if (!mapping || mapping.size === 0) return text;
+  return text.replace(/[A-Za-z_][A-Za-z0-9_]*/g, (id) => mapping.get(id) || id);
+}
+
+/**
+ * True when `updatedLines` is not `originalLines` with only the budgeted
+ * deletions removed and the budgeted additions inserted.
+ *
+ * @param {string[]} originalLines
+ * @param {string[]} updatedLines
+ * @param {Map<string, number>} delCounts
+ * @param {Map<string, number>} addCounts
+ * @returns {boolean}
+ */
+function editViolates(originalLines, updatedLines, delCounts, addCounts) {
+  if (!isPlusMinusEdit(originalLines, updatedLines, delCounts, addCounts)) return true;
+  const origCounts = lineCounts(originalLines);
+  const updCounts = lineCounts(updatedLines);
+  for (const [text, n] of delCounts) {
+    if (addCounts.has(text)) continue;
+    const have = origCounts.get(text) || 0;
+    if (have === 0) continue;
+    const left = updCounts.get(text) || 0;
+    if (left > have - Math.min(have, n)) return true;
+  }
+  for (const [text, n] of addCounts) {
+    if (delCounts.has(text)) continue;
+    const have = origCounts.get(text) || 0;
+    const got = updCounts.get(text) || 0;
+    if (got < have + n) return true;
+  }
+  return false;
+}
+
+/**
+ * Best `+`/`-` alignment of one hunk against `fileLines`, starting at `start`.
+ *
+ * Context ops may be skipped when they do not equal the current file line, so
+ * a stale context line is never written. `delta` is a uniform leading-space
+ * shift: a diff line matches the file line `delta` spaces deeper (or shallower).
+ * File lines inside the matched span are only kept (matched context) or dropped
+ * (a `-` line). Added lines are emitted at that same shift.
+ *
+ * @param {Array<{ kind: string, text: string }>} ops
+ * @param {string[]} fileLines
+ * @param {number} start
+ * @param {number} delta
+ * @returns {{ matchedContext: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[] } | null}
+ */
+function alignHunkAt(ops, fileLines, start, delta) {
+  const consumable = ops.reduce((n, op) => n + (op.kind === 'add' ? 0 : 1), 0);
+  const last = Math.min(fileLines.length, start + consumable);
+  /** @type {Map<number, { matchedContext: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[] } | null>} */
+  const memo = new Map();
+  const width = fileLines.length + 1;
+
+  /**
+   * @param {number} opIdx
+   * @param {number} i
+   * @returns {{ matchedContext: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[] } | null}
+   */
+  const rec = (opIdx, i) => {
+    const key = opIdx * width + i;
+    if (memo.has(key)) return memo.get(key) ?? null;
+    /** @type {{ matchedContext: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[] } | null} */
+    let result = null;
+    if (opIdx === ops.length) {
+      result = { matchedContext: 0, end: i, replacement: [], addFlags: [], removed: [], added: [] };
+    } else if (i > last) {
+      result = null;
+    } else {
+      const op = ops[opIdx];
+      if (op.kind === 'add') {
+        const addedText = shiftIndent(op.text, delta);
+        const rest = addedText === null ? null : rec(opIdx + 1, i);
+        if (rest && addedText !== null) {
+          result = {
+            matchedContext: rest.matchedContext,
+            end: rest.end,
+            replacement: [addedText, ...rest.replacement],
+            addFlags: [true, ...rest.addFlags],
+            removed: rest.removed,
+            added: [addedText, ...rest.added],
+          };
+        }
+      } else if (op.kind === 'del') {
+        const shifted = shiftIndent(op.text, delta);
+        if (shifted !== null && i < last && i < fileLines.length && fileLines[i] === shifted) {
+          const rest = rec(opIdx + 1, i + 1);
+          if (rest) {
+            result = {
+              matchedContext: rest.matchedContext,
+              end: rest.end,
+              replacement: rest.replacement,
+              addFlags: rest.addFlags,
+              removed: [fileLines[i], ...rest.removed],
+              added: rest.added,
+            };
+          }
+        }
+      } else {
+        const skipped = rec(opIdx + 1, i);
+        /** @type {{ matchedContext: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[] } | null} */
+        let matched = null;
+        const shifted = shiftIndent(op.text, delta);
+        if (shifted !== null && i < last && i < fileLines.length && fileLines[i] === shifted) {
+          const rest = rec(opIdx + 1, i + 1);
+          if (rest) {
+            matched = {
+              matchedContext: rest.matchedContext + 1,
+              end: rest.end,
+              replacement: [fileLines[i], ...rest.replacement],
+              addFlags: [false, ...rest.addFlags],
+              removed: rest.removed,
+              added: rest.added,
+            };
+          }
+        }
+        if (matched && skipped) {
+          result = matched.matchedContext >= skipped.matchedContext ? matched : skipped;
+        } else {
+          result = matched || skipped;
+        }
+      }
+    }
+    memo.set(key, result);
+    return result;
+  };
+
+  return rec(0, start);
+}
+
+/**
+ * @param {{ matchedContext: number, start: number, delta: number }} candidate
+ * @param {{ matchedContext: number, start: number, delta: number }} best
+ * @param {number} hint
+ * @returns {boolean}
+ */
+function betterAlignment(candidate, best, hint) {
+  // A literal (delta 0) alignment wins outright, so an exact `-` line keeps
+  // the anchor it had before indent-shifted matches existed.
+  if ((candidate.delta === 0) !== (best.delta === 0)) return candidate.delta === 0;
+  if (candidate.matchedContext !== best.matchedContext) {
+    return candidate.matchedContext > best.matchedContext;
+  }
+  const candidateDist = Math.abs(candidate.start - hint);
+  const bestDist = Math.abs(best.start - hint);
+  if (candidateDist !== bestDist) return candidateDist < bestDist;
+  return candidate.start < best.start;
+}
+
+/**
+ * @param {Array<{ kind: string, text: string }>} ops
+ * @param {string[]} fileLines
+ * @param {number} cursor
+ * @param {number} hint
+ * @returns {{
+ *   skip: boolean,
+ *   start: number,
+ *   end: number,
+ *   replacement: string[],
+ *   removed: string[],
+ *   added: string[],
+ *   addFlags: boolean[],
+ *   matchedContext: number,
+ *   delta: number,
+ *   relocated: boolean,
+ *   adapted: boolean,
+ * } | null}
+ */
+function locateHunk(ops, fileLines, cursor, hint) {
+  const nDel = ops.reduce((n, op) => n + (op.kind === 'del' ? 1 : 0), 0);
+  const nAdd = ops.reduce((n, op) => n + (op.kind === 'add' ? 1 : 0), 0);
+  const nCtx = ops.reduce((n, op) => n + (op.kind === 'context' ? 1 : 0), 0);
+  if (nDel === 0 && nAdd === 0) {
+    return {
+      skip: true,
+      start: cursor,
+      end: cursor,
+      replacement: [],
+      removed: [],
+      added: [],
+      addFlags: [],
+      matchedContext: 0,
+      delta: 0,
+      relocated: false,
+      adapted: false,
+    };
+  }
+  // Pure insertion with no context: the hunk header is the only anchor.
+  if (nDel === 0 && nCtx === 0) {
+    const at = Math.min(Math.max(hint, cursor), fileLines.length);
+    const added = ops.filter((op) => op.kind === 'add').map((op) => op.text);
+    return {
+      skip: false,
+      start: at,
+      end: at,
+      replacement: added,
+      removed: [],
+      added,
+      addFlags: added.map(() => true),
+      matchedContext: 0,
+      delta: 0,
+      relocated: false,
+      adapted: false,
+    };
+  }
+
+  /** @type {{ start: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[], matchedContext: number, delta: number } | null} */
+  let best = null;
+  for (const delta of candidateDeltas(ops, fileLines)) {
+    /** @type {number[]} */
+    const starts = [];
+    for (let s = cursor; s < fileLines.length; s++) {
+      for (const op of ops) {
+        if (op.kind === 'add') continue;
+        const shifted = shiftIndent(op.text, delta);
+        if (shifted !== null && fileLines[s] === shifted) {
+          starts.push(s);
+          break;
+        }
+      }
+    }
+    if (nAdd > 0) starts.push(fileLines.length);
+
+    for (const start of starts) {
+      const found = alignHunkAt(ops, fileLines, start, delta);
+      if (!found || found.end < start) continue;
+      const candidate = {
+        start,
+        end: found.end,
+        replacement: found.replacement,
+        addFlags: found.addFlags,
+        removed: found.removed,
+        added: found.added,
+        matchedContext: found.matchedContext,
+        delta,
+      };
+      if (!best || betterAlignment(candidate, best, hint)) best = candidate;
+    }
+  }
+
+  if (!best) return null;
+  // A pure insertion whose context matched nothing has no safe anchor.
+  if (nDel === 0 && best.matchedContext === 0 && nCtx > 0) return null;
+  const adapted = adaptHunkAdditions(best, ops, fileLines);
+  return { skip: false, ...adapted, relocated: best.start !== hint };
+}
+
+/**
+ * Rewrite '+' lines when drifted context reveals a rename. File lines that
+ * were kept as context are not touched.
+ *
+ * @param {{ start: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[], matchedContext: number, delta: number }} best
+ * @param {Array<{ kind: string, text: string }>} ops
+ * @param {string[]} fileLines
+ * @returns {{ start: number, end: number, replacement: string[], addFlags: boolean[], removed: string[], added: string[], matchedContext: number, delta: number, adapted: boolean }}
+ */
+function adaptHunkAdditions(best, ops, fileLines) {
+  /** @type {string[]} */
+  const contexts = [];
+  for (const op of ops) {
+    if (op.kind === 'context' && !isEllipsis(op.text)) contexts.push(op.text);
+  }
+  const mapping = identMapForLines(fileLines, contexts, best.start - 40, best.end + 40);
+  if (mapping.size === 0) return { ...best, adapted: false };
+  /** @type {string[]} */
+  const added = [];
+  let adapted = false;
+  const flags = best.addFlags || [];
+  const replacement = best.replacement.map((line, i) => {
+    if (!flags[i]) return line;
+    const next = applyIdentMap(line, mapping);
+    if (next !== line) adapted = true;
+    added.push(next);
+    return next;
+  });
+  return { ...best, replacement, added, adapted };
+}
+
+/**
+ * Replay a patch's `+`/`-` lines, allowing one indent shift per hunk and a
+ * match away from the hunk header.
+ *
+ * @param {string} originalContent
+ * @param {string[]} originalLines
+ * @param {Array<{ hint: number, ops: Array<{ kind: string, text: string }> }>} hunks
+ * @returns {{ content: string, delCounts: Map<string, number>, addCounts: Map<string, number>, shifted: boolean, relocated: boolean, adapted: boolean } | null}
+ */
+function walkIntent(originalContent, originalLines, hunks) {
+  const originalNoTrailingNewline =
+    !!originalContent && originalContent.length > 0 && !/[\n\r]$/.test(originalContent);
+  let endsWithoutNewline = false;
+  /** @type {string[]} */
+  const newLines = [];
+  let cursor = 0;
+  /** @type {Map<string, number>} */
+  const delCounts = new Map();
+  /** @type {Map<string, number>} */
+  const addCounts = new Map();
+  let shifted = false;
+  let relocated = false;
+  let adapted = false;
+
+  const pushOriginal = (k) => {
+    newLines.push(originalLines[k]);
+    endsWithoutNewline = k === originalLines.length - 1 && originalNoTrailingNewline;
+  };
+  const bump = (map, text) => map.set(text, (map.get(text) || 0) + 1);
+
+  for (const hunk of hunks) {
+    const located = locateHunk(hunk.ops, originalLines, cursor, hunk.hint);
+    if (!located) return null;
+    if (located.skip) continue;
+    if (located.delta) shifted = true;
+    if (located.relocated) relocated = true;
+    if (located.adapted) adapted = true;
+    for (let k = cursor; k < located.start; k++) pushOriginal(k);
+    for (const line of located.removed) bump(delCounts, line);
+    for (const line of located.added) bump(addCounts, line);
+    for (const line of located.replacement) {
+      newLines.push(line);
+      endsWithoutNewline = false;
+    }
+    cursor = located.end;
+  }
+
+  for (let k = cursor; k < originalLines.length; k++) pushOriginal(k);
+
+  let content = newLines.join('\n');
+  if (content && !endsWithoutNewline) content += '\n';
+  return { content, delCounts, addCounts, shifted, relocated, adapted };
+}
+
+/**
+ * Whether `updatedContent` does something other than apply this diff's
+ * `+`/`-` lines to `originalContent`.
+ *
+ * Armed when a context line does not occur anywhere in the original file —
+ * the case where a model copies the diff's stale context in, or drops lines
+ * the hunk never removed. A context line that differs only by a uniform
+ * indentation shift, or a hunk that matches somewhere other than its `@@`
+ * line, still counts as context: the edit is accepted at the file's indent.
+ * A result that deletes any other line, or an empty rewrite of a non-empty
+ * file, is still a violation.
+ *
+ * A `-` line that merely fails to match (quotes, whitespace) does not by
+ * itself arm the check when every context line is present as written, so a
+ * fuzzy model rewrite of that line can still stand.
+ *
+ * @param {string} originalContent
+ * @param {string} updatedContent
+ * @param {string} patch
+ * @returns {boolean}
+ */
+export function diffOutputViolatesIntent(originalContent, updatedContent, patch) {
+  const hunks = parsePatchHunks(patch);
+  if (!hunks || hunks.length === 0) return false;
+
+  const originalLines = splitLines(originalContent || '');
+  const updatedLines = splitLines(updatedContent || '');
+  const present = new Set(originalLines);
+  /** @type {Map<string, number>} */
+  const delCounts = new Map();
+  /** @type {Map<string, number>} */
+  const addCounts = new Map();
+  let badContext = false;
+  for (const hunk of hunks) {
+    for (const op of hunk.ops) {
+      if (op.kind === 'context') {
+        if (!present.has(op.text)) badContext = true;
+      } else if (op.kind === 'del') {
+        delCounts.set(op.text, (delCounts.get(op.text) || 0) + 1);
+      } else if (op.kind === 'add') {
+        addCounts.set(op.text, (addCounts.get(op.text) || 0) + 1);
+      }
+    }
+  }
+
+  const walked = walkIntent(originalContent, originalLines, hunks);
+
+  // Empty output is not a successful apply unless the anchored edit itself
+  // deletes every remaining line and adds nothing.
+  if (isBlank(updatedContent) && !isBlank(originalContent)) {
+    if (walked && !editViolates(originalLines, updatedLines, walked.delCounts, walked.addCounts)) {
+      return false;
+    }
+    return true;
+  }
+
+  if (!badContext) return false;
+
+  // Indent-shifted or relocated hunk: only the file-side +/- edit is in bounds.
+  if (walked) return editViolates(originalLines, updatedLines, walked.delCounts, walked.addCounts);
+  return editViolates(originalLines, updatedLines, delCounts, addCounts);
+}
+
+/**
+ * Apply only the `+`/`-` lines of a patch, ignoring context lines that are
+ * not actually in the file.
+ *
+ * A context or `-` line may match with a uniform indentation shift, and the
+ * hunk may sit somewhere other than the hunk header. Added lines are written
+ * at that same indent. When drifted context pairs a diff name with the
+ * file's own name (`user_id` in the diff, `uid` in the file), `+` lines are
+ * rewritten onto those names. Returns null when a `-` line cannot be found
+ * even then, when a pure insertion has no matching context to anchor it, or
+ * when a body line is ambiguous. Never writes a context line that was not
+ * already in the original.
+ *
+ * @param {string} originalContent
+ * @param {string} patch
+ * @returns {string | null}
+ */
+export function applyIntentIgnoringBadContext(originalContent, patch) {
+  const hunks = parsePatchHunks(patch);
+  if (!hunks || hunks.length === 0) return null;
+  const originalLines = splitLines(originalContent || '');
+  const walked = walkIntent(originalContent, originalLines, hunks);
+  if (!walked) return null;
+  return walked.content;
+}
+
+/**
+ * Deterministic +/- apply that rewrote at least one added identifier onto
+ * a name the file already uses. Null when the hunk cannot be anchored or
+ * when no identifier changed, so the caller can still ask the model.
+ *
+ * @param {string} originalContent
+ * @param {string} patch
+ * @returns {string | null}
+ */
+export function applyAdaptedIdentifiers(originalContent, patch) {
+  const hunks = parsePatchHunks(patch);
+  if (!hunks || hunks.length === 0) return null;
+  const originalLines = splitLines(originalContent || '');
+  const walked = walkIntent(originalContent, originalLines, hunks);
+  if (!walked || !walked.adapted) return null;
+  return walked.content;
+}