fix(diff): correct inline highlight offsets for tab and whitespace changes

Diff on raw code so whitespace-only changes (e.g. tab to spaces) are
detected, then map raw offsets to rendered offsets using expandtabs
column semantics with a defensive fallback if lengths mismatch.

- Add _build_offset_map using expandtabs column tracking with bounded
  monotonic fallback when rendered length diverges
- Reuse highlighted Text objects for skipped (low-similarity) pairs to
  avoid redundant highlighting
- Preserve trailing whitespace in highlighted output (strip only the
  newline Pygments appends, not meaningful trailing spaces)
- Use public Text.spans instead of private Text._spans in tests
- Add tests for tab-indented diffs, tab-to-space changes, mixed
  tab+space edits, precise per-character offsets, and trailing
  whitespace preservation

Author: ahyangyi

CHANGELOG.md

@@ -32,6 +32,7 @@ Only write entries that are worth mentioning to users.
 - Shell: Add `/undo` and `/fork` commands for session forking — `/undo` lets you pick a previous turn and fork a new session with the selected message pre-filled for re-editing; `/fork` duplicates the entire session history into a new session; the original session is always preserved
 - CLI: Add `-r` as a short alias for `--session` and print a resume hint (`kimi -r <session-id>`) whenever a session exits — covers normal exit, Ctrl-C, `/undo`, `/fork`, and `/sessions` switch so users can always find their way back
 - Core: Fix `custom_headers` not being passed to non-Kimi providers — OpenAI, Anthropic, Google GenAI, and Vertex AI providers now correctly forward custom headers configured in `providers.*.custom_headers`
+- Shell: Fix inline diff highlights misaligned on lines containing tabs — raw-code diff offsets are now mapped to rendered positions via expandtabs column tracking so highlight spans land correctly after tab expansion
 
 ## 1.29.0 (2026-04-01)
 

src/kimi_cli/utils/rich/diff_render.py

@@ -139,10 +139,48 @@ def _make_highlighter(path: str) -> KimiSyntax:
 
 def _highlight(highlighter: KimiSyntax, code: str) -> Text:
     t = highlighter.highlight(code)
-    t.rstrip()
+    # Pygments appends a trailing newline (ensurenl=True); strip only that,
+    # not trailing whitespace which may be meaningful in diffs.
+    if t.plain.endswith("\n"):
+        t.right_crop(1)
     return t
 
 
+def _build_offset_map(raw: str, rendered: str, tab_size: int) -> list[int]:
+    """Build a mapping from raw-string indices to rendered-string indices.
+
+    The highlighter expands tabs via ``str.expandtabs(tab_size)`` before
+    tokenising.  We replicate the same column-aware expansion that the
+    Python builtin defines (the only parameter is *tab_size*; the behaviour
+    is fully specified in the language docs and has no external
+    configurability).
+
+    Returns a list of length ``len(raw) + 1`` where ``result[i]`` is the
+    rendered offset corresponding to raw position *i*.
+    """
+    if raw == rendered:
+        return list(range(len(raw) + 1))
+    offsets: list[int] = []
+    col = 0
+    for ch in raw:
+        offsets.append(col)
+        if ch == "\t":
+            col += tab_size - (col % tab_size)
+        else:
+            col += 1
+    offsets.append(col)
+    if col != len(rendered):
+        # The highlighter transformed the text in a way we didn't expect.
+        # Return a bounded, monotonic best-effort map so inline stylizing
+        # can proceed without crashing or producing out-of-range offsets.
+        rendered_len = len(rendered)
+        raw_len = len(raw)
+        if raw_len == 0:
+            return [rendered_len]
+        return [(i * rendered_len) // raw_len for i in range(raw_len)] + [rendered_len]
+    return offsets
+
+
 def _apply_inline_diff(
     highlighter: KimiSyntax,
     del_lines: list[DiffLine],
@@ -153,20 +191,27 @@ def _apply_inline_diff(
     Modifies DiffLine.content in place for paired lines.
     """
     colors = get_diff_colors()
+    tab_size = highlighter.tab_size
     paired = min(len(del_lines), len(add_lines))
     for j in range(paired):
         old_code = del_lines[j].code
         new_code = add_lines[j].code
+        old_text = _highlight(highlighter, old_code)
+        new_text = _highlight(highlighter, new_code)
+        # Store highlighted content even when skipping inline pairing,
+        # so _highlight_hunk's second pass doesn't re-highlight these lines.
+        del_lines[j].content = old_text
+        add_lines[j].content = new_text
         sm = SequenceMatcher(None, old_code, new_code)
         if sm.ratio() < _INLINE_DIFF_MIN_RATIO:
             continue
-        old_text = _highlight(highlighter, old_code)
-        new_text = _highlight(highlighter, new_code)
+        old_map = _build_offset_map(old_code, old_text.plain, tab_size)
+        new_map = _build_offset_map(new_code, new_text.plain, tab_size)
         for op, i1, i2, j1, j2 in sm.get_opcodes():
             if op in ("delete", "replace"):
-                old_text.stylize(colors.del_hl, i1, i2)
+                old_text.stylize(colors.del_hl, old_map[i1], old_map[i2])
             if op in ("insert", "replace"):
-                new_text.stylize(colors.add_hl, j1, j2)
+                new_text.stylize(colors.add_hl, new_map[j1], new_map[j2])
         del_lines[j].content = old_text
         del_lines[j].is_inline_paired = True
         add_lines[j].content = new_text

tests/utils/test_diff_render.py

@@ -163,6 +163,187 @@ def test_unequal_block_sizes_partial_pairing(self) -> None:
         # 3rd delete not paired
         assert not deletes[2].is_inline_paired
 
+    def test_inline_diff_with_tabs(self) -> None:
+        """Inline highlight offsets must account for tab-to-space expansion."""
+        old = "\told_value = 1"
+        new = "\tnew_value = 2"
+        hunks = _build_diff_lines(old, new, 1, 1)
+        hl = _make_highlighter("test.py")
+        _highlight_hunk(hl, hunks[0])
+        deletes = [dl for dl in hunks[0] if dl.kind == DiffLineKind.DELETE]
+        adds = [dl for dl in hunks[0] if dl.kind == DiffLineKind.ADD]
+        assert deletes[0].is_inline_paired
+        assert adds[0].is_inline_paired
+        assert deletes[0].content is not None
+        assert adds[0].content is not None
+        del_plain = deletes[0].content.plain
+        add_plain = adds[0].content.plain
+        assert "old_value" in del_plain
+        assert "new_value" in add_plain
+        # Verify the highlight spans cover the actual changed words,
+        # not characters shifted by unexpanded-tab offsets.
+        from kimi_cli.utils.rich.diff_render import get_diff_colors
+
+        colors = get_diff_colors()
+        assert deletes[0].content is not None
+        assert adds[0].content is not None
+        del_hl_spans = [
+            (s.start, s.end) for s in deletes[0].content.spans if s.style == colors.del_hl
+        ]
+        add_hl_spans = [(s.start, s.end) for s in adds[0].content.spans if s.style == colors.add_hl]
+        # The highlighted region in the old line must cover "old" (from old_value)
+        del_highlighted = "".join(del_plain[s:e] for s, e in del_hl_spans)
+        add_highlighted = "".join(add_plain[s:e] for s, e in add_hl_spans)
+        assert "old" in del_highlighted, f"expected 'old' in highlighted text: {del_highlighted!r}"
+        assert "new" in add_highlighted, f"expected 'new' in highlighted text: {add_highlighted!r}"
+
+    def test_inline_diff_tab_to_spaces(self) -> None:
+        """A change from tab to spaces should be highlighted as an inline diff."""
+        old = "\tvalue = 1"
+        new = "    value = 1"
+        hunks = _build_diff_lines(old, new, 1, 1)
+        hl = _make_highlighter("test.py")
+        _highlight_hunk(hl, hunks[0])
+        deletes = [dl for dl in hunks[0] if dl.kind == DiffLineKind.DELETE]
+        adds = [dl for dl in hunks[0] if dl.kind == DiffLineKind.ADD]
+        assert deletes[0].is_inline_paired
+        assert adds[0].is_inline_paired
+        # The inline highlight should cover the indentation region where
+        # tab vs spaces differ.
+        from kimi_cli.utils.rich.diff_render import get_diff_colors
+
+        colors = get_diff_colors()
+        assert deletes[0].content is not None
+        assert adds[0].content is not None
+        del_hl_spans = [
+            (s.start, s.end) for s in deletes[0].content.spans if s.style == colors.del_hl
+        ]
+        add_hl_spans = [(s.start, s.end) for s in adds[0].content.spans if s.style == colors.add_hl]
+        # There must be highlight spans — the whitespace change should not be invisible
+        assert del_hl_spans, "tab indentation should be highlighted in deleted line"
+        assert add_hl_spans, "space indentation should be highlighted in added line"
+
+    def test_inline_diff_mixed_tab_and_space(self) -> None:
+        """Inline highlight must handle a tab adjacent to a literal space."""
+        old = "a\t b"
+        new = "a   b"
+        hunks = _build_diff_lines(old, new, 1, 1)
+        hl = _make_highlighter("test.txt")
+        _highlight_hunk(hl, hunks[0])
+        deletes = [dl for dl in hunks[0] if dl.kind == DiffLineKind.DELETE]
+        adds = [dl for dl in hunks[0] if dl.kind == DiffLineKind.ADD]
+        assert deletes[0].is_inline_paired
+        assert adds[0].is_inline_paired
+        from kimi_cli.utils.rich.diff_render import get_diff_colors
+
+        colors = get_diff_colors()
+        assert deletes[0].content is not None
+        assert adds[0].content is not None
+        del_hl_spans = [
+            (s.start, s.end) for s in deletes[0].content.spans if s.style == colors.del_hl
+        ]
+        add_hl_spans = [(s.start, s.end) for s in adds[0].content.spans if s.style == colors.add_hl]
+        # The tab+space region in the old line must be highlighted with a
+        # non-zero width — not collapsed to an empty range.
+        assert del_hl_spans, "tab+space region should be highlighted in deleted line"
+        assert all(s < e for s, e in del_hl_spans), "highlight spans must have non-zero width"
+        assert add_hl_spans, "space region should be highlighted in added line"
+        assert all(s < e for s, e in add_hl_spans), "highlight spans must have non-zero width"
+
+    def test_inline_diff_tab_to_spaces_precise(self) -> None:
+        """Highlight spans must cover exactly the indentation region."""
+        # "a\tb" with tab_size=4: rendered as "a   b" (tab expands to 3 spaces)
+        # "a   b": literal 3 spaces
+        # The only difference is the tab vs 3 spaces — both render as "a   b".
+        # The highlight should cover the whitespace region (rendered[1:4]).
+        old = "a\tb"
+        new = "a   b"
+        hunks = _build_diff_lines(old, new, 1, 1)
+        hl = _make_highlighter("test.txt")
+        _highlight_hunk(hl, hunks[0])
+        deletes = [dl for dl in hunks[0] if dl.kind == DiffLineKind.DELETE]
+        adds = [dl for dl in hunks[0] if dl.kind == DiffLineKind.ADD]
+        assert deletes[0].is_inline_paired
+        assert adds[0].is_inline_paired
+        from kimi_cli.utils.rich.diff_render import get_diff_colors
+
+        colors = get_diff_colors()
+        assert deletes[0].content is not None
+        assert adds[0].content is not None
+        del_hl_spans = [
+            (s.start, s.end) for s in deletes[0].content.spans if s.style == colors.del_hl
+        ]
+        add_hl_spans = [(s.start, s.end) for s in adds[0].content.spans if s.style == colors.add_hl]
+        del_plain = deletes[0].content.plain  # "a   b"
+        add_plain = adds[0].content.plain  # "a   b"
+        del_highlighted = "".join(del_plain[s:e] for s, e in del_hl_spans)
+        add_highlighted = "".join(add_plain[s:e] for s, e in add_hl_spans)
+        # The highlighted region must be exactly the whitespace, not spill into "a" or "b".
+        assert "a" not in del_highlighted, f"'a' should not be highlighted: {del_hl_spans}"
+        assert "b" not in del_highlighted, f"'b' should not be highlighted: {del_hl_spans}"
+        assert "a" not in add_highlighted, f"'a' should not be highlighted: {add_hl_spans}"
+        assert "b" not in add_highlighted, f"'b' should not be highlighted: {add_hl_spans}"
+        assert del_hl_spans, "whitespace region should be highlighted in deleted line"
+        assert add_hl_spans, "whitespace region should be highlighted in added line"
+
+    def test_inline_diff_multiple_tabs_precise(self) -> None:
+        """Changing only the first tab must not highlight the second tab."""
+        # old: "a\t\ta" with tab_size=4 renders as "a       a"
+        #       a=col0, tab1 expands to 3sp (cols 1-3), tab2 expands to 4sp (cols 4-7), a=col8
+        # new: "a \ta" renders as "a   a"
+        #       a=col0, space=col1, tab expands to 2sp (cols 2-3), a=col4
+        # Only the first tab (old rendered[1:4]) should be highlighted,
+        # NOT the second tab (old rendered[4:8]).
+        old = "a\t\ta"
+        new = "a \ta"
+        hunks = _build_diff_lines(old, new, 1, 1)
+        hl = _make_highlighter("test.txt")
+        _highlight_hunk(hl, hunks[0])
+        deletes = [dl for dl in hunks[0] if dl.kind == DiffLineKind.DELETE]
+        assert deletes[0].is_inline_paired
+        assert deletes[0].content is not None
+        from kimi_cli.utils.rich.diff_render import get_diff_colors
+
+        colors = get_diff_colors()
+        del_hl_spans = [
+            (s.start, s.end) for s in deletes[0].content.spans if s.style == colors.del_hl
+        ]
+        # The highlight in the old line must cover only the first tab's
+        # rendered region [1:4], not spill into the second tab [4:8].
+        assert del_hl_spans, "first tab region should be highlighted"
+        for s, e in del_hl_spans:
+            assert e <= 4, (
+                f"highlight span ({s},{e}) extends into second tab region "
+                f"(rendered[4:8]), should stop at 4"
+            )
+
+    def test_inline_diff_trailing_whitespace(self) -> None:
+        """Trailing whitespace must be preserved and highlighted in diffs."""
+        old = "hello   "
+        new = "hello"
+        hunks = _build_diff_lines(old, new, 1, 1)
+        hl = _make_highlighter("test.txt")
+        _highlight_hunk(hl, hunks[0])  # should not raise
+        deletes = [dl for dl in hunks[0] if dl.kind == DiffLineKind.DELETE]
+        adds = [dl for dl in hunks[0] if dl.kind == DiffLineKind.ADD]
+        assert deletes[0].is_inline_paired
+        assert adds[0].is_inline_paired
+        # Trailing spaces must be preserved in the rendered content,
+        # not stripped away — they are a meaningful part of the diff.
+        assert deletes[0].content is not None
+        assert deletes[0].content.plain == "hello   "
+        from kimi_cli.utils.rich.diff_render import get_diff_colors
+
+        colors = get_diff_colors()
+        del_hl_spans = [
+            (s.start, s.end) for s in deletes[0].content.spans if s.style == colors.del_hl
+        ]
+        # The trailing spaces should be highlighted as the deleted region.
+        del_highlighted = "".join(deletes[0].content.plain[s:e] for s, e in del_hl_spans)
+        assert "   " in del_highlighted, (
+            f"trailing spaces should be highlighted, got: {del_highlighted!r}"
+        )
+
 
 # ---------------------------------------------------------------------------
 # collect_diff_hunks