# Read-only session snapshot and RAM-only native terminal reader. use markdown_render.nu [format-blocks] def is-string [value: any] { ($value | describe) == string } def is-record [value: any] { ($value | describe) | str starts-with record } def key [anchor: record] { [$anchor.message_id $anchor.block_id $anchor.line] | to json --raw } export def load [file: path] { let path = $file | path expand let snapshot = try { let size = ls --all $path | first | get size | into int open --raw $path | into binary | bytes at ..<$size | decode utf-8 } catch { error make {msg: 'Cannot read selected session file'} } mut malformed = 0 mut invalid = 0 mut header: any = null mut entries = [] for line in ($snapshot | split row (char nl)) { if ($line | str trim | is-empty) { continue } let e = try { $line | from json --strict } catch { null } if not (is-record $e) { $malformed += 1; continue } if $e.type? == session { if $header == null and (is-string $e.id?) { $header = $e } } else if (is-string $e.type?) and (is-string $e.id?) and $e.id != '' and ('parentId' in $e) and ($e.parentId == null or (is-string $e.parentId)) { $entries = ($entries | append $e) } else { $invalid += 1 } } if $header == null { error make {msg: 'Selected file has no valid session header'} } mut by_id = {} for e in $entries { $by_id = ($by_id | upsert $e.id $e) } mut current = $entries | last 1 | get -o 0 let leaf = $current.id? | default $header.id mut seen = {} mut branch = [] mut missing = 0 mut cycles = 0 while $current != null { if ($seen | get -o $current.id | default false) { $cycles += 1; break } $seen = ($seen | upsert $current.id true) $branch = ($branch | append $current) if $current.parentId == null { break } let parent = $by_id | get -o $current.parentId if $parent == null { $missing += 1; break } $current = $parent } let messages = $branch | reverse | each {|e| if $e.type != message or not (is-record $e.message?) { return null } let role = $e.message.role? if $role not-in [user assistant] { return null } let content = $e.message.content? let blocks = if (is-string $content) { [{kind: raw_text text: $content}] } else if (($content | describe) =~ '^(list|table)') { $content | each {|block| if not (is-record $block) { return null } if $block.type? == text and (is-string $block.text?) { {kind: raw_text text: $block.text} } else if $block.type? == image { {kind: image mime_type: ($block.mimeType? | default '') data: (if (is-string $block.data?) { $block.data } else { '' })} } } | compact } else { [] } {id: $e.id role: $role blocks: $blocks raw_message: $e.message} } | compact {path: $path cwd: (if (is-string $header.cwd?) { $header.cwd } else { '' }) id: $header.id messages: $messages metadata: { selected_leaf_id: $leaf aggregate: {parsed_entries: ($entries | length) branch_entries: ($branch | length) malformed_lines: $malformed structurally_invalid_entries: $invalid missing_parent_links: $missing cyclic_parent_links: $cycles} }} } export def prepare [loaded: record --width: int = 80] { mut sources = [] mut messages = [] # Per-reader random namespace, within Kitty's unsigned 32-bit image ID range. mut image_id = random int 100000..2000000000 mut owned = [] for message in $loaded.messages { mut blocks = [] for entry in ($message.blocks | enumerate) { let b = $entry.item let prefix = [$message.id $entry.index] | to json --raw let converted = if $b.kind == raw_text { $sources = ($sources | append {message_id: $message.id content_index: $entry.index block_id: $prefix text: $b.text}) [{id: $prefix kind: raw_text text: $b.text}] } else if $b.kind == image and $b.mime_type == image/png and ($b.data | str length) > 0 and ($b.data | str length) <= 2097152 and ($b.data =~ '^[A-Za-z0-9+/]*={0,2}$') { $image_id += 1 $owned = ($owned | append $image_id) let image = {id: ($prefix + ':image') kind: image image_id: $image_id data: $b.data} [($image | reject data | insert transmission (transmit $image))] } else { # Do not interpolate untrusted MIME strings into terminal output. [{id: ($prefix + ':unsupported-image') kind: text text: '[image unavailable: PNG ≤2 MiB base64 only]'}] } $blocks = ($blocks | append $converted) } $messages = ($messages | append ($message | update blocks $blocks)) } let initial = $loaded | update messages $messages | upsert raw_sources $sources | upsert reader_anchor {} | upsert latest_page true | upsert owned_image_ids $owned let state = reflow $initial $width let anchor = if ($state.history.lines | is-empty) { {} } else { $state.history.lines | last | select message_id block_id line } $state | update reader_anchor $anchor } # Only one width's layout is retained; logical blocks and complete sources stay in RAM. export def reflow [state: record width: int] { let width = [1 $width] | math max if $state.layout_width? == $width { return $state } let history = $state.messages | each {|message| let visible = $message.blocks | any {|block| $block.kind == image or ($block.text? | default '' | str trim | is-not-empty) } if not $visible { return [] } let boundary = {message_id: $message.id block_id: 'role' line: 0 text: (if $message.role == user { '● you' } else { '◆ pi' }) image: null} let blocks = $message.blocks | each {|block| if $block.kind == raw_text { format-blocks $block.text $block.id --width $width } else { [$block] } } | flatten let lines = $blocks | each {|block| if $block.kind == text { [{message_id: $message.id block_id: $block.id line: ($block.line? | default 0) text: $block.text image: null}] } else { [0 1 2] | each {|line| {message_id: $message.id block_id: $block.id line: $line text: '' image: $block} } } } | flatten $lines | prepend $boundary } | flatten let indexes = $history | enumerate | each {|entry| [(key $entry.item) $entry.index] } | into record $state | upsert history {lines: $history indexes: $indexes} | upsert layout_width $width } def current-index [state: record] { if ($state.reader_anchor | is-empty) { return 0 } let exact = $state.history.indexes | get -o (key $state.reader_anchor) if $exact != null { return $exact } # Anchor offsets are positions within the same logical source line, not chunks. $state.history.lines | enumerate | where {|entry| $entry.item.message_id == $state.reader_anchor.message_id and $entry.item.block_id == $state.reader_anchor.block_id and $entry.item.line <= $state.reader_anchor.line } | last 1 | get -o 0.index | default 0 } def page-start [state: record height: int] { if $state.latest_page? == true { [0 (($state.history.lines | length) - $height)] | math max } else { current-index $state } } def at-index [state: record index: int] { if ($state.history.lines | is-empty) { return $state | upsert latest_page false } let bounded = [0 ([($index) (($state.history.lines | length) - 1)] | math min)] | math max $state | update reader_anchor ($state.history.lines | get $bounded | select message_id block_id line) | upsert latest_page false } export def scroll [state: record delta: int] { at-index $state ((current-index $state) + $delta) } # Physical Kitty placements, chunked in multiples of four base64 characters. def transmit [image: record] { let chunks = $image.data | parse --regex '(?.{1,4096})' | get chunk let last = ($chunks | length) - 1 $chunks | enumerate | each {|chunk| let more = if $chunk.index == $last { 0 } else { 1 } let options = if $chunk.index == 0 { $'a=T,f=100,i=($image.image_id),p=1,c=8,r=3,q=2,m=($more)' } else { $'m=($more)' } $'(ansi escape)_G($options);($chunk.item)(ansi escape)\' } | str join } def delete-placements [placements: list] { $placements | each {|p| $'(ansi escape)_Ga=d,d=I,i=($p.image_id),q=2(ansi escape)\' } | str join } export def render [state: record dims: record] { let columns = [1 $dims.columns] | math max let rows = [1 $dims.rows] | math max let state = reflow $state $columns let height = [0 ($rows - 1)] | math max let start = page-start $state $height mut frame = $'(ansi escape)[H(ansi escape)[2J' mut placements = [] if $columns < 48 or $rows < 4 { $frame += ('Resize: 48 columns minimum' | str substring 0..<$columns) } else { for entry in ($state.history.lines | skip $start | take $height | enumerate) { let row = $entry.index + 1 let line = $entry.item $frame += $'(ansi escape)[($row);1H' if $line.image == null { $frame += ($line.text + (ansi reset)) } else if $line.line == 0 { if ($entry.index + 3) <= $height { $frame += $line.image.transmission $placements = ($placements | append {image_id: $line.image.image_id placement_id: 1 row: $row column: 1 columns: 8 rows: 3}) } else { $frame += '[image]' } } else if $entry.index == 0 { $frame += '[image ↑]' } } } let counts = $state.metadata.aggregate let issues = $counts.malformed_lines + $counts.structurally_invalid_entries + $counts.missing_parent_links + $counts.cyclic_parent_links let footer = (if $issues > 0 { $'⚠ ($issues) history issues Enter resume q back' } else { '↑↓ scroll g/G ends Enter resume q back' }) | str substring 0..<$columns $frame += $'(ansi escape)[($rows);1H(ansi d)($footer)(ansi reset)' {frame: $frame placements: $placements state: $state} } # Catch only the documented ordinary timeout; unexpected input failures propagate. def listen [] { try { input listen --timeout 5ms } catch {|e| if $e.msg == 'Timed out while waiting for user input' { null } else { error make {msg: 'Reader input failed'} } } } # `run` is a Nu parser keyword; module main supplies `pi_reader run `. export def main [action: string file: path] { if $action != run { error make {msg: 'Expected: pi_reader run '} } let path = $file | path expand let owner = job id let tag = random int 1..2000000000 mut worker: any = null mut state: any = null mut placements = [] mut action = 'back' mut dirty = true mut dims = {columns: 80 rows: 24} let failed = try { $dims = (term size) let initial_width = $dims.columns $worker = (job spawn { let result = try { {state: (prepare (load $path) --width $initial_width)} } catch { {failed: true} } $result | job send $owner --tag $tag }) print --no-newline $'(ansi escape)[?1049h(ansi escape)[?25l' loop { if $state == null { let result = try { job recv --tag $tag --timeout 0sec } catch {|e| if $e.msg == 'No message was received in the requested time interval' { null } else { error make {msg: 'Reader worker failed'} } } if $result != null { if $result.failed? == true { error make {msg: 'Cannot load selected session'} } $state = $result.state $dirty = true } } if $dirty { print --no-newline (delete-placements $placements) $placements = [] if $state == null { print --no-newline $'(ansi escape)[H(ansi escape)[2JLoading session… q back' } else { $state = (reflow $state $dims.columns) let view = render $state $dims $placements = $view.placements print --no-newline $view.frame if $state.latest_page { $state = (at-index $state (page-start $state ([0 ($dims.rows - 1)] | math max))) } } $dirty = false } let event = listen if $event == null { continue } if $event.type == resize { $dims = {columns: $event.col rows: $event.row} $dirty = true } else if $event.type == key { let code = $event.code if $code in [esc escape q] or ($code == c and control in $event.modifiers) { break } if $code == enter and $state != null { $action = 'resume'; break } if $state == null { continue } let page = [1 ($dims.rows - 2)] | math max match $code { j | down => { $state = (scroll $state 1) } k | up => { $state = (scroll $state -1) } g | home => { $state = (at-index $state 0) } G | end => { $state = ($state | upsert latest_page true) } page_up | pageup => { $state = (scroll $state (0 - $page)) } page_down | pagedown => { $state = (scroll $state $page) } _ => { continue } } $dirty = true } } false } catch { true } # Cleanup always precedes resume delegation in the caller. try { job kill $worker } catch { null } | ignore # Discard any late result from this invocation's private mailbox tag. try { job recv --tag $tag --timeout 0sec | ignore } catch { null } | ignore print --no-newline ((delete-placements $placements) + $'(ansi reset)(ansi escape)[?25h(ansi escape)[?1049l') if $failed { error make {msg: 'Reader failed for selected session file'} } {action: $action path: $path cwd: ($state.cwd? | default '')} }