main.go

package main

import (
	"errors"
	"flag"
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"

	"github.com/charmbracelet/huh"
	"github.com/tombenner/leancommit/internal/codex"
	"github.com/tombenner/leancommit/internal/gitx"
)

const defaultSessionFiles = 5

var demoTitles = []string{
	"Add Role-Based Access Controls",
	"Improve Invoice Export Workflow",
	"Refactor Background Job Retry Handling",
	"Add Audit Log Filtering",
	"Fix Mobile Navigation State",
}

var (
	version = "dev"
	commit  = "none"
	date    = "unknown"
)

type config struct {
	sessionsDir  string
	sessionFiles int
	dryRun       bool
	noPush       bool
	printOnly    bool
	version      bool
	demo         bool
	limit        int
}

func main() {
	if err := run(); err != nil {
		fmt.Fprintf(os.Stderr, "leancommit: %v\n", err)
		os.Exit(1)
	}
}

func run() error {
	return runWith(os.Args[1:], os.LookupEnv, os.Stdout, os.Stdin, os.Stderr, version, selectTitle, gitx.EnsureWorkTree, runGitCommit)
}

type titleSelector func([]string, *string) error
type workTreeChecker func(string) error
type gitCommitter func(gitx.Runner, string, bool) error

func runWith(args []string, getenv func(string) (string, bool), stdout io.Writer, stdin io.Reader, stderr io.Writer, buildVersion string, selectFn titleSelector, ensureWorkTree workTreeChecker, commitFn gitCommitter) error {
	cfg, err := parseConfig(args, getenv)
	if err != nil {
		return err
	}

	if cfg.version {
		fmt.Fprintf(stdout, "leancommit %s (%s, %s)\n", buildVersion, commit, date)
		return nil
	}

	if localDemoMode(buildVersion, cfg) {
		return runDemo(cfg, stdout, selectFn)
	}

	files, err := codex.FindLatestPlanFiles(cfg.sessionsDir, cfg.sessionFiles)
	if err != nil {
		return err
	}

	plans, err := codex.ParsePlansFiles(files)
	if err != nil {
		return err
	}
	titles := codex.UniqueTitles(plans, cfg.limit)
	if len(titles) == 0 {
		return fmt.Errorf("%w: %s", codex.ErrNoPlanTitles, cfg.sessionsDir)
	}

	if cfg.printOnly {
		fmt.Fprintln(stdout, titles[0])
		return nil
	}

	if err := ensureWorkTree("."); err != nil {
		return err
	}

	selected := titles[0]
	if err := selectTitle(titles, &selected); err != nil {
		return err
	}

	runner := gitx.Runner{
		Dir:    ".",
		Stdin:  stdin,
		Stdout: stdout,
		Stderr: stderr,
		DryRun: cfg.dryRun,
	}
	return commitFn(runner, selected, !cfg.noPush)
}

func runDemo(cfg config, stdout io.Writer, selectFn titleSelector) error {
	if cfg.printOnly {
		fmt.Fprintln(stdout, demoTitles[0])
		return nil
	}

	selected := demoTitles[0]
	if err := selectFn(demoTitles, &selected); err != nil {
		return err
	}
	printDemoGitLogs(stdout, selected)
	return nil
}

func localDemoMode(buildVersion string, cfg config) bool {
	return buildVersion == "dev" && cfg.demo
}

func printDemoGitLogs(stdout io.Writer, message string) {
	fmt.Fprintf(stdout, "[main 543b71c] %s\n", message)
	fmt.Fprint(stdout, ` 6 files changed, 163 insertions(+), 93 deletions(-)
Enumerating objects: 25, done.
Counting objects: 100% (25/25), done.
Delta compression using up to 8 threads
Compressing objects: 100% (12/12), done.
Writing objects: 100% (13/13), 3.95 KiB | 3.95 MiB/s, done.
Total 13 (delta 9), reused 0 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (9/9), completed with 9 local objects.
To github.com:myuser/myrepo.git
   ebfefaf..543b71c  main -> main
`)
}

func runGitCommit(runner gitx.Runner, message string, push bool) error {
	return runner.CommitAndMaybePush(message, push)
}

func parseConfig(args []string, getenv func(string) (string, bool)) (config, error) {
	home, err := os.UserHomeDir()
	if err != nil {
		return config{}, fmt.Errorf("find home directory: %w", err)
	}

	defaultSessionsDir := home + string(os.PathSeparator) + ".codex" + string(os.PathSeparator) + "sessions"
	sessionsDirDefault := envString(getenv, "LEANCOMMIT_SESSIONS_DIR", defaultSessionsDir)
	sessionFilesDefault, err := envInt(getenv, "LEANCOMMIT_SESSION_FILES", defaultSessionFiles)
	if err != nil {
		return config{}, err
	}
	demoDefault, err := envBool(getenv, "LEANCOMMIT_DEMO", false)
	if err != nil {
		return config{}, err
	}

	fs := flag.NewFlagSet("leancommit", flag.ContinueOnError)
	sessionsDir := fs.String("sessions-dir", sessionsDirDefault, "Codex sessions directory")
	sessionFiles := fs.Int("session-files", sessionFilesDefault, "number of newest Codex session files to scan")
	dryRun := fs.Bool("dry-run", false, "print git commands without running them")
	noPush := fs.Bool("no-push", false, "skip git push")
	printOnly := fs.Bool("print", false, "print the newest deduped plan title and exit")
	versionFlag := fs.Bool("version", false, "print version information and exit")
	limit := fs.Int("limit", 50, "maximum number of unique plan titles to show")
	if err := fs.Parse(args); err != nil {
		return config{}, err
	}

	if *limit <= 0 {
		return config{}, fmt.Errorf("--limit must be greater than 0")
	}
	if *sessionFiles <= 0 {
		return config{}, fmt.Errorf("--session-files must be greater than 0")
	}

	return config{
		sessionsDir:  *sessionsDir,
		sessionFiles: *sessionFiles,
		dryRun:       *dryRun,
		noPush:       *noPush,
		printOnly:    *printOnly,
		version:      *versionFlag,
		demo:         demoDefault,
		limit:        *limit,
	}, nil
}

func envString(getenv func(string) (string, bool), key, fallback string) string {
	value, ok := getenv(key)
	if !ok || value == "" {
		return fallback
	}
	return value
}

func envInt(getenv func(string) (string, bool), key string, fallback int) (int, error) {
	value, ok := getenv(key)
	if !ok || value == "" {
		return fallback, nil
	}
	parsed, err := strconv.Atoi(value)
	if err != nil {
		return 0, fmt.Errorf("%s must be an integer: %w", key, err)
	}
	return parsed, nil
}

func envBool(getenv func(string) (string, bool), key string, fallback bool) (bool, error) {
	value, ok := getenv(key)
	if !ok || value == "" {
		return fallback, nil
	}
	switch strings.ToLower(value) {
	case "1", "true", "yes", "on":
		return true, nil
	case "0", "false", "no", "off":
		return false, nil
	default:
		return false, fmt.Errorf("%s must be one of 1, true, yes, on, 0, false, no, or off", key)
	}
}

func selectTitle(titles []string, selected *string) error {
	options := make([]huh.Option[string], 0, len(titles))
	for _, title := range titles {
		options = append(options, huh.NewOption(title, title))
	}

	err := huh.NewSelect[string]().
		Title("Commit message").
		Options(options...).
		Value(selected).
		Run()
	if err == nil {
		return nil
	}
	if errors.Is(err, huh.ErrUserAborted) {
		return fmt.Errorf("selector canceled")
	}
	return fmt.Errorf("selector failed: %w", err)
}