Files
skillshare/internal/git/info.go
T
Willie bf32112032 feat(git): show pending remote commits and auto-merge metadata conflicts
Two machines sharing a source repo kept stopping at the same two places.
The Git page had no way to know the remote moved until a push bounced, so
it now fetches once on open and labels Pull with the commit count (status
itself stays offline because the sidebar polls it). And both machines
rewrite .metadata.json on every install or update, so nearly every
diverged pull conflicted there; those conflicts are now merged per entry,
keeping the later installed_at, while any other conflict still stops the
pull and names the files.
2026-09-25 02:22:35 +08:00

1170 lines
34 KiB
Go

package git
import (
"bufio"
"bytes"
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"time"
"skillshare/internal/install"
)
// DiffStats holds git diff statistics
type DiffStats struct {
FilesChanged int `json:"filesChanged"`
Insertions int `json:"insertions"`
Deletions int `json:"deletions"`
}
// CommitInfo holds a single commit info
type CommitInfo struct {
Hash string `json:"hash"`
Message string `json:"message"`
}
// UpdateInfo holds info about changes from an update
type UpdateInfo struct {
Commits []CommitInfo
Stats DiffStats
UpToDate bool
BeforeHash string
AfterHash string
}
// ErrNoRemoteBranches indicates the origin remote currently has no branches.
var ErrNoRemoteBranches = errors.New("no remote branches found")
// GetCurrentHash returns the current HEAD hash (short)
func GetCurrentHash(repoPath string) (string, error) {
cmd := exec.Command("git", "rev-parse", "--short", "HEAD")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
// GetCurrentFullHash returns the current HEAD hash (full 40-char).
func GetCurrentFullHash(repoPath string) (string, error) {
cmd := exec.Command("git", "rev-parse", "HEAD")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
// ResetHard resets the working tree to the given revision.
func ResetHard(repoPath, rev string) error {
cmd := exec.Command("git", "reset", "--hard", rev)
cmd.Dir = repoPath
return cmd.Run()
}
// Fetch runs git fetch
func Fetch(repoPath string) error {
return FetchWithEnv(repoPath, nil)
}
// FetchWithEnv runs git fetch with additional environment variables.
func FetchWithEnv(repoPath string, extraEnv []string) error {
cmd := exec.Command("git", "fetch")
cmd.Dir = repoPath
if len(extraEnv) > 0 {
cmd.Env = append(os.Environ(), extraEnv...)
}
return cmd.Run()
}
// GetCommitsBetween returns commits between two refs
func GetCommitsBetween(repoPath, from, to string) ([]CommitInfo, error) {
cmd := exec.Command("git", "-c", "color.ui=false", "log", "--oneline", from+".."+to)
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return nil, err
}
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
var commits []CommitInfo
for _, line := range lines {
if line == "" {
continue
}
parts := strings.SplitN(line, " ", 2)
if len(parts) == 2 {
commits = append(commits, CommitInfo{
Hash: parts[0],
Message: parts[1],
})
}
}
return commits, nil
}
// GetDiffStats returns diff statistics between two refs
func GetDiffStats(repoPath, from, to string) (DiffStats, error) {
cmd := exec.Command("git", "diff", "--shortstat", from+".."+to)
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return DiffStats{}, err
}
return parseDiffStats(string(out)), nil
}
// parseDiffStats parses git diff --shortstat output
// Example: " 5 files changed, 120 insertions(+), 30 deletions(-)"
func parseDiffStats(output string) DiffStats {
stats := DiffStats{}
output = strings.TrimSpace(output)
if output == "" {
return stats
}
parts := strings.Split(output, ", ")
for _, part := range parts {
part = strings.TrimSpace(part)
if strings.Contains(part, "file") {
stats.FilesChanged = extractNumber(part)
} else if strings.Contains(part, "insertion") {
stats.Insertions = extractNumber(part)
} else if strings.Contains(part, "deletion") {
stats.Deletions = extractNumber(part)
}
}
return stats
}
func extractNumber(s string) int {
var numStr string
for _, c := range s {
if c >= '0' && c <= '9' {
numStr += string(c)
} else if numStr != "" {
break
}
}
n, _ := strconv.Atoi(numStr)
return n
}
func runGitWithProgress(repoPath string, args []string, extraEnv []string, onProgress func(string)) error {
cmd := exec.Command("git", args...)
cmd.Dir = repoPath
if len(extraEnv) > 0 {
cmd.Env = append(os.Environ(), extraEnv...)
}
tokenAuth := install.UsedTokenAuth(extraEnv)
if onProgress == nil {
var stderr bytes.Buffer
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return install.WrapGitError(stderr.String(), err, tokenAuth)
}
return nil
}
stderrPipe, err := cmd.StderrPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
return err
}
var allStderr strings.Builder
captureProgress := func(line string) {
allStderr.WriteString(line)
allStderr.WriteByte('\n')
onProgress(line)
}
if scanErr := streamGitProgress(stderrPipe, captureProgress); scanErr != nil {
_ = cmd.Wait()
return scanErr
}
if err := cmd.Wait(); err != nil {
return install.WrapGitError(allStderr.String(), err, tokenAuth)
}
return nil
}
func streamGitProgress(stderr io.Reader, onProgress func(string)) error {
scanner := bufio.NewScanner(stderr)
scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
scanner.Split(scanGitProgress)
for scanner.Scan() {
line := strings.TrimSpace(scanner.Text())
if line != "" {
onProgress(line)
}
}
return scanner.Err()
}
func scanGitProgress(data []byte, atEOF bool) (advance int, token []byte, err error) {
for i, b := range data {
if b == '\n' || b == '\r' {
return i + 1, data[:i], nil
}
}
if atEOF && len(data) > 0 {
return len(data), data, nil
}
return 0, nil, nil
}
// Pull runs git pull and returns update info (quiet mode)
func Pull(repoPath string) (*UpdateInfo, error) {
return PullWithEnv(repoPath, nil)
}
// PullWithAuth runs git pull with token auth env inferred from origin remote.
func PullWithAuth(repoPath string) (*UpdateInfo, error) {
return PullWithEnv(repoPath, AuthEnvForRepo(repoPath))
}
// PullWithProgress runs git pull and optionally streams progress lines to
// onProgress when non-nil.
func PullWithProgress(repoPath string, extraEnv []string, onProgress func(string)) (*UpdateInfo, error) {
info := &UpdateInfo{}
beforeHash, err := GetCurrentFullHash(repoPath)
if err != nil {
return nil, err
}
info.BeforeHash = beforeHash
// Merge explicitly: without pull.rebase/pull.ff configured, git refuses to
// reconcile a branch that both this machine and the remote moved.
args := []string{"pull", "--no-rebase", "--ff", "--no-edit", "--quiet"}
if onProgress != nil {
args[len(args)-1] = "--progress"
}
if err := runGitWithProgress(repoPath, args, extraEnv, onProgress); err != nil {
conflicts := conflictedFiles(repoPath)
if len(conflicts) == 0 || resolveMetadataConflicts(repoPath, conflicts) != nil {
// A conflicted merge would leave markers that a later commit-all picks up.
abort := exec.Command("git", "merge", "--abort")
abort.Dir = repoPath
abort.Run() // best-effort; fails harmlessly when no merge started
if len(conflicts) > 0 {
return nil, fmt.Errorf("pull stopped: this machine and the remote both changed %s; the merge was undone, resolve it with git in %s", strings.Join(conflicts, ", "), repoPath)
}
return nil, err
}
}
afterHash, err := GetCurrentFullHash(repoPath)
if err != nil {
return nil, err
}
info.AfterHash = afterHash
if beforeHash == afterHash {
info.UpToDate = true
return info, nil
}
commits, _ := GetCommitsBetween(repoPath, beforeHash, afterHash)
info.Commits = commits
stats, _ := GetDiffStats(repoPath, beforeHash, afterHash)
info.Stats = stats
return info, nil
}
// conflictedFiles lists the paths an in-progress merge left unmerged.
func conflictedFiles(dir string) []string {
cmd := exec.Command("git", "diff", "--name-only", "--diff-filter=U")
cmd.Dir = dir
out, err := cmd.Output()
if err != nil {
return nil
}
return strings.Fields(string(out))
}
// resolveMetadataConflicts concludes a merge whose only conflicts are
// .metadata.json files, merging them per entry (see install.MergeMetadata).
// Both machines rewriting the shared file is the common case, not a real clash.
func resolveMetadataConflicts(dir string, conflicts []string) error {
stage := func(n int, path string) []byte {
cmd := exec.Command("git", "show", fmt.Sprintf(":%d:%s", n, path))
cmd.Dir = dir
out, _ := cmd.Output() // a missing stage (file absent on that side) reads as empty
return out
}
for _, path := range conflicts {
if filepath.Base(path) != install.MetadataFileName {
return fmt.Errorf("%s is not metadata", path)
}
merged, err := install.MergeMetadata(stage(1, path), stage(2, path), stage(3, path))
if err != nil {
return err
}
if err := os.WriteFile(filepath.Join(dir, path), merged, 0644); err != nil {
return err
}
add := exec.Command("git", "add", "--", path)
add.Dir = dir
if err := add.Run(); err != nil {
return err
}
}
commit := exec.Command("git", "commit", "--no-edit")
commit.Dir = dir
return commit.Run()
}
// PullWithEnv runs git pull and returns update info (quiet mode) with
// additional environment variables.
func PullWithEnv(repoPath string, extraEnv []string) (*UpdateInfo, error) {
return PullWithProgress(repoPath, extraEnv, nil)
}
// FileChange describes a single file change between two git revisions.
type FileChange struct {
Status string // A=added, M=modified, D=deleted, R=renamed
Path string
OldPath string // non-empty for renames
LinesAdded int
LinesDeleted int
}
// GetChangedFiles returns file-level changes between two revisions.
// Uses NUL-delimited output (-z) for safe handling of special filenames.
func GetChangedFiles(repoPath, from, to string) ([]FileChange, error) {
// Get name-status with NUL delimiter
statusCmd := exec.Command("git", "diff", "--name-status", "-z", "-M", from+".."+to)
statusCmd.Dir = repoPath
statusOut, err := statusCmd.Output()
if err != nil {
return nil, err
}
// Get numstat with NUL delimiter
numCmd := exec.Command("git", "diff", "--numstat", "-z", "-M", from+".."+to)
numCmd.Dir = repoPath
numOut, err := numCmd.Output()
if err != nil {
return nil, err
}
// Parse NUL-delimited name-status.
// Format: status\0path\0 (for A/M/D)
// Rxxx\0oldpath\0newpath\0 (for renames)
type statusEntry struct {
status string
path string
oldPath string
}
var entries []statusEntry
fields := strings.Split(string(statusOut), "\x00")
for i := 0; i < len(fields); {
s := fields[i]
if s == "" {
i++
continue
}
if strings.HasPrefix(s, "R") {
// Rename: status, oldpath, newpath
if i+2 >= len(fields) {
break
}
entries = append(entries, statusEntry{
status: "R",
oldPath: fields[i+1],
path: fields[i+2],
})
i += 3
} else {
// A, M, D, etc.: status, path
if i+1 >= len(fields) {
break
}
entries = append(entries, statusEntry{
status: s[:1],
path: fields[i+1],
})
i += 2
}
}
// Parse NUL-delimited numstat.
// Normal: added\tdeleted\tpath\0
// Rename: added\tdeleted\t\0oldpath\0newpath\0
// When -z is used, renames have an empty path field followed by NUL-separated old/new paths.
numMap := map[string][2]int{} // path -> [added, deleted]
numFields := strings.Split(string(numOut), "\x00")
for i := 0; i < len(numFields); {
record := numFields[i]
if record == "" {
i++
continue
}
parts := strings.SplitN(record, "\t", 3)
if len(parts) < 3 {
i++
continue
}
added, _ := strconv.Atoi(parts[0])
deleted, _ := strconv.Atoi(parts[1])
pathField := parts[2]
if pathField == "" {
// Rename: next two NUL-delimited fields are oldpath and newpath
if i+2 < len(numFields) {
newPath := numFields[i+2]
numMap[newPath] = [2]int{added, deleted}
i += 3
} else {
i++
}
} else {
numMap[pathField] = [2]int{added, deleted}
i++
}
}
var changes []FileChange
for _, e := range entries {
fc := FileChange{
Status: e.status,
Path: e.path,
OldPath: e.oldPath,
}
if nums, ok := numMap[e.path]; ok {
fc.LinesAdded = nums[0]
fc.LinesDeleted = nums[1]
}
changes = append(changes, fc)
}
return changes, nil
}
// IsDirty checks if repo has uncommitted changes
func IsDirty(repoPath string) (bool, error) {
cmd := exec.Command("git", "status", "--porcelain")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return false, err
}
return strings.TrimSpace(string(out)) != "", nil
}
// GetDirtyFiles returns list of modified files
func GetDirtyFiles(repoPath string) ([]string, error) {
cmd := exec.Command("git", "-c", "color.status=false", "status", "--short")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return nil, err
}
lines := strings.Split(strings.TrimSpace(string(out)), "\n")
var files []string
for _, line := range lines {
if line != "" {
files = append(files, line)
}
}
return files, nil
}
// Restore discards all local changes
func Restore(repoPath string) error {
cmd := exec.Command("git", "restore", ".")
cmd.Dir = repoPath
return cmd.Run()
}
// IsRepo checks if the directory is a git repository
func IsRepo(dir string) bool {
cmd := exec.Command("git", "rev-parse", "--git-dir")
cmd.Dir = dir
return cmd.Run() == nil
}
// IsInstalled reports whether the git executable is available on PATH. Every
// other helper shells out to git, so callers can use this to surface a clear
// "git is not installed" message instead of a raw exec error.
func IsInstalled() bool {
_, err := exec.LookPath("git")
return err == nil
}
// HasRemote checks if the repo has at least one remote configured
func HasRemote(dir string) bool {
cmd := exec.Command("git", "remote")
cmd.Dir = dir
out, err := cmd.Output()
if err != nil {
return false
}
return strings.TrimSpace(string(out)) != ""
}
// StageAll stages all changes (git add -A)
func StageAll(dir string) error {
cmd := exec.Command("git", "add", "-A")
cmd.Dir = dir
return cmd.Run()
}
// Commit creates a commit with the given message
func Commit(dir, msg string) error {
cmd := exec.Command("git", "commit", "-m", msg)
cmd.Dir = dir
out, err := cmd.CombinedOutput()
if err != nil {
return fmt.Errorf("git commit failed: %s", strings.TrimSpace(string(out)))
}
return nil
}
// PushRemote pushes to the default remote
func PushRemote(dir string) error {
return PushRemoteWithEnv(dir, nil)
}
// PushRemoteWithAuth pushes to the default remote with token auth env inferred
// from origin remote.
func PushRemoteWithAuth(dir string) error {
return PushRemoteWithEnv(dir, AuthEnvForRepo(dir))
}
// PushRemoteWithEnv pushes to the default remote with additional environment
// variables, setting upstream on the first push (see PushArgs). Error output is
// sanitized of credential values via WrapGitError.
func PushRemoteWithEnv(dir string, extraEnv []string) error {
cmd := exec.Command("git", PushArgs(dir, extraEnv)...)
cmd.Dir = dir
cmd.Env = append(append(os.Environ(), "LC_ALL=C"), extraEnv...)
var outBuf bytes.Buffer
cmd.Stdout = &outBuf
cmd.Stderr = &outBuf
err := cmd.Run()
if err != nil {
wrapped := install.WrapGitError(outBuf.String(), err, install.UsedTokenAuth(extraEnv))
out := outBuf.String()
if strings.Contains(out, "[rejected]") && (strings.Contains(out, "fetch first") || strings.Contains(out, "non-fast-forward")) {
return fmt.Errorf("%w: %v", ErrPushRejected, wrapped)
}
return wrapped
}
return nil
}
// ErrPushRejected reports that the remote has commits this repository lacks,
// so the push needs a pull first.
var ErrPushRejected = errors.New("remote has commits this machine does not have; pull first, then push")
// PushArgs returns the git push arguments for dir. The first push sets
// upstream, targeting origin's default branch when it is named differently
// from the local branch (origin is fetched to find it). Later pushes name a
// differently named upstream branch explicitly, which push.default=simple
// otherwise refuses.
func PushArgs(dir string, extraEnv []string) []string {
local, err := GetCurrentBranch(dir)
if err != nil {
local = "main"
}
if !HasUpstream(dir) {
fetch := exec.Command("git", "fetch", "origin")
fetch.Dir = dir
fetch.Env = append(os.Environ(), extraEnv...)
if fetch.Run() == nil {
if remote, err := GetRemoteDefaultBranch(dir); err == nil && remote != local {
return []string{"push", "-u", "origin", local + ":" + remote}
}
}
return []string{"push", "-u", "origin", local}
}
upstream, _ := GetTrackingBranch(dir)
if remote, branch, ok := strings.Cut(upstream, "/"); ok && remote != "" && branch != "" && branch != local {
return []string{"push", remote, "HEAD:" + branch}
}
return []string{"push"}
}
// AheadCount returns how many commits on HEAD are not on any remote-tracking
// branch, which is what a push would upload. It returns 0 when unknown, e.g.
// before the first commit.
func AheadCount(dir string) int {
cmd := exec.Command("git", "rev-list", "--count", "HEAD", "--not", "--remotes")
cmd.Dir = dir
out, err := cmd.Output()
if err != nil {
return 0
}
n, _ := strconv.Atoi(strings.TrimSpace(string(out)))
return n
}
// BehindCount returns how many upstream commits HEAD lacks, as of the last
// fetch. It returns 0 when unknown, e.g. without an upstream.
func BehindCount(dir string) int {
cmd := exec.Command("git", "rev-list", "--count", "HEAD..@{u}")
cmd.Dir = dir
out, err := cmd.Output()
if err != nil {
return 0
}
n, _ := strconv.Atoi(strings.TrimSpace(string(out)))
return n
}
// ErrMergeFailed reports that merging origin's history during a first pull
// failed, usually on a conflict. The merge has been aborted.
var ErrMergeFailed = errors.New("merging remote history failed")
// FirstPull attaches a branch without upstream tracking to origin's default
// branch. Local directories are kept by merging the remote history (it may be
// unrelated); with force, or with nothing local, the branch is reset to the
// remote instead. Returns ErrNoRemoteBranches while origin is still empty.
func FirstPull(dir string, force bool) (*UpdateInfo, error) {
authEnv := AuthEnvForRepo(dir)
fetch := exec.Command("git", "fetch", "origin")
fetch.Dir = dir
fetch.Env = append(append(os.Environ(), "LC_ALL=C"), authEnv...)
if out, err := fetch.CombinedOutput(); err != nil {
return nil, install.WrapGitError(string(out), err, install.UsedTokenAuth(authEnv))
}
branch, err := GetRemoteDefaultBranch(dir)
if err != nil {
return nil, err
}
hasLocal, err := HasLocalSkillDirs(dir)
if err != nil {
return nil, err
}
info := &UpdateInfo{}
info.BeforeHash, _ = GetCurrentFullHash(dir) // empty before the first commit
remote := "origin/" + branch
if hasLocal && !force {
merge := exec.Command("git", "-c", "merge.ff=false", "merge", "--allow-unrelated-histories", "--no-edit", remote)
merge.Dir = dir
if out, err := merge.CombinedOutput(); err != nil {
abort := exec.Command("git", "merge", "--abort")
abort.Dir = dir
abort.Run() // best-effort cleanup
return nil, fmt.Errorf("%w with %s: %s", ErrMergeFailed, remote, strings.TrimSpace(string(out)))
}
} else {
reset := exec.Command("git", "reset", "--hard", remote)
reset.Dir = dir
if out, err := reset.CombinedOutput(); err != nil {
return nil, fmt.Errorf("reset to %s failed: %s", remote, strings.TrimSpace(string(out)))
}
}
local, _ := GetCurrentBranch(dir)
if local == "" {
local = "main"
}
track := exec.Command("git", "branch", "--set-upstream-to="+remote, local)
track.Dir = dir
track.Run() // best-effort
info.AfterHash, _ = GetCurrentFullHash(dir)
info.UpToDate = info.BeforeHash == info.AfterHash
if info.BeforeHash != "" && !info.UpToDate {
info.Commits, _ = GetCommitsBetween(dir, info.BeforeHash, info.AfterHash)
info.Stats, _ = GetDiffStats(dir, info.BeforeHash, info.AfterHash)
}
return info, nil
}
// GetStatus returns git status --porcelain output
func GetStatus(dir string) (string, error) {
cmd := exec.Command("git", "status", "--porcelain")
cmd.Dir = dir
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
// HasUpstream checks if the current branch has upstream tracking configured.
func HasUpstream(dir string) bool {
cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
cmd.Dir = dir
return cmd.Run() == nil
}
// GetCurrentBranch returns the current branch name
func GetCurrentBranch(repoPath string) (string, error) {
cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
// GetRemoteDefaultBranch returns the default branch name for origin.
// Resolution order:
// 1. refs/remotes/origin/HEAD
// 2. common branch names (main, master)
// 3. first discovered refs/remotes/origin/* branch
func GetRemoteDefaultBranch(repoPath string) (string, error) {
cmd := exec.Command("git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD")
cmd.Dir = repoPath
if out, err := cmd.Output(); err == nil {
branch := strings.TrimSpace(string(out))
branch = strings.TrimPrefix(branch, "origin/")
if branch != "" {
return branch, nil
}
}
for _, branch := range []string{"main", "master"} {
checkCmd := exec.Command("git", "rev-parse", "--verify", "refs/remotes/origin/"+branch)
checkCmd.Dir = repoPath
if err := checkCmd.Run(); err == nil {
return branch, nil
}
}
listCmd := exec.Command("git", "for-each-ref", "--format=%(refname:short)", "refs/remotes/origin")
listCmd.Dir = repoPath
out, err := listCmd.Output()
if err != nil {
return "", err
}
for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
ref := strings.TrimSpace(line)
if ref == "" || ref == "origin/HEAD" {
continue
}
ref = strings.TrimPrefix(ref, "origin/")
if ref != "" {
return ref, nil
}
}
return "", ErrNoRemoteBranches
}
// HasRemoteSkillDirs reports whether origin/<remoteBranch> has at least one top-level directory.
func HasRemoteSkillDirs(repoPath, remoteBranch string) (bool, error) {
lsCmd := exec.Command("git", "ls-tree", "-d", "--name-only", "origin/"+remoteBranch)
lsCmd.Dir = repoPath
lsOut, err := lsCmd.Output()
if err != nil {
return false, err
}
return strings.TrimSpace(string(lsOut)) != "", nil
}
// HasLocalSkillDirs reports whether the repo root has at least one directory besides .git.
func HasLocalSkillDirs(repoPath string) (bool, error) {
entries, err := os.ReadDir(repoPath)
if err != nil {
return false, err
}
for _, e := range entries {
if e.IsDir() && e.Name() != ".git" {
return true, nil
}
}
return false, nil
}
// GetBehindCount fetches from origin and returns how many commits local is behind
func GetBehindCount(repoPath string) (int, error) {
return GetBehindCountWithEnv(repoPath, nil)
}
// GetBehindCountWithAuth fetches from origin and returns how many commits local
// is behind, injecting HTTPS token auth based on origin remote when available.
func GetBehindCountWithAuth(repoPath string) (int, error) {
return GetBehindCountWithEnv(repoPath, AuthEnvForRepo(repoPath))
}
// GetBehindCountWithEnv is like GetBehindCount but with additional env vars.
func GetBehindCountWithEnv(repoPath string, extraEnv []string) (int, error) {
if err := FetchWithEnv(repoPath, extraEnv); err != nil {
return 0, err
}
branch, err := GetCurrentBranch(repoPath)
if err != nil {
return 0, err
}
cmd := exec.Command("git", "rev-list", "--count", "HEAD..origin/"+branch)
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return 0, err
}
n, _ := strconv.Atoi(strings.TrimSpace(string(out)))
return n, nil
}
// GetRemoteHeadHash returns the HEAD hash of a remote repo without cloning
func GetRemoteHeadHash(repoURL string) (string, error) {
return GetRemoteHeadHashWithEnv(repoURL, nil)
}
// GetRemoteHeadHashWithAuth returns remote HEAD hash with HTTPS token auth
// injection when token env vars are available.
func GetRemoteHeadHashWithAuth(repoURL string) (string, error) {
return GetRemoteHeadHashWithEnv(repoURL, install.AuthEnvForURL(repoURL))
}
// remoteHashTimeout bounds lightweight remote probes used by check/status flows.
var remoteHashTimeout = 15 * time.Second
// GetRemoteHeadHashWithEnv is like GetRemoteHeadHash but with additional env vars.
func GetRemoteHeadHashWithEnv(repoURL string, extraEnv []string) (string, error) {
out, err := runRemoteLsRemote([]string{repoURL, "HEAD"}, extraEnv)
if err != nil {
return "", err
}
return parseRemoteHash(out, "")
}
// GetRemoteRefHash returns the hash of a specific branch on a remote repo.
// If branch is empty, returns HEAD hash (same as GetRemoteHeadHash).
// The returned hash is truncated to 7 characters.
func GetRemoteRefHash(repoURL, branch string) (string, error) {
return GetRemoteRefHashWithEnv(repoURL, branch, nil)
}
// GetRemoteRefHashWithAuth returns the remote ref hash with HTTPS token auth.
func GetRemoteRefHashWithAuth(repoURL, branch string) (string, error) {
return GetRemoteRefHashWithEnv(repoURL, branch, install.AuthEnvForURL(repoURL))
}
// GetRemoteRefHashWithEnv returns the hash of a specific ref (branch, tag, or
// commit SHA) on a remote repo. A pinned SHA never moves, so a full SHA is
// returned without a network round-trip; an abbreviated hex ref is looked up
// first, since it may also be a branch or tag name.
func GetRemoteRefHashWithEnv(repoURL, branch string, extraEnv []string) (string, error) {
if len(branch) == 40 && install.IsCommitSHA(branch) {
return abbrevHash(branch), nil
}
args := []string{repoURL, "HEAD"}
if branch != "" {
// refs/tags/<name>^{} is the peeled commit of an annotated tag.
args = []string{repoURL, "refs/heads/" + branch, "refs/tags/" + branch, "refs/tags/" + branch + "^{}"}
}
out, err := runRemoteLsRemote(args, extraEnv)
if err != nil {
return "", err
}
hash, err := parseRemoteHash(out, branch)
if err != nil && install.IsCommitSHA(branch) {
return abbrevHash(branch), nil
}
return hash, err
}
func runRemoteLsRemote(args []string, extraEnv []string) (string, error) {
ctx, cancel := context.WithTimeout(context.Background(), remoteHashTimeout)
defer cancel()
cmd := exec.CommandContext(ctx, "git", append([]string{"ls-remote"}, args...)...)
cmd.Env = append(os.Environ(),
"GIT_TERMINAL_PROMPT=0",
"GIT_ASKPASS=",
"SSH_ASKPASS=",
)
if len(extraEnv) > 0 {
cmd.Env = append(cmd.Env, extraEnv...)
}
var stderr bytes.Buffer
cmd.Stderr = &stderr
out, err := cmd.Output()
if ctx.Err() == context.DeadlineExceeded {
return "", fmt.Errorf("git ls-remote timed out after %s", remoteHashTimeout)
}
if err != nil {
return "", install.WrapGitError(stderr.String(), err, install.UsedTokenAuth(extraEnv))
}
return string(out), nil
}
// parseRemoteHash picks the commit from ls-remote output: a branch wins over a
// same-named tag, and an annotated tag's peeled commit wins over the tag object.
func parseRemoteHash(out, branch string) (string, error) {
var hash string
for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
fields := strings.Fields(line)
if len(fields) == 0 {
continue
}
ref := ""
if len(fields) > 1 {
ref = fields[1]
}
switch {
case strings.HasPrefix(ref, "refs/heads/"):
return abbrevHash(fields[0]), nil
case strings.HasSuffix(ref, "^{}"), hash == "":
hash = fields[0]
}
}
if hash == "" {
if branch != "" {
return "", fmt.Errorf("remote ref %q not found", branch)
}
return "", fmt.Errorf("no HEAD ref found")
}
return abbrevHash(hash), nil
}
func abbrevHash(hash string) string {
if len(hash) > 7 {
return hash[:7]
}
return hash
}
// ForcePull fetches and resets to origin (handles force push)
func ForcePull(repoPath string) (*UpdateInfo, error) {
return ForcePullWithEnv(repoPath, nil)
}
// ForcePullWithAuth runs force-pull flow with token auth env inferred from origin remote.
func ForcePullWithAuth(repoPath string) (*UpdateInfo, error) {
return ForcePullWithEnv(repoPath, AuthEnvForRepo(repoPath))
}
// ForcePullWithProgress runs fetch+hard-reset and optionally streams fetch
// progress lines when onProgress is non-nil.
func ForcePullWithProgress(repoPath string, extraEnv []string, onProgress func(string)) (*UpdateInfo, error) {
info := &UpdateInfo{}
beforeHash, err := GetCurrentFullHash(repoPath)
if err != nil {
return nil, err
}
info.BeforeHash = beforeHash
branch, err := GetCurrentBranch(repoPath)
if err != nil {
return nil, err
}
fetchArgs := []string{"fetch"}
if onProgress == nil {
fetchArgs = []string{"fetch", "--quiet"}
} else {
fetchArgs = []string{"fetch", "--progress"}
}
if err := runGitWithProgress(repoPath, fetchArgs, extraEnv, onProgress); err != nil {
return nil, err
}
cmd := exec.Command("git", "reset", "--hard", "origin/"+branch)
cmd.Dir = repoPath
if err := cmd.Run(); err != nil {
return nil, err
}
afterHash, err := GetCurrentFullHash(repoPath)
if err != nil {
return nil, err
}
info.AfterHash = afterHash
if beforeHash == afterHash {
info.UpToDate = true
return info, nil
}
commits, _ := GetCommitsBetween(repoPath, beforeHash, afterHash)
info.Commits = commits
stats, _ := GetDiffStats(repoPath, beforeHash, afterHash)
info.Stats = stats
return info, nil
}
// ForcePullWithEnv fetches and resets to origin with additional env vars.
func ForcePullWithEnv(repoPath string, extraEnv []string) (*UpdateInfo, error) {
return ForcePullWithProgress(repoPath, extraEnv, nil)
}
// AuthEnvForRepo returns HTTPS token auth env vars for the repo's origin remote.
func AuthEnvForRepo(repoPath string) []string {
url, _ := GetRemoteURL(repoPath)
return install.AuthEnvForURL(url)
}
// GetRemoteURL returns the fetch URL for the "origin" remote.
func GetRemoteURL(repoPath string) (string, error) {
cmd := exec.Command("git", "remote", "get-url", "origin")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
// validRemoteArg rejects values that git could parse as an option flag. A
// remote URL beginning with "-" enables argv flag smuggling (e.g. "--upload-pack=…"),
// so reject it; a legitimate remote URL never starts with a dash.
func validRemoteArg(url string) error {
if url == "" {
return fmt.Errorf("empty remote URL")
}
if strings.HasPrefix(url, "-") {
return fmt.Errorf("invalid remote URL %q: must not start with '-'", url)
}
return nil
}
// SetRemoteURL updates the fetch/push URL for the "origin" remote.
func SetRemoteURL(repoPath, newURL string) error {
if err := validRemoteArg(newURL); err != nil {
return err
}
cmd := exec.Command("git", "remote", "set-url", "--", "origin", newURL)
cmd.Dir = repoPath
return cmd.Run()
}
// SetOrAddRemote points the "origin" remote at url: it updates the URL when
// origin already exists and adds the remote otherwise. ("git remote set-url"
// fails when origin is absent and "git remote add" fails when it exists, so the
// correct command depends on the current state.)
func SetOrAddRemote(repoPath, url string) error {
if err := validRemoteArg(url); err != nil {
return err
}
if _, err := GetRemoteURL(repoPath); err == nil {
return SetRemoteURL(repoPath, url)
}
cmd := exec.Command("git", "remote", "add", "--", "origin", url)
cmd.Dir = repoPath
return cmd.Run()
}
// GetHeadMessage returns the subject line of the HEAD commit.
func GetHeadMessage(repoPath string) (string, error) {
cmd := exec.Command("git", "log", "-1", "--format=%s")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
// ListLocalBranches returns local branch names sorted alphabetically.
func ListLocalBranches(repoPath string) ([]string, error) {
cmd := exec.Command("git", "branch", "--format=%(refname:short)")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return nil, err
}
var branches []string
for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
if b := strings.TrimSpace(line); b != "" {
branches = append(branches, b)
}
}
return branches, nil
}
// ListRemoteBranches returns remote-only branch names (stripping "origin/" prefix).
// Branches that already exist locally are excluded.
func ListRemoteBranches(repoPath string) ([]string, error) {
cmd := exec.Command("git", "branch", "-r", "--format=%(refname:short)")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return nil, err
}
locals, _ := ListLocalBranches(repoPath)
localSet := make(map[string]struct{}, len(locals))
for _, l := range locals {
localSet[l] = struct{}{}
}
var branches []string
for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
ref := strings.TrimSpace(line)
if ref == "" || ref == "origin/HEAD" || strings.Contains(ref, "->") {
continue
}
name := strings.TrimPrefix(ref, "origin/")
if _, exists := localSet[name]; exists {
continue
}
branches = append(branches, name)
}
return branches, nil
}
// Checkout switches to the given branch. If the branch exists only on
// the remote, a new local tracking branch is created automatically.
func Checkout(repoPath, branch string) error {
// Check if local branch exists
check := exec.Command("git", "rev-parse", "--verify", "refs/heads/"+branch)
check.Dir = repoPath
if check.Run() == nil {
// Local branch exists — simple checkout
cmd := exec.Command("git", "checkout", branch)
cmd.Dir = repoPath
out, err := cmd.CombinedOutput()
if err != nil {
return fmt.Errorf("git checkout failed: %s", strings.TrimSpace(string(out)))
}
return nil
}
// Try remote tracking branch
cmd := exec.Command("git", "checkout", "-b", branch, "origin/"+branch)
cmd.Dir = repoPath
out, err := cmd.CombinedOutput()
if err != nil {
return fmt.Errorf("git checkout failed: %s", strings.TrimSpace(string(out)))
}
return nil
}
// GetTrackingBranch returns the upstream tracking branch (e.g. "origin/main").
// Returns empty string (no error) if no upstream is set.
func GetTrackingBranch(repoPath string) (string, error) {
cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "@{upstream}")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return "", nil
}
return strings.TrimSpace(string(out)), nil
}