main.go

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"

	"github.com/spf13/cobra"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/vomlabs/zetup/config"
	"github.com/vomlabs/zetup/generator"
	"github.com/vomlabs/zetup/tui"
	"github.com/vomlabs/zetup/update"
)

var version = "dev"

func main() {
	rootCmd := &cobra.Command{
		Use:   "zetup",
		Short: "The quickest way to start building",
		Long:  "Zetup simplifies setting up a new project — from web to Java, it's set up in seconds.",
	}

	initCmd := &cobra.Command{
		Use:   "init",
		Short: "Launch the interactive project wizard",
		Args:  cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			cwd, err := os.Getwd()
			if err != nil {
				return fmt.Errorf("failed to get current directory: %w", err)
			}

			m := tui.InitialModel()
			p := tea.NewProgram(m, tea.WithAltScreen())
			finalModel, err := p.Run()
			if err != nil {
				return err
			}

			model := finalModel.(tui.Model)
			if !model.Generated {
				fmt.Println("Cancelled.")
				return nil
			}

			cfg := model.ToConfig()
			if err := generator.Scaffold(cfg, cwd); err != nil {
				return fmt.Errorf("scaffolding failed: %w", err)
			}

			fmt.Println("\n  Done! Happy building!")
			return nil
		},
	}

	versionCmd := &cobra.Command{
		Use:   "version",
		Short: "Print the current version and check for updates",
		Args:  cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			fmt.Printf("zetup %s\n\n", version)

			latest, err := update.LatestVersion()
			if err != nil {
				fmt.Printf("Could not check for updates: %v\n", err)
				return nil
			}

			cmp := update.CompareVersions(version, latest)
			if cmp >= 0 {
				fmt.Println("You're up to date!")
			} else {
				fmt.Printf("Update available: %s\n", latest)
				fmt.Println("Run `zetup upgrade` to update to the latest version.")
			}
			return nil
		},
	}
	rootCmd.AddCommand(versionCmd)

	upgradeCmd := &cobra.Command{
		Use:   "upgrade",
		Short: "Download and install the latest version",
		Args:  cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			latest, err := update.LatestVersion()
			if err != nil {
				return fmt.Errorf("could not check for updates: %w", err)
			}

			cmp := update.CompareVersions(version, latest)
			if cmp >= 0 {
				fmt.Println("You're already up to date.")
				return nil
			}

			fmt.Printf("Downloading %s ...\n", latest)

			downloadURL, err := update.DownloadLatest()
			if err != nil {
				return fmt.Errorf("could not find download: %w", err)
			}

			assetResp, err := http.Get(downloadURL)
			if err != nil {
				return fmt.Errorf("download failed: %w", err)
			}
			defer assetResp.Body.Close()

			if assetResp.StatusCode != 200 {
				return fmt.Errorf("download returned status %d", assetResp.StatusCode)
			}

			exe, err := os.Executable()
			if err != nil {
				return fmt.Errorf("could not determine executable path: %w", err)
			}

			tmp := exe + ".new"
			f, err := os.OpenFile(tmp, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0755)
			if err != nil {
				return fmt.Errorf("could not create temp file: %w", err)
			}

			written, err := io.Copy(f, assetResp.Body)
			if err != nil {
				f.Close()
				os.Remove(tmp)
				return fmt.Errorf("download incomplete after %d bytes: %w", written, err)
			}
			f.Close()

			if err := os.Rename(tmp, exe); err != nil {
				os.Remove(tmp)
				return fmt.Errorf("could not replace binary: %w", err)
			}

			fmt.Printf("Updated to %s\n", latest)
			return nil
		},
	}
	rootCmd.AddCommand(upgradeCmd)

	configCmd := &cobra.Command{
		Use:   "config",
		Short: "Manage user defaults (author, package manager, etc.)",
		Long: "View or change persistent defaults used by the wizard.\n" +
			"Config is stored at ~/.config/zetup/config.yaml.\n" +
			"\nKeys:\n" +
			"  author       Default author name\n" +
			"  email        Default email\n" +
			"  license      Default license (MIT, Apache-2.0, GPL-3.0, etc.)\n" +
			"  pkg_manager  Preferred package manager (npm, pnpm, bun)\n" +
			"  init_git     Whether to init git by default (true/false)",
		RunE: func(cmd *cobra.Command, args []string) error {
			userCfg, err := cfg.Load()
			if err != nil {
				return fmt.Errorf("failed to load config: %w", err)
			}
			return printConfig(userCfg)
		},
	}

	configShowCmd := &cobra.Command{
		Use:   "show",
		Short: "Show all config values",
		Args:  cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			userCfg, err := cfg.Load()
			if err != nil {
				return fmt.Errorf("failed to load config: %w", err)
			}
			return printConfig(userCfg)
		},
	}
	configCmd.AddCommand(configShowCmd)

	configGetCmd := &cobra.Command{
		Use:   "get <key>",
		Short: "Get a config value",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			userCfg, err := cfg.Load()
			if err != nil {
				return fmt.Errorf("failed to load config: %w", err)
			}
			val := getField(userCfg, args[0])
			if val == "" {
				return fmt.Errorf("unknown key %q", args[0])
			}
			fmt.Println(val)
			return nil
		},
	}
	configCmd.AddCommand(configGetCmd)

	configSetCmd := &cobra.Command{
		Use:   "set <key> <value>",
		Short: "Set a config value",
		Args:  cobra.ExactArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			userCfg, err := cfg.Load()
			if err != nil {
				return fmt.Errorf("failed to load config: %w", err)
			}
			if err := setField(userCfg, args[0], args[1]); err != nil {
				return err
			}
			if err := cfg.Save(userCfg); err != nil {
				return fmt.Errorf("failed to save config: %w", err)
			}
			fmt.Printf("  %s = %s\n", args[0], args[1])
			return nil
		},
	}
	configCmd.AddCommand(configSetCmd)

	configInitCmd := &cobra.Command{
		Use:   "init",
		Short: "Create a default config file",
		Args:  cobra.NoArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			userCfg := cfg.Default()
			if err := cfg.Save(userCfg); err != nil {
				return fmt.Errorf("failed to save config: %w", err)
			}
			p, _ := cfg.Path()
			fmt.Printf("  Created config at %s\n", p)
			return nil
		},
	}
	configCmd.AddCommand(configInitCmd)

	rootCmd.AddCommand(configCmd)
	rootCmd.AddCommand(initCmd)
	if err := rootCmd.Execute(); err != nil {
		os.Exit(1)
	}
}

func printConfig(c *cfg.UserConfig) error {
	p, err := cfg.Path()
	if err != nil {
		return err
	}
	fmt.Printf("Config: %s\n\n", p)

	fields := []struct {
		key, val string
	}{
		{"author", c.Author},
		{"email", c.Email},
		{"license", c.License},
		{"pkg_manager", c.PkgManager},
	}
	for _, f := range fields {
		if f.val != "" {
			fmt.Printf("  %-12s %s\n", f.key, f.val)
		}
	}
	if c.InitGit != nil {
		fmt.Printf("  %-12s %v\n", "init_git", *c.InitGit)
	}

	if c.Author == "" && c.Email == "" && c.License == "" &&
		c.PkgManager == "" && c.InitGit == nil {
		fmt.Println("  (no values set)")
	}
	return nil
}

func getField(c *cfg.UserConfig, key string) string {
	switch strings.ToLower(key) {
	case "author":
		return c.Author
	case "email":
		return c.Email
	case "license":
		return c.License
	case "pkg_manager":
		return c.PkgManager
	case "init_git":
		if c.InitGit == nil {
			return ""
		}
		return fmt.Sprintf("%v", *c.InitGit)
	}
	return ""
}

func setField(c *cfg.UserConfig, key, val string) error {
	switch strings.ToLower(key) {
	case "author":
		c.Author = val
	case "email":
		c.Email = val
	case "license":
		c.License = val
	case "pkg_manager":
		val = strings.ToLower(val)
		switch val {
		case "npm", "pnpm", "bun":
		default:
			return fmt.Errorf("invalid package manager %q (expected npm, pnpm, or bun)", val)
		}
		c.PkgManager = val
	case "init_git":
		switch strings.ToLower(val) {
		case "true", "yes", "1":
			v := true
			c.InitGit = &v
		case "false", "no", "0":
			v := false
			c.InitGit = &v
		default:
			return fmt.Errorf("invalid value %q (expected true or false)", val)
		}
	default:
		return fmt.Errorf("unknown key %q (see zetup config --help)", key)
	}
	return nil
}