mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
- Fallback fetch pulled only the default branch because a depth-1 clone is single-branch; fetch all heads and tags so an abbreviated SHA off the default branch resolves. - Move the --track guard from CLI flag parsing into InstallTrackedRepo so the Web UI is covered too, and reject tags as well as SHAs: both leave HEAD detached with nothing for `git pull` to follow. - An all-hex branch or tag name (e.g. 20240915) was treated as a SHA in check and never queried; look the ref up first and fall back to the literal SHA only when the remote has no such ref. Full 40-char SHAs still skip the network. - Rename the git package's 7-char shortHash to abbrevHash to avoid clashing with install's 12-char helper. Refs #281
1092 lines
31 KiB
Go
1092 lines
31 KiB
Go
package git
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"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
|
|
|
|
args := []string{"pull", "--quiet"}
|
|
if onProgress != nil {
|
|
args = []string{"pull", "--progress"}
|
|
}
|
|
if err := runGitWithProgress(repoPath, args, extraEnv, onProgress); 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
|
|
}
|
|
|
|
// 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 {
|
|
return install.WrapGitError(outBuf.String(), err, install.UsedTokenAuth(extraEnv))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|