Merge branch 'break'

Author: capocasa

src/threecode/engine.nim

@@ -243,7 +243,16 @@ proc diffRowBytes(text, prevText: string; width: int): string =
   ## clears to end of line without touching the next row: padding to the
   ## full width would put the cursor on the last cell, which a following
   ## `\n` (or the terminal's pending wrap) turns into an extra row shift.
-  result = "\r" & text & "\x1b[K"
+  ## A row whose text fills the width skips the EL: in the wrap-pending
+  ## state the cursor still rests ON the last cell, and EL erases from
+  ## the cursor cell inclusive (xterm's ClearRight), which would blank
+  ## the just-written char or caret cell that filled the margin. ttty
+  ## models EL as preserving that cell, so only a real terminal shows
+  ## the loss.
+  if width > 0 and minline.visualCols(text) >= width:
+    result = "\r" & text
+  else:
+    result = "\r" & text & "\x1b[K"
 
 proc paintVolatileRegion*(e: var TerminalEngine; width: int;
                           sections: openArray[VolatileRow];

src/threecode/minline.nim

@@ -494,11 +494,13 @@ proc lineSpans*(text: string; promptW, contW, width: int): seq[LineSpan] =
     let rw = runeCellWidth(text.runeAt(i))
     if col + rw > width:
       if text[i] == ' ':
-        # A space that overflows is itself the break.
+        # A space that overflows is itself the break, and only that one
+        # space collapses into it. The rest of the run is typed content:
+        # it renders on the next row (via the caret slice while trailing,
+        # via the span once text follows) and the caret steps over it,
+        # instead of every trailing space vanishing into the wrap.
         result[result.high].stop = contentEnd
-        var s = i
-        while s < text.len and text[s] == ' ':
-          s += runeLenSafe(text, s)
+        let s = i + runeLenSafe(text, i)
         result.add (s, s)
         i = s
         col = contW

tests/core/test_minline.nim

@@ -191,11 +191,13 @@ suite "minline pure helpers":
     let bytes = renderBuffer("hello world", "", "", 5)
     check bytes == "hello\r\nworld"
 
-  test "renderBuffer: multi-space run collapses at the break":
-    # width 5: "a" then 8 spaces then "b". The spaces overflow and form one
-    # break run; "b" lands on row 1 with no leading spaces.
+  test "renderBuffer: multi-space run keeps all but one space":
+    # width 5: "a" then 8 spaces then "b". Exactly one space collapses
+    # into the wrap (the first that overflows the row); the rest are
+    # content the user typed: the ones that still fit row 0 are blank
+    # cells beyond the painted slice, the others render leading row 1.
     let bytes = renderBuffer("a        b", "", "", 5)
-    check bytes == "a\r\nb"
+    check bytes == "a\r\n   b"
 
   test "renderBuffer: word-wrap does not duplicate fragment on original line":
     # width 30, prompt 2, contW 2 -> 28 data cells per row.

tests/tty/probe_margin_bytes.nim

@@ -0,0 +1,142 @@
+## Byte-capture repro for the two margin bugs:
+##
+## 1. typing the char that fills the last column: caret and char omitted.
+## 2. multiple trailing spaces: all collapsed into the wrap, not just one.
+##
+## Drives the real stub binary under a PTY at width 12 and dumps the exact
+## bytes each keystroke paints, plus the grid state.
+
+import std/[json, os, strutils, unicode]
+import tty_expect, stub_helpers
+import ttty/grid
+
+proc newFixture(name: string): string =
+  result = getCurrentDir() / "testdata" / "output" / "tty" /
+    (name & "_" & $getCurrentProcessId())
+  if dirExists(result): removeDir(result)
+  createDir(result); createDir(result / "data"); createDir(result / "run")
+
+proc writeConfiguredProvider(root: string) =
+  createDir(root / "xdg" / "3code")
+  writeFile(root / "xdg" / "3code" / "config", """
+[settings]
+current = "stub.stub-model"
+
+[provider]
+name = "stub"
+url = "stub://provider"
+key = "stub"
+family = "glm"
+models = "stub-model"
+""")
+
+proc stubEnv(root, responsesPath: string): seq[EnvVar] =
+  createDir(root / "tmp")
+  @[
+    (key: "TERM", val: "xterm-256color"),
+    (key: "PATH", val: getEnv("PATH")),
+    (key: "HOME", val: root),
+    (key: "TMPDIR", val: root / "tmp"),
+    (key: "XDG_CONFIG_HOME", val: root / "xdg"),
+    (key: "XDG_DATA_HOME", val: root / "data"),
+    (key: "THREECODE_STUB_RESPONSES", val: responsesPath),
+  ]
+
+proc startStub(root: string; cols = DefaultTtyCols; rows = DefaultTtyRows): TtySession =
+  newTtySession(ensureStubBinary(), args = ["-x", "-i"], cwd = root / "run",
+                env = stubEnv(root, root / "run" / "stub_responses.json"),
+                cols = cols, rows = rows)
+
+proc vis(b: string): string =
+  ## escape bytes made readable
+  for ch in b:
+    case ch
+    of '\x1b': result.add "<E>"
+    of '\r': result.add "<CR>"
+    of '\n': result.add "<LF>"
+    of '\x7f': result.add "<DEL>"
+    else: result.add ch
+
+proc dump(s: TtySession; label: string) =
+  s.drain(150, recordFrame = true)
+  echo "=== [", label, "] cursor row=", s.grid.row, " col=", s.grid.col, " ==="
+  for i, row in s.grid.rows:
+    var line = ""
+    for cell in row:
+      let ch = cell.rune.toUTF8
+      if cell.attrs.hasAttr(saReverse): line.add "[" & ch & "]"
+      else: line.add ch
+    echo align($i, 2), " |", line, "|"
+
+proc typeSlow(s: TtySession; text: string) =
+  for ch in text:
+    s.send $ch
+    s.drain(40)
+
+when isMainModule:
+  let root = newFixture("margin_bytes_a")
+  writeConfiguredProvider(root)
+  writeFile(root / "run" / "stub_responses.json", $(%*[
+    {"content": "ok", "usage": {"promptTokens": 1, "completionTokens": 1,
+                                "totalTokens": 2, "cachedTokens": 0}}
+  ]))
+
+  # Width 12: prompt "❯ " is 2 cells, 10 data cells fill the row.
+  let tty = startStub(root, cols = 12, rows = 14)
+  tty.expect "\u276f"
+  tty.expectIdleCaret()
+  discard tty.freshRaw()
+  tty.advanceRawMark()
+  dump(tty, "w12 idle")
+
+  typeSlow(tty, "012345678")
+  tty.expectIdleCaret()
+  var raw = tty.freshRaw()
+  echo "--- bytes for '012345678' ---"
+  echo raw.vis
+  tty.advanceRawMark()
+  dump(tty, "nine chars")
+
+  tty.send "9"
+  tty.expectIdleCaret()
+  raw = tty.freshRaw()
+  echo "--- bytes for '9' (fills last cell) ---"
+  echo raw.vis
+  tty.advanceRawMark()
+  dump(tty, "tenth char fills row")
+
+  tty.send "x"
+  tty.expectIdleCaret()
+  raw = tty.freshRaw()
+  echo "--- bytes for 'x' (wraps to next row) ---"
+  echo raw.vis
+  tty.advanceRawMark()
+  dump(tty, "eleventh char wraps")
+  tty.close()
+
+  # Spaces: "abcdefg" + 5 spaces. abcdefg occupies cols 2..8; three spaces
+  # fit (cols 9..11), the fourth is the margin break, the fifth belongs on
+  # the next row.
+  let root2 = newFixture("margin_bytes_b")
+  writeConfiguredProvider(root2)
+  writeFile(root2 / "run" / "stub_responses.json", $(%*[
+    {"content": "ok", "usage": {"promptTokens": 1, "completionTokens": 1,
+                                "totalTokens": 2, "cachedTokens": 0}}
+  ]))
+  let t2 = startStub(root2, cols = 12, rows = 14)
+  t2.expect "\u276f"
+  t2.expectIdleCaret()
+  discard t2.freshRaw()
+  t2.advanceRawMark()
+  typeSlow(t2, "abcdefg")
+  t2.expectIdleCaret()
+  t2.advanceRawMark()
+  dump(t2, "seven chars")
+  for n in 1 .. 5:
+    t2.send " "
+    t2.expectIdleCaret()
+    echo "--- bytes for space #", n, " ---"
+    echo t2.freshRaw().vis
+    t2.advanceRawMark()
+    dump(t2, "after space #" & $n)
+  t2.close()

tests/tty/test_tty_functional.nim

@@ -3235,6 +3235,12 @@ when false:
     check tty.drawnCaretCount(promptRow) == 0
     check tty.drawnCaretCount(promptRow + 1) == 1
     check tty.drawnCaretCol(promptRow + 1) == 2
+    # Byte contract, not grid: in the wrap-pending state xterm's cursor
+    # still rests ON the last cell and EL erases from the cursor cell
+    # inclusive, so a full row followed by `\x1b[K` blanks the char that
+    # filled the margin. ttty models EL as preserving that cell, which
+    # is exactly why the grid checks above can't catch the loss.
+    check "\u276f 0123456789\x1b[K" notin tty.raw
     # Keep typing: the wrap settles on that same row, in place; no
     # content moved and the prompt row did not shift down.
     tty.send "xy"
@@ -3258,7 +3264,37 @@ when false:
     tty.expectIdleCaret()
     check tty.rows()[promptRow].startsWith("\u276f abcdefg")
     check tty.rows()[promptRow + 1] == "  xy"
-    check tty.drawnCaretCol(promptRow + 1) == 4
+    # Only ONE trailing space may collapse into the wrap. Typing spaces
+    # one keystroke at a time past the margin: each one after the
+    # collapsed break must paint on the caret's row and advance the
+    # caret a cell. Before the fix the whole trailing run collapsed into
+    # the break: the caret froze at the continuation prompt while the
+    # user kept typing spaces (arrow keys still stepped over every one).
+    tty.send "\x1b"
+    tty.drain(200)
+    tty.send "abcdefg"
+    tty.expectIdleCaret()
+    check tty.drawnCaretCol(promptRow) == 9
+    tty.send " "
+    tty.expectIdleCaret()
+    check tty.drawnCaretCol(promptRow) == 10
+    tty.send " "
+    tty.expectIdleCaret()
+    check tty.drawnCaretCol(promptRow) == 11
+    # The third space fills the row's last cell: the caret drops to the
+    # row below, the wrap's home.
+    tty.send " "
+    tty.expectIdleCaret()
+    check tty.drawnCaretCol(promptRow + 1) == 2
+    # The fourth space is the one space the wrap collapses.
+    tty.send " "
+    tty.expectIdleCaret()
+    check tty.drawnCaretCol(promptRow + 1) == 2
+    # The fifth paints and the caret advances past it.
+    tty.send " "
+    tty.expectIdleCaret()
+    check tty.drawnCaretCol(promptRow + 1) == 3
+    check tty.rows()[promptRow].startsWith("\u276f abcdefg")
     # Submit from the caret-only row: the transient row must vanish into
     # the committed block, with no blank row or leftover caret cell
     # between the committed prompt and the reply chrome.