feat: implement repo create command

cmd/repo.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"text/tabwriter"
 
 	"code.gitea.io/sdk/gitea"
@@ -50,12 +51,35 @@ var repoForkCmd = &cobra.Command{
 	RunE:  runRepoFork,
 }
 
+var repoCreateCmd = &cobra.Command{
+	Use:   "create <name>",
+	Short: "Create a new repository",
+	Long: `Create a new repository on the Forgejo instance.
+
+Name can be "reponame" (creates under your account) or "org/reponame"
+(creates under an organization). Repositories are public by default; use --private to create a private one.`,
+	Args: cobra.ExactArgs(1),
+	RunE: runRepoCreate,
+}
+
 func init() {
 	rootCmd.AddCommand(repoCmd)
-	repoCmd.AddCommand(repoViewCmd)
-	repoCmd.AddCommand(repoListCmd)
 	repoCmd.AddCommand(repoCloneCmd)
+	repoCmd.AddCommand(repoCreateCmd)
 	repoCmd.AddCommand(repoForkCmd)
+	repoCmd.AddCommand(repoListCmd)
+	repoCmd.AddCommand(repoViewCmd)
+
+	repoCreateCmd.Flags().StringP("description", "d", "", "Description of the repository")
+	repoCreateCmd.Flags().Bool("private", false, "Make the new repository private")
+	repoCreateCmd.Flags().Bool("public", false, "Make the new repository public")
+	repoCreateCmd.Flags().Bool("add-readme", false, "Add a README file to the new repository")
+	repoCreateCmd.Flags().StringP("gitignore", "g", "", "Gitignore template (e.g. Go, Python)")
+	repoCreateCmd.Flags().StringP("license", "l", "", "License template (e.g. MIT, Apache-2.0)")
+	repoCreateCmd.Flags().String("homepage", "", "Repository home page URL")
+	repoCreateCmd.Flags().BoolP("clone", "c", false, "Clone the new repository to the current directory")
+	repoCreateCmd.Flags().StringP("team", "t", "", "Team name to be granted access (org repos only)")
+	repoCreateCmd.MarkFlagsMutuallyExclusive("public", "private")
 
 	repoCloneCmd.Flags().StringP("protocol", "p", "https", "Clone protocol: https or ssh")
 }
@@ -237,3 +261,125 @@ func runRepoFork(cmd *cobra.Command, args []string) error {
 
 	return nil
 }
+
+func runRepoCreate(cmd *cobra.Command, args []string) error {
+	inputName := args[0]
+	org, repoName, isOrg, err := parseCreateName(inputName)
+	if err != nil {
+		return err
+	}
+
+	private, _ := cmd.Flags().GetBool("private")
+	description, _ := cmd.Flags().GetString("description")
+	addReadme, _ := cmd.Flags().GetBool("add-readme")
+	gitignore, _ := cmd.Flags().GetString("gitignore")
+	license, _ := cmd.Flags().GetString("license")
+	homepage, _ := cmd.Flags().GetString("homepage")
+	doClone, _ := cmd.Flags().GetBool("clone")
+	team, _ := cmd.Flags().GetString("team")
+
+	cfg, err := config.Load()
+	if err != nil {
+		return err
+	}
+
+	client, err := api.NewClientFromConfig(cfg, "", getDetectedHost())
+	if err != nil {
+		return err
+	}
+
+	opt := gitea.CreateRepoOption{
+		Name:        repoName,
+		Description: description,
+		Private:     private,
+		AutoInit:    addReadme,
+		Gitignores:  gitignore,
+		License:     license,
+	}
+
+	var repo *gitea.Repository
+	if isOrg {
+		repo, _, err = client.CreateOrgRepo(org, opt)
+	} else {
+		repo, _, err = client.CreateRepo(opt)
+	}
+	if err != nil {
+		return fmt.Errorf("failed to create repository: %w", err)
+	}
+
+	if homepage != "" {
+		ownerName := org
+		if !isOrg {
+			// For personal repos, get the owner from the created repo or fall back to API
+			if repo.Owner != nil {
+				ownerName = repo.Owner.UserName
+			} else {
+				user, _, userErr := client.GetMyUserInfo()
+				if userErr != nil {
+					fmt.Fprintf(os.Stderr, "warning: repository created but could not determine owner for homepage: %v\n", userErr)
+					homepage = "" // skip EditRepo
+				} else {
+					ownerName = user.UserName
+				}
+			}
+		}
+		if homepage != "" {
+			_, _, err = client.EditRepo(ownerName, repo.Name, gitea.EditRepoOption{
+				Website: &homepage,
+			})
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "warning: repository created but failed to set homepage: %v\n", err)
+			}
+		}
+	}
+
+	if team != "" {
+		if !isOrg {
+			fmt.Fprintln(os.Stderr, "warning: --team is only meaningful for organization repositories")
+		} else {
+			_, err = client.AddRepoTeam(org, repo.Name, team)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "warning: repository created but failed to add team %q: %v\n", team, err)
+			}
+		}
+	}
+
+	fmt.Printf("Repository created: %s\n", repo.HTMLURL)
+
+	if doClone {
+		cloneURL := repo.CloneURL
+		if hostCfg, hostErr := cfg.GetHost("", getDetectedHost()); hostErr == nil {
+			if hostCfg.GitProtocol == "ssh" {
+				cloneURL = repo.SSHURL
+			}
+		}
+		fmt.Printf("Cloning into %s...\n", repo.Name)
+		gitCmd := exec.Command("git", "clone", cloneURL, repo.Name)
+		gitCmd.Stdout = os.Stdout
+		gitCmd.Stderr = os.Stderr
+		gitCmd.Stdin = os.Stdin
+		if err := gitCmd.Run(); err != nil {
+			return fmt.Errorf("failed to clone repository: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// parseCreateName parses the name argument for repo creation.
+// Returns org, repoName, and whether it targets an org.
+// Input: "reponame" → ("", "reponame", false)
+// Input: "org/reponame" → ("org", "reponame", true)
+func parseCreateName(name string) (org, repoName string, isOrg bool, err error) {
+	parts := strings.SplitN(name, "/", 2)
+	if len(parts) == 2 {
+		if parts[0] == "" || parts[1] == "" {
+			return "", "", false, fmt.Errorf("invalid repository name %q: org and repo name must not be empty", name)
+		}
+		return parts[0], parts[1], true, nil
+	}
+	if name == "" {
+		return "", "", false, fmt.Errorf("repository name must not be empty")
+	}
+	return "", name, false, nil
+}