gitea-api/main.go

package main

import (
	_ "embed"
	"flag"
	"os"
	"path"

	"code.gitea.io/sdk/gitea"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/config"
	"golang.design/x/clipboard"

	logger "git.site.quack-lab.dev/dave/cylogger"
)

var Version = "1.0.0"

func main() {
	name := flag.String("name", "", "Name of the repository")
	flag.String("n", "", "Name of the repository")

	private := flag.Bool("private", false, "Make the repository private")
	flag.Bool("p", false, "Make the repository private (shorthand)")

	noinit := flag.Bool("noinit", false, "Do not add remote to the new repo")
	flag.Bool("ni", false, "Do not add remote to the new repo (shorthand)")

	forceInit := flag.Bool("f", false, "Force assignment of the remote (deletes existing origin)")

	remote := flag.String("remote", "origin", "Name of the remote to create for the new repository")
	flag.String("r", "origin", "Name of the remote to create for the new repository (shorthand)")

	version := flag.Bool("v", false, "Show version")
	flag.Bool("version", false, "Show version")

	help := flag.Bool("h", false, "Show help")
	flag.Bool("help", false, "Show help")

	flag.Parse()
	logger.InitFlag()
	
	logger.Info("Starting repo %s", Version)

	if *version {
		logger.Info("Version: %s", Version)
		return
	}
	if *help {
		flag.PrintDefaults()
		return
	}

	err := clipboard.Init()
	if err != nil {
		logger.Error("Error initializing clipboard: %v", err)
		return
	}

	username, ok := os.LookupEnv("GITEA_USER")
	if !ok {
		logger.Error("GITEA_USER environment variable is required")
		return
	}
	password, ok := os.LookupEnv("GITEA_PASSWORD")
	if !ok {
		logger.Error("GITEA_PASSWORD environment variable is required")
		return
	}
	url, ok := os.LookupEnv("GITEA_URL")
	if !ok {
		logger.Error("GITEA_URL environment variable is required")
		return
	}

	if username == "" || password == "" {
		logger.Error("GITEA_USER and GITEA_PASSWORD environment variables are required")
		return
	}

	if flag.NArg() > 0 {
		*name = flag.Arg(0)
	}

	if *name == "" {
		logger.Error("Repository name is required")
		return
	}

	logger.Info("Username: %s", username)
	logger.Info("URL: %s", url)
	logger.Info("Name: %s", *name)
	logger.Info("Private: %t", *private)
	logger.Info("Noinit: %t", *noinit)
	logger.Info("ForceInit: %t", *forceInit)
	logger.Info("Remote: %s", *remote)

	client, err := gitea.NewClient(url)
	if err != nil {
		logger.Error("Error creating client: %v", err)
		return
	}
	client.SetBasicAuth(username, password)

	logger.Info("Getting repository...")
	repo, _, err := client.GetRepo(username, *name)
	if err == nil {
		logger.Info("Repository already exists at:\n%s", repo.CloneURL)
		clipboard.Write(clipboard.FmtText, []byte(repo.CloneURL))
	} else {
		logger.Info("Repository does not exist, creating...")
		repo, _, err = client.CreateRepo(gitea.CreateRepoOption{
			Name:          *name,
			Private:       *private,
			DefaultBranch: "master",
		})
		if err != nil {
			logger.Error("Error creating repository: %v", err)
			return
		}
		logger.Info("Repository created at: %s", repo.CloneURL)
		clipboard.Write(clipboard.FmtText, []byte(repo.CloneURL))
	}

	if !*noinit {
		logger.Info("Adding remote to local repository...")
		cwd, err := os.Getwd()
		if err != nil {
			logger.Error("Error getting current working directory: %v", err)
			return
		}
		cwd = path.Clean(cwd)

		var localRepo *git.Repository
		logger.Info("Checking if local repository exists at %s/.git...", cwd)
		_, err = os.Stat(path.Join(cwd, ".git"))
		if err == nil {
			localRepo, err = git.PlainOpen(cwd)
			if err != nil {
				logger.Error("Error opening git repository: %v", err)
				return
			}
		} else {
			localRepo, err = git.PlainInit(cwd, false)
			if err != nil {
				logger.Error("Error initializing git repository: %v", err)
				return
			}
		}
		logger.Info("Checking if remote %s exists in local repository...", *remote)
		_, err = localRepo.Remote(*remote)
		if err == nil {
			logger.Info("Remote %s exists in local repository", *remote)
			if *forceInit {
				logger.Info("Deleting remote %s from local repository...", *remote)
				err = localRepo.DeleteRemote(*remote)
				if err != nil {
					logger.Error("Error deleting remote %s from local repository: %v", *remote, err)
					return
				}
				logger.Info("Remote %s deleted from local repository", *remote)
			} else {
				logger.Error("Remote %s already exists in local repository", *remote)
				return
			}
		}

		logger.Info("Adding remote %s to local repository...", *remote)
		_, err = localRepo.CreateRemote(&config.RemoteConfig{
			Name: *remote,
			URLs: []string{repo.CloneURL},
		})
		if err != nil {
			logger.Error("Error adding remote %s to local repository: %v", *remote, err)
			return
		}
		logger.Info("Remote added to local repository")
	}
	logger.Info("Done")
}