repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
nushell/modules/pi.nu
Raw# Pi CLI with a native session browser.
use work_scope.nu
use pi_reader.nu
use pi_names.nu
@complete external
export def --wrapped main [...args] {
work_scope pi ...$args
}
# Read one shared store; visibility is applied separately from storage discovery.
def session-inventory [] {
let agent = $env.PI_CODING_AGENT_DIR? | default ('~/.pi/agent' | path expand) --empty | path expand
let override = $env.PI_CODING_AGENT_SESSION_DIR? | default ''
let root = if ($override | is-not-empty) {
$override
} else {
let settings_path = $agent | path join settings.json
let settings = if ($settings_path | path exists) { open $settings_path } else { {} }
$settings.sessionDir? | default ($agent | path join sessions) --empty
} | path expand
let rows = if ($root | path exists) {
cd $root
glob '**/*.jsonl' --no-dir | each {|file|
try {
let header = open --raw $file | lines | first | from json
if $header.type? != 'session' { return null }
let parent = $header.parentSession? | default ''
{
id: $header.id
cwd: $header.cwd
modified: (ls --all $file | first | get modified)
path: ($file | path expand)
parentSession: (if ($parent | describe) != string or ($parent | is-empty) { null } else {
$file | path dirname | path join $parent | path expand
})
}
} catch {
print --stderr $"Skipping unreadable session: ($file)"
null
}
} | where {|row| $row != null } | sort-by modified --reverse
} else { [] }
let paths = $rows | each {|row| [$row.path true] } | into record
mut parents = $rows | each {|row|
[$row.path (if $row.parentSession != null and ($paths | get -o $row.parentSession | default false) { $row.parentSession } else { null })]
} | into record
# Promote missing-parent components; break corrupt cycles once so no files vanish.
mut visited = {}
for row in $rows {
mut trail = []
mut cursor = $row.path
while $cursor != null and not ($visited | get -o $cursor | default false) {
if $cursor in $trail { $parents = ($parents | upsert $cursor null); break }
$trail = ($trail | append $cursor)
$cursor = ($parents | get -o $cursor)
}
for path in $trail { $visited = ($visited | upsert $path true) }
}
let resolved = $parents
let counts = $resolved | transpose path parent | where parent != null | group-by parent | transpose parent children
| each {|group| [$group.parent ($group.children | length)] } | into record
$rows | each {|row|
$row | insert parent ($resolved | get -o $row.path) | insert children ($counts | get -o $row.path | default 0)
}
}
def scoped-sessions [rows: list, cwd: string, global: bool] {
let selected = if $global { $rows } else { $rows | where cwd == $cwd }
let paths = $selected | each {|row| [$row.path true] } | into record
let scoped = $selected | each {|row|
let inside = $row.parent != null and ($paths | get -o $row.parent | default false)
let outside = $row.parent != null and not $inside
$row | insert scope_parent (if $inside { $row.parent } else { null })
| insert parentOutsideScope $outside
| insert session ((if $outside { '↳ ' } else { '' }) + (pi_names clean ($row.id | str substring --grapheme-clusters 0..<12)))
}
let counts = $scoped | where scope_parent != null | group-by scope_parent | transpose parent children
| each {|group| [$group.parent ($group.children | length)] } | into record
$scoped | each {|row| $row | update children ($counts | get -o $row.path | default 0) }
}
# List exact saved-cwd matches; --global includes every directory in the shared store.
export def "sessions list" [--global] {
let cwd = $env.PWD
scoped-sessions (session-inventory) $cwd $global
}
def resume-selection [result: record] {
if $result.action != resume { return }
if ($result.cwd | is-empty) or not ($result.cwd | path exists) or ($result.cwd | path type) != dir {
error make {msg: $"Session directory is unavailable: ($result.cwd)"}
}
do {
cd $result.cwd
work_scope pi --session $result.path
}
}
# Read the complete saved branch; Enter resumes only after terminal cleanup.
export def "sessions read" [file: path] {
resume-selection (pi_reader run $file)
}
# Filter metadata with native fuzzy search, then inspect before resuming.
export def sessions [--global] {
let cwd = $env.PWD
let inventory = session-inventory
mut all = $global
mut parent: any = null
let browser = pi_names start
mut version = 0
try { loop {
let rows = scoped-sessions $inventory $cwd $all
let current = $parent
let visible = $rows | where scope_parent == $current
let scope = if $all { 'global' } else { 'local' }
let title = if $current == null { $'Pi sessions · ($scope)' } else {
$'Children · ($rows | where path == $current | first | get id) · ($scope)'
}
let can_go_up = $current != null
let next_scope = if $all { 'local' } else { 'global' }
let context_hint = if ($rows | any {|row| $row.parentOutsideScope }) { ' ↳ parent outside scope' } else { '' }
$version = $version + 1
pi_names mailbox-write $browser.table view $version $visible
pi_names mailbox-write $browser.table selected 0 null
let view_version = $version
let picked = $visible
| tui search --id query --fuzzy --columns [session cwd id path] --bind / --placeholder 'project / session'
| tui table --id sessions --focus --title $title --columns [modified cwd session children]
| tui label $'/ search Tab focus Ctrl+A ($next_scope) → children ← parent Enter read Esc/q quit($context_hint)'
| tui bind ctrl+a {|| {action: submit selected: {navigation: scope}} }
| tui bind right {|state|
if ($state.selected.children? | default 0) > 0 {
{action: submit selected: {navigation: children path: $state.selected.path}}
} else { null }
}
| tui bind left {||
if $can_go_up { {action: submit selected: {navigation: up}} } else { null }
}
| tui run --refresh 100ms {|state| pi_names refresh $browser.table $view_version $state }
if $picked == null or $picked.action? != submit { break }
if $picked.selected.navigation? == scope {
$all = not $all
$parent = null
continue
}
if $picked.selected.navigation? == up {
$parent = ($rows | where path == $current | first | get scope_parent)
continue
}
if $picked.selected.navigation? == children { $parent = $picked.selected.path; continue }
if $picked.selected.path? == null { break }
let result = pi_reader run $picked.selected.path
if $result.action == resume { pi_names stop $browser; resume-selection $result; return }
} } catch {|err|
pi_names stop $browser
error make $err
}
pi_names stop $browser
}