railmux 0.4.2.dev2__tar.gz → 0.4.2.dev4__tar.gz

{railmux-0.4.2.dev2/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.dev2
+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.dev2 → 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.dev2 → 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.dev2 → railmux-0.4.2.dev4}/src/railmux/transcript.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import io
 import json
 import os
+import re
 import sys
 from pathlib import Path
 
@@ -23,6 +24,10 @@ RED = "\033[31m"
 RESET = "\033[0m"
 CLAUDE_ACCENT = "\033[38;5;147m"
 CLAUDE_MUTED = "\033[38;5;244m"
+ITALIC = "\033[3m"
+BOLD_OFF = "\033[22m"
+ITALIC_OFF = "\033[23m"
+FG_DEFAULT = "\033[39m"
 
 _CODEX_SYNTHETIC_PREFIXES = (
     "<environment_context>",
@@ -223,9 +228,70 @@ def _render_claude_tool_results(record: dict, calls: dict[str, str]):
         yield _truncate(text, 500) + "\n"
 
 
-def _claude_native_block(marker: str, text: str, *, colour: str) -> str:
+_MD_FENCE_RE = re.compile(r"^\s*(```|~~~)")
+_MD_HEADING_RE = re.compile(r"^(#{1,6})\s+(.*?)\s*#*\s*$")
+_MD_INLINE_RE = re.compile(
+    r"(`+)(.+?)\1"
+    r"|\*\*(?=\S)(.+?)(?<=\S)\*\*"
+    r"|__(?=\S)(.+?)(?<=\S)__"
+    r"|(?<![\w*])\*(?=[^\s*])(.+?)(?<=[^\s*])\*(?![\w*])"
+)
+
+
+def _markdown_inline(line: str, *, bold: bool = False) -> str:
+    """Style inline code, bold and italic spans like Claude's markdown view.
+
+    Only targeted "off" codes close each span, so an enclosing style (for
+    example a bold heading) survives an inner code or italic span. *bold*
+    marks an already-bold context whose nested strong spans must not end it.
+    """
+
+    def replace(match: re.Match[str]) -> str:
+        code, strong, strong_alt, emphasis = (
+            match.group(2), match.group(3), match.group(4), match.group(5))
+        if code is not None:
+            return f"{CLAUDE_ACCENT}{code}{FG_DEFAULT}"
+        if strong is not None or strong_alt is not None:
+            inner = _markdown_inline(
+                strong if strong is not None else strong_alt, bold=True)
+            return inner if bold else f"{BOLD}{inner}{BOLD_OFF}"
+        return f"{ITALIC}{_markdown_inline(emphasis, bold=bold)}{ITALIC_OFF}"
+
+    return _MD_INLINE_RE.sub(replace, line)
+
+
+def _markdown_lines(lines: list[str]) -> list[str]:
+    """Approximate Claude Code's markdown rendering for sanitized text lines.
+
+    Styled lines end with a full reset: every span is already closed, and the
+    reset keeps row wrappers from carrying an ever-growing SGR prefix.
+    """
+    rendered: list[str] = []
+    in_fence = False
+    for line in lines:
+        if _MD_FENCE_RE.match(line):
+            in_fence = not in_fence
+            continue
+        if in_fence:
+            rendered.append(line)
+            continue
+        heading = _MD_HEADING_RE.match(line)
+        if heading:
+            inner = _markdown_inline(heading.group(2), bold=True)
+            rendered.append(f"{BOLD}{inner}{RESET}")
+            continue
+        styled = _markdown_inline(line)
+        rendered.append(styled + RESET if styled != line else line)
+    return rendered
+
+
+def _claude_native_block(
+    marker: str, text: str, *, colour: str, markdown: bool = False,
+) -> str:
     """Render a static, non-interactive approximation of one Claude TUI block."""
     lines = _sanitize_text(text).strip().splitlines()
+    if markdown:
+        lines = _markdown_lines(lines)
     if not lines:
         return ""
     continuation = "\n".join(f"  {line}" for line in lines[1:])
@@ -269,7 +335,8 @@ def _render_claude_native_assistant(
         block_type = block.get("type")
         if block_type == "text":
             rendered = _claude_native_block(
-                "●", str(block.get("text", "")), colour=CLAUDE_ACCENT
+                "●", str(block.get("text", "")), colour=CLAUDE_ACCENT,
+                markdown=True,
             )
             if rendered:
                 yield rendered

{railmux-0.4.2.dev2 → 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.dev2
+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.dev2 → 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.dev2 → 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.dev2 → railmux-0.4.2.dev4}/tests/test_transcript.py

@@ -856,3 +856,42 @@ def test_transcript_unknown_prefix_does_not_force_claude_detection():
         }),
     ])
     assert "codex hello" in "".join(format_transcript(io.StringIO(text)))
+
+
+def test_claude_native_history_styles_assistant_markdown():
+    text = "\n".join([
+        "## Plan **now**",
+        "Use **bold**, `code_name` and *emphasis* in snake_case 2*3*4.",
+        "```",
+        "**literal** `kept`",
+        "```",
+    ])
+    record = {
+        "type": "assistant",
+        "message": {"role": "assistant", "content": [
+            {"type": "text", "text": text},
+        ]},
+    }
+    rendered = "".join(format_transcript(
+        io.StringIO(json.dumps(record) + "\n"), fmt="claude", claude_native=True
+    ))
+
+    assert f"{BOLD}Plan now{RESET}" in rendered
+    assert f"{BOLD}bold\033[22m" in rendered
+    assert f"{CLAUDE_ACCENT}code_name\033[39m" in rendered
+    assert "\033[3memphasis\033[23m" in rendered
+    assert "snake_case 2*3*4." in rendered
+    assert "  **literal** `kept`\n" in rendered
+    assert "```" not in rendered
+
+
+def test_claude_native_user_prompt_keeps_raw_markdown():
+    record = {
+        "type": "user",
+        "message": {"role": "user", "content": "keep **this** raw"},
+    }
+    rendered = "".join(format_transcript(
+        io.StringIO(json.dumps(record) + "\n"), fmt="claude", claude_native=True
+    ))
+
+    assert "keep **this** raw" in rendered

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

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