fix(edit): replace segment-only NFKC mapper with full composition grouping

SebTardif · SebTardif · commit 5151cca255e4 · 2026-07-01T11:48:57.000-07:00
The mapLineOffsetThroughNfkc function previously only grouped base
characters with following combining marks (\p{M}). NFKC can also compose
adjacent non-mark code points (e.g., Hangul Compatibility Jamo
U+3131 + U+314F compose to U+AC00). This caused offset miscalculation
when such sequences appeared before a fuzzy-matched region.

Replace the combining-mark-only grouping with a greedy approach that
extends each segment as long as the next code point participates in NFKC
composition (i.e., normalizing the extended segment differs from
normalizing each part separately).

Add a Hangul Jamo regression test that verifies correct offset mapping
when Compatibility Jamo compose under NFKC.

Signed-off-by: Sebastien Tardif &lt;sebtardif@ncf.ca&gt;
diff --git a/src/agents/sessions/tools/edit-diff.test.ts b/src/agents/sessions/tools/edit-diff.test.ts
@@ -194,6 +194,30 @@ describe("applyEditsToNormalizedContent", () => {
     expect(lines[1]).toBe("footer");
   });
 
+  it("fuzzy match handles Hangul Jamo composition (non-combining-mark NFKC merge)", () => {
+    // Hangul Compatibility Jamo ㄱ (U+3131) + ㅏ (U+314F) compose to 가
+    // under NFKC (2 code points -> 1), but ㅏ is NOT a combining mark
+    // (\p{M}), so the old segment-only mapper that only grouped base +
+    // combining marks would treat them as separate segments and miscount
+    // the NFKC offsets.
+    const content = [
+      "\u3131\u314F X = \u2018val\u2019;",
+      "footer",
+    ].join("\n");
+
+    // Smart quotes trigger fuzzy matching; ㄱㅏ -> 가 shifts positions
+    const result = applyEditsToNormalizedContent(
+      normalizeToLF(content),
+      [{ oldText: "X = 'val';", newText: "Y = 'new';" }],
+      "test.ts",
+    );
+
+    const lines = result.newContent.split("\n");
+    // X must be consumed (replaced); Hangul Jamo preserved
+    expect(lines[0]).toBe("\u3131\u314F Y = 'new';");
+    expect(lines[1]).toBe("footer");
+  });
+
   it("baseContent is always the original content", () => {
     const content = "line with smart\u2019s\nline with trailing   ";
 
diff --git a/src/agents/sessions/tools/edit-diff.ts b/src/agents/sessions/tools/edit-diff.ts
@@ -206,9 +206,9 @@ function getNoChangeError(path: string, totalEdits: number): EditNoChangeError {
  * line. The other fuzzy normalizations (trimEnd, smart quotes, dashes,
  * special spaces) are same-length replacements that do not shift positions.
  *
- * This function groups each base character with its following combining marks
- * and normalizes the complete segment, so cross-code-point NFKC composition
- * is handled correctly.
+ * This function groups code points into composition blocks by checking
+ * whether adjacent code points interact under NFKC (combining marks,
+ * Hangul Jamo L+V+T composition, and any other cross-code-point merges).
  */
 function mapLineOffsetThroughNfkc(origLine: string, normOffset: number, snapToEnd = false): number {
   const nfkcLine = origLine.normalize("NFKC");
@@ -220,9 +220,10 @@ function mapLineOffsetThroughNfkc(origLine: string, normOffset: number, snapToEn
     return Math.min(normOffset, origLine.length);
   }
 
-  // Walk through original code points, grouping each base character with its
-  // following combining marks. Normalize each complete group with NFKC to
-  // find how many normalized code units it produces.
+  // Walk through original code points, grouping each base character with
+  // all following code points that participate in NFKC composition with it.
+  // This handles combining marks, Hangul Jamo (L+V+T → syllable), and any
+  // other cross-code-point compositions that NFKC performs.
   let origPos = 0;
   let nfkcPos = 0;
   const codePoints = Array.from(origLine);
@@ -233,12 +234,19 @@ function mapLineOffsetThroughNfkc(origLine: string, normOffset: number, snapToEn
       return origPos;
     }
 
-    // Collect base code point + any following combining marks as one segment.
+    // Greedily extend the segment as long as the next code point
+    // participates in NFKC composition with the current segment.
     let segment = codePoints[i];
     let segOrigLen = codePoints[i].length;
     i++;
-    while (i < codePoints.length && /^\p{M}/u.test(codePoints[i])) {
-      segment += codePoints[i];
+    while (i < codePoints.length) {
+      const extended = segment + codePoints[i];
+      const extNfkc = extended.normalize("NFKC");
+      const separateNfkc = segment.normalize("NFKC") + codePoints[i].normalize("NFKC");
+      if (extNfkc === separateNfkc) {
+        break; // next code point does not compose with segment
+      }
+      segment = extended;
       segOrigLen += codePoints[i].length;
       i++;
     }
