repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by bugabinga

nushell/modules/git.nu

Raw
# Git worktree helpers.
# Layout:
#   <root>/.git              bare repository
#   <root>/<repo>.<branch>   worktrees

const WT_REPO_NAME = "wt.repo-name"
const WT_MAIN_BRANCH = "wt.main-branch"
const WT_SOURCE_PATH = "wt.source-path"

# Run git and fail with stderr as Nushell error.
def gitx [args: list<any>, cwd?: path] {
    let res = if ($cwd == null) {
        ^git ...$args | complete
    } else {
        ^git -C $cwd ...$args | complete
    }

    if $res.exit_code != 0 {
        let msg = ($res.stderr | str trim)
        error make {msg: (if ($msg | is-empty) { $"git failed: git ($args | str join ' ')" } else { $msg })}
    }

    $res.stdout | str trim
}

# Run git, return completion record.
def gitc [args: list<any>, cwd?: path] {
    if ($cwd == null) {
        ^git ...$args | complete
    } else {
        ^git -C $cwd ...$args | complete
    }
}

# Branch name -> path-safe suffix.
def branch-slug [branch: string] {
    $branch
    | str replace --all --regex '[^A-Za-z0-9._-]+' '-'
    | str trim --char '-'
}

# URL/path -> repo name.
def repo-name-from [source: string] {
    let base = ($source | path basename)
    $base | str replace --regex '\.git$' ''
}

# Current layout record. Fails outside co/wt layout.
def layout [] {
    let common = (gitx ["rev-parse" "--path-format=absolute" "--git-common-dir"])
    let bare = (gitc ["--git-dir" $common "config" "--bool" "--get" "core.bare"])

    if (($bare.stdout | str trim) != "true") {
        error make {msg: "not inside co/wt layout: git common dir is not bare"}
    }

    let root = ($common | path dirname)
    let repo_res = (gitc ["--git-dir" $common "config" "--get" $WT_REPO_NAME])
    let repo = if $repo_res.exit_code == 0 {
        $repo_res.stdout | str trim
    } else {
        $root | path basename | str replace --regex '\.wt$' ''
    }

    let main_res = (gitc ["--git-dir" $common "config" "--get" $WT_MAIN_BRANCH])
    let main = if $main_res.exit_code == 0 { $main_res.stdout | str trim } else { "main" }

    {root: $root, git_dir: $common, repo: $repo, main: $main}
}

# Computed worktree path for branch.
def wt-path [branch: string] {
    let l = (layout)
    [$l.root $"($l.repo).(branch-slug $branch)"] | path join
}

# Parse `git worktree list --porcelain` into records.
def parse-worktree-list [text: string] {
    $text
    | split row "\n\n"
    | where {|block| not (($block | str trim) | is-empty) }
    | each {|block|
        mut rec = {path: null, head: null, branch: null, detached: false, bare: false, locked: false, lock_reason: null, prunable: false}

        for line in ($block | lines) {
            if ($line | str starts-with "worktree ") {
                $rec = ($rec | upsert path ($line | str replace "worktree " ""))
            } else if ($line | str starts-with "HEAD ") {
                $rec = ($rec | upsert head ($line | str replace "HEAD " ""))
            } else if ($line | str starts-with "branch ") {
                let b = ($line | str replace "branch " "" | str replace "refs/heads/" "")
                $rec = ($rec | upsert branch $b)
            } else if $line == "detached" {
                $rec = ($rec | upsert detached true)
            } else if $line == "bare" {
                $rec = ($rec | upsert bare true)
            } else if ($line | str starts-with "locked") {
                let reason = ($line | str replace "locked" "" | str trim)
                $rec = ($rec | upsert locked true | upsert lock_reason (if ($reason | is-empty) { null } else { $reason }))
            } else if ($line | str starts-with "prunable") {
                $rec = ($rec | upsert prunable true)
            }
        }

        $rec
    }
}

# Worktree table, no dirty check.
def worktrees-basic [] {
    let l = (layout)
    parse-worktree-list (gitx ["--git-dir" $l.git_dir "worktree" "list" "--porcelain"])
}

# Find actual worktree path by branch; fallback to convention path.
def path-for-branch [branch: string] {
    let found = (worktrees-basic | where branch == $branch | first)
    if ($found == null) { wt-path $branch } else { $found.path }
}

# Create branch + worktree, or add existing branch.
def create-worktree [branch: string, base: string] {
    let l = (layout)
    let path = (wt-path $branch)

    if ($path | path exists) {
        error make {msg: $"path exists: ($path)"}
    }

    let exists = ((gitc ["--git-dir" $l.git_dir "show-ref" "--verify" "--quiet" $"refs/heads/($branch)"]).exit_code == 0)

    if $exists {
        gitx ["--git-dir" $l.git_dir "worktree" "add" $path $branch] | ignore
    } else {
        gitx ["--git-dir" $l.git_dir "worktree" "add" "-b" $branch $path $base] | ignore
    }

    $path
}

# Current branch, refusing detached HEAD.
def current-branch [] {
    let b = (gitx ["rev-parse" "--abbrev-ref" "HEAD"])
    if $b == "HEAD" { error make {msg: "detached HEAD is not supported"} }
    $b
}

# Remove worktree, maybe branch, and cd away if removing current worktree.
def --env remove-worktree [branch: string, delete_branch: bool, force: bool] {
    let l = (layout)
    let target = (path-for-branch $branch | path expand)
    let cwd_top = (try { gitx ["rev-parse" "--show-toplevel"] } catch { "" } | path expand)

    if $target == $cwd_top {
        if $branch == $l.main {
            cd $l.root
        } else {
            let main_path = (path-for-branch $l.main)
            if ($main_path | path exists) { cd $main_path } else { cd $l.root }
        }
    }

    let remove_args = if $force {
        ["--git-dir" $l.git_dir "worktree" "remove" "--force" $target]
    } else {
        ["--git-dir" $l.git_dir "worktree" "remove" $target]
    }
    gitx $remove_args | ignore

    if $delete_branch {
        let branch_flag = if $force { "-D" } else { "-d" }
        gitx ["--git-dir" $l.git_dir "branch" $branch_flag $branch] | ignore
    }

    $target
}

# Create fresh layout from remote/local repo URL/path.
def --env co-fresh [source: string, name?: string, branch?: string, dir?: path] {
    let repo = if ($name == null) { repo-name-from $source } else { $name }
    let parent = if ($dir == null) { "." } else { $dir }
    let root = ([$parent $repo] | path join | path expand)
    let git_dir = ([$root ".git"] | path join)

    if ($root | path exists) {
        error make {msg: $"target exists: ($root)"}
    }

    mkdir $root
    gitx ["clone" "--bare" $source $git_dir] | ignore

    let chosen_branch = if (($branch == null) or ($branch | is-empty)) {
        gitx ["--git-dir" $git_dir "symbolic-ref" "--short" "HEAD"]
    } else {
        $branch
    }

    gitx ["--git-dir" $git_dir "config" $WT_REPO_NAME $repo] | ignore
    gitx ["--git-dir" $git_dir "config" $WT_MAIN_BRANCH $chosen_branch] | ignore

    let worktree = ([$root $"($repo).(branch-slug $chosen_branch)"] | path join)
    gitx ["--git-dir" $git_dir "worktree" "add" $worktree $chosen_branch] | ignore
    cd $worktree

    {root: $root, worktree: $worktree, branch: $chosen_branch}
}

# Migrate current checkout into sibling .wt layout; original untouched.
def --env co-current [name?: string, branch?: string, plan: bool = false, dirty: string = "refuse"] {
    let src = (gitx ["rev-parse" "--show-toplevel"] | path expand)
    let src_name = ($src | path basename)
    let repo = if ($name == null) { $src_name } else { $name }
    let parent = ($src | path dirname)
    let root = ([$parent $"($repo).wt"] | path join | path expand)
    let git_dir = ([$root ".git"] | path join)
    let current = (current-branch)
    let chosen_branch = if (($branch == null) or ($branch | is-empty)) { $current } else { $branch }
    let target = ([$root $"($repo).(branch-slug $chosen_branch)"] | path join)
    let status_before = (gitx ["status" "--porcelain=v1"] $src)
    let is_dirty = (not ($status_before | is-empty))
    let stash_res = (gitc ["stash" "list"] $src)
    let stash_count = if $stash_res.exit_code == 0 { ($stash_res.stdout | lines | length) } else { 0 }

    if not ($dirty in ["refuse" "copy"]) {
        error make {msg: "--dirty must be one of: refuse, copy"}
    }

    let migration = {
        mode: "current-checkout"
        source: $src
        target_root: $root
        target_git_dir: $git_dir
        target_worktree: $target
        repo: $repo
        branch: $chosen_branch
        dirty: $is_dirty
        dirty_mode: $dirty
        stashes: $stash_count
        destructive: false
    }

    if $plan { return $migration }

    if ($root | path exists) {
        error make {msg: $"target exists: ($root)"}
    }

    if $is_dirty and $dirty == "refuse" {
        error make {msg: "working tree has changes; rerun with `co . --dirty copy` or commit/stash first"}
    }

    if $stash_count > 0 {
        print -e $"warning: ($stash_count) stash(es) remain only in original checkout: ($src)"
    }

    let tmp = (mktemp -d)
    let staged_patch = ([$tmp "staged.patch"] | path join)
    let unstaged_patch = ([$tmp "unstaged.patch"] | path join)

    if $is_dirty {
        ^git -C $src diff --binary --cached | save --force $staged_patch
        ^git -C $src diff --binary | save --force $unstaged_patch
    }

    mkdir $root
    gitx ["clone" "--bare" $src $git_dir] | ignore
    gitx ["--git-dir" $git_dir "config" $WT_REPO_NAME $repo] | ignore
    gitx ["--git-dir" $git_dir "config" $WT_MAIN_BRANCH $chosen_branch] | ignore
    gitx ["--git-dir" $git_dir "config" $WT_SOURCE_PATH $src] | ignore
    gitx ["--git-dir" $git_dir "worktree" "add" $target $chosen_branch] | ignore

    if $is_dirty {
        if (not ((open --raw $staged_patch) | is-empty)) {
            gitx ["apply" "--index" $staged_patch] $target | ignore
        }
        if (not ((open --raw $unstaged_patch) | is-empty)) {
            gitx ["apply" $unstaged_patch] $target | ignore
        }

        let rsync = (which rsync | length) > 0
        if $rsync {
            gitx ["-C" $src "status"] | ignore # cheap sanity: source still repo
            ^rsync -a --ignore-existing --exclude .git $"($src)/" $"($target)/" | complete | ignore
        } else {
            ^cp -a -n $"($src)/." $target | complete | ignore
        }

        let status_after = (gitx ["status" "--porcelain=v1"] $target)
        if $status_before != $status_after {
            error make {msg: $"dirty-copy verification failed; original untouched at ($src), target left for inspection at ($root)"}
        }
    }

    rm -rf $tmp
    cd $target

    $migration
}

# Bootstrap checkout.
export def --env co [
    source: string = "."      # URL/path, or `.` to migrate current checkout
    name?: string             # repo/root name
    --branch (-b): string = "" # branch to check out; default remote/current HEAD
    --dir (-d): path = "."    # parent dir for fresh checkout
    --plan                    # with `co .`: preview only
    --dirty: string = "refuse" # `refuse` | `copy`
] {
    if $source == "." {
        co-current $name $branch $plan $dirty
    } else {
        if $plan { error make {msg: "--plan only applies to `co .`"} }
        if $dirty != "refuse" { error make {msg: "--dirty only applies to `co .`"} }
        co-fresh $source $name $branch $dir
    }
}

# Summary.
export def wt [] { wt ls }

export def "wt root" [] { (layout).root }
export def "wt repo" [] { (layout).repo }
export def "wt path" [branch: string] { wt-path $branch }

export def "wt ls" [] {
    let cwd_top = (try { gitx ["rev-parse" "--show-toplevel"] } catch { "" } | path expand)

    worktrees-basic | where bare == false | each {|row|
        let p = ($row.path | path expand)
        let dirty = if (($p | path exists) and (not $row.bare) and ($row.branch != null)) {
            not ((gitx ["status" "--porcelain=v1"] $p) | is-empty)
        } else {
            false
        }

        $row
        | upsert current ($p == $cwd_top)
        | upsert dirty $dirty
    }
}

export def --env "wt new" [
    branch: string
    --base (-b): string = "HEAD"
    --switch (-s)
] {
    let p = (create-worktree $branch $base)
    if $switch { cd $p }
    $p
}

export def --env "wt go" [
    branch: string
    --create (-c)
    --base (-b): string = "HEAD"
] {
    let p = (path-for-branch $branch)
    if (not ($p | path exists)) {
        if $create {
            create-worktree $branch $base | ignore
        } else {
            error make {msg: $"no worktree for branch `($branch)`; rerun with --create"}
        }
    }
    cd $p
    $p
}

export def --env "wt rm" [
    name?: string
    --branch (-b) # also delete git branch
    --force (-f)
] {
    let b = if ($name == null) { current-branch } else { $name }
    remove-worktree $b $branch $force
}

export def --env "wt done" [
    branch?: string
    --force (-f)
] {
    let b = if ($branch == null) { current-branch } else { $branch }
    remove-worktree $b true $force
}

export def "wt prune" [] {
    let l = (layout)
    gitx ["--git-dir" $l.git_dir "worktree" "prune"] | ignore
}

export def "wt repair" [] {
    let l = (layout)
    gitx ["--git-dir" $l.git_dir "worktree" "repair"] | ignore
}

# Thin native aliases for muscle memory / git parity.
export def --env "wt add" [branch: string, --base (-b): string = "HEAD", --switch (-s)] {
    wt new $branch --base $base --switch=$switch
}

export def "wt list" [] { wt ls }

export def "wt lock" [branch?: string, reason?: string] {
    let b = if ($branch == null) { current-branch } else { $branch }
    let p = (path-for-branch $b)
    let l = (layout)
    if ($reason == null) {
        gitx ["--git-dir" $l.git_dir "worktree" "lock" $p] | ignore
    } else {
        gitx ["--git-dir" $l.git_dir "worktree" "lock" "--reason" $reason $p] | ignore
    }
}

export def "wt unlock" [branch?: string] {
    let b = if ($branch == null) { current-branch } else { $branch }
    let p = (path-for-branch $b)
    let l = (layout)
    gitx ["--git-dir" $l.git_dir "worktree" "unlock" $p] | ignore
}

export def "wt move" [branch: string, dest: path] {
    let p = (path-for-branch $branch)
    let l = (layout)
    gitx ["--git-dir" $l.git_dir "worktree" "move" $p $dest] | ignore
    $dest
}

export def --env "wt remove" [name?: string, --branch (-b), --force (-f)] {
    wt rm $name --branch=$branch --force=$force
}