use std/assert use ../modules/pi_reader.nu use ../modules/markdown.nu use ../modules/markdown_render.nu [display-width] const module_path = path self ../modules/pi_reader.nu const pi_path = path self ../modules/pi.nu let temp = mktemp --directory --tmpdir pi-reader-test.XXXXXX try { let cwd = $temp | path join 'project α space' mkdir $cwd let file = $cwd | path join 'history α space.jsonl' let png = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=' let unknown = ['| first | second |' '| --- | --- |' '| TABLEVALUE | tail |' '' 'inline `CODEVALUE` **STRONGVALUE**'] | str join (char nl) let long = (1..10 | each { 'abcdefghijklmnopqrstuvwxyz' } | str join) + ' literal\nKEPT' let prose = (1..12 | each { 'ordinary → English words stay whole “quoted” 中語 한글 カナ 👩‍💻 é ' } | str join) + (1..140 | each { 'Z' } | str join) + (char nl) + 'EXPLICIT-LINE' let entries = [ {type: session version: 3 id: test-session cwd: $cwd timestamp: '2026-01-01T00:00:00Z'} {type: message id: pre parentId: null message: {role: user content: [{type: text text: 'PRECOMPACTION'} {type: text text: '# SECOND-BLOCK'} {type: text text: $prose}]}} {type: message id: sibling parentId: pre message: {role: assistant content: 'EXCLUDED-SIBLING'}} {type: compaction id: compact parentId: pre summary: 'summary' firstKeptEntryId: pre tokensBefore: 100} {type: message id: multi parentId: compact message: {role: assistant content: [{type: thinking thinking: 'HIDDEN-THINKING'} {type: text text: $unknown} {type: text text: $long} {type: image mimeType: image/png data: $png}]}} {type: message id: tool parentId: multi message: {role: toolResult content: [{type: text text: 'HIDDEN-TOOL'}]}} {type: message id: empty parentId: tool message: {role: assistant content: []}} {type: message id: last parentId: empty message: {role: assistant content: 'FINAL-ENDPOINT'}} ] $entries | each {|entry| $entry | to json --raw } | str join (char nl) | save $file let original_hash = open --raw $file | hash sha256 let loaded = pi_reader load $file assert equal $loaded.cwd $cwd assert equal ($loaded.messages | get id) [pre multi empty last] let state = pi_reader prepare $loaded assert equal ($state.messages | length) 4 assert equal ($state.raw_sources | get text) ['PRECOMPACTION' '# SECOND-BLOCK' $prose $unknown $long 'FINAL-ENDPOINT'] assert equal ($state.raw_sources | get block_id | uniq | length) ($state.raw_sources | length) assert equal ($state.messages | where id == empty | get 0.raw_message) $entries.6.message assert equal ($state.history.lines | where message_id == empty | length) 0 assert equal ($state.history.lines | where block_id == role | length) 3 for blocks in [[] [{kind: raw_text text: ''}] [{kind: raw_text text: ' '}]] { let hidden = $loaded | update messages [{id: hidden role: assistant blocks: $blocks raw_message: {role: assistant content: [{type: toolCall name: test} {type: thinking thinking: PRIVATE}]}}] let prepared = pi_reader prepare $hidden assert equal ($prepared.messages | length) 1 assert equal $prepared.messages.0.raw_message $hidden.messages.0.raw_message assert equal ($prepared.history.lines | length) 0 } let first = pi_reader scroll $state (-1000000) let last = pi_reader scroll $first 1000000 assert equal $first.reader_anchor.message_id pre assert equal $last.reader_anchor.message_id last let lines = $state.history.lines let anchors = $lines | each {|line| $line | select message_id block_id line | to json --raw } assert equal ($anchors | uniq | length) ($lines | length) assert equal (pi_reader prepare $loaded | get history.lines | each {|line| $line | select message_id block_id line }) ($lines | each {|line| $line | select message_id block_id line }) for columns in [48 80 125] { let layout = pi_reader reflow $first $columns let direct = pi_reader render $first {columns: $columns rows: 24} assert equal $direct.state.history $layout.history assert equal $direct.state.reader_anchor $first.reader_anchor assert equal $layout.raw_sources $state.raw_sources let ordinary = (1..15 | each { 'ordinary → English words stay whole “quoted” ' } | str join) let wrapped = $ordinary | markdown render --width $columns | split row (char nl) assert equal ($wrapped | str join) $ordinary assert (($wrapped | each {|line| display-width $line } | math max) >= ($columns - 12)) for word in [ordinary English words whole “quoted”] { assert equal ($wrapped | each {|line| $line | parse --regex $word | length } | math sum) 15 } assert equal (pi_reader prepare $loaded --width $columns | get history.lines | select message_id block_id line text) ($layout.history.lines | select message_id block_id line text) let prose_lines = $layout.history.lines | where {|line| $line.block_id | str starts-with '["pre",2]'} assert equal ($prose_lines | get text | str join (char nl) | str replace --all (char nl) '') ($prose | str replace --all (char nl) '') assert (($prose_lines | each {|line| display-width $line.text } | math max) >= ($columns - 2)) for line in $layout.history.lines { if $line.image == null { assert ((display-width $line.text) <= $columns) } let active = $layout | update reader_anchor ($line | select message_id block_id line) let view = pi_reader render $active {columns: $columns rows: 24} if $line.image == null { assert ($view.frame | ansi strip | str contains ($line.text | ansi strip)) } else if $line.line == 0 { assert equal ($view.placements | length) 1 assert ($view.frame | str contains $png) assert ($view.frame | str contains 'f=100') } } assert equal (pi_reader scroll $layout -1000000 | get reader_anchor.message_id) pre assert equal (pi_reader scroll $layout 1000000 | get reader_anchor.message_id) last } let narrow = pi_reader reflow $first 48 let anchored = $narrow | update reader_anchor ($narrow.history.lines | where {|line| ($line.block_id | str starts-with '["pre",2]') and $line.line > 100 } | first | select message_id block_id line) let wide = pi_reader reflow $anchored 125 assert equal $wide.reader_anchor $anchored.reader_anchor let back = pi_reader reflow $wide 48 assert equal $back.reader_anchor $anchored.reader_anchor assert equal (pi_reader render $back {columns: 48 rows: 24} | get frame) (pi_reader render $anchored {columns: 48 rows: 24} | get frame) let moved = pi_reader scroll $wide 1 assert ($moved.reader_anchor.line > $anchored.reader_anchor.line) let words = 'ordinary → English words stay whole “quoted”' | markdown render --width 24 assert equal ($words | str replace --all (char nl) '') 'ordinary → English words stay whole “quoted”' for word in [ordinary English words whole “quoted”] { assert ($words | str contains $word) } assert equal (display-width '→“”') 3 assert equal (display-width '中한カ👩‍💻é') 9 let body = $lines | where image == null | get text | ansi strip | str join (char nl) for visible in [PRECOMPACTION SECOND-BLOCK TABLEVALUE CODEVALUE FINAL-ENDPOINT] { assert ($body | str contains $visible) } for hidden in [EXCLUDED-SIBLING HIDDEN-THINKING HIDDEN-TOOL] { assert (not ($body | str contains $hidden)) } # Literal fallback must reconstruct all source characters, not merely a marker. let chunks = $lines | where {|line| $line.message_id == multi and ($line.block_id | str starts-with '["multi",1]') } assert equal ($chunks | get text | str join) $long assert equal (open --raw $file | hash sha256) $original_hash # Native standalone command, both pipeline and file entry points. assert (('# HEADING' | markdown render | ansi strip) | str contains HEADING) $unknown | save ($temp | path join example.md) assert ((markdown render ($temp | path join example.md) | ansi strip) | str contains TABLEVALUE) let unsafe = $'ESC:(char --integer 27)]52;c;payload(char --integer 7)' let escaped = $unsafe | markdown render assert (not ($escaped | str contains $'(char --integer 27)]52')) assert (not ($escaped | str contains (char --integer 7))) # Header-only snapshots and complete/incomplete final records stay read-only. let empty_file = $temp | path join empty.jsonl $entries.0 | to json --raw | save $empty_file let blank = pi_reader prepare (pi_reader load $empty_file) assert equal ($blank.messages | length) 0 assert equal ((pi_reader render $blank {columns: 80 rows: 24}).placements | length) 0 let broken = $temp | path join malformed.jsonl (open --raw $file) + "\n{incomplete" | save $broken let partial = pi_reader load $broken assert equal ($partial.messages | get id) [pre multi empty last] assert ($partial.metadata.aggregate.malformed_lines > 0) # Term/input ownership replacement only; worker and real module still execute. for scenario in [back resume] { let event = if $scenario == back { 'q' } else { 'enter' } let code = $" def 'term size' [] { {columns: 80 rows: 24} } def 'input listen' [--timeout: duration] { sleep 5ms; {type: key code: '($event)' modifiers: []} } use '($module_path)' let result = pi_reader run $env.PI_READER_TEST_FILE print \"READER_RESULT:\"; $result | to json --raw | print " let result = with-env {PI_READER_TEST_FILE: $file} { ^($nu.current-exe) --no-config-file -c $code | complete } assert equal $result.exit_code 0 $result.stderr let returned = $result.stdout | split row 'READER_RESULT:' | last | from json assert equal $returned.action $scenario assert equal $returned.path $file assert ($result.stdout | str contains $'(char --integer 27)[?25h') assert ($result.stdout | str contains $'(char --integer 27)[?1049l') } # Unexpected input failure and failed background load must restore the terminal. let invalid_file = $temp | path join invalid.jsonl 'PRIVATE-INVALID-JSON' | save $invalid_file for failure in [input loading] { let target = if $failure == input { $file } else { $invalid_file } let body = if $failure == input { "error make {msg: 'INJECTED_INPUT_FAILURE'}" } else { 'sleep 5ms; null' } let code = $" def 'term size' [] { {columns: 80 rows: 24} } def 'input listen' [--timeout: duration] { ($body) } use '($module_path)' pi_reader run $env.PI_READER_TEST_FILE " let result = with-env {PI_READER_TEST_FILE: $target} { ^($nu.current-exe) --no-config-file -c $code | complete } assert ($result.exit_code != 0) assert ($result.stderr | str contains 'Reader failed') assert (not ($result.stderr | str contains 'PRIVATE-INVALID-JSON')) assert ($result.stdout | str contains $'(char --integer 27)[?25h') assert ($result.stdout | str contains $'(char --integer 27)[?1049l') } if $nu.os-info.family == unix { let bin = $temp | path join bin mkdir $bin '#!/bin/sh while [ "$#" -gt 0 ]; do case "$1" in --*) shift ;; *) break ;; esac done exec "$@" ' | save ($bin | path join systemd-run) '#!/bin/sh printf "PI_LAUNCH\n" printf "%s\n" "$PWD" "$@" > "$PI_RESUME_ARGS" exit "${PI_TEST_EXIT:-0}" ' | save ($bin | path join pi) ^chmod +x ($bin | path join systemd-run) ($bin | path join pi) let args_file = $temp | path join resume-args.txt let code = $" def 'term size' [] { {columns: 80 rows: 24} } def 'input listen' [--timeout: duration] { sleep 5ms; {type: key code: enter modifiers: []} } use '($pi_path)' pi sessions read $env.PI_READER_TEST_FILE " for status in [0 17] { let result = with-env {PATH: ($env.PATH | prepend $bin), PI_READER_TEST_FILE: $file, PI_RESUME_ARGS: $args_file, PI_TEST_EXIT: ($status | into string)} { ^($nu.current-exe) --no-config-file -c $code | complete } assert equal $result.exit_code $status $result.stderr assert equal (open --raw $args_file | lines) [$cwd --session $file] assert ($result.stdout | str contains PI_LAUNCH) let before_launch = $result.stdout | split row PI_LAUNCH | first assert ($before_launch | str contains $'(char --integer 27)[?1049l') 'Terminal must be restored before invoking Pi' } } assert equal (open --raw $file | hash sha256) $original_hash rm --recursive $temp } catch {|err| rm --recursive --force $temp error make $err } print 'Pi reader full-branch content, anchors, rendering, fallback, source safety, and controller contracts passed'