railmux 0.4.2.dev3__tar.gz → 0.4.2.dev4__tar.gz

{railmux-0.4.2.dev3/src/railmux.egg-info → railmux-0.4.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev3
+Version: 0.4.2.dev4
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.2.dev4/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.2.dev4"

{railmux-0.4.2.dev3 → railmux-0.4.2.dev4}/src/railmux/fast_display_server.py

@@ -1747,6 +1747,83 @@ def _transcript_rows(
         os.close(fd)
 
 
+_OVERLAP_STYLE_RE = re.compile(rb"\x1b\[[0-9;]*m")
+_OVERLAP_SPACE_RE = re.compile(r"\s+")
+_OVERLAP_ANCHOR_CHARS = 12
+_OVERLAP_SINGLE_ANCHOR_CHARS = 24
+_OVERLAP_SEARCH_SCREENS = 4
+_OVERLAP_MIN_SEARCH_ROWS = 200
+
+
+def _overlap_text(row: bytes) -> str:
+    """Return a row's visible text without styling or any whitespace.
+
+    The transcript and the provider wrap and indent the same message
+    differently, so only the whitespace-free character stream is comparable.
+    """
+    text = _OVERLAP_STYLE_RE.sub(b"", row).decode("utf-8", errors="replace")
+    return _OVERLAP_SPACE_RE.sub("", text)
+
+
+def _transcript_rows_before_screen(
+    transcript_rows: Sequence[bytes],
+    screen_rows: Sequence[bytes],
+) -> int:
+    """Return how many transcript rows precede the live screen's content.
+
+    Transcript-backed history appends the live viewport after the transcript,
+    whose tail usually holds the same newest message. Locate the screen's
+    text in the transcript tail through distinctive anchor rows and cut the
+    transcript where the screen begins. Two anchors must agree on that start
+    unless one long anchor is the only candidate; without a credible match
+    every transcript row is kept.
+    """
+    total = len(transcript_rows)
+    window = max(
+        _OVERLAP_MIN_SEARCH_ROWS, _OVERLAP_SEARCH_SCREENS * len(screen_rows))
+    first = max(0, total - window)
+    row_starts: list[int] = []
+    parts: list[str] = []
+    offset = 0
+    for row in transcript_rows[first:]:
+        row_starts.append(offset)
+        text = _overlap_text(row)
+        parts.append(text)
+        offset += len(text)
+    haystack = "".join(parts)
+    screen_offset = 0
+    starts: list[tuple[int, int]] = []
+    for row in screen_rows:
+        text = _overlap_text(row)
+        if len(text) >= _OVERLAP_ANCHOR_CHARS and haystack.count(text) == 1:
+            starts.append((haystack.index(text) - screen_offset, len(text)))
+            if len(starts) == 2:
+                break
+        screen_offset += len(text)
+    if not starts:
+        return total
+    if len(starts) == 1:
+        if starts[0][1] < _OVERLAP_SINGLE_ANCHOR_CHARS:
+            return total
+    else:
+        # Allow small rendering differences (list numbering, bullets).
+        tolerance = 16 + abs(starts[0][0]) // 20
+        if abs(starts[0][0] - starts[1][0]) > tolerance:
+            return total
+    start = max(0, starts[0][0])
+    # Keep a row that begins before the screen: it may carry text the screen
+    # no longer shows, and a partial duplicate is better than a loss.
+    keep = len(row_starts)
+    for index, row_start in enumerate(row_starts):
+        if row_start >= start:
+            keep = index
+            break
+    # Drop trailing blank rows so the screen is not preceded by a gap.
+    while keep and not parts[keep - 1]:
+        keep -= 1
+    return first + keep
+
+
 def _capture_pane_history(
     pyte: object,
     pane: _PaneGeometry,
@@ -1852,14 +1929,18 @@ def _capture_pane_history(
     transcript_used = transcript_entry is not None and bool(transcript_entry.rows)
     if transcript_used:
         assert transcript_entry is not None
-        transcript_lines = transcript_entry.rows
+        kept = _transcript_rows_before_screen(transcript_entry.rows, current_raw)
+        trimmed = len(transcript_entry.rows) - kept
+        transcript_lines = transcript_entry.rows[:kept]
         history_count = max(0, max_lines - pane.height)
         source_lines = (
             transcript_lines[-history_count:] if history_count else ()
         ) + current_raw
         timeline_end = max(
             pane.height,
-            (transcript_entry.total_rows or len(transcript_entry.rows)) + pane.height,
+            (transcript_entry.total_rows or len(transcript_entry.rows))
+            - trimmed
+            + pane.height,
         )
     else:
         source_lines = rendered_raw
@@ -1910,7 +1991,7 @@ def _capture_pane_history(
             budget_truncated
             or (
                 transcript_entry.more_available
-                or len(transcript_entry.rows) + pane.height > len(lines)
+                or len(transcript_lines) + pane.height > len(lines)
                 if transcript_used and transcript_entry is not None
                 else pane.history_size + pane.height > len(lines)
             )

{railmux-0.4.2.dev3 → railmux-0.4.2.dev4}/src/railmux/tmux_server.py

@@ -22,6 +22,8 @@ _SESSION_ID_RE = re.compile(r"[A-Za-z0-9-]{1,256}\Z")
 _HISTORY_SOURCE_SCHEMA = 1
 _TRANSCRIPT_SOURCE_SCHEMA = 1
 _MAX_TRANSCRIPT_SOURCE_BYTES = 8192
+_CONTINUATION_TAIL_BYTES = 4096
+_MAX_CONTINUATION_HOPS = 8
 _DEFAULT_DISCOVERY_TIMEOUT = 2.0
 _WINDOWS_DISCOVERY_TIMEOUT = 5.0
 
@@ -415,11 +417,8 @@ def decode_transcript_source(raw: str) -> TranscriptSource | None:
     return TranscriptSource(provider, session_id, path)
 
 
-def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
-    """Open an exact same-user transcript without following the final symlink."""
-    source = decode_transcript_source(raw)
-    if source is None:
-        return None
+def _open_owned_regular_file(path: Path) -> int | None:
+    """Open a same-user regular file without following the final symlink."""
     flags = os.O_RDONLY
     if hasattr(os, "O_CLOEXEC"):
         flags |= os.O_CLOEXEC
@@ -427,7 +426,7 @@ def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
         flags |= os.O_NOFOLLOW
     fd = -1
     try:
-        fd = os.open(source.path, flags)
+        fd = os.open(path, flags)
         info = os.fstat(fd)
     except OSError:
         if fd >= 0:
@@ -443,6 +442,67 @@ def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
     ):
         os.close(fd)
         return None
+    return fd
+
+
+def _claude_continuation_id(fd: int) -> str | None:
+    """Return the successor session named by a final ``continued-in`` record.
+
+    Claude Code can move a live conversation to a new session file, copying
+    the full history and ending the old file with one ``continued-in``
+    record. Only that exact final record is trusted.
+    """
+    try:
+        size = os.fstat(fd).st_size
+        tail = os.pread(
+            fd,
+            min(size, _CONTINUATION_TAIL_BYTES),
+            max(0, size - _CONTINUATION_TAIL_BYTES),
+        )
+    except OSError:
+        return None
+    lines = tail.rstrip(b"\n").rsplit(b"\n", 1)
+    if b"continued-in" not in lines[-1]:
+        return None
+    try:
+        record = json.loads(lines[-1])
+    except (UnicodeDecodeError, ValueError):
+        return None
+    if not isinstance(record, dict) or record.get("type") != "continued-in":
+        return None
+    successor = record.get("continuedInSessionId")
+    if not isinstance(successor, str) or not _SESSION_ID_RE.fullmatch(successor):
+        return None
+    return successor
+
+
+def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
+    """Open an exact same-user transcript without following the final symlink.
+
+    A Claude transcript that was continued in another session resolves to the
+    newest same-directory successor, so history keeps following the live pane.
+    """
+    source = decode_transcript_source(raw)
+    if source is None:
+        return None
+    fd = _open_owned_regular_file(source.path)
+    if fd is None:
+        return None
+    if source.provider != "claude":
+        return source, fd
+    seen = {source.session_id}
+    for _ in range(_MAX_CONTINUATION_HOPS):
+        successor = _claude_continuation_id(fd)
+        if successor is None or successor in seen:
+            break
+        path = source.path.with_name(f"{successor}.jsonl")
+        next_fd = _open_owned_regular_file(path)
+        if next_fd is None:
+            break
+        os.close(fd)
+        fd = next_fd
+        source = TranscriptSource(source.provider, successor, path)
+        seen.add(successor)
     return source, fd
 
 

{railmux-0.4.2.dev3 → railmux-0.4.2.dev4/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev3
+Version: 0.4.2.dev4
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.4.2.dev3 → railmux-0.4.2.dev4}/tests/test_fast_display_server.py

@@ -1593,6 +1593,85 @@ def test_server_claude_history_uses_stable_transcript_suffix(monkeypatch):
     assert hot.lines[-2:] == (b"live-a", b"live-b")
 
 
+def test_server_claude_history_drops_transcript_tail_shown_on_screen(monkeypatch):
+    pane = fast_display_server._PaneGeometry(
+        "%8",
+        31,
+        0,
+        24,
+        4,
+        mouse_forwardable=True,
+        alternate_on=True,
+        transcript_source="exact-marker",
+        transcript_backed=True,
+        claude_history_policy="local",
+    )
+    # The transcript wraps the newest answer at the pane edge while the live
+    # Claude screen uses a hanging indent and styling for the same text.
+    transcript_rows = (
+        b"\x1b[0mold question here\x1b[0m",
+        b"\x1b[0m\x1b[0m",
+        b"\x1b[0m\xe2\x97\x8f first answer line alph",
+        b"a beta gamma delta\x1b[0m",
+        b"\x1b[0m  second answer line kept\x1b[0m",
+    )
+    live = (
+        b"\xe2\x97\x8f first answer line",
+        b"  \x1b[1malpha beta gamma delta\x1b[0m",
+        b"  second answer line kept",
+        b"\xe2\x9d\xaf",
+    )
+    monkeypatch.setattr(
+        subprocess,
+        "check_output",
+        lambda *_args, **_kwargs: b"\n".join(live) + b"\n",
+    )
+    monkeypatch.setattr(
+        fast_display_server,
+        "_transcript_rows",
+        lambda *_args, **_kwargs: fast_display_server._TranscriptCacheEntry(
+            (1, 2, 3, 4), transcript_rows, False
+        ),
+    )
+    monkeypatch.setattr(
+        fast_display_server,
+        "_render_history_lines",
+        lambda _pyte, lines, _width: tuple(lines),
+    )
+
+    snapshot = fast_display_server._capture_pane_history(object(), pane, 1, 300)
+
+    assert snapshot is not None
+    assert snapshot.lines == (transcript_rows[0],) + live
+    assert snapshot.timeline_end == 1 + pane.height
+
+
+def test_transcript_overlap_keeps_rows_without_credible_screen_match():
+    rows = tuple(
+        f"repeated status line number {index % 2}".encode() for index in range(8)
+    )
+    unrelated = (b"nothing in common with the transcript at all", b"")
+    repeated = (b"repeated status line number 0", b"repeated status line number 1")
+    short = (b"tiny", b"")
+
+    keep = fast_display_server._transcript_rows_before_screen
+    assert keep(rows, unrelated) == len(rows)
+    assert keep(rows, repeated) == len(rows)
+    assert keep(rows, short) == len(rows)
+    assert keep((), unrelated) == 0
+
+
+def test_transcript_overlap_rejects_disagreeing_anchors():
+    rows = (
+        b"first distinctive anchor row",
+        b"filler " * 20,
+        b"second distinctive anchor row",
+    )
+    screen = (b"second distinctive anchor row", b"first distinctive anchor row")
+
+    assert fast_display_server._transcript_rows_before_screen(rows, screen) == 3
+
+
 @pytest.mark.parametrize(
     ("policy", "choice_required"),
     [("ask", True), ("native", False)],

{railmux-0.4.2.dev3 → railmux-0.4.2.dev4}/tests/test_tmux_server.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 import subprocess
 from types import SimpleNamespace
@@ -519,6 +520,65 @@ def test_transcript_source_round_trip_opens_only_exact_same_user_file(tmp_path):
     os.close(opened[1])
 
 
+def _continued_in(session_id: str) -> str:
+    return json.dumps({
+        "type": "continued-in",
+        "sessionId": "previous",
+        "continuedInSessionId": session_id,
+    }) + "\n"
+
+
+def test_claude_transcript_source_follows_continued_in_chain(tmp_path):
+    first, second, third = (
+        "47fca075-9cb8-44fb-a314-d57ef2256ad9",
+        "96fd3642-6c17-4c9b-8129-08d3d9db3e8a",
+        "02b59000-6bb4-4ec5-bdca-24f7a96b0467",
+    )
+    (tmp_path / f"{first}.jsonl").write_text(
+        '{"type":"user"}\n' + _continued_in(second))
+    (tmp_path / f"{second}.jsonl").write_text(
+        '{"type":"user"}\n' + _continued_in(third))
+    (tmp_path / f"{third}.jsonl").write_text('{"type":"assistant"}\n')
+    marker = tmux_server.encode_transcript_source(
+        "claude", first, tmp_path / f"{first}.jsonl")
+
+    opened = tmux_server.open_transcript_source(marker)
+
+    assert opened is not None
+    source, fd = opened
+    try:
+        assert source.session_id == third
+        assert source.path == tmp_path / f"{third}.jsonl"
+        assert os.read(fd, 100) == b'{"type":"assistant"}\n'
+    finally:
+        os.close(fd)
+
+
+@pytest.mark.parametrize(
+    "tail",
+    [
+        _continued_in("missing-successor"),
+        _continued_in("../escape"),
+        _continued_in("47fca075-9cb8-44fb-a314-d57ef2256ad9"),
+        _continued_in("96fd3642-6c17-4c9b-8129-08d3d9db3e8a") + '{"type":"user"}\n',
+    ],
+)
+def test_claude_transcript_source_keeps_file_without_valid_successor(
+    tmp_path, tail,
+):
+    session_id = "47fca075-9cb8-44fb-a314-d57ef2256ad9"
+    path = tmp_path / f"{session_id}.jsonl"
+    path.write_text('{"type":"user"}\n' + tail)
+    (tmp_path / "96fd3642-6c17-4c9b-8129-08d3d9db3e8a.jsonl").write_text("{}\n")
+    marker = tmux_server.encode_transcript_source("claude", session_id, path)
+
+    opened = tmux_server.open_transcript_source(marker)
+
+    assert opened is not None
+    os.close(opened[1])
+    assert opened[0].session_id == session_id and opened[0].path == path
+
+
 def test_codex_transcript_source_requires_matching_rollout_file(tmp_path):
     session_id = "019fcaad-27a1-70c0-8029-8a9c7803fa6b"
     path = tmp_path / f"rollout-2026-08-04T02-49-33-{session_id}.jsonl"

railmux-0.4.2.dev3/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.2.dev3"