Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

nushell/tests/pi-reader.test.nu

Raw
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'