feat(cmd): refactor pr command and enhance log output

Refactor 'gh stack pr' to wrap 'gh pr create' interactively:
- Pass through user flags after '--' (e.g., --fill, --web, --title)
- Auto-draft PRs targeting non-trunk branches
- Use FindPRByHead to discover newly created PRs
- Improve error messages with actionable hints
- Extract updateExistingPR helper for clarity

Enhance 'gh stack log' to display PR URLs:
- Show clickable URLs in tree view
- Add URL column to porcelain output

Author: boneskull

cmd/log.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/boneskull/gh-stack/internal/config"
 	"github.com/boneskull/gh-stack/internal/git"
+	"github.com/boneskull/gh-stack/internal/github"
 	"github.com/boneskull/gh-stack/internal/tree"
 	"github.com/spf13/cobra"
 )
@@ -48,16 +49,19 @@ func runLog(cmd *cobra.Command, args []string) error {
 	g := git.New(cwd)
 	currentBranch, _ := g.CurrentBranch() //nolint:errcheck // empty string is fine for display
 
+	// Try to get GitHub client for PR URLs (optional - may fail if not in a GitHub repo)
+	gh, _ := github.NewClient() //nolint:errcheck // nil is fine, URLs won't be shown
+
 	if logPorcelainFlag {
-		printPorcelain(root, currentBranch)
+		printPorcelain(root, currentBranch, gh)
 	} else {
-		printTree(root, "", true, currentBranch)
+		printTree(root, "", true, currentBranch, gh)
 	}
 
 	return nil
 }
 
-func printTree(node *tree.Node, prefix string, isLast bool, current string) {
+func printTree(node *tree.Node, prefix string, isLast bool, current string, gh *github.Client) {
 	// Determine the branch indicator
 	connector := "├── "
 	if isLast {
@@ -75,7 +79,11 @@ func printTree(node *tree.Node, prefix string, isLast bool, current string) {
 
 	prInfo := ""
 	if node.PR > 0 {
-		prInfo = fmt.Sprintf(" (#%d)", node.PR)
+		if gh != nil {
+			prInfo = fmt.Sprintf(" (#%d) %s", node.PR, gh.PRURL(node.PR))
+		} else {
+			prInfo = fmt.Sprintf(" (#%d)", node.PR)
+		}
 	}
 
 	fmt.Printf("%s%s%s%s%s\n", prefix, connector, marker, node.Name, prInfo)
@@ -92,11 +100,11 @@ func printTree(node *tree.Node, prefix string, isLast bool, current string) {
 
 	for i, child := range node.Children {
 		isLastChild := i == len(node.Children)-1
-		printTree(child, childPrefix, isLastChild, current)
+		printTree(child, childPrefix, isLastChild, current, gh)
 	}
 }
 
-func printPorcelain(node *tree.Node, current string) {
+func printPorcelain(node *tree.Node, current string, gh *github.Client) {
 	var printNode func(*tree.Node, int)
 	printNode = func(n *tree.Node, depth int) {
 		isCurrent := "0"
@@ -107,7 +115,11 @@ func printPorcelain(node *tree.Node, current string) {
 		if n.Parent != nil {
 			parent = n.Parent.Name
 		}
-		fmt.Printf("%s\t%s\t%d\t%s\n", n.Name, parent, n.PR, isCurrent)
+		prURL := ""
+		if n.PR > 0 && gh != nil {
+			prURL = gh.PRURL(n.PR)
+		}
+		fmt.Printf("%s\t%s\t%d\t%s\t%s\n", n.Name, parent, n.PR, isCurrent, prURL)
 		for _, child := range n.Children {
 			printNode(child, depth+1)
 		}

cmd/pr.go

@@ -2,27 +2,40 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 
+	gh "github.com/cli/go-gh/v2"
+	"github.com/spf13/cobra"
+
 	"github.com/boneskull/gh-stack/internal/config"
 	"github.com/boneskull/gh-stack/internal/git"
 	"github.com/boneskull/gh-stack/internal/github"
 	"github.com/boneskull/gh-stack/internal/tree"
-	"github.com/spf13/cobra"
 )
 
 var prCmd = &cobra.Command{
-	Use:   "pr",
+	Use:   "pr [-- <gh-pr-create-flags>...]",
 	Short: "Create or update a PR for the current branch",
-	Long:  `Create a new PR targeting the parent branch, or update an existing PR's base.`,
-	RunE:  runPR,
+	Long: `Create a new PR targeting the parent branch, or update an existing PR's base.
+
+This command wraps 'gh pr create', automatically setting the base branch to the
+stack parent. Any additional flags after '--' are passed through to 'gh pr create'.
+
+Examples:
+  gh stack pr                          # Interactive PR creation
+  gh stack pr -- --title "My PR"       # With title
+  gh stack pr -- --fill --web          # Fill from commits, open in browser
+  gh stack pr --base main              # Override base branch`,
+	RunE:               runPR,
+	DisableFlagParsing: false,
 }
 
 var prBaseFlag string
 
 func init() {
-	prCmd.Flags().StringVar(&prBaseFlag, "base", "", "override base branch")
+	prCmd.Flags().StringVar(&prBaseFlag, "base", "", "override base branch (default: stack parent)")
 	rootCmd.AddCommand(prCmd)
 }
 
@@ -37,8 +50,7 @@ func runPR(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	// Create GitHub client
-	gh, err := github.NewClient()
+	ghClient, err := github.NewClient()
 	if err != nil {
 		return err
 	}
@@ -52,80 +64,91 @@ func runPR(cmd *cobra.Command, args []string) error {
 	// Get parent (base branch)
 	parent, err := cfg.GetParent(branch)
 	if err != nil {
-		return fmt.Errorf("branch %q is not tracked", branch)
+		return fmt.Errorf("branch %q is not tracked; use 'gh stack create' or 'gh stack track' first", branch)
 	}
 
-	base := prBaseFlag
-	if base == "" {
-		base = parent
-	}
-
-	// Get trunk for draft decision and comment generation
 	trunk, err := cfg.GetTrunk()
 	if err != nil {
 		return err
 	}
 
+	base := prBaseFlag
+	if base == "" {
+		base = parent
+	}
+
 	// Check if PR already exists
 	existingPR, _ := cfg.GetPR(branch) //nolint:errcheck // 0 is fine if no PR
 	if existingPR > 0 {
-		// Update existing PR's base if needed
-		fmt.Printf("PR #%d already exists, updating base to %q\n", existingPR, base)
-		if updateErr := gh.UpdatePRBase(existingPR, base); updateErr != nil {
-			return fmt.Errorf("failed to update PR base: %w", updateErr)
-		}
-
-		// Update stack comment
-		root, buildErr := tree.Build(cfg)
-		if buildErr != nil {
-			return fmt.Errorf("build tree: %w", buildErr)
-		}
-		comment := github.GenerateStackComment(root, branch, trunk)
-		if comment != "" {
-			if commentErr := gh.CreateOrUpdateStackComment(existingPR, comment); commentErr != nil {
-				fmt.Printf("Warning: failed to update stack comment: %v\n", commentErr)
-			}
-		}
-		return nil
+		return updateExistingPR(ghClient, cfg, existingPR, branch, base, trunk)
 	}
 
-	// Create new PR
-	fmt.Printf("Creating PR for %q targeting %q...\n", branch, base)
+	// Build args for gh pr create
+	ghArgs := []string{"pr", "create", "--base", base}
 
-	var prNumber int
+	// Auto-draft if not targeting trunk (middle of stack)
 	if base != trunk {
-		// Create as draft since it's part of a stack
-		prNumber, err = gh.CreateDraftPR(branch, base, branch, "")
-		if err != nil {
-			return err
-		}
-		fmt.Printf("Created draft PR #%d for %s -> %s\n", prNumber, branch, base)
-	} else {
-		prNumber, err = gh.CreatePR(branch, base, branch, "")
-		if err != nil {
-			return err
-		}
-		fmt.Printf("Created PR #%d for %s -> %s\n", prNumber, branch, base)
+		ghArgs = append(ghArgs, "--draft")
+		fmt.Printf("Creating draft PR (base %q is not trunk %q)\n", base, trunk)
+	}
+
+	// Pass through any additional args from user
+	ghArgs = append(ghArgs, args...)
+
+	// Let user interact with gh pr create
+	ctx := context.Background()
+	if execErr := gh.ExecInteractive(ctx, ghArgs...); execErr != nil {
+		return fmt.Errorf("gh pr create failed: %w", execErr)
+	}
+
+	// Find the PR we just created
+	pr, err := ghClient.FindPRByHead(branch)
+	if err != nil {
+		return fmt.Errorf("failed to find created PR: %w", err)
+	}
+	if pr == nil {
+		// User might have cancelled
+		fmt.Println("No PR was created.")
+		return nil
 	}
 
 	// Store PR number
-	if setPRErr := cfg.SetPR(branch, prNumber); setPRErr != nil {
-		return setPRErr
+	if setErr := cfg.SetPR(branch, pr.Number); setErr != nil {
+		return setErr
 	}
 
 	// Post stack navigation comment
-	root, buildErr := tree.Build(cfg)
-	if buildErr != nil {
-		return fmt.Errorf("build tree: %w", buildErr)
+	root, err := tree.Build(cfg)
+	if err != nil {
+		return fmt.Errorf("build tree: %w", err)
+	}
+
+	if err := ghClient.GenerateAndPostStackComment(root, branch, trunk, pr.Number); err != nil {
+		fmt.Printf("Warning: failed to add stack comment: %v\n", err)
+	}
+
+	fmt.Printf("Stored PR #%d for branch %q\n", pr.Number, branch)
+	return nil
+}
+
+// updateExistingPR updates the base branch and stack comment for an existing PR.
+func updateExistingPR(ghClient *github.Client, cfg *config.Config, prNumber int, branch, base, trunk string) error {
+	fmt.Printf("PR #%d already exists, updating base to %q\n", prNumber, base)
+
+	if err := ghClient.UpdatePRBase(prNumber, base); err != nil {
+		return fmt.Errorf("failed to update PR base: %w", err)
+	}
+
+	// Update stack comment
+	root, err := tree.Build(cfg)
+	if err != nil {
+		return fmt.Errorf("build tree: %w", err)
 	}
 
-	comment := github.GenerateStackComment(root, branch, trunk)
-	if comment != "" {
-		if err := gh.CreateOrUpdateStackComment(prNumber, comment); err != nil {
-			fmt.Printf("Warning: failed to add stack comment: %v\n", err)
-			// Don't fail the command for comment issues
-		}
+	if err := ghClient.GenerateAndPostStackComment(root, branch, trunk, prNumber); err != nil {
+		fmt.Printf("Warning: failed to update stack comment: %v\n", err)
 	}
 
+	fmt.Println(ghClient.PRURL(prNumber))
 	return nil
 }

internal/git/git_test.go

@@ -256,3 +256,4 @@ func TestNeedsRebase(t *testing.T) {
 		t.Error("feature should need rebase after main moved forward")
 	}
 }
+

internal/github/github_test.go

@@ -295,3 +295,71 @@ func TestClient_UpdatePRBase(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }
+
+func TestClient_FindPRByHead(t *testing.T) {
+	mock := &mockREST{
+		getFn: func(path string, response any) error {
+			expectedPath := "repos/owner/repo/pulls?head=owner:feature-branch&state=open"
+			if path != expectedPath {
+				t.Errorf("expected path %q, got %q", expectedPath, path)
+			}
+
+			if prs, ok := response.(*[]PR); ok {
+				*prs = []PR{
+					{Number: 42, State: "open", Draft: false},
+				}
+			}
+			return nil
+		},
+	}
+
+	client := NewClientWithREST(mock, "owner", "repo")
+	pr, err := client.FindPRByHead("feature-branch")
+
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if pr == nil {
+		t.Fatal("expected PR, got nil")
+	}
+	if pr.Number != 42 {
+		t.Errorf("expected PR number 42, got %d", pr.Number)
+	}
+}
+
+func TestClient_FindPRByHead_NotFound(t *testing.T) {
+	mock := &mockREST{
+		getFn: func(path string, response any) error {
+			// Return empty slice (no PRs)
+			if prs, ok := response.(*[]PR); ok {
+				*prs = []PR{}
+			}
+			return nil
+		},
+	}
+
+	client := NewClientWithREST(mock, "owner", "repo")
+	pr, err := client.FindPRByHead("nonexistent-branch")
+
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if pr != nil {
+		t.Errorf("expected nil PR, got %+v", pr)
+	}
+}
+
+func TestClient_FindPRByHead_Error(t *testing.T) {
+	mock := &mockREST{
+		getFn: func(path string, response any) error {
+			return errors.New("API error")
+		},
+	}
+
+	client := NewClientWithREST(mock, "owner", "repo")
+	_, err := client.FindPRByHead("feature")
+
+	if err == nil {
+		t.Fatal("expected error, got nil")
+	}
+}