main.go

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"time"
)

var version = "dev"

const (
	defaultGroqModel = "llama-3.3-70b-versatile"
	groqAPIURL       = "https://api.groq.com/openai/v1/chat/completions"
	groqAPIKeyConfig = "gitpilot.groq-api-key"
	groqModelConfig  = "gitpilot.groq-model"
	initConfigKey    = "gitpilot.initialized"
	keychainService  = "gitpilot"
	keychainAccount  = "groq-api-key"
	colorReset       = "\033[0m"
	colorDim         = "\033[38;5;245m"
	colorBorder      = "\033[38;5;240m"
	colorAccent      = "\033[38;5;111m"
	colorInfo        = "\033[38;5;117m"
	colorSuccess     = "\033[38;5;114m"
	colorWarn        = "\033[38;5;221m"
	colorError       = "\033[38;5;203m"
	colorStrong      = "\033[1m"

	maxAIContextChars        = 16000
	maxCommitRequestTokens   = 1400
	maxGroupingRequestTokens = 1200
	maxDiffExcerptChars      = 3500
	minDiffExcerptChars      = 600
	diffHeadLines            = 24
	diffTailLines            = 14
	maxSemanticItems         = 12
	maxSampleLines           = 8
	estimatedCharsPerToken   = 4
	maxGroqAttempts          = 4
)

type FileChange struct {
	FileName string
	Status   string
	Diff     string
}

type chatCompletionRequest struct {
	Model       string        `json:"model"`
	Temperature float64       `json:"temperature"`
	MaxTokens   int           `json:"max_tokens,omitempty"`
	Messages    []chatMessage `json:"messages"`
}

type chatMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type chatCompletionResponse struct {
	Choices []struct {
		Message chatMessage `json:"message"`
	} `json:"choices"`
	Error *struct {
		Message string `json:"message"`
	} `json:"error,omitempty"`
}

type CommitPlan struct {
	Label   string
	Changes []FileChange
}

type CommitInfo struct {
	Hash    string
	Subject string
}

type commitGroupProposal struct {
	Label string   `json:"label"`
	Files []string `json:"files"`
}

type commitRunSummary struct {
	Mode      string
	Committed []string
	Skipped   []string
	Failed    []string
}

func printWelcome() {
	printPanel([]string{
		colorStrong + "Git Pilot" + colorReset,
		colorDim + "AI-assisted Git workflow for structured commits and push approvals" + colorReset,
		"",
		colorDim + "Commands: auth, init, status, diff, commit, push, pull, pr, config, version, help, exit" + colorReset,
	})
}

func printSection(title string) {
	fmt.Printf("\n%s──%s %s%s%s\n", colorBorder, colorReset, colorStrong, title, colorReset)
}

func printSuccess(message string) {
	fmt.Printf("%s●%s %s%s%s\n", colorSuccess, colorReset, colorSuccess, message, colorReset)
}

func printWarning(message string) {
	fmt.Printf("%s●%s %s%s%s\n", colorWarn, colorReset, colorWarn, message, colorReset)
}

func printError(message string) {
	fmt.Printf("%s●%s %s%s%s\n", colorError, colorReset, colorError, message, colorReset)
}

func printInfo(message string) {
	fmt.Printf("%s●%s %s%s%s\n", colorInfo, colorReset, colorInfo, message, colorReset)
}

func printPanel(lines []string) {
	expanded := make([]string, 0, len(lines))
	for _, line := range lines {
		parts := strings.Split(line, "\n")
		expanded = append(expanded, parts...)
	}

	width := 0
	for _, line := range expanded {
		if len(stripANSI(line)) > width {
			width = len(stripANSI(line))
		}
	}
	if width < 24 {
		width = 24
	}

	fmt.Printf("%s╭%s╮%s\n", colorBorder, strings.Repeat("─", width+2), colorReset)
	for _, line := range expanded {
		padding := width - len(stripANSI(line))
		fmt.Printf("%s│%s %s%s %s│%s\n", colorBorder, colorReset, line, strings.Repeat(" ", padding), colorBorder, colorReset)
	}
	fmt.Printf("%s╰%s╯%s\n", colorBorder, strings.Repeat("─", width+2), colorReset)
}

func stripANSI(text string) string {
	var builder strings.Builder
	inEscape := false

	for _, r := range text {
		if r == '\033' {
			inEscape = true
			continue
		}
		if inEscape {
			if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
				inEscape = false
			}
			continue
		}
		builder.WriteRune(r)
	}

	return builder.String()
}

func styleStatus(status string) string {
	switch {
	case strings.Contains(status, "?"):
		return colorInfo + "new     " + colorReset
	case strings.Contains(status, "A"):
		return colorSuccess + "added   " + colorReset
	case strings.Contains(status, "M"):
		return colorWarn + "modified" + colorReset
	case strings.Contains(status, "D"):
		return colorError + "deleted " + colorReset
	case strings.Contains(status, "R"):
		return colorAccent + "renamed " + colorReset
	default:
		return colorDim + status + colorReset
	}
}

func renderChoice(index int, title, description string) string {
	return fmt.Sprintf("%s[%d]%s %s%s%s\n    %s%s%s", colorAccent, index, colorReset, colorStrong, title, colorReset, colorDim, description, colorReset)
}

func readCommand() []string {
	reader := bufio.NewReader(os.Stdin)
	fmt.Printf("%s%sgitpilot%s %s›%s ", colorAccent, colorStrong, colorReset, colorBorder, colorReset)

	line, err := reader.ReadString('\n')
	if err != nil && !errors.Is(err, io.EOF) {
		printError("Failed to read command: " + err.Error())
		return nil
	}

	line = strings.TrimSpace(line)
	if line == "" {
		return nil
	}

	return strings.Fields(line)
}

func runInteractive() {
	for {
		args := readCommand()
		if len(args) == 0 {
			continue
		}

		if args[0] == "exit" {
			fmt.Println("Goodbye!")
			break
		}

		executeCommand(args)
	}
}

func executeCommand(args []string) {
	switch args[0] {
	case "init":
		executeInit()
	case "status":
		executeStatus()
	case "diff":
		executeDiff()
	case "commit":
		executeCommit(args[1:])
	case "push":
		if err := executePush(); err != nil {
			fmt.Println("❌ Push failed:", err)
		}
	case "pull":
		executePull()
	case "auth":
		executeAuth(args[1:])
	case "config":
		executeConfig(args[1:])
	case "pr":
		executePR(args[1:])
	case "help":
		printHelp()
	case "version":
		fmt.Printf("gitpilot %s (%s/%s)\n", version, runtime.GOOS, runtime.GOARCH)
	default:
		printError("Invalid command. Type 'help'")
	}
}

func runGitCommand(args ...string) (string, error) {
	cmd := exec.Command("git", args...)
	output, err := cmd.CombinedOutput()
	if err != nil {
		return string(output), fmt.Errorf("git %s: %w", strings.Join(args, " "), err)
	}

	return string(output), nil
}

func getChangedFiles() ([]FileChange, error) {
	output, err := runGitCommand("status", "--porcelain")
	if err != nil {
		return nil, err
	}

	// Preserve leading spaces because porcelain status uses them as data,
	// e.g. " M main.go" for unstaged modifications.
	lines := strings.Split(strings.TrimRight(output, "\n"), "\n")
	if len(lines) == 1 && lines[0] == "" {
		return nil, nil
	}

	var changes []FileChange
	seen := make(map[string]struct{})

	for _, line := range lines {
		if len(line) < 4 {
			continue
		}

		status := strings.TrimSpace(line[:2])
		path := strings.TrimSpace(line[3:])
		if strings.Contains(path, " -> ") {
			parts := strings.Split(path, " -> ")
			path = strings.TrimSpace(parts[len(parts)-1])
		}

		if _, ok := seen[path]; ok {
			continue
		}
		seen[path] = struct{}{}

		diff, diffErr := getDiffForFile(path, status)
		if diffErr != nil {
			printWarning("Skipping file: " + path)
			continue
		}

		changes = append(changes, FileChange{
			FileName: path,
			Status:   status,
			Diff:     diff,
		})
	}

	return changes, nil
}

func getDiffForFile(fileName, status string) (string, error) {
	if strings.Contains(status, "?") {
		return runDiffAllowExitCodeOne("diff", "--no-index", "--", "/dev/null", fileName)
	}

	var sections []string

	if stagedDiff, err := runDiffAllowExitCodeOne("diff", "--cached", "--", fileName); err == nil && strings.TrimSpace(stagedDiff) != "" {
		sections = append(sections, stagedDiff)
	}

	if workingDiff, err := runDiffAllowExitCodeOne("diff", "--", fileName); err == nil && strings.TrimSpace(workingDiff) != "" {
		sections = append(sections, workingDiff)
	}

	if len(sections) == 0 {
		return "", errors.New("no diff available")
	}

	return strings.Join(sections, "\n"), nil
}

func runDiffAllowExitCodeOne(args ...string) (string, error) {
	cmd := exec.Command("git", args...)
	output, err := cmd.CombinedOutput()
	if err != nil {
		var exitErr *exec.ExitError
		if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 && len(output) > 0 {
			return string(output), nil
		}
		return "", err
	}

	return string(output), nil
}

func filterChanges(changes []FileChange, targets []string) ([]FileChange, error) {
	if len(targets) == 0 {
		return changes, nil
	}

	lookup := make(map[string]FileChange, len(changes))
	for _, change := range changes {
		lookup[change.FileName] = change
	}

	var filtered []FileChange
	for _, target := range targets {
		change, ok := lookup[target]
		if !ok {
			return nil, fmt.Errorf("file %q has no detected changes", target)
		}
		filtered = append(filtered, change)
	}

	return filtered, nil
}

func executeInit() {
	printSection("Init")

	if _, err := runGitCommand("rev-parse", "--is-inside-work-tree"); err != nil {
		printError("Current directory is not a Git repository.")
		return
	}

	branch, _ := runGitCommand("branch", "--show-current")
	remoteName := getDefaultRemoteName()
	model := strings.TrimSpace(getGroqModel())

	if _, err := runGitCommand("config", "--get", groqModelConfig); err != nil {
		if err := setGitConfig(groqModelConfig, defaultGroqModel); err != nil {
			printError("Failed to save default Groq model: " + err.Error())
			return
		}
		model = defaultGroqModel
	}

	if _, err := runGitCommand("config", "--get", initConfigKey); err != nil {
		if err := setGitConfig(initConfigKey, "true"); err != nil {
			printError("Failed to save Git Pilot initialization state: " + err.Error())
			return
		}
	}

	printPanel([]string{
		colorStrong + "Repository ready for Git Pilot" + colorReset,
		colorDim + "Branch" + colorReset + "  " + strings.TrimSpace(branch),
		colorDim + "Remote" + colorReset + "  " + remoteName,
		colorDim + "Model" + colorReset + "   " + model,
	})

	if _, err := getGroqAPIKey(); err != nil {
		printWarning("Groq API key is not configured yet.")
		fmt.Println("Set GROQ_API_KEY or run: config groq-key <your-key>")
		return
	}

	printSuccess("Groq API key detected.")
}

func executeStatus() {
	printSection("Repository Status")

	output, err := runGitCommand("status")
	if err != nil {
		printWarning("Git returned an error.")
	}

	fmt.Println(output)
}

func executeDiff() {
	printSection("Changed Files")

	changes, err := getChangedFiles()
	if err != nil {
		printError(err.Error())
		return
	}

	if len(changes) == 0 {
		fmt.Println("No changes detected.")
		return
	}

	lines := []string{
		fmt.Sprintf("%s%d file(s) changed%s", colorStrong, len(changes), colorReset),
	}
	for index, change := range changes {
		lines = append(lines, fmt.Sprintf("%s%2d%s  %s  %s", colorDim, index+1, colorReset, styleStatus(change.Status), change.FileName))
	}
	printPanel(lines)
}

func executeCommit(args []string) {
	printSection("Commit Session")

	changes, err := getChangedFiles()
	if err != nil {
		printError(err.Error())
		return
	}

	if len(changes) == 0 {
		fmt.Println("No changes detected.")
		return
	}

	apiKey, err := getGroqAPIKey()
	if err != nil {
		printError(err.Error())
		fmt.Println("Set GROQ_API_KEY or run: config groq-key <your-key>")
		return
	}

	model := getGroqModel()
	mode := ""
	targets := []string(nil)

	if len(args) > 0 {
		mode = args[0]
		targets = args[1:]
	} else {
		mode = promptCommitMode()
		if mode == "" {
			printWarning("Commit cancelled.")
			return
		}
	}

	plans, err := buildCommitPlans(apiKey, model, mode, changes, targets)
	if err != nil {
		printError(err.Error())
		return
	}

	summary := commitRunSummary{Mode: mode}
	printInfo("Planned commits: " + strconv.Itoa(len(plans)))

	for index, plan := range plans {
		printSection(fmt.Sprintf("Commit %d of %d", index+1, len(plans)))
		printPanel([]string{
			colorStrong + plan.Label + colorReset,
			colorDim + strconv.Itoa(len(plan.Changes)) + " file(s) in this commit" + colorReset,
			"",
			formatFilesForDisplay(plan.Changes),
		})
		printInfo("Generating AI commit message...")

		message, err := generateCommitMessage(apiKey, model, plan.Changes)
		if err != nil {
			printError("AI generation failed: " + err.Error())
			summary.Failed = append(summary.Failed, plan.Label)
			continue
		}

		printCommitPreview(plan, message)
		if !approveCommit(plan, message) {
			printWarning("Commit skipped.")
			summary.Skipped = append(summary.Skipped, plan.Label)
			continue
		}

		if err := performCommit(mode, plan.Changes, message); err != nil {
			printError("Commit failed: " + err.Error())
			summary.Failed = append(summary.Failed, plan.Label)
			continue
		}

		printSuccess("Commit created.")
		summary.Committed = append(summary.Committed, fmt.Sprintf("%s -> %s", plan.Label, message))
	}

	printCommitSummary(summary)
	if len(summary.Committed) > 0 {
		promptPushAfterCommits()
	}
}

func promptCommitMode() string {
	reader := bufio.NewReader(os.Stdin)

	for {
		printSection("Commit Mode")
		fmt.Println("How do you want to split these commits?")
		fmt.Println(renderChoice(1, "File wise", "One commit per changed file."))
		fmt.Println(renderChoice(2, "Group wise", "AI groups related files into logical commit categories."))
		fmt.Printf("%sSelect mode%s %s(1/2)%s: ", colorStrong, colorReset, colorDim, colorReset)

		answer, err := reader.ReadString('\n')
		if err != nil && !errors.Is(err, io.EOF) {
			printError("Failed to read choice: " + err.Error())
			return ""
		}

		switch strings.TrimSpace(answer) {
		case "1":
			return "file"
		case "2":
			return "group"
		case "":
			if errors.Is(err, io.EOF) {
				return ""
			}
		default:
			printWarning("Please choose 1 or 2.")
		}
	}
}

func buildCommitPlans(apiKey, model, mode string, changes []FileChange, targets []string) ([]CommitPlan, error) {
	switch mode {
	case "group":
		if len(targets) > 0 {
			groupChanges, err := filterChanges(changes, targets)
			if err != nil {
				return nil, err
			}
			return []CommitPlan{{
				Label:   "group: " + formatFileList(groupChanges),
				Changes: groupChanges,
			}}, nil
		}

		return buildGroupedCommitPlans(apiKey, model, changes)
	case "categories":
		return buildGroupedCommitPlans(apiKey, model, changes)
	case "all":
		groupChanges, err := filterChanges(changes, targets)
		if err != nil {
			return nil, err
		}
		return []CommitPlan{{
			Label:   "group: " + formatFileList(groupChanges),
			Changes: groupChanges,
		}}, nil
	case "file":
		fileChanges := changes
		var err error
		if len(targets) > 0 {
			fileChanges, err = filterChanges(changes, targets)
		}
		if err != nil {
			return nil, err
		}
		plans := make([]CommitPlan, 0, len(fileChanges))
		for _, change := range fileChanges {
			plans = append(plans, CommitPlan{
				Label:   "file: " + change.FileName,
				Changes: []FileChange{change},
			})
		}
		return plans, nil
	default:
		return nil, errors.New("unknown commit mode. Use: commit, commit file <file...>, or commit group <file...>")
	}
}

func printCommitPreview(plan CommitPlan, message string) {
	printPanel([]string{
		colorStrong + "Commit Preview" + colorReset,
		colorDim + "Target" + colorReset + "  " + plan.Label,
		colorDim + "Files" + colorReset + "   " + formatFileList(plan.Changes),
		colorDim + "Message" + colorReset + " " + colorAccent + message + colorReset,
	})
}

func approveCommit(plan CommitPlan, message string) bool {
	reader := bufio.NewReader(os.Stdin)
	fmt.Printf("Approve commit for %s? [y/N]: ", plan.Label)

	answer, err := reader.ReadString('\n')
	if err != nil && !errors.Is(err, io.EOF) {
		printError("Failed to read approval: " + err.Error())
		return false
	}

	answer = strings.TrimSpace(strings.ToLower(answer))
	return answer == "y" || answer == "yes"
}

func promptYesNo(prompt string) bool {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print(prompt)

	answer, err := reader.ReadString('\n')
	if err != nil && !errors.Is(err, io.EOF) {
		printError("Failed to read approval: " + err.Error())
		return false
	}

	answer = strings.TrimSpace(strings.ToLower(answer))
	return answer == "y" || answer == "yes"
}

func performCommit(mode string, changes []FileChange, message string) error {
	if len(changes) == 0 {
		return errors.New("no changes to commit")
	}

	if len(changes) > 1 && mode == "all" {
		if _, err := runGitCommand("add", "-A"); err != nil {
			return err
		}
		_, err := runGitCommand("commit", "-m", message)
		return err
	}

	paths := make([]string, 0, len(changes))
	for _, change := range changes {
		paths = append(paths, change.FileName)
	}

	addArgs := append([]string{"add", "-A", "--"}, paths...)
	if _, err := runGitCommand(addArgs...); err != nil {
		return err
	}

	commitArgs := append([]string{"commit", "--only", "-m", message, "--"}, paths...)
	_, err := runGitCommand(commitArgs...)
	return err
}

func buildGroupedCommitPlans(apiKey, model string, changes []FileChange) ([]CommitPlan, error) {
	content, err := generateCommitGroups(apiKey, model, changes)
	if err != nil {
		return nil, err
	}

	proposals, err := parseCommitGroups(content)
	if err != nil {
		return nil, err
	}

	lookup := make(map[string]FileChange, len(changes))
	for _, change := range changes {
		lookup[change.FileName] = change
	}

	used := make(map[string]struct{})
	var plans []CommitPlan

	for _, proposal := range proposals {
		if len(proposal.Files) == 0 {
			continue
		}

		var group []FileChange
		for _, file := range proposal.Files {
			change, ok := lookup[file]
			if !ok {
				continue
			}
			if _, seen := used[file]; seen {
				continue
			}

			used[file] = struct{}{}
			group = append(group, change)
		}

		if len(group) == 0 {
			continue
		}

		label := proposal.Label
		if strings.TrimSpace(label) == "" {
			label = formatFileList(group)
		}

		plans = append(plans, CommitPlan{
			Label:   label,
			Changes: group,
		})
	}

	for _, change := range changes {
		if _, seen := used[change.FileName]; seen {
			continue
		}
		plans = append(plans, CommitPlan{
			Label:   "remaining: " + change.FileName,
			Changes: []FileChange{change},
		})
	}

	if len(plans) == 0 {
		return nil, errors.New("AI did not produce any valid commit groups")
	}

	return plans, nil
}

func generateCommitGroups(apiKey, model string, changes []FileChange) (string, error) {
	payload := chatCompletionRequest{
		Model:       model,
		Temperature: 0.1,
		MaxTokens:   500,
		Messages: []chatMessage{
			{
				Role: "system",
				Content: "You group changed file paths into logical git commits. Use only path, status, and area metadata; do not assume diff contents. Return JSON only. " +
					`Use this schema: [{"label":"short category label","files":["path1","path2"]}]. ` +
					"Each file must appear at most once.",
			},
			{
				Role:    "user",
				Content: buildGroupingPrompt(changes),
			},
		},
	}

	payload = limitChatPayload(payload, maxGroupingRequestTokens)
	return sendGroqChat(apiKey, payload)
}

func buildGroupingPrompt(changes []FileChange) string {
	var builder strings.Builder
	builder.WriteString("Group these changed files into logical commits from the file graph only.\n")
	builder.WriteString("Use directory structure, path names, extensions, status, and inferred area. Keep unrelated paths separate.\n\n")
	builder.WriteString(buildChangedFilesGraph(changes))

	return builder.String()
}

func buildChangedFilesGraph(changes []FileChange) string {
	var builder strings.Builder
	builder.WriteString("Changed file graph:\n")
	for _, change := range changes {
		builder.WriteString(formatGraphPath(change.FileName))
		builder.WriteString(" [")
		builder.WriteString(change.Status)
		builder.WriteString(", ")
		builder.WriteString(classifyFileArea(change.FileName))
		builder.WriteString("]")
		builder.WriteString("\n")
	}
	return builder.String()
}

func formatGraphPath(path string) string {
	parts := strings.Split(filepath.ToSlash(path), "/")
	if len(parts) == 0 {
		return "- " + path
	}

	var builder strings.Builder
	for index, part := range parts {
		if part == "" {
			continue
		}
		if builder.Len() == 0 {
			builder.WriteString("- ")
		} else {
			builder.WriteString(" > ")
		}
		builder.WriteString(part)
		if index == len(parts)-1 {
			builder.WriteString(" (")
			builder.WriteString(path)
			builder.WriteString(")")
		}
	}
	return builder.String()
}

func parseCommitGroups(content string) ([]commitGroupProposal, error) {
	cleaned := strings.TrimSpace(content)
	cleaned = strings.TrimPrefix(cleaned, "```json")
	cleaned = strings.TrimPrefix(cleaned, "```")
	cleaned = strings.TrimSuffix(cleaned, "```")
	cleaned = strings.TrimSpace(cleaned)

	var proposals []commitGroupProposal
	if err := json.Unmarshal([]byte(cleaned), &proposals); err != nil {
		return nil, fmt.Errorf("failed to parse AI commit groups: %w", err)
	}

	return proposals, nil
}

func printCommitSummary(summary commitRunSummary) {
	printSection("Commit Session Summary")
	lines := []string{
		colorDim + "Mode" + colorReset + "      " + summary.Mode,
		colorSuccess + "Committed" + colorReset + " " + strconv.Itoa(len(summary.Committed)),
		colorWarn + "Skipped" + colorReset + "   " + strconv.Itoa(len(summary.Skipped)),
		colorError + "Failed" + colorReset + "    " + strconv.Itoa(len(summary.Failed)),
	}
	if len(summary.Committed) > 0 {
		lines = append(lines, "", colorStrong+"Created"+colorReset)
		for _, item := range summary.Committed {
			lines = append(lines, "  + "+item)
		}
	}
	if len(summary.Skipped) > 0 {
		lines = append(lines, "", colorStrong+"Skipped"+colorReset)
		for _, item := range summary.Skipped {
			lines = append(lines, "  - "+item)
		}
	}
	if len(summary.Failed) > 0 {
		lines = append(lines, "", colorStrong+"Failed"+colorReset)
		for _, item := range summary.Failed {
			lines = append(lines, "  x "+item)
		}
	}
	printPanel(lines)
}

func promptPushAfterCommits() {
	printSection("Push")
	if !promptYesNo("Push committed changes now? [y/N]: ") {
		printWarning("Push skipped.")
		return
	}

	if err := executePush(); err != nil {
		printError("Push failed: " + err.Error())
	}
}

func formatFileList(changes []FileChange) string {
	names := make([]string, 0, len(changes))
	for _, change := range changes {
		names = append(names, change.FileName)
	}
	return strings.Join(names, ", ")
}

func formatFilesForDisplay(changes []FileChange) string {
	lines := make([]string, 0, len(changes))
	for _, change := range changes {
		lines = append(lines, fmt.Sprintf("  %s %s", styleStatus(change.Status), change.FileName))
	}
	return strings.Join(lines, "\n")
}

func generateCommitMessage(apiKey, model string, changes []FileChange) (string, error) {
	prompt := buildCommitPrompt(changes)
	payload := chatCompletionRequest{
		Model:       model,
		Temperature: 0.15,
		MaxTokens:   200,
		Messages: []chatMessage{
			{
				Role: "system",
				Content: "You write high-signal git commit subjects. Reply with exactly one imperative conventional commit subject. " +
					"Allowed prefixes: feat:, fix:, docs:, style:, refactor:, perf:, test:, build:, ci:, chore:, revert:. " +
					"Choose the prefix from the actual changed area and intent. Use a concrete object and action from the provided summaries. " +
					"Never use vague words like update, changes, stuff, misc, null, handle, or file unless they are part of a real API name. " +
					"No quotes, no markdown, no bullet points, max 72 characters.",
			},
			{
				Role:    "user",
				Content: prompt,
			},
		},
	}

	payload = limitChatPayload(payload, maxCommitRequestTokens)
	message, err := sendGroqChat(apiKey, payload)
	if err != nil {
		return "", err
	}
	message = sanitizeCommitMessage(message)
	if isUsableCommitMessage(message) {
		return message, nil
	}

	payload.Messages = append(payload.Messages,
		chatMessage{Role: "assistant", Content: message},
		chatMessage{Role: "user", Content: "That subject is too vague or malformed. Generate one specific conventional commit subject using the file summaries and changed symbols. Do not include null, generic filler, or explanations."},
	)
	payload = limitChatPayload(payload, maxCommitRequestTokens)
	message, err = sendGroqChat(apiKey, payload)
	if err != nil {
		return "", err
	}
	message = sanitizeCommitMessage(message)
	if isUsableCommitMessage(message) {
		return message, nil
	}

	return fallbackCommitMessage(changes), nil
}

func buildCommitPrompt(changes []FileChange) string {
	var builder strings.Builder
	builder.WriteString("Generate a git commit message for these changes.\n")
	builder.WriteString("Summarize the main behavior change, not the implementation trivia.\n\n")
	builder.WriteString("Prefix selection guidance:\n")
	builder.WriteString("- feat: new user-facing behavior or capability\n")
	builder.WriteString("- fix: bug fix or error handling correction\n")
	builder.WriteString("- docs: documentation-only changes\n")
	builder.WriteString("- refactor: internal restructuring without behavior change\n")
	builder.WriteString("- test: tests only\n")
	builder.WriteString("- build: build, packaging, release, dependency, or installer changes\n")
	builder.WriteString("- ci: workflow or automation changes\n")
	builder.WriteString("- chore: maintenance that does not fit the above\n\n")
	builder.WriteString(buildManagedChangeContext(changes, maxAIContextChars))

	return builder.String()
}

func sanitizeCommitMessage(message string) string {
	message = strings.TrimSpace(message)
	message = strings.TrimPrefix(message, "```")
	message = strings.TrimSuffix(message, "```")
	message = strings.TrimSpace(message)
	lines := strings.Split(message, "\n")
	for _, line := range lines {
		line = strings.TrimSpace(line)
		line = strings.TrimPrefix(line, "- ")
		line = strings.TrimPrefix(line, "* ")
		line = strings.Trim(line, `"'`)
		if line != "" {
			message = line
			break
		}
	}
	if len(message) > 72 {
		message = strings.TrimSpace(message[:72])
	}
	return message
}

func isUsableCommitMessage(message string) bool {
	if message == "" || !hasConventionalPrefix(message) {
		return false
	}

	lower := strings.ToLower(message)
	badFragments := []string{
		": null",
		" null ",
		"undefined",
		"todo",
		"misc",
		"stuff",
		"changes",
		"update files",
		"handle changes",
		"handle updates",
	}
	for _, fragment := range badFragments {
		if strings.Contains(lower, fragment) {
			return false
		}
	}

	parts := strings.SplitN(message, ":", 2)
	if len(parts) != 2 {
		return false
	}
	subject := strings.TrimSpace(parts[1])
	if len(subject) < 8 {
		return false
	}
	return len(strings.Fields(subject)) >= 2
}

func hasConventionalPrefix(message string) bool {
	lower := strings.ToLower(message)
	for _, prefix := range conventionalPrefixes() {
		if strings.HasPrefix(lower, prefix) {
			return true
		}
	}
	return false
}

func conventionalPrefixes() []string {
	return []string{"feat:", "fix:", "docs:", "style:", "refactor:", "perf:", "test:", "build:", "ci:", "chore:", "revert:"}
}

func fallbackCommitMessage(changes []FileChange) string {
	prefix := fallbackPrefix(changes)
	object := fallbackObject(changes)
	action := fallbackAction(changes)
	message := prefix + " " + action + " " + object
	if len(message) > 72 {
		message = strings.TrimSpace(message[:72])
	}
	return message
}

func fallbackPrefix(changes []FileChange) string {
	if len(changes) == 0 {
		return "chore:"
	}

	areas := make(map[string]int)
	for _, change := range changes {
		areas[classifyFileArea(change.FileName)]++
	}
	if len(areas) == 1 {
		for area := range areas {
			switch area {
			case "documentation":
				return "docs:"
			case "tests":
				return "test:"
			case "ci":
				return "ci:"
			case "build/tooling", "dependencies":
				return "build:"
			case "configuration":
				return "chore:"
			}
		}
	}

	for _, change := range changes {
		stats := analyzeDiff(change.Diff)
		if stats.NewFile || strings.Contains(change.Status, "?") || strings.Contains(change.Status, "A") {
			return "feat:"
		}
	}

	return "refactor:"
}

func fallbackAction(changes []FileChange) string {
	if len(changes) == 1 {
		stats := analyzeDiff(changes[0].Diff)
		switch {
		case stats.NewFile || strings.Contains(changes[0].Status, "?") || strings.Contains(changes[0].Status, "A"):
			return "add"
		case stats.Deleted || strings.Contains(changes[0].Status, "D"):
			return "remove"
		case stats.Renamed || strings.Contains(changes[0].Status, "R"):
			return "rename"
		}
	}
	return "revise"
}

func fallbackObject(changes []FileChange) string {
	if len(changes) == 0 {
		return "project changes"
	}
	if len(changes) == 1 {
		return humanizePath(changes[0].FileName)
	}

	areaCounts := make(map[string]int)
	for _, change := range changes {
		areaCounts[classifyFileArea(change.FileName)]++
	}
	bestArea := "project changes"
	bestCount := 0
	for area, count := range areaCounts {
		if count > bestCount {
			bestArea = area
			bestCount = count
		}
	}
	return bestArea
}

func humanizePath(path string) string {
	base := filepath.Base(path)
	ext := filepath.Ext(base)
	name := strings.TrimSuffix(base, ext)
	name = strings.ReplaceAll(name, "_", " ")
	name = strings.ReplaceAll(name, "-", " ")
	name = strings.TrimSpace(name)
	if name == "" {
		name = strings.TrimSpace(base)
	}
	if name == "" {
		return "project file"
	}
	return name
}

type diffStats struct {
	Added      int
	Removed    int
	HunkCount  int
	Hunks      []string // first 8 stored for display
	Binary     bool
	NewFile    bool
	Deleted    bool
	Renamed    bool
	RenameFrom string
	RenameTo   string
}

func buildManagedChangeContext(changes []FileChange, budget int) string {
	if budget < 1000 {
		budget = 1000
	}

	var builder strings.Builder
	builder.WriteString("Changed files overview:\n")
	for _, change := range changes {
		stats := analyzeDiff(change.Diff)
		descriptor := describeChange(change, stats)
		builder.WriteString("- ")
		builder.WriteString(change.Status)
		builder.WriteString(" ")
		builder.WriteString(change.FileName)
		builder.WriteString(" (")
		builder.WriteString(descriptor)
		builder.WriteString(", ")
		if stats.Binary {
			builder.WriteString("binary")
		} else {
			builder.WriteString("+")
			builder.WriteString(strconv.Itoa(stats.Added))
			builder.WriteString(" -")
			builder.WriteString(strconv.Itoa(stats.Removed))
			builder.WriteString(", ")
			builder.WriteString(strconv.Itoa(stats.HunkCount))
			builder.WriteString(" hunk(s)")
		}
		builder.WriteString(")\n")
	}
	builder.WriteString("\nDiff context:\n")
	builder.WriteString("Large diffs are summarized with representative excerpts to stay within the model request limit.\n\n")

	if builder.Len() >= budget {
		return truncateContext(builder.String(), budget)
	}

	for index, change := range changes {
		remainingFiles := len(changes) - index
		remainingBudget := budget - builder.Len()
		if remainingBudget <= 0 {
			break
		}

		fileBudget := remainingBudget / remainingFiles
		if fileBudget > maxDiffExcerptChars {
			fileBudget = maxDiffExcerptChars
		}
		if fileBudget < minDiffExcerptChars && remainingBudget >= minDiffExcerptChars {
			fileBudget = minDiffExcerptChars
		}

		entry := buildFileChangeContext(change, fileBudget)
		if builder.Len()+len(entry) > budget {
			entry = buildFileChangeContext(change, remainingBudget)
		}
		if builder.Len()+len(entry) > budget {
			break
		}
		builder.WriteString(entry)
	}

	return truncateContext(builder.String(), budget)
}

func buildFileChangeContext(change FileChange, budget int) string {
	var header strings.Builder
	stats := analyzeDiff(change.Diff)
	header.WriteString("File: ")
	header.WriteString(change.FileName)
	header.WriteString("\nStatus: ")
	header.WriteString(change.Status)
	header.WriteString("\n")
	header.WriteString("Area: ")
	header.WriteString(classifyFileArea(change.FileName))
	header.WriteString("\nChange type: ")
	header.WriteString(describeChange(change, stats))
	header.WriteString("\n")
	header.WriteString(buildSemanticSummary(change, stats))

	if budget <= header.Len()+120 {
		header.WriteString(formatDiffSummary(stats))
		header.WriteString("\n")
		return header.String()
	}

	diffBudget := budget - header.Len() - 2
	header.WriteString(compactDiff(change.Diff, diffBudget))
	header.WriteString("\n\n")
	return header.String()
}

func compactDiff(diff string, budget int) string {
	diff = strings.TrimSpace(diff)
	if diff == "" {
		return "Diff: unavailable\n"
	}
	if len(diff) <= budget {
		return "Diff:\n" + diff + "\n"
	}

	stats := analyzeDiff(diff)
	summary := formatDiffSummary(stats)
	prefix := summary + "Representative diff excerpt (truncated):\n"
	excerptBudget := budget - len(prefix) - len("\n[diff truncated]\n")
	if excerptBudget <= 0 {
		return truncateContext(summary, budget)
	}

	return prefix + excerptDiff(diff, excerptBudget) + "\n[diff truncated]\n"
}

func analyzeDiff(diff string) diffStats {
	var stats diffStats
	for _, line := range strings.Split(diff, "\n") {
		switch {
		case strings.HasPrefix(line, "Binary files "):
			stats.Binary = true
		case strings.HasPrefix(line, "new file mode "):
			stats.NewFile = true
		case strings.HasPrefix(line, "deleted file mode "):
			stats.Deleted = true
		case strings.HasPrefix(line, "rename from "):
			stats.Renamed = true
			stats.RenameFrom = strings.TrimSpace(strings.TrimPrefix(line, "rename from "))
		case strings.HasPrefix(line, "rename to "):
			stats.Renamed = true
			stats.RenameTo = strings.TrimSpace(strings.TrimPrefix(line, "rename to "))
		case strings.HasPrefix(line, "@@"):
			stats.HunkCount++
			if len(stats.Hunks) < 8 {
				stats.Hunks = append(stats.Hunks, strings.TrimSpace(line))
			}
		case strings.HasPrefix(line, "+++") || strings.HasPrefix(line, "---"):
			continue
		case strings.HasPrefix(line, "+"):
			stats.Added++
		case strings.HasPrefix(line, "-"):
			stats.Removed++
		}
	}
	return stats
}

func describeChange(change FileChange, stats diffStats) string {
	switch {
	case stats.NewFile || strings.Contains(change.Status, "?") || strings.Contains(change.Status, "A"):
		return "new file"
	case stats.Deleted || strings.Contains(change.Status, "D"):
		return "deleted file"
	case stats.Renamed || strings.Contains(change.Status, "R"):
		if stats.RenameFrom != "" && stats.RenameTo != "" {
			return "renamed from " + stats.RenameFrom + " to " + stats.RenameTo
		}
		return "renamed file"
	case strings.Contains(change.Status, "M"):
		return "modified file"
	default:
		return "changed file"
	}
}

func classifyFileArea(path string) string {
	lower := strings.ToLower(path)
	base := strings.ToLower(filepath.Base(path))
	ext := strings.ToLower(filepath.Ext(path))

	switch {
	case strings.HasPrefix(lower, ".github/") || strings.Contains(lower, "/workflows/"):
		return "ci"
	case base == "readme.md" || ext == ".md" || strings.HasPrefix(lower, "docs/"):
		return "documentation"
	case base == "go.mod" || base == "go.sum" || base == "package.json" || base == "package-lock.json" || base == "pnpm-lock.yaml" || base == "yarn.lock":
		return "dependencies"
	case base == "makefile" || base == "dockerfile" || strings.Contains(lower, "goreleaser") || strings.Contains(lower, "install"):
		return "build/tooling"
	case strings.HasSuffix(lower, "_test.go") || strings.Contains(lower, "/test/") || strings.Contains(lower, "/tests/") || strings.Contains(lower, ".test.") || strings.Contains(lower, ".spec."):
		return "tests"
	case ext == ".go" || ext == ".js" || ext == ".jsx" || ext == ".ts" || ext == ".tsx" || ext == ".py" || ext == ".rs" || ext == ".java" || ext == ".rb" || ext == ".php":
		return "source"
	case ext == ".json" || ext == ".yaml" || ext == ".yml" || ext == ".toml" || ext == ".ini" || ext == ".env":
		return "configuration"
	default:
		return "project files"
	}
}

func buildSemanticSummary(change FileChange, stats diffStats) string {
	if stats.Binary {
		return "Semantic summary: binary content changed; infer intent from file path and status.\n"
	}

	added, removed := collectChangedContent(change.Diff)
	symbols := extractSemanticItems(change.FileName, added)
	removedItems := extractSemanticItems(change.FileName, removed)

	var builder strings.Builder
	builder.WriteString("Semantic summary:\n")
	if len(symbols) > 0 {
		builder.WriteString("- Added or changed notable items: ")
		builder.WriteString(strings.Join(symbols, "; "))
		builder.WriteString("\n")
	}
	if len(removedItems) > 0 && !stats.NewFile {
		builder.WriteString("- Removed notable items: ")
		builder.WriteString(strings.Join(removedItems, "; "))
		builder.WriteString("\n")
	}
	if len(symbols) == 0 && len(removedItems) == 0 {
		samples := representativeLines(added, maxSampleLines)
		if len(samples) == 0 {
			samples = representativeLines(removed, maxSampleLines)
		}
		if len(samples) > 0 {
			builder.WriteString("- Representative content: ")
			builder.WriteString(strings.Join(samples, " | "))
			builder.WriteString("\n")
		} else {
			builder.WriteString("- No readable changed content detected beyond diff metadata.\n")
		}
	}

	return builder.String()
}

func collectChangedContent(diff string) ([]string, []string) {
	var added []string
	var removed []string
	for _, line := range strings.Split(diff, "\n") {
		switch {
		case strings.HasPrefix(line, "+++") || strings.HasPrefix(line, "---"):
			continue
		case strings.HasPrefix(line, "+"):
			if text := cleanSemanticLine(strings.TrimPrefix(line, "+")); text != "" {
				added = append(added, text)
			}
		case strings.HasPrefix(line, "-"):
			if text := cleanSemanticLine(strings.TrimPrefix(line, "-")); text != "" {
				removed = append(removed, text)
			}
		}
	}
	return added, removed
}

func extractSemanticItems(path string, lines []string) []string {
	seen := make(map[string]struct{})
	var items []string
	for _, line := range lines {
		item := semanticItemForLine(path, line)
		if item == "" {
			continue
		}
		if _, ok := seen[item]; ok {
			continue
		}
		seen[item] = struct{}{}
		items = append(items, item)
		if len(items) >= maxSemanticItems {
			break
		}
	}
	return items
}

func semanticItemForLine(path, line string) string {
	trimmed := cleanSemanticLine(line)
	if trimmed == "" {
		return ""
	}

	lowerPath := strings.ToLower(path)
	lower := strings.ToLower(trimmed)
	switch {
	case strings.HasSuffix(lowerPath, ".md") && strings.HasPrefix(trimmed, "#"):
		return truncateSemanticItem("heading " + strings.TrimSpace(strings.TrimLeft(trimmed, "#")))
	case strings.HasPrefix(trimmed, "func "):
		return truncateSemanticItem(trimmed)
	case strings.HasPrefix(trimmed, "type ") || strings.HasPrefix(trimmed, "const ") || strings.HasPrefix(trimmed, "var "):
		return truncateSemanticItem(trimmed)
	case strings.HasPrefix(trimmed, "package "):
		return truncateSemanticItem(trimmed)
	case strings.HasPrefix(trimmed, "class ") || strings.HasPrefix(trimmed, "interface "):
		return truncateSemanticItem(trimmed)
	case strings.HasPrefix(trimmed, "export ") || strings.HasPrefix(trimmed, "function "):
		return truncateSemanticItem(trimmed)
	case strings.Contains(lower, "func ") || strings.Contains(lower, "function ") || strings.Contains(lower, " class "):
		return truncateSemanticItem(trimmed)
	case strings.HasSuffix(lowerPath, ".json") || strings.HasSuffix(lowerPath, ".yml") || strings.HasSuffix(lowerPath, ".yaml") || strings.HasSuffix(lowerPath, ".toml"):
		if key := configKeyFromLine(trimmed); key != "" {
			return truncateSemanticItem("config " + key)
		}
	}

	return ""
}

func representativeLines(lines []string, limit int) []string {
	var samples []string
	for _, line := range lines {
		if isLowSignalLine(line) {
			continue
		}
		samples = append(samples, truncateSemanticItem(line))
		if len(samples) >= limit {
			break
		}
	}
	return samples
}

func cleanSemanticLine(line string) string {
	line = strings.TrimSpace(line)
	if line == "" || line == "{" || line == "}" || line == "[" || line == "]" || line == "," {
		return ""
	}
	return strings.Join(strings.Fields(line), " ")
}

func isLowSignalLine(line string) bool {
	trimmed := cleanSemanticLine(line)
	if trimmed == "" {
		return true
	}
	lower := strings.ToLower(trimmed)
	return lower == "package main" ||
		strings.HasPrefix(lower, "import ") ||
		strings.HasPrefix(lower, "//") ||
		strings.HasPrefix(lower, "/*") ||
		strings.HasPrefix(lower, "*") ||
		len(trimmed) < 4
}

func configKeyFromLine(line string) string {
	for _, sep := range []string{":", "="} {
		if index := strings.Index(line, sep); index > 0 {
			key := strings.Trim(strings.TrimSpace(line[:index]), `"'`)
			if key != "" && !strings.Contains(key, " ") {
				return key
			}
		}
	}
	return ""
}

func truncateSemanticItem(item string) string {
	const limit = 110
	item = strings.TrimSpace(item)
	if len(item) <= limit {
		return item
	}
	return item[:limit-3] + "..."
}

func formatDiffSummary(stats diffStats) string {
	if stats.Binary {
		return "Diff summary: binary file changed.\n"
	}

	var builder strings.Builder
	builder.WriteString("Diff summary: +")
	builder.WriteString(strconv.Itoa(stats.Added))
	builder.WriteString(" -")
	builder.WriteString(strconv.Itoa(stats.Removed))
	builder.WriteString(" across ")
	builder.WriteString(strconv.Itoa(stats.HunkCount))
	builder.WriteString(" hunk(s).\n")
	if len(stats.Hunks) > 0 {
		builder.WriteString("Hunks:\n")
		for _, hunk := range stats.Hunks {
			builder.WriteString("- ")
			builder.WriteString(hunk)
			builder.WriteString("\n")
		}
	}
	return builder.String()
}

func excerptDiff(diff string, budget int) string {
	lines := strings.Split(diff, "\n")
	if len(lines) <= diffHeadLines+diffTailLines {
		return truncateContext(diff, budget)
	}

	selected := make([]string, 0, diffHeadLines+diffTailLines+1)
	selected = append(selected, lines[:diffHeadLines]...)
	selected = append(selected, "[middle of diff omitted]")
	selected = append(selected, lines[len(lines)-diffTailLines:]...)

	excerpt := strings.Join(selected, "\n")
	return truncateContext(excerpt, budget)
}

func truncateContext(text string, limit int) string {
	if limit <= 0 || len(text) <= limit {
		return text
	}
	const marker = "\n[context truncated]\n"
	if limit <= len(marker) {
		return text[:limit]
	}
	return text[:limit-len(marker)] + marker
}

func limitChatPayload(payload chatCompletionRequest, requestTokenBudget int) chatCompletionRequest {
	if requestTokenBudget <= 0 {
		return payload
	}

	availableInputTokens := requestTokenBudget - payload.MaxTokens - 80
	if availableInputTokens < 300 {
		availableInputTokens = 300
	}

	for estimateChatInputTokens(payload.Messages) > availableInputTokens {
		userIndex := largestUserMessageIndex(payload.Messages)
		if userIndex < 0 {
			break
		}

		current := payload.Messages[userIndex].Content
		overTokens := estimateChatInputTokens(payload.Messages) - availableInputTokens
		cutChars := overTokens * estimatedCharsPerToken
		target := len(current) - cutChars
		if target < 500 {
			target = 500
		}
		if target >= len(current) {
			target = len(current) - estimatedCharsPerToken
		}
		if target <= 0 {
			break
		}

		payload.Messages[userIndex].Content = truncateContext(current, target)
	}

	return payload
}

func largestUserMessageIndex(messages []chatMessage) int {
	largestIndex := -1
	largestSize := 0
	for index, message := range messages {
		if message.Role == "user" && len(message.Content) > largestSize {
			largestIndex = index
			largestSize = len(message.Content)
		}
	}
	return largestIndex
}

func estimateChatInputTokens(messages []chatMessage) int {
	total := 0
	for _, message := range messages {
		total += estimateTokens(message.Role)
		total += estimateTokens(message.Content)
		total += 4
	}
	return total + 8
}

func estimateTokens(text string) int {
	if text == "" {
		return 0
	}

	tokens := len(text) / estimatedCharsPerToken
	if len(text)%estimatedCharsPerToken != 0 {
		tokens++
	}
	return tokens
}

func sendGroqChat(apiKey string, payload chatCompletionRequest) (string, error) {
	var lastErr error
	for attempt := 1; attempt <= maxGroqAttempts; attempt++ {
		content, err := sendGroqChatOnce(apiKey, payload)
		if err == nil {
			return content, nil
		}

		lastErr = err
		wait, ok := groqRetryDelay(err)
		if !ok || attempt == maxGroqAttempts {
			return "", err
		}

		if wait < 500*time.Millisecond {
			wait = 500 * time.Millisecond
		}
		if wait > 30*time.Second {
			wait = 30 * time.Second
		}
		time.Sleep(wait)
	}

	return "", lastErr
}

type groqHTTPError struct {
	statusCode int
	status     string
	message    string
}

func (err groqHTTPError) Error() string {
	if err.message != "" {
		return err.message
	}
	return "groq request failed with status " + err.status
}

func groqRetryDelay(err error) (time.Duration, bool) {
	var httpErr groqHTTPError
	if !errors.As(err, &httpErr) {
		return 0, false
	}
	if httpErr.statusCode != http.StatusTooManyRequests && !strings.Contains(strings.ToLower(httpErr.message), "rate limit") {
		return 0, false
	}

	lower := strings.ToLower(httpErr.message)
	marker := "try again in "
	if index := strings.Index(lower, marker); index >= 0 {
		remainder := httpErr.message[index+len(marker):]
		fields := strings.Fields(remainder)
		if len(fields) > 0 {
			rawDuration := strings.TrimRight(fields[0], ".,;")
			if delay, parseErr := time.ParseDuration(rawDuration); parseErr == nil {
				return delay + 250*time.Millisecond, true
			}
		}
	}

	return 5 * time.Second, true
}

func sendGroqChatOnce(apiKey string, payload chatCompletionRequest) (string, error) {
	body, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	req, err := http.NewRequest(http.MethodPost, groqAPIURL, bytes.NewReader(body))
	if err != nil {
		return "", err
	}

	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 60 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	responseBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}

	var completion chatCompletionResponse
	if err := json.Unmarshal(responseBody, &completion); err != nil {
		return "", err
	}

	if resp.StatusCode >= 400 {
		if completion.Error != nil && completion.Error.Message != "" {
			return "", groqHTTPError{statusCode: resp.StatusCode, status: resp.Status, message: completion.Error.Message}
		}
		return "", groqHTTPError{statusCode: resp.StatusCode, status: resp.Status}
	}

	if len(completion.Choices) == 0 {
		return "", errors.New("groq returned no choices")
	}

	return strings.TrimSpace(completion.Choices[0].Message.Content), nil
}

func getConfigDir() string {
	home, err := os.UserHomeDir()
	if err != nil {
		return ""
	}
	return filepath.Join(home, ".config", "gitpilot")
}

func getCredentialsPath() string {
	return filepath.Join(getConfigDir(), "credentials")
}

func readPassword(prompt string) (string, error) {
	fmt.Print(prompt)
	if runtime.GOOS != "windows" {
		off := exec.Command("stty", "-echo")
		off.Stdin = os.Stdin
		_ = off.Run()
		defer func() {
			on := exec.Command("stty", "echo")
			on.Stdin = os.Stdin
			_ = on.Run()
			fmt.Println()
		}()
	}
	reader := bufio.NewReader(os.Stdin)
	pass, err := reader.ReadString('\n')
	return strings.TrimRight(pass, "\r\n"), err
}

func keychainRead() (string, error) {
	var cmd *exec.Cmd
	switch runtime.GOOS {
	case "darwin":
		cmd = exec.Command("security", "find-generic-password",
			"-s", keychainService, "-a", keychainAccount, "-w")
	case "linux":
		cmd = exec.Command("secret-tool", "lookup",
			"service", keychainService, "account", keychainAccount)
	case "windows":
		script := `[Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime]|Out-Null;` +
			`$v=New-Object Windows.Security.Credentials.PasswordVault;` +
			`$c=$v.Retrieve('gitpilot','groq-api-key');$c.RetrievePassword();$c.Password`
		cmd = exec.Command("powershell", "-NonInteractive", "-Command", script)
	default:
		return "", errors.New("keychain not supported")
	}
	out, err := cmd.Output()
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(string(out)), nil
}

func keychainWrite(key string) error {
	switch runtime.GOOS {
	case "darwin":
		return exec.Command("security", "add-generic-password",
			"-U", "-s", keychainService, "-a", keychainAccount, "-w", key).Run()
	case "linux":
		cmd := exec.Command("secret-tool", "store",
			"--label=gitpilot Groq API key",
			"service", keychainService, "account", keychainAccount)
		cmd.Stdin = strings.NewReader(key)
		return cmd.Run()
	case "windows":
		script := `[Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime]|Out-Null;` +
			`$v=New-Object Windows.Security.Credentials.PasswordVault;` +
			`$c=New-Object Windows.Security.Credentials.PasswordCredential('gitpilot','groq-api-key',$env:GITPILOT_KEY);` +
			`$v.Add($c)`
		cmd := exec.Command("powershell", "-NonInteractive", "-Command", script)
		cmd.Env = append(os.Environ(), "GITPILOT_KEY="+key)
		return cmd.Run()
	default:
		return errors.New("keychain not supported")
	}
}

func keychainDelete() error {
	switch runtime.GOOS {
	case "darwin":
		return exec.Command("security", "delete-generic-password",
			"-s", keychainService, "-a", keychainAccount).Run()
	case "linux":
		return exec.Command("secret-tool", "clear",
			"service", keychainService, "account", keychainAccount).Run()
	case "windows":
		script := `[Windows.Security.Credentials.PasswordVault,Windows.Security.Credentials,ContentType=WindowsRuntime]|Out-Null;` +
			`$v=New-Object Windows.Security.Credentials.PasswordVault;` +
			`try{$c=$v.Retrieve('gitpilot','groq-api-key');$v.Remove($c)}catch{}`
		return exec.Command("powershell", "-NonInteractive", "-Command", script).Run()
	default:
		return errors.New("keychain not supported")
	}
}

func credFileRead() (string, error) {
	data, err := os.ReadFile(getCredentialsPath())
	if err != nil {
		return "", err
	}
	for _, line := range strings.Split(string(data), "\n") {
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "groq_api_key=") {
			return strings.TrimPrefix(line, "groq_api_key="), nil
		}
	}
	return "", errors.New("key not found in credentials file")
}

func credFileWrite(key string) error {
	dir := getConfigDir()
	if err := os.MkdirAll(dir, 0700); err != nil {
		return err
	}
	return os.WriteFile(getCredentialsPath(), []byte("groq_api_key="+key+"\n"), 0600)
}

func credFileDelete() error {
	return os.Remove(getCredentialsPath())
}

func validateGroqKey(key string) error {
	req, err := http.NewRequest("GET", "https://api.groq.com/openai/v1/models", nil)
	if err != nil {
		return err
	}
	req.Header.Set("Authorization", "Bearer "+key)
	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	resp.Body.Close()
	if resp.StatusCode == 401 {
		return errors.New("invalid API key (401 Unauthorized)")
	}
	if resp.StatusCode >= 400 {
		return fmt.Errorf("API returned status %d", resp.StatusCode)
	}
	return nil
}

func maskKey(key string) string {
	if len(key) <= 8 {
		return "****"
	}
	return key[:4] + "****" + key[len(key)-4:]
}

func getGroqAPIKey() (string, error) {
	// 1. Environment variable — CI/CD or explicit override
	if key := strings.TrimSpace(os.Getenv("GROQ_API_KEY")); key != "" {
		return key, nil
	}
	// 2. OS keychain (macOS Keychain / Linux libsecret / Windows Credential Manager)
	if key, err := keychainRead(); err == nil && key != "" {
		return key, nil
	}
	// 3. ~/.config/gitpilot/credentials (chmod 0600)
	if key, err := credFileRead(); err == nil && key != "" {
		return key, nil
	}
	return "", errors.New("not authenticated — run: gitpilot auth login")
}

func executeAuth(args []string) {
	if len(args) == 0 {
		printSection("Auth")
		fmt.Println("Usage:")
		fmt.Println("  auth login    Store Groq API key securely")
		fmt.Println("  auth logout   Remove stored API key")
		fmt.Println("  auth status   Show authentication state")
		return
	}
	switch args[0] {
	case "login":
		executeAuthLogin()
	case "logout":
		executeAuthLogout()
	case "status":
		executeAuthStatus()
	default:
		printError("Unknown auth subcommand: " + args[0])
	}
}

func executeAuthLogin() {
	printSection("Authentication")
	fmt.Println(colorDim + "Get your Groq API key from: https://console.groq.com/keys" + colorReset)
	fmt.Println()

	key, err := readPassword("Paste your API key (input hidden): ")
	if err != nil || strings.TrimSpace(key) == "" {
		printError("No key entered.")
		return
	}
	key = strings.TrimSpace(key)

	fmt.Print(colorDim + "Validating key..." + colorReset)
	if err := validateGroqKey(key); err != nil {
		fmt.Println()
		printError("Validation failed: " + err.Error())
		return
	}
	fmt.Println(" " + colorSuccess + "✓" + colorReset)

	keychainNames := map[string]string{
		"darwin":  "macOS Keychain",
		"linux":   "GNOME Keyring (libsecret)",
		"windows": "Windows Credential Manager",
	}

	if err := keychainWrite(key); err == nil {
		printSuccess("Stored in " + keychainNames[runtime.GOOS])
	} else {
		if err2 := credFileWrite(key); err2 != nil {
			printError("Failed to store key: " + err2.Error())
			return
		}
		printSuccess("Stored in " + getCredentialsPath() + " (chmod 0600)")
	}
}

func executeAuthLogout() {
	removed := false
	if keychainDelete() == nil {
		removed = true
	}
	if credFileDelete() == nil {
		removed = true
	}
	if removed {
		printSuccess("API key removed.")
	} else {
		printWarning("No stored key found.")
	}
}

func executeAuthStatus() {
	printSection("Auth Status")
	if key := strings.TrimSpace(os.Getenv("GROQ_API_KEY")); key != "" {
		printSuccess("Authenticated via environment variable (" + maskKey(key) + ")")
		return
	}
	if key, err := keychainRead(); err == nil && key != "" {
		names := map[string]string{
			"darwin":  "macOS Keychain",
			"linux":   "GNOME Keyring",
			"windows": "Windows Credential Manager",
		}
		printSuccess("Authenticated via " + names[runtime.GOOS] + " (" + maskKey(key) + ")")
		return
	}
	if key, err := credFileRead(); err == nil && key != "" {
		printSuccess("Authenticated via credentials file (" + maskKey(key) + ")")
		return
	}
	printWarning("Not authenticated — run: gitpilot auth login")
}

func getGroqModel() string {
	if model := strings.TrimSpace(os.Getenv("GROQ_MODEL")); model != "" {
		return model
	}

	output, err := runGitCommand("config", "--get", groqModelConfig)
	if err == nil {
		if model := strings.TrimSpace(output); model != "" {
			return model
		}
	}

	return defaultGroqModel
}

func executeConfig(args []string) {
	if len(args) == 0 {
		printSection("Config")
		fmt.Println("Usage:")
		fmt.Println("  config groq-model <model>   Set the Groq model")
		fmt.Println("  config show                 Show current config")
		fmt.Println()
		fmt.Println("To manage your API key use: gitpilot auth login")
		return
	}

	switch args[0] {
	case "groq-key":
		printWarning("'config groq-key' is deprecated — use: gitpilot auth login")
	case "groq-model":
		if len(args) < 2 {
			fmt.Println("Usage: config groq-model <model>")
			return
		}
		if err := setGitConfig(groqModelConfig, args[1]); err != nil {
			printError("Failed to save Groq model: " + err.Error())
			return
		}
		printSuccess("Saved Groq model to local git config.")
	case "show":
		printConfig()
	default:
		printError("Unknown config option.")
	}
}

func setGitConfig(key, value string) error {
	_, err := runGitCommand("config", "--local", key, value)
	return err
}

func printConfig() {
	printSection("Config")
	keySource := "not set — run: gitpilot auth login"
	if strings.TrimSpace(os.Getenv("GROQ_API_KEY")) != "" {
		keySource = "environment variable"
	} else if _, err := keychainRead(); err == nil {
		names := map[string]string{
			"darwin":  "macOS Keychain",
			"linux":   "GNOME Keyring",
			"windows": "Windows Credential Manager",
		}
		keySource = names[runtime.GOOS]
	} else if _, err := credFileRead(); err == nil {
		keySource = getCredentialsPath()
	}

	printPanel([]string{
		colorDim + "Groq key source" + colorReset + "  " + keySource,
		colorDim + "Groq model" + colorReset + "       " + getGroqModel(),
	})
}

func getDefaultRemoteName() string {
	output, err := runGitCommand("remote")
	if err != nil {
		return "missing"
	}

	for _, remote := range strings.Split(strings.TrimSpace(output), "\n") {
		remote = strings.TrimSpace(remote)
		if remote != "" {
			return remote
		}
	}

	return "missing"
}

func executePush() error {
	printSection("Push Preview")

	statusOutput, statusErr := runGitCommand("status", "--short", "--branch")
	if statusErr == nil && strings.TrimSpace(statusOutput) != "" {
		printPanel([]string{
			colorStrong + "Repository state" + colorReset,
			colorDim + strings.TrimSpace(statusOutput) + colorReset,
		})
	}

	if !promptYesNo("Approve push? [y/N]: ") {
		printWarning("Push cancelled.")
		return nil
	}

	fmt.Println("Running git push...")
	output, err := runGitCommand("push")
	if strings.TrimSpace(output) != "" {
		fmt.Println(output)
	}
	if err != nil {
		return err
	}

	printSuccess("Push completed.")
	return nil
}

func executePull() {
	printSection("Pull Preview")

	branchOutput, branchErr := runGitCommand("branch", "--show-current")
	branch := strings.TrimSpace(branchOutput)
	if branchErr != nil || branch == "" {
		branch = "(unknown)"
	}

	remote := getDefaultRemoteName()
	statusOutput, statusErr := runGitCommand("status", "--short", "--branch")

	lines := []string{
		colorStrong + "Pull target" + colorReset,
		colorDim + "Remote" + colorReset + "  " + remote,
		colorDim + "Branch" + colorReset + "  " + branch,
	}

	if statusErr == nil && strings.TrimSpace(statusOutput) != "" {
		lines = append(lines, "", colorStrong+"Repository state"+colorReset, colorDim+strings.TrimSpace(statusOutput)+colorReset)
	}

	printPanel(lines)

	if remote == "missing" {
		printError("No Git remote is configured.")
		return
	}

	if !promptYesNo("Approve pull? [y/N]: ") {
		printWarning("Pull cancelled.")
		return
	}

	printInfo("Running git pull --ff-only...")
	output, err := runGitCommand("pull", "--ff-only", remote, branch)
	if strings.TrimSpace(output) != "" {
		fmt.Println(output)
	}
	if err != nil {
		printError("Pull failed: " + err.Error())
		return
	}

	printSuccess("Pull completed.")
}

func executePR(args []string) {
	printSection("PR Message")

	apiKey, err := getGroqAPIKey()
	if err != nil {
		printError(err.Error())
		fmt.Println("Set GROQ_API_KEY or run: config groq-key <your-key>")
		return
	}

	base := "origin/main"
	if len(args) > 0 && strings.TrimSpace(args[0]) != "" {
		base = strings.TrimSpace(args[0])
	}

	commits, err := getCommitsAhead(base)
	if err != nil {
		printError(err.Error())
		return
	}
	if len(commits) == 0 {
		printWarning("No commits found ahead of " + base)
		return
	}

	printPanel([]string{
		colorStrong + "PR source" + colorReset,
		colorDim + "Base" + colorReset + "    " + base,
		colorDim + "Commits" + colorReset + " " + strconv.Itoa(len(commits)),
		"",
		formatCommitList(commits),
	})

	printInfo("Generating Markdown PR message from commit history...")
	content, err := generatePRMessage(apiKey, getGroqModel(), base, commits)
	if err != nil {
		printError("PR generation failed: " + err.Error())
		return
	}

	printSection("Copy Paste Markdown")
	fmt.Println(content)
}

func getCommitsAhead(base string) ([]CommitInfo, error) {
	output, err := runGitCommand("log", "--pretty=format:%H\t%s", base+"..HEAD")
	if err != nil {
		return nil, err
	}

	if strings.TrimSpace(output) == "" {
		return nil, nil
	}

	lines := strings.Split(strings.TrimSpace(output), "\n")
	commits := make([]CommitInfo, 0, len(lines))
	for _, line := range lines {
		parts := strings.SplitN(line, "\t", 2)
		if len(parts) != 2 {
			continue
		}
		commits = append(commits, CommitInfo{
			Hash:    strings.TrimSpace(parts[0]),
			Subject: strings.TrimSpace(parts[1]),
		})
	}

	return commits, nil
}

func formatCommitList(commits []CommitInfo) string {
	lines := make([]string, 0, len(commits))
	for index, commit := range commits {
		shortHash := commit.Hash
		if len(shortHash) > 7 {
			shortHash = shortHash[:7]
		}
		lines = append(lines, fmt.Sprintf("  %s%2d%s  %s  %s", colorDim, index+1, colorReset, shortHash, commit.Subject))
	}
	return strings.Join(lines, "\n")
}

func generatePRMessage(apiKey, model, base string, commits []CommitInfo) (string, error) {
	payload := chatCompletionRequest{
		Model:       model,
		Temperature: 0.2,
		MaxTokens:   1000,
		Messages: []chatMessage{
			{
				Role: "system",
				Content: "You write professional pull request descriptions in Markdown. " +
					"Return a copy-paste-ready PR message only. Include a short title line at the top, then sections for Summary, Changes, and Testing. " +
					"Base everything only on the commit history provided. Do not invent changes not implied by the commits.",
			},
			{
				Role:    "user",
				Content: buildPRPrompt(base, commits),
			},
		},
	}

	return sendGroqChat(apiKey, payload)
}

func buildPRPrompt(base string, commits []CommitInfo) string {
	var builder strings.Builder
	builder.WriteString("Generate a pull request message in Markdown based only on these commits.\n")
	builder.WriteString("Base branch: ")
	builder.WriteString(base)
	builder.WriteString("\n\n")

	for _, commit := range commits {
		builder.WriteString("Commit: ")
		builder.WriteString(commit.Hash)
		builder.WriteString("\nSubject: ")
		builder.WriteString(commit.Subject)
		builder.WriteString("\n\n")
	}

	return builder.String()
}

func printHelp() {
	printWelcome()
	printSection("Examples")
	printPanel([]string{
		"commit",
		colorDim + "Interactive commit session with approval per commit" + colorReset,
		"",
		"commit file main.go",
		colorDim + "Direct file-wise mode for selected files" + colorReset,
		"",
		"commit group",
		colorDim + "Direct AI group-wise mode" + colorReset,
		"",
		"pr",
		colorDim + "Generate a Markdown PR message from commits ahead of origin/main" + colorReset,
		"",
		"auth login",
		colorDim + "Store Groq API key securely (Keychain / libsecret / Credential Manager)" + colorReset,
		"",
		"auth status",
		colorDim + "Show authentication state and key source" + colorReset,
		"",
		fmt.Sprintf("config groq-model %s", defaultGroqModel),
		colorDim + "Set the Groq model for AI generation" + colorReset,
	})
}

func main() {
	if len(os.Args) > 1 {
		executeCommand(os.Args[1:])
	} else {
		printWelcome()
		runInteractive()
	}
}