git.go

package main

import (
	"bytes"
	"context"
	"fmt"
	"os/exec"
	"strings"
	"time"
)

// Commit represents a single git commit.
type Commit struct {
	Hash        string
	Parents     []string
	AuthorName  string
	AuthorEmail string
	AuthorDate  time.Time
	Subject     string
	Decorations []Decoration
}

// ShortHash returns the first 7 characters of the hash.
func (c *Commit) ShortHash() string {
	if len(c.Hash) > 7 {
		return c.Hash[:7]
	}
	return c.Hash
}

// RelativeDate returns a human-readable relative date.
func (c *Commit) RelativeDate() string {
	d := time.Since(c.AuthorDate)
	switch {
	case d < time.Minute:
		return "just now"
	case d < time.Hour:
		m := int(d.Minutes())
		if m == 1 {
			return "1 minute ago"
		}
		return fmt.Sprintf("%d minutes ago", m)
	case d < 24*time.Hour:
		h := int(d.Hours())
		if h == 1 {
			return "1 hour ago"
		}
		return fmt.Sprintf("%d hours ago", h)
	case d < 30*24*time.Hour:
		days := int(d.Hours() / 24)
		if days == 1 {
			return "1 day ago"
		}
		return fmt.Sprintf("%d days ago", days)
	case d < 365*24*time.Hour:
		months := int(d.Hours() / 24 / 30)
		if months <= 1 {
			return "1 month ago"
		}
		return fmt.Sprintf("%d months ago", months)
	default:
		years := int(d.Hours() / 24 / 365)
		if years == 1 {
			return "1 year ago"
		}
		return fmt.Sprintf("%d years ago", years)
	}
}

// DecorationKind indicates the type of a decoration.
type DecorationKind int

const (
	DecorationBranch DecorationKind = iota
	DecorationTag
	DecorationHead
)

// Decoration represents a branch or tag label on a commit.
type Decoration struct {
	Name string
	Kind DecorationKind
}

// gitOutput runs a git command in dir and returns its output.
func gitOutput(ctx context.Context, dir string, args ...string) ([]byte, error) {
	cmd := exec.CommandContext(ctx, "git", args...)
	cmd.Dir = dir
	out, err := cmd.Output()
	if err != nil {
		return nil, fmt.Errorf("git %s: %w", args[0], err)
	}
	return out, nil
}

const commitFormat = "--format=%H%x00%P%x00%an%x00%ae%x00%aI%x00%s%x00%D"

// LoadCommits loads all commits from the given repository directory.
func LoadCommits(dir string) ([]Commit, error) {
	out, err := gitOutput(context.Background(), dir, "log", "--all", commitFormat)
	if err != nil {
		return nil, err
	}
	return parseCommits(out)
}

// SearchCommits searches for commits matching the query.
// The query is matched against subject (--grep), author (--author), and hash prefix.
// The context can be used to cancel the git process.
func SearchCommits(ctx context.Context, dir, query string) ([]Commit, error) {
	out, err := gitOutput(ctx, dir, "log", "--all",
		"--grep="+query, "--author="+query, commitFormat)
	if err != nil {
		return nil, err
	}
	return parseCommits(out)
}

// LoadDiff returns the full commit info and diff for a single commit.
// The context can be used to cancel the git process.
func LoadDiff(ctx context.Context, dir, hash string) (string, error) {
	out, err := gitOutput(ctx, dir, "show", "--format=fuller", "--root", hash)
	if err != nil {
		return "", err
	}
	return string(out), nil
}

func parseCommits(data []byte) ([]Commit, error) {
	var commits []Commit
	for _, line := range bytes.Split(data, []byte("\n")) {
		if len(line) == 0 {
			continue
		}
		parts := bytes.SplitN(line, []byte{0}, 7)
		if len(parts) < 7 {
			continue
		}

		t, err := time.Parse(time.RFC3339, string(parts[4]))
		if err != nil {
			t = time.Time{}
		}

		var parents []string
		if len(parts[1]) > 0 {
			parents = strings.Split(string(parts[1]), " ")
		}

		c := Commit{
			Hash:        string(parts[0]),
			Parents:     parents,
			AuthorName:  string(parts[2]),
			AuthorEmail: string(parts[3]),
			AuthorDate:  t,
			Subject:     string(parts[5]),
			Decorations: parseDecorations(string(parts[6])),
		}
		commits = append(commits, c)
	}
	return commits, nil
}

func parseDecorations(raw string) []Decoration {
	if raw == "" {
		return nil
	}
	var decs []Decoration
	for _, part := range strings.Split(raw, ", ") {
		part = strings.TrimSpace(part)
		if part == "" {
			continue
		}
		switch {
		case strings.HasPrefix(part, "HEAD -> "):
			decs = append(decs, Decoration{
				Name: strings.TrimPrefix(part, "HEAD -> "),
				Kind: DecorationHead,
			})
		case strings.HasPrefix(part, "tag: "):
			decs = append(decs, Decoration{
				Name: strings.TrimPrefix(part, "tag: "),
				Kind: DecorationTag,
			})
		case part == "HEAD":
			decs = append(decs, Decoration{
				Name: "HEAD",
				Kind: DecorationHead,
			})
		default:
			// Strip remote prefix for display.
			name := part
			if strings.HasPrefix(name, "origin/") {
				name = part
			}
			decs = append(decs, Decoration{
				Name: name,
				Kind: DecorationBranch,
			})
		}
	}
	return decs
}