first pass at commands and scaffolding

Author: skarim

cmd/add.go

@@ -0,0 +1,89 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/githubnext/gh-stack/internal/config"
+	"github.com/githubnext/gh-stack/internal/git"
+	"github.com/githubnext/gh-stack/internal/stack"
+	"github.com/spf13/cobra"
+)
+
+func NewAddCmd(cfg *config.Config) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "add [branch]",
+		Short: "Add a new branch on top of the current stack",
+		Args:  cobra.MaximumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runAdd(cfg, args)
+		},
+	}
+	return cmd
+}
+
+func runAdd(cfg *config.Config, args []string) error {
+	gitDir, err := git.GitDir()
+	if err != nil {
+		return fmt.Errorf("not a git repository")
+	}
+
+	sf, err := stack.Load(gitDir)
+	if err != nil {
+		return err
+	}
+
+	currentBranch, err := git.CurrentBranch()
+	if err != nil {
+		return err
+	}
+
+	s := sf.FindStackForBranch(currentBranch)
+	if s == nil {
+		return fmt.Errorf("current branch %q is not part of a stack; run 'gh stack init' first", currentBranch)
+	}
+
+	idx := s.IndexOf(currentBranch)
+	if idx >= 0 && idx < len(s.Branches)-1 {
+		return fmt.Errorf("can only add branches on top of the stack; checkout the top branch %q first", s.Branches[len(s.Branches)-1].Branch)
+	}
+
+	var branchName string
+	if len(args) > 0 {
+		branchName = args[0]
+	} else {
+		fmt.Fprintf(cfg.Err, "Enter a name for the new branch: ")
+		if _, err := fmt.Fscan(cfg.In, &branchName); err != nil {
+			return fmt.Errorf("could not read branch name: %w", err)
+		}
+	}
+
+	if branchName == "" {
+		return fmt.Errorf("branch name cannot be empty")
+	}
+
+	if err := sf.ValidateNoDuplicateBranch(branchName); err != nil {
+		return err
+	}
+
+	if git.BranchExists(branchName) {
+		return fmt.Errorf("branch %q already exists", branchName)
+	}
+
+	if err := git.CreateBranch(branchName, currentBranch); err != nil {
+		return fmt.Errorf("failed to create branch: %w", err)
+	}
+
+	if err := git.CheckoutBranch(branchName); err != nil {
+		return fmt.Errorf("failed to checkout branch: %w", err)
+	}
+
+	head, _ := git.HeadSHA(branchName)
+	s.Branches = append(s.Branches, stack.BranchRef{Branch: branchName, Head: head})
+
+	if err := stack.Save(gitDir, sf); err != nil {
+		return err
+	}
+
+	cfg.Successf("Created and checked out branch %q\n", branchName)
+	return nil
+}

cmd/checkout.go

@@ -0,0 +1,171 @@
+package cmd
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/githubnext/gh-stack/internal/config"
+	"github.com/githubnext/gh-stack/internal/git"
+	"github.com/githubnext/gh-stack/internal/stack"
+	"github.com/spf13/cobra"
+)
+
+type checkoutOptions struct {
+	target   string
+	noSwitch bool
+}
+
+func NewCheckoutCmd(cfg *config.Config) *cobra.Command {
+	opts := &checkoutOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "checkout <pr-or-branch>",
+		Short: "Checkout a stack from a PR number or branch name",
+		Long:  "Discover and check out an entire stack from a pull request number, URL, or branch name.",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			opts.target = args[0]
+			return runCheckout(cfg, opts)
+		},
+	}
+
+	cmd.Flags().BoolVar(&opts.noSwitch, "no-switch", false, "Fetch and track the stack without switching branches")
+
+	return cmd
+}
+
+func runCheckout(cfg *config.Config, opts *checkoutOptions) error {
+	gitDir, err := git.GitDir()
+	if err != nil {
+		return fmt.Errorf("not a git repository")
+	}
+
+	client, err := cfg.GitHubClient()
+	if err != nil {
+		return err
+	}
+
+	repo, err := cfg.Repo()
+	if err != nil {
+		return err
+	}
+
+	owner := repo.Owner
+	name := repo.Name
+
+	// Resolve target to a branch name
+	var headBranch string
+	prNum, parseErr := parsePRTarget(opts.target)
+	if parseErr == nil && prNum > 0 {
+		pr, prErr := client.GetPR(prNum)
+		if prErr != nil {
+			return fmt.Errorf("failed to fetch PR #%d: %w", prNum, prErr)
+		}
+		headBranch = pr.HeadRefName
+	} else {
+		headBranch = opts.target
+	}
+
+	// Discover the stack via PR chain: first find the PR for this branch
+	cfg.Printf("Discovering stack from branch %q...\n", headBranch)
+	startPR, err := client.FindPRForBranch(headBranch)
+	if err != nil {
+		return fmt.Errorf("failed to find PR for branch %q: %w", headBranch, err)
+	}
+	if startPR == nil {
+		return fmt.Errorf("no pull request found for branch %q", headBranch)
+	}
+
+	prs, trunk, err := client.FindStackPRs(startPR)
+	if err != nil {
+		return fmt.Errorf("failed to discover stack: %w", err)
+	}
+
+	if len(prs) == 0 {
+		return fmt.Errorf("no pull requests found for branch %q", headBranch)
+	}
+
+	// Fetch all branches
+	cfg.Printf("Fetching %d branches...\n", len(prs))
+	if err := git.Fetch("origin"); err != nil {
+		cfg.Warningf("fetch failed: %v\n", err)
+	}
+
+	var branches []stack.BranchRef
+	for _, pr := range prs {
+		branchName := pr.HeadRefName
+
+		if !git.BranchExists(branchName) {
+			// Create local branch tracking the remote
+			if err := git.CreateBranch(branchName, "origin/"+branchName); err != nil {
+				cfg.Warningf("failed to create branch %q: %v\n", branchName, err)
+				continue
+			}
+		}
+
+		if err := git.SetUpstreamTracking(branchName, "origin/"+branchName); err != nil {
+			cfg.Warningf("failed to set upstream for %q: %v\n", branchName, err)
+		}
+
+		head, _ := git.HeadSHA(branchName)
+		branches = append(branches, stack.BranchRef{
+			Branch: branchName,
+			Head:   head,
+		})
+	}
+
+	// Save to local tracking
+	sf, err := stack.Load(gitDir)
+	if err != nil {
+		return err
+	}
+
+	trunkHead, _ := git.HeadSHA(trunk)
+	newStack := stack.Stack{
+		Trunk:    stack.BranchRef{Branch: trunk, Head: trunkHead},
+		Branches: branches,
+	}
+
+	sf.AddStack(newStack)
+
+	repoStr := fmt.Sprintf("%s/%s", owner, name)
+	sf.Repository = repoStr
+
+	if err := stack.Save(gitDir, sf); err != nil {
+		return err
+	}
+
+	// Switch to the target branch
+	if !opts.noSwitch {
+		if err := git.CheckoutBranch(headBranch); err != nil {
+			cfg.Warningf("failed to checkout %q: %v\n", headBranch, err)
+		}
+	}
+
+	cfg.Successf("Checked out stack with %d branches (trunk: %s)\n", len(branches), trunk)
+	for i, b := range branches {
+		marker := "  "
+		if b.Branch == headBranch {
+			marker = "* "
+		}
+		cfg.Outf("%s%d. %s\n", marker, i+1, b.Branch)
+	}
+
+	return nil
+}
+
+func parsePRTarget(target string) (int, error) {
+	// Handle #123 format
+	target = strings.TrimPrefix(target, "#")
+
+	// Handle URL format
+	if strings.Contains(target, "/pull/") {
+		parts := strings.Split(target, "/pull/")
+		if len(parts) == 2 {
+			target = strings.TrimSuffix(parts[1], "/")
+		}
+	}
+
+	return strconv.Atoi(target)
+}