git.go

package main

import (
	"bufio"
	"fmt"
	"os/exec"
	"strconv"
	"strings"
	"time"
)

// Commit represents a single git commit
type Commit struct {
	Hash       string
	Author     string
	Email      string
	Timestamp  time.Time
	Message    string
	FilesChanged int
	Insertions   int
	Deletions    int
}

// FileChurn represents change frequency for a file
type FileChurn struct {
	Path       string
	Changes    int
	Insertions int
	Deletions  int
	Authors    map[string]int
}

// GetCommits retrieves commits from the last N days
func GetCommits(repoPath string, days int) ([]Commit, error) {
	since := time.Now().AddDate(0, 0, -days).Format("2006-01-02")

	// Use a custom format for reliable parsing
	// Format: hash|author|email|timestamp|message
	format := "%H|%an|%ae|%aI|%s"

	cmd := exec.Command("git", "-C", repoPath, "log",
		"--since="+since,
		"--format="+format,
		"--shortstat",
		"--no-merges",
	)

	output, err := cmd.Output()
	if err != nil {
		return nil, fmt.Errorf("git log failed: %w", err)
	}

	return parseCommits(string(output))
}

func parseCommits(output string) ([]Commit, error) {
	var commits []Commit
	scanner := bufio.NewScanner(strings.NewReader(output))

	var current *Commit
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" {
			continue
		}

		// Try to parse as commit line (has | separators)
		parts := strings.SplitN(line, "|", 5)
		if len(parts) == 5 && len(parts[0]) == 40 {
			// This is a commit line
			ts, err := time.Parse(time.RFC3339, parts[3])
			if err != nil {
				continue
			}
			c := Commit{
				Hash:      parts[0],
				Author:    parts[1],
				Email:     parts[2],
				Timestamp: ts,
				Message:   parts[4],
			}
			commits = append(commits, c)
			current = &commits[len(commits)-1]
		} else if current != nil && strings.Contains(line, "changed") {
			// This is a stat line like "3 files changed, 10 insertions(+), 2 deletions(-)"
			parseStatLine(line, current)
			current = nil
		}
	}

	return commits, nil
}

func parseStatLine(line string, c *Commit) {
	parts := strings.Split(line, ",")
	for _, part := range parts {
		part = strings.TrimSpace(part)
		fields := strings.Fields(part)
		if len(fields) < 2 {
			continue
		}
		num, err := strconv.Atoi(fields[0])
		if err != nil {
			continue
		}
		switch {
		case strings.Contains(fields[1], "file"):
			c.FilesChanged = num
		case strings.Contains(fields[1], "insertion"):
			c.Insertions = num
		case strings.Contains(fields[1], "deletion"):
			c.Deletions = num
		}
	}
}

// GetFileChurn analyzes which files change most frequently
func GetFileChurn(repoPath string, days int) ([]FileChurn, error) {
	since := time.Now().AddDate(0, 0, -days).Format("2006-01-02")

	cmd := exec.Command("git", "-C", repoPath, "log",
		"--since="+since,
		"--format=%H|%an",
		"--numstat",
		"--no-merges",
	)

	output, err := cmd.Output()
	if err != nil {
		return nil, fmt.Errorf("git log failed: %w", err)
	}

	return parseFileChurn(string(output))
}

func parseFileChurn(output string) ([]FileChurn, error) {
	churnMap := make(map[string]*FileChurn)
	scanner := bufio.NewScanner(strings.NewReader(output))

	var currentAuthor string
	for scanner.Scan() {
		line := scanner.Text()
		if line == "" {
			continue
		}

		// Check if it's a commit header line
		parts := strings.SplitN(line, "|", 2)
		if len(parts) == 2 && len(parts[0]) == 40 {
			currentAuthor = parts[1]
			continue
		}

		// Parse numstat line: insertions\tdeletions\tfilepath
		fields := strings.Split(line, "\t")
		if len(fields) == 3 {
			ins, _ := strconv.Atoi(fields[0])
			del, _ := strconv.Atoi(fields[1])
			path := fields[2]

			if path == "" || fields[0] == "-" {
				continue // Skip binary files
			}

			fc, ok := churnMap[path]
			if !ok {
				fc = &FileChurn{
					Path:    path,
					Authors: make(map[string]int),
				}
				churnMap[path] = fc
			}
			fc.Changes++
			fc.Insertions += ins
			fc.Deletions += del
			if currentAuthor != "" {
				fc.Authors[currentAuthor]++
			}
		}
	}

	// Convert map to sorted slice
	result := make([]FileChurn, 0, len(churnMap))
	for _, fc := range churnMap {
		result = append(result, *fc)
	}

	// Sort by change frequency (descending)
	sortFileChurn(result)

	return result, nil
}

func sortFileChurn(files []FileChurn) {
	// Simple insertion sort (no external deps)
	for i := 1; i < len(files); i++ {
		key := files[i]
		j := i - 1
		for j >= 0 && files[j].Changes < key.Changes {
			files[j+1] = files[j]
			j--
		}
		files[j+1] = key
	}
}