repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
nushell/tests/pi-reader.test.nu
Rawuse 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'