Luigit
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
}