main.go

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime/debug"
	"strconv"
	"strings"
	"time"
)

// ANSI color codes
const (
	colorCyan   = "\033[36m"
	colorYellow = "\033[33m"
	colorGreen  = "\033[32m"
	colorRed    = "\033[31m"
	colorGray   = "\033[90m"
	colorReset  = "\033[0m"
)

// version is set at build time via -ldflags "-X main.version=..."
// When installed via `go install`, it falls back to the module version.
var version = "dev"

// debugMode controls whether verbose debug output is printed.
var debugMode bool

// getVersion returns the build version, falling back to the module version.
func getVersion() string {
	if version != "dev" {
		return version
	}
	if info, ok := debug.ReadBuildInfo(); ok && info.Main.Version != "" && info.Main.Version != "(devel)" {
		return info.Main.Version
	}
	return version
}

// userConfig represents the optional ~/.config/ai-commit/config.json file.
type userConfig struct {
	AIProvider string `json:"ai_provider,omitempty"`
}

// configPath returns the path to the config file (~/.config/ai-commit/config.json).
func configPath() string {
	home, err := os.UserHomeDir()
	if err != nil {
		home = "."
	}
	return filepath.Join(home, ".config", "ai-commit", "config.json")
}

// loadConfig reads ~/.config/ai-commit/config.json if it exists and returns the
// parsed config. Returns an empty config when the file is missing or invalid.
func loadConfig() userConfig {
	data, err := os.ReadFile(configPath())
	if err != nil {
		return userConfig{}
	}
	var cfg userConfig
	if err := json.Unmarshal(data, &cfg); err != nil {
		return userConfig{}
	}
	return cfg
}

// resolveProvider determines which AI provider to use. Priority order:
// 1. Explicit --provider flag (if non-empty)
// 2. Config file ai_provider value
// 3. Auto-detect: first available binary in PATH (copilot, then claude)
func resolveProvider(flagValue string) string {
	if flagValue != "" {
		return flagValue
	}
	cfg := loadConfig()
	if cfg.AIProvider != "" {
		return cfg.AIProvider
	}
	// Auto-detect based on available binaries.
	for _, p := range []string{"copilot", "claude"} {
		if _, err := exec.LookPath(p); err == nil {
			return p
		}
	}
	return "copilot"
}

func main() {
	allFlag := flag.Bool("all", false, "Stage all changes before diffing")
	flag.BoolVar(allFlag, "A", false, "Stage all changes before diffing (shorthand)")
	providerFlag := flag.String("provider", "", "AI provider to use: \"copilot\" or \"claude\" (default from config or \"copilot\")")
	modelFlag := flag.String("model", "", "AI model to use (default depends on provider)")
	maxTurnsFlag := flag.Int("max-turns", 3, "Maximum number of agentic turns the AI model can take")
	debugFlag := flag.Bool("debug", false, "Enable verbose debug output")
	versionFlag := flag.Bool("version", false, "Print version and exit")
	flag.Parse()

	if *versionFlag {
		fmt.Println("ai-commit " + getVersion())
		os.Exit(0)
	}

	debugMode = *debugFlag

	provider := resolveProvider(*providerFlag)
	if provider != "copilot" && provider != "claude" {
		exitError("unsupported provider " + strconv.Quote(provider) + ". Supported: copilot, claude")
	}

	// Apply default model per provider when not explicitly set.
	model := *modelFlag
	if model == "" {
		switch provider {
		case "claude":
			model = "haiku"
		default:
			model = "claude-haiku-4.5"
		}
	}

	printDebug("ai-commit started")
	printDebug("flags: all=%v, provider=%s, model=%s, max-turns=%d, debug=%v", *allFlag, provider, model, *maxTurnsFlag, debugMode)

	// 1. Verify we're inside a git repository.
	if err := exec.Command("git", "rev-parse", "--is-inside-work-tree").Run(); err != nil {
		exitError("Not inside a git repository.")
	}
	printDebug("confirmed inside a git repository")

	// 2. Optionally stage all changes.
	if *allFlag {
		printCyan("Staging all changes...")
		printDebug("running: git add -A")
		if err := runGit("add", "-A"); err != nil {
			exitError("Failed to stage changes: " + err.Error())
		}
	}

	// 3. Get the list of touched files and the stat summary.
	printCyan("Collecting changed files...")
	namesList, err := runGitOutput("diff", "--cached", "--name-status")
	if err != nil {
		exitError("Failed to list changed files: " + err.Error())
	}
	if strings.TrimSpace(namesList) == "" {
		exitError("No staged changes found. Did you forget to stage your changes? Try running with -A or --all to stage everything.")
	}
	printDebug("name-status output (%d bytes):\n%s", len(namesList), namesList)

	stat, err := runGitOutput("diff", "--cached", "--stat")
	if err != nil {
		exitError("Failed to get diff stat: " + err.Error())
	}
	printDebug("stat output (%d bytes):\n%s", len(stat), stat)

	// 4. Generate a commit message via AI (read-only agent).
	//    We feed it only the file list + stat summary and let it fetch
	//    whatever additional context it needs using its built-in tools.
	printCyan("Generating commit message with AI (" + provider + ")...")

	prompt := `You are a commit-message generator. Your job is to produce a single,
concise git commit message for the staged changes described below.

CHANGED FILES (name-status):
` + namesList + `
DIFF STAT:
` + stat + `
INSTRUCTIONS:
1. You have read-only access to the repository. Use your tools to inspect
   files if you need more context (e.g. read a file, run "git diff --cached",
   run "git diff --cached -- <path>", or "git log").
2. Do NOT modify any files or run any write commands.
3. After gathering enough context, output your final commit message wrapped
   between the markers <COMMIT_MSG> and </COMMIT_MSG>.
   Do NOT include any explanation, reasoning, or commentary outside these
   markers. Example output:
   <COMMIT_MSG>
   Fix null pointer in user login flow
   </COMMIT_MSG>`

	cmd := buildAICommand(provider, model, *maxTurnsFlag, prompt)
	printDebug("%s args: %v", provider, cmd.Args[1:])
	printDebug("prompt length: %d bytes", len(prompt))

	var out []byte
	start := time.Now()

	if debugMode {
		// In debug mode, capture stdout and stderr separately so we can
		// show ALL copilot output (tool calls, reasoning, etc.) while
		// still extracting the commit message from stdout.
		var stdoutBuf, stderrBuf bytes.Buffer
		cmd.Stdout = &stdoutBuf
		cmd.Stderr = &stderrBuf

		printDebug("running %s command...", provider)
		err = cmd.Run()
		elapsed := time.Since(start)

		if stderrBuf.Len() > 0 {
			printDebug("%s stderr (%d bytes):\n%s", provider, stderrBuf.Len(), stderrBuf.String())
		}
		printDebug("%s stdout (%d bytes):\n%s", provider, stdoutBuf.Len(), stdoutBuf.String())
		printDebug("%s exited in %s", provider, elapsed)

		if err != nil {
			exitError("Failed to generate commit message: " + err.Error() + "\nstderr: " + stderrBuf.String())
		}
		out = stdoutBuf.Bytes()
	} else {
		out, err = cmd.Output()
		if err != nil {
			stderr := ""
			if exitErr, ok := err.(*exec.ExitError); ok {
				stderr = string(exitErr.Stderr)
			}
			exitError("Failed to generate commit message: " + err.Error() + "\n" + stderr)
		}
	}

	rawOutput := strings.TrimSpace(string(out))
	stripped := stripANSI(rawOutput)
	printDebug("raw output length: %d bytes, stripped length: %d bytes", len(rawOutput), len(stripped))

	message := extractCommitMessage(stripped)
	if message == "" {
		exitError("AI returned an empty commit message.")
	}
	printDebug("extracted commit message: %q", message)

	// 5. Display the proposed message and ask for confirmation.
	fmt.Printf("\n%sProposed commit message:%s\n", colorCyan, colorReset)
	fmt.Printf("%s%s%s\n\n", colorYellow, message, colorReset)
	fmt.Printf("Confirm commit? (y/n): ")

	reader := bufio.NewReader(os.Stdin)
	input, _ := reader.ReadString('\n')
	input = strings.TrimSpace(strings.ToLower(input))

	if input != "y" && input != "yes" {
		fmt.Printf("%sCommit aborted.%s\n", colorRed, colorReset)
		os.Exit(1)
	}

	// 6. Commit with the generated message.
	if err := runGit("commit", "-m", message); err != nil {
		exitError("Failed to commit: " + err.Error())
	}

	fmt.Printf("%sCommit successful!%s\n", colorGreen, colorReset)
}

// buildAICommand constructs the exec.Cmd for the chosen AI provider.
// For "copilot" it uses GitHub Copilot CLI with --allow-tool restrictions.
// For "claude" it uses Claude Code CLI with --allowedTools restrictions.
func buildAICommand(provider, model string, maxTurns int, prompt string) *exec.Cmd {
	switch provider {
	case "claude":
		args := []string{
			"-p", prompt,
			"--model", model,
			"--max-turns", strconv.Itoa(maxTurns),
			"--allowedTools", "Bash(git diff:*)",
			"--allowedTools", "Bash(git log:*)",
			"--allowedTools", "Bash(git show:*)",
			"--allowedTools", "Bash(git blame:*)",
			"--allowedTools", "Bash(git status)",
			"--allowedTools", "Read",
		}
		return exec.Command("claude", args...)
	default: // "copilot"
		args := []string{
			"--model", model,
			"-p", prompt,
			"-s",
			"--autopilot",
			"--max-autopilot-continues", strconv.Itoa(maxTurns),
			"--allow-tool", "shell(git diff:*)",
			"--allow-tool", "shell(git log:*)",
			"--allow-tool", "shell(git show:*)",
			"--allow-tool", "shell(git blame:*)",
			"--allow-tool", "shell(git status)",
		}
		return exec.Command("copilot", args...)
	}
}

// extractCommitMessage extracts the commit message from the AI's output.
// It looks for content between <COMMIT_MSG> and </COMMIT_MSG> markers.
// If no markers are found, it returns the entire output as-is.
func extractCommitMessage(raw string) string {
	const openTag = "<COMMIT_MSG>"
	const closeTag = "</COMMIT_MSG>"
	if start := strings.Index(raw, openTag); start != -1 {
		after := raw[start+len(openTag):]
		if end := strings.Index(after, closeTag); end != -1 {
			return strings.TrimSpace(after[:end])
		}
		// Opening tag found but no closing tag — take everything after it.
		return strings.TrimSpace(after)
	}

	return raw
}

// ansiPattern matches ANSI escape sequences (colors, cursor movement, etc.).
var ansiPattern = regexp.MustCompile(`\x1b\[[0-9;]*[a-zA-Z]`)

// stripANSI removes all ANSI escape codes from a string.
func stripANSI(s string) string {
	return ansiPattern.ReplaceAllString(s, "")
}

// runGit executes a git command and discards its output.
// Returns an error if the command fails.
func runGit(args ...string) error {
	cmd := exec.Command("git", args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	return cmd.Run()
}

// runGitOutput executes a git command and returns its stdout as a string.
func runGitOutput(args ...string) (string, error) {
	cmd := exec.Command("git", args...)
	out, err := cmd.Output()
	if err != nil {
		return "", err
	}
	return string(out), nil
}

// printCyan prints a status message in cyan.
func printCyan(msg string) {
	fmt.Printf("%s%s%s\n", colorCyan, msg, colorReset)
}

// exitError prints an error message in red and exits with code 1.
func exitError(msg string) {
	fmt.Fprintf(os.Stderr, "%sError: %s%s\n", colorRed, msg, colorReset)
	os.Exit(1)
}

// printDebug prints a debug message in gray when debug mode is enabled.
func printDebug(format string, args ...any) {
	if !debugMode {
		return
	}
	msg := fmt.Sprintf(format, args...)
	fmt.Fprintf(os.Stderr, "%s[debug] %s%s\n", colorGray, msg, colorReset)
}