Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

nushell/modules/wt-forge.nu

Raw
# Explicit pull-request listing for `git wt`.
# Network access occurs only when callers invoke `prs`.

def assert-context [context: record] {
    for field in [common_dir path] {
        let value = ($context | get -o $field)
        if $value == null or (($value | describe) != "string") or ($value | is-empty) {
            error make {msg: $"forge context requires nonempty string `($field)`"}
        }
    }
}

def git-output [cwd: path, args: list<string>] {
    let result = (^git -C $cwd ...$args | complete)
    if $result.exit_code != 0 {
        let detail = ($result.stderr | str trim)
        let message = if ($detail | is-empty) { "git remote lookup failed" } else { $detail }
        error make {msg: $message}
    }
    $result.stdout | str trim
}

def remote-url [context: record, remote: string] {
    let url = (git-output $context.path ["remote" "get-url" $remote])
    if ($url | is-empty) { error make {msg: $"remote has no URL: ($remote)"} }
    $url
}

def github-remote [url: string] {
    # Match the hostname, never an owner/repository path containing 'github'.
    let host = ($url | str replace --regex '^[A-Za-z][A-Za-z0-9+.-]*://' ''
        | str replace --regex '^[^/@]+@' '' | split row '/' | first
        | split row ':' | first | str lowercase)
    $host =~ '(^|\.)github(\.|$)'
}

def cli-path [name: string] {
    let found = (which --all $name | where type == external)
    if ($found | is-empty) {
        error make {msg: $"($name) CLI is required for explicit PR lookup"}
    }
    $found | first | get path
}

def github-records [text: string, remote: string] {
    let parsed = try {
        $text | from json --strict
    } catch {|err|
        error make {msg: $"gh returned invalid PR JSON: ($err.msg)"}
    }
    let parsed_type = ($parsed | describe)
    if not (($parsed_type | str starts-with "list<") or ($parsed_type | str starts-with "table<")) {
        error make {msg: "gh returned PR JSON that is not a list"}
    }

    $parsed | each {|pr|
        if not (($pr | describe) | str starts-with "record<") {
            error make {msg: "gh returned a non-record PR"}
        }
        let number = ($pr | get -o number)
        let title = ($pr | get -o title)
        if (($number | describe) != "int") or $number <= 0 or (($title | describe) != "string") {
            error make {msg: "gh returned PR JSON without positive number and string title"}
        }
        {number: $number, title: $title, remote: $remote, provider: "github", ref: $"refs/pull/($number)/head"}
    }
}

# Parse exactly fj's uncoloured minimal PR row: `#<number> <title> (by <author>)`.
# Any nonempty output that is not entirely composed of these rows is rejected.
export def parse-fj-minimal [text: string, remote: string] {
    let trimmed = ($text | str trim)
    if ($trimmed | is-empty) { return [] }

    $trimmed | lines | each {|line|
        let matches = ($line | parse --regex '^#(?P<number>[1-9][0-9]*)\s+(?P<title>.+)\s+\(by\s+[^()\r\n]+\)$')
        if ($matches | length) != 1 {
            error make {msg: $"unrecognized fj minimal PR output: ($line)"}
        }
        let row = ($matches | first)
        let title = ($row.title | str trim)
        if ($title | is-empty) {
            error make {msg: $"unrecognized fj minimal PR output: ($line)"}
        }
        let number = ($row.number | into int)
        {number: $number, title: $title, remote: $remote, provider: "forgejo", ref: $"refs/pull/($number)/head"}
    }
}

def gh-prs [url: string, remote: string] {
    let gh = (cli-path "gh")
    let result = (run-external $gh "pr" "list" "--repo" $url "--json" "number,title" "--limit" "100" | complete)
    if $result.exit_code != 0 {
        let detail = ($result.stderr | str trim)
        let message = if ($detail | is-empty) { "gh PR lookup failed" } else { $"gh PR lookup failed: ($detail)" }
        error make {msg: $message}
    }
    github-records $result.stdout $remote
}

def fj-prs [context: record, remote: string] {
    let fj = (cli-path "fj")
    let result = (run-external $fj "--style" "minimal" "pr" "-R" $remote "search" "--state" "open" "-C" $context.path | complete)
    if $result.exit_code != 0 {
        let detail = ($result.stderr | str trim)
        let message = if ($detail | is-empty) { "fj PR lookup failed" } else { $"fj PR lookup failed: ($detail)" }
        error make {msg: $message}
    }
    parse-fj-minimal $result.stdout $remote
}

# Return PR records via the provider implied by the selected Git remote.
export def prs [
    context: record
    --remote: string
] {
    assert-context $context
    if ($remote | is-empty) { error make {msg: "--remote requires a remote name"} }

    let url = (remote-url $context $remote)
    if (github-remote $url) {
        gh-prs $url $remote
    } else {
        fj-prs $context $remote
    }
}