Merge remote-tracking branch 'origin' into blank-issue

.github/PULL_REQUEST_TEMPLATE/bug_fix.md

@@ -6,7 +6,7 @@ about: Fix a bug in GitHub CLI
 
 <!--
 Please make sure you read our contributing guidelines at
-https://github.com/cli/cli/blob/master/.github/CONTRIBUTING.md
+https://github.com/cli/cli/blob/trunk/.github/CONTRIBUTING.md
 before opening opening a pull request. Thanks!
 -->
 

.github/workflows/go.yml

@@ -10,7 +10,7 @@ jobs:
 
     steps:
       - name: Set up Go 1.14
-        uses: actions/setup-go@v2-beta
+        uses: actions/setup-go@v2
         with:
           go-version: 1.14
 

.github/workflows/lint.yml

@@ -5,6 +5,11 @@ on:
       - "**.go"
       - go.mod
       - go.sum
+  pull_request:
+    paths:
+      - "**.go"
+      - go.mod
+      - go.sum
 
 jobs:
   lint:
@@ -12,7 +17,7 @@ jobs:
 
     steps:
       - name: Set up Go 1.14
-        uses: actions/setup-go@v2-beta
+        uses: actions/setup-go@v2
         with:
           go-version: 1.14
 

.github/workflows/releases.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
       - name: Set up Go 1.14
-        uses: actions/setup-go@v2-beta
+        uses: actions/setup-go@v2
         with:
           go-version: 1.14
       - name: Generate changelog
@@ -44,6 +44,11 @@ jobs:
           token: ${{secrets.SITE_GITHUB_TOKEN}}
       - name: Publish documentation site
         if: "!contains(github.ref, '-')" # skip prereleases
+        env:
+          GIT_COMMITTER_NAME: cli automation
+          GIT_AUTHOR_NAME: cli automation
+          GIT_COMMITTER_EMAIL: noreply@github.com
+          GIT_AUTHOR_EMAIL: noreply@github.com
         run: make site-publish
       - name: Move project cards
         if: "!contains(github.ref, '-')" # skip prereleases

.gitignore

@@ -1,4 +1,5 @@
 /bin
+/share/man/man1
 /gh-cli
 .envrc
 /dist

.goreleaser.yml

@@ -6,6 +6,7 @@ release:
 before:
   hooks:
     - go mod tidy
+    - make manpages
 
 builds:
   - <<: &build_defaults
@@ -17,10 +18,12 @@ builds:
     id: macos
     goos: [darwin]
     goarch: [amd64]
+
   - <<: *build_defaults
     id: linux
     goos: [linux]
     goarch: [386, amd64, arm64]
+
   - <<: *build_defaults
     id: windows
     goos: [windows]
@@ -35,11 +38,16 @@ archives:
     replacements:
       darwin: macOS
     format: tar.gz
+    files:
+      - LICENSE
+      - ./share/man/man1/gh*.1
   - id: windows
     builds: [windows]
     <<: *archive_defaults
     wrap_in_directory: false
     format: zip
+    files:
+      - LICENSE
 
 brews:
   - name: gh
@@ -57,8 +65,9 @@ brews:
         depends_on "go"
       end
     install: |
-      system "make" if build.head?
+      system "make", "bin/gh", "manpages" if build.head?
       bin.install "bin/gh"
+      man1.install Dir["./share/man/man1/gh*.1"]
       (bash_completion/"gh.sh").write `#{bin}/gh completion -s bash`
       (zsh_completion/"_gh").write `#{bin}/gh completion -s zsh`
       (fish_completion/"gh.fish").write `#{bin}/gh completion -s fish`
@@ -76,6 +85,8 @@ nfpms:
     formats:
       - deb
       - rpm
+    files:
+      "./share/man/man1/gh*.1": "/usr/share/man/man1"
 
 scoop:
   bucket:

Makefile

@@ -11,8 +11,8 @@ endif
 LDFLAGS := -X github.com/cli/cli/command.Version=$(GH_VERSION) $(LDFLAGS)
 LDFLAGS := -X github.com/cli/cli/command.BuildDate=$(BUILD_DATE) $(LDFLAGS)
 ifdef GH_OAUTH_CLIENT_SECRET
-	LDFLAGS := -X github.com/cli/cli/context.oauthClientID=$(GH_OAUTH_CLIENT_ID) $(LDFLAGS)
-	LDFLAGS := -X github.com/cli/cli/context.oauthClientSecret=$(GH_OAUTH_CLIENT_SECRET) $(LDFLAGS)
+	LDFLAGS := -X github.com/cli/cli/internal/config.oauthClientID=$(GH_OAUTH_CLIENT_ID) $(LDFLAGS)
+	LDFLAGS := -X github.com/cli/cli/internal/config.oauthClientSecret=$(GH_OAUTH_CLIENT_SECRET) $(LDFLAGS)
 endif
 
 bin/gh: $(BUILD_FILES)
@@ -28,7 +28,7 @@ site:
 site-docs: site
 	git -C site pull
 	git -C site rm 'manual/gh*.md' 2>/dev/null || true
-	go run ./cmd/gen-docs site/manual
+	go run ./cmd/gen-docs --website --doc-path site/manual
 	for f in site/manual/gh*.md; do sed -i.bak -e '/^### SEE ALSO/,$$d' "$$f"; done
 	rm -f site/manual/*.bak
 	git -C site add 'manual/gh*.md'
@@ -44,3 +44,8 @@ endif
 	git -C site commit -m '$(GITHUB_REF:refs/tags/v%=%)' index.html
 	git -C site push
 .PHONY: site-publish
+
+
+.PHONY: manpages
+manpages:
+	go run ./cmd/gen-docs --man-page --doc-path ./share/man/man1/

README.md

@@ -3,7 +3,7 @@
 `gh` is GitHub on the command line, and it's now available in beta. It brings pull requests, issues, and other GitHub concepts to
 the terminal next to where you are already working with `git` and your code.
 
-![screenshot](https://user-images.githubusercontent.com/98482/73286699-9f922180-41bd-11ea-87c9-60a2d31fd0ac.png)
+![screenshot of gh pr status](https://user-images.githubusercontent.com/98482/84171218-327e7a80-aa40-11ea-8cd1-5177fc2d0e72.png)
 
 ## Availability
 
@@ -136,4 +136,4 @@ Install a prebuilt binary from the [releases page][]
 [Chocolatey]: https://chocolatey.org
 [releases page]: https://github.com/cli/cli/releases/latest
 [hub]: https://github.com/github/hub
-[contributing page]: https://github.com/cli/cli/blob/master/.github/CONTRIBUTING.md
+[contributing page]: https://github.com/cli/cli/blob/trunk/.github/CONTRIBUTING.md

api/client.go

@@ -16,14 +16,18 @@ import (
 // ClientOption represents an argument to NewClient
 type ClientOption = func(http.RoundTripper) http.RoundTripper
 
-// NewClient initializes a Client
-func NewClient(opts ...ClientOption) *Client {
+// NewHTTPClient initializes an http.Client
+func NewHTTPClient(opts ...ClientOption) *http.Client {
 	tr := http.DefaultTransport
 	for _, opt := range opts {
 		tr = opt(tr)
 	}
-	http := &http.Client{Transport: tr}
-	client := &Client{http: http}
+	return &http.Client{Transport: tr}
+}
+
+// NewClient initializes a Client
+func NewClient(opts ...ClientOption) *Client {
+	client := &Client{http: NewHTTPClient(opts...)}
 	return client
 }
 
@@ -145,6 +149,45 @@ func (gr GraphQLErrorResponse) Error() string {
 	return fmt.Sprintf("graphql error: '%s'", strings.Join(errorMessages, ", "))
 }
 
+// Returns whether or not scopes are present, appID, and error
+func (c Client) HasScopes(wantedScopes ...string) (bool, string, error) {
+	url := "https://api.github.com/user"
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return false, "", err
+	}
+
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+
+	res, err := c.http.Do(req)
+	if err != nil {
+		return false, "", err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return false, "", handleHTTPError(res)
+	}
+
+	appID := res.Header.Get("X-Oauth-Client-Id")
+	hasScopes := strings.Split(res.Header.Get("X-Oauth-Scopes"), ",")
+
+	found := 0
+	for _, s := range hasScopes {
+		for _, w := range wantedScopes {
+			if w == strings.TrimSpace(s) {
+				found++
+			}
+		}
+	}
+
+	if found == len(wantedScopes) {
+		return true, appID, nil
+	}
+
+	return false, appID, nil
+}
+
 // GraphQL performs a GraphQL request and parses the response
 func (c Client) GraphQL(query string, variables map[string]interface{}, data interface{}) error {
 	url := "https://api.github.com/graphql"

api/queries_gist.go

@@ -0,0 +1,52 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+)
+
+// Gist represents a GitHub's gist.
+type Gist struct {
+	Description string                    `json:"description,omitempty"`
+	Public      bool                      `json:"public,omitempty"`
+	Files       map[GistFilename]GistFile `json:"files,omitempty"`
+	HTMLURL     string                    `json:"html_url,omitempty"`
+}
+
+type GistFilename string
+
+type GistFile struct {
+	Content string `json:"content,omitempty"`
+}
+
+// Create a gist for authenticated user.
+//
+// GitHub API docs: https://developer.github.com/v3/gists/#create-a-gist
+func GistCreate(client *Client, description string, public bool, files map[string]string) (*Gist, error) {
+	gistFiles := map[GistFilename]GistFile{}
+
+	for filename, content := range files {
+		gistFiles[GistFilename(filename)] = GistFile{content}
+	}
+
+	path := "gists"
+	body := &Gist{
+		Description: description,
+		Public:      public,
+		Files:       gistFiles,
+	}
+	result := Gist{}
+
+	requestByte, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+	requestBody := bytes.NewReader(requestByte)
+
+	err = client.REST("POST", path, requestBody, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}

api/queries_issue_test.go

@@ -39,7 +39,8 @@ func TestIssueList(t *testing.T) {
 	} } }
 	`))
 
-	_, err := IssueList(client, ghrepo.FromFullName("OWNER/REPO"), "open", []string{}, "", 251, "")
+	repo, _ := ghrepo.FromFullName("OWNER/REPO")
+	_, err := IssueList(client, repo, "open", []string{}, "", 251, "")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

api/queries_pr.go

@@ -2,7 +2,10 @@ package api
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"io/ioutil"
+	"net/http"
 	"strings"
 
 	"github.com/shurcooL/githubv4"
@@ -45,6 +48,7 @@ type PullRequest struct {
 	BaseRefName string
 	HeadRefName string
 	Body        string
+	Mergeable   string
 
 	Author struct {
 		Login string
@@ -201,6 +205,38 @@ func (pr *PullRequest) ChecksStatus() (summary PullRequestChecksStatus) {
 	return
 }
 
+func (c Client) PullRequestDiff(baseRepo ghrepo.Interface, prNumber int) (string, error) {
+	url := fmt.Sprintf("https://api.github.com/repos/%s/pulls/%d",
+		ghrepo.FullName(baseRepo), prNumber)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", err
+	}
+
+	req.Header.Set("Accept", "application/vnd.github.v3.diff; charset=utf-8")
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	b, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode == 200 {
+		return string(b), nil
+	}
+
+	if resp.StatusCode == 404 {
+		return "", &NotFoundError{errors.New("pull request not found")}
+	}
+
+	return "", errors.New("pull request diff lookup failed")
+}
+
 func PullRequests(client *Client, repo ghrepo.Interface, currentPRNumber int, currentPRHeadRef, currentUsername string) (*PullRequestsPayload, error) {
 	type edges struct {
 		TotalCount int
@@ -382,6 +418,7 @@ func PullRequestByNumber(client *Client, repo ghrepo.Interface, number int) (*Pu
 				state
 				closed
 				body
+				mergeable
 				author {
 				  login
 				}
@@ -490,6 +527,7 @@ func PullRequestForBranch(client *Client, repo ghrepo.Interface, baseBranch, hea
 					title
 					state
 					body
+					mergeable
 					author {
 						login
 					}
@@ -953,6 +991,29 @@ func PullRequestMerge(client *Client, repo ghrepo.Interface, pr *PullRequest, m
 	return err
 }
 
+func PullRequestReady(client *Client, repo ghrepo.Interface, pr *PullRequest) error {
+	var mutation struct {
+		MarkPullRequestReadyForReview struct {
+			PullRequest struct {
+				ID githubv4.ID
+			}
+		} `graphql:"markPullRequestReadyForReview(input: $input)"`
+	}
+
+	input := githubv4.MarkPullRequestReadyForReviewInput{PullRequestID: pr.ID}
+
+	v4 := githubv4.NewClient(client.http)
+	return v4.Mutate(context.Background(), &mutation, input, nil)
+}
+
+func BranchDeleteRemote(client *Client, repo ghrepo.Interface, branch string) error {
+	var response struct {
+		NodeID string `json:"node_id"`
+	}
+	path := fmt.Sprintf("repos/%s/%s/git/refs/heads/%s", repo.RepoOwner(), repo.RepoName(), branch)
+	return client.REST("DELETE", path, nil, &response)
+}
+
 func min(a, b int) int {
 	if a < b {
 		return a

api/queries_repo.go

@@ -84,6 +84,9 @@ func GitHubRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 			hasIssuesEnabled
 			description
 			viewerPermission
+			defaultBranchRef {
+				name
+			}
 		}
 	}`
 	variables := map[string]interface{}{

api/queries_repo_test.go

@@ -50,7 +50,7 @@ func Test_RepoMetadata(t *testing.T) {
 	http := &httpmock.Registry{}
 	client := NewClient(ReplaceTripper(http))
 
-	repo := ghrepo.FromFullName("OWNER/REPO")
+	repo, _ := ghrepo.FromFullName("OWNER/REPO")
 	input := RepoMetadataInput{
 		Assignees:  true,
 		Reviewers:  true,
@@ -181,7 +181,7 @@ func Test_RepoResolveMetadataIDs(t *testing.T) {
 	http := &httpmock.Registry{}
 	client := NewClient(ReplaceTripper(http))
 
-	repo := ghrepo.FromFullName("OWNER/REPO")
+	repo, _ := ghrepo.FromFullName("OWNER/REPO")
 	input := RepoResolveInput{
 		Assignees: []string{"monalisa", "hubot"},
 		Reviewers: []string{"monalisa", "octocat", "OWNER/core", "/robots"},

api/queries_user.go

@@ -0,0 +1,18 @@
+package api
+
+import (
+	"context"
+
+	"github.com/shurcooL/githubv4"
+)
+
+func CurrentLoginName(client *Client) (string, error) {
+	var query struct {
+		Viewer struct {
+			Login string
+		}
+	}
+	v4 := githubv4.NewClient(client.http)
+	err := v4.Query(context.Background(), &query, nil)
+	return query.Viewer.Login, err
+}

auth/oauth.go

@@ -41,7 +41,7 @@ func (oa *OAuthFlow) ObtainAccessToken() (accessToken string, err error) {
 	state, _ := randomString(20)
 
 	code := ""
-	listener, err := net.Listen("tcp", "localhost:0")
+	listener, err := net.Listen("tcp4", "127.0.0.1:0")
 	if err != nil {
 		return
 	}
@@ -66,9 +66,9 @@ func (oa *OAuthFlow) ObtainAccessToken() (accessToken string, err error) {
 		fmt.Fprintf(os.Stderr, "Please open the following URL manually:\n%s\n", startURL)
 		fmt.Fprintf(os.Stderr, "")
 		// TODO: Temporary workaround for https://github.com/cli/cli/issues/297
-		fmt.Fprintf(os.Stderr, "If you are on a server or other headless system, use this workaround instead:")
-		fmt.Fprintf(os.Stderr, "  1. Complete authentication on a GUI system")
-		fmt.Fprintf(os.Stderr, "  2. Copy the contents of ~/.config/gh/config.yml to this system")
+		fmt.Fprintf(os.Stderr, "If you are on a server or other headless system, use this workaround instead:\n")
+		fmt.Fprintf(os.Stderr, "  1. Complete authentication on a GUI system;\n")
+		fmt.Fprintf(os.Stderr, "  2. Copy the contents of `~/.config/gh/hosts.yml` to this system.\n")
 	}
 
 	_ = http.Serve(listener, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

cmd/gen-docs/main.go

@@ -7,22 +7,57 @@ import (
 
 	"github.com/cli/cli/command"
 	"github.com/spf13/cobra/doc"
+	"github.com/spf13/pflag"
 )
 
 func main() {
-	if len(os.Args) < 2 {
-		fatal("Usage: gen-docs <destination-dir>")
-	}
-	dir := os.Args[1]
 
-	err := os.MkdirAll(dir, 0755)
+	var flagError pflag.ErrorHandling
+	docCmd := pflag.NewFlagSet("", flagError)
+	manPage := docCmd.BoolP("man-page", "", false, "Generate manual pages")
+	website := docCmd.BoolP("website", "", false, "Generate website pages")
+	dir := docCmd.StringP("doc-path", "", "", "Path directory where you want generate doc files")
+	help := docCmd.BoolP("help", "h", false, "Help about any command")
+
+	if err := docCmd.Parse(os.Args); err != nil {
+		os.Exit(1)
+	}
+
+	if *help {
+		_, err := fmt.Fprintf(os.Stderr, "Usage of %s:\n\n%s", os.Args[0], docCmd.FlagUsages())
+		if err != nil {
+			fatal(err)
+		}
+		os.Exit(1)
+	}
+
+	if *dir == "" {
+		fatal("no dir set")
+	}
+
+	err := os.MkdirAll(*dir, 0755)
 	if err != nil {
 		fatal(err)
 	}
 
-	err = doc.GenMarkdownTreeCustom(command.RootCmd, dir, filePrepender, linkHandler)
-	if err != nil {
-		fatal(err)
+	if *website {
+		err = doc.GenMarkdownTreeCustom(command.RootCmd, *dir, filePrepender, linkHandler)
+		if err != nil {
+			fatal(err)
+		}
+	}
+
+	if *manPage {
+		header := &doc.GenManHeader{
+			Title:   "gh",
+			Section: "1",
+			Source:  "", //source and manual are just put at the top of the manpage, before name
+			Manual:  "", //if source is an empty string, it's set to "Auto generated by spf13/cobra"
+		}
+		err = doc.GenManTree(command.RootCmd, header, *dir)
+		if err != nil {
+			fatal(err)
+		}
 	}
 }
 

cmd/gh/main.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/cli/cli/command"
 	"github.com/cli/cli/internal/config"
+	"github.com/cli/cli/pkg/cmdutil"
 	"github.com/cli/cli/update"
 	"github.com/cli/cli/utils"
 	"github.com/mgutz/ansi"
@@ -29,6 +30,28 @@ func main() {
 
 	hasDebug := os.Getenv("DEBUG") != ""
 
+	stderr := utils.NewColorable(os.Stderr)
+
+	expandedArgs := []string{}
+	if len(os.Args) > 0 {
+		expandedArgs = os.Args[1:]
+	}
+
+	cmd, _, err := command.RootCmd.Traverse(expandedArgs)
+	if err != nil || cmd == command.RootCmd {
+		originalArgs := expandedArgs
+		expandedArgs, err = command.ExpandAlias(os.Args)
+		if err != nil {
+			fmt.Fprintf(stderr, "failed to process aliases:  %s\n", err)
+			os.Exit(2)
+		}
+		if hasDebug {
+			fmt.Fprintf(stderr, "%v -> %v\n", originalArgs, expandedArgs)
+		}
+	}
+
+	command.RootCmd.SetArgs(expandedArgs)
+
 	if cmd, err := command.RootCmd.ExecuteC(); err != nil {
 		printError(os.Stderr, err, cmd, hasDebug)
 		os.Exit(1)
@@ -48,6 +71,10 @@ func main() {
 }
 
 func printError(out io.Writer, err error, cmd *cobra.Command, debug bool) {
+	if err == cmdutil.SilentError {
+		return
+	}
+
 	var dnsError *net.DNSError
 	if errors.As(err, &dnsError) {
 		fmt.Fprintf(out, "error connecting to %s\n", dnsError.Name)
@@ -60,7 +87,7 @@ func printError(out io.Writer, err error, cmd *cobra.Command, debug bool) {
 
 	fmt.Fprintln(out, err)
 
-	var flagError *command.FlagError
+	var flagError *cmdutil.FlagError
 	if errors.As(err, &flagError) || strings.HasPrefix(err.Error(), "unknown command ") {
 		if !strings.HasSuffix(err.Error(), "\n") {
 			fmt.Fprintln(out)

cmd/gh/main_test.go

@@ -7,7 +7,7 @@ import (
 	"net"
 	"testing"
 
-	"github.com/cli/cli/command"
+	"github.com/cli/cli/pkg/cmdutil"
 	"github.com/spf13/cobra"
 )
 
@@ -49,7 +49,7 @@ check your internet connection or githubstatus.com
 		{
 			name: "Cobra flag error",
 			args: args{
-				err:   &command.FlagError{Err: errors.New("unknown flag --foo")},
+				err:   &cmdutil.FlagError{Err: errors.New("unknown flag --foo")},
 				cmd:   cmd,
 				debug: false,
 			},

command/alias.go

@@ -0,0 +1,208 @@
+package command
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/cli/cli/utils"
+	"github.com/google/shlex"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	RootCmd.AddCommand(aliasCmd)
+	aliasCmd.AddCommand(aliasSetCmd)
+	aliasCmd.AddCommand(aliasListCmd)
+	aliasCmd.AddCommand(aliasDeleteCmd)
+}
+
+var aliasCmd = &cobra.Command{
+	Use:   "alias",
+	Short: "Create shortcuts for gh commands",
+}
+
+var aliasSetCmd = &cobra.Command{
+	Use: "set <alias> <expansion>",
+	// NB: this allows a user to eschew quotes when specifiying an alias expansion. We'll have to
+	// revisit it if we ever want to add flags to alias set but we have no current plans for that.
+	DisableFlagParsing: true,
+	Short:              "Create a shortcut for a gh command",
+	Long:               `This command lets you write your own shortcuts for running gh. They can be simple strings or accept placeholder arguments.`,
+	Example: `
+	gh alias set pv 'pr view'
+	# gh pv -w 123 -> gh pr view -w 123.
+
+	gh alias set bugs 'issue list --label="bugs"'
+	# gh bugs -> gh issue list --label="bugs".
+
+	gh alias set epicsBy 'issue list --author="$1" --label="epic"'
+	# gh epicsBy vilmibm -> gh issue list --author="$1" --label="epic"
+`,
+	Args: cobra.MinimumNArgs(2),
+	RunE: aliasSet,
+}
+
+func aliasSet(cmd *cobra.Command, args []string) error {
+	ctx := contextForCommand(cmd)
+	cfg, err := ctx.Config()
+	if err != nil {
+		return err
+	}
+
+	aliasCfg, err := cfg.Aliases()
+	if err != nil {
+		return err
+	}
+
+	alias := args[0]
+	expansion := processArgs(args[1:])
+
+	expansionStr := strings.Join(expansion, " ")
+
+	out := colorableOut(cmd)
+	fmt.Fprintf(out, "- Adding alias for %s: %s\n", utils.Bold(alias), utils.Bold(expansionStr))
+
+	if validCommand([]string{alias}) {
+		return fmt.Errorf("could not create alias: %q is already a gh command", alias)
+	}
+
+	if !validCommand(expansion) {
+		return fmt.Errorf("could not create alias: %s does not correspond to a gh command", utils.Bold(expansionStr))
+	}
+
+	successMsg := fmt.Sprintf("%s Added alias.", utils.Green("✓"))
+
+	oldExpansion, ok := aliasCfg.Get(alias)
+	if ok {
+		successMsg = fmt.Sprintf("%s Changed alias %s from %s to %s",
+			utils.Green("✓"),
+			utils.Bold(alias),
+			utils.Bold(oldExpansion),
+			utils.Bold(expansionStr),
+		)
+	}
+
+	err = aliasCfg.Add(alias, expansionStr)
+	if err != nil {
+		return fmt.Errorf("could not create alias: %s", err)
+	}
+
+	fmt.Fprintln(out, successMsg)
+
+	return nil
+}
+
+func validCommand(expansion []string) bool {
+	cmd, _, err := RootCmd.Traverse(expansion)
+	return err == nil && cmd != RootCmd
+}
+
+func processArgs(args []string) []string {
+	if len(args) == 1 {
+		split, _ := shlex.Split(args[0])
+		return split
+	}
+
+	newArgs := []string{}
+	for _, a := range args {
+		if !strings.HasPrefix(a, "-") && strings.Contains(a, " ") {
+			a = fmt.Sprintf("%q", a)
+		}
+		newArgs = append(newArgs, a)
+	}
+
+	return newArgs
+}
+
+var aliasListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List your aliases",
+	Long:  `This command prints out all of the aliases gh is configured to use.`,
+	Args:  cobra.ExactArgs(0),
+	RunE:  aliasList,
+}
+
+func aliasList(cmd *cobra.Command, args []string) error {
+	ctx := contextForCommand(cmd)
+	cfg, err := ctx.Config()
+	if err != nil {
+		return fmt.Errorf("couldn't read config: %w", err)
+	}
+
+	aliasCfg, err := cfg.Aliases()
+	if err != nil {
+		return fmt.Errorf("couldn't read aliases config: %w", err)
+	}
+
+	stderr := colorableErr(cmd)
+
+	if aliasCfg.Empty() {
+		fmt.Fprintf(stderr, "no aliases configured\n")
+		return nil
+	}
+
+	stdout := colorableOut(cmd)
+
+	tp := utils.NewTablePrinter(stdout)
+
+	aliasMap := aliasCfg.All()
+	keys := []string{}
+	for alias := range aliasMap {
+		keys = append(keys, alias)
+	}
+	sort.Strings(keys)
+
+	for _, alias := range keys {
+		if tp.IsTTY() {
+			// ensure that screen readers pause
+			tp.AddField(alias+":", nil, nil)
+		} else {
+			tp.AddField(alias, nil, nil)
+		}
+		tp.AddField(aliasMap[alias], nil, nil)
+		tp.EndRow()
+	}
+
+	return tp.Render()
+}
+
+var aliasDeleteCmd = &cobra.Command{
+	Use:     "delete <alias>",
+	Short:   "Delete an alias.",
+	Args:    cobra.ExactArgs(1),
+	Example: "gh alias delete co",
+	RunE:    aliasDelete,
+}
+
+func aliasDelete(cmd *cobra.Command, args []string) error {
+	alias := args[0]
+
+	ctx := contextForCommand(cmd)
+	cfg, err := ctx.Config()
+	if err != nil {
+		return fmt.Errorf("couldn't read config: %w", err)
+	}
+
+	aliasCfg, err := cfg.Aliases()
+	if err != nil {
+		return fmt.Errorf("couldn't read aliases config: %w", err)
+	}
+
+	expansion, ok := aliasCfg.Get(alias)
+	if !ok {
+		return fmt.Errorf("no such alias %s", alias)
+
+	}
+
+	err = aliasCfg.Delete(alias)
+	if err != nil {
+		return fmt.Errorf("failed to delete alias %s: %w", alias, err)
+	}
+
+	out := colorableOut(cmd)
+	redCheck := utils.Red("✓")
+	fmt.Fprintf(out, "%s Deleted alias %s; was %s\n", redCheck, alias, expansion)
+
+	return nil
+}

command/alias_test.go

@@ -0,0 +1,321 @@
+package command
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/cli/cli/internal/config"
+	"github.com/cli/cli/test"
+)
+
+func TestAliasSet_gh_command(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	_, err := RunCommand("alias set pr pr status")
+	if err == nil {
+		t.Fatal("expected error")
+	}
+
+	eq(t, err.Error(), `could not create alias: "pr" is already a gh command`)
+}
+
+func TestAliasSet_empty_aliases(t *testing.T) {
+	cfg := `---
+aliases:
+editor: vim
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	output, err := RunCommand("alias set co pr checkout")
+
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Added alias")
+
+	expected := `aliases:
+    co: pr checkout
+editor: vim
+`
+	eq(t, mainBuf.String(), expected)
+}
+
+func TestAliasSet_existing_alias(t *testing.T) {
+	cfg := `---
+hosts:
+  github.com:
+    user: OWNER
+    oauth_token: token123
+aliases:
+  co: pr checkout
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	output, err := RunCommand("alias set co pr checkout -Rcool/repo")
+
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Changed alias co from pr checkout to pr checkout -Rcool/repo")
+}
+
+func TestAliasSet_space_args(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	output, err := RunCommand(`alias set il issue list -l 'cool story'`)
+
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), `Adding alias for il: issue list -l "cool story"`)
+
+	test.ExpectLines(t, mainBuf.String(), `il: issue list -l "cool story"`)
+}
+
+func TestAliasSet_arg_processing(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+	cases := []struct {
+		Cmd                string
+		ExpectedOutputLine string
+		ExpectedConfigLine string
+	}{
+		{"alias set co pr checkout", "- Adding alias for co: pr checkout", "co: pr checkout"},
+
+		{`alias set il "issue list"`, "- Adding alias for il: issue list", "il: issue list"},
+
+		{`alias set iz 'issue list'`, "- Adding alias for iz: issue list", "iz: issue list"},
+
+		{`alias set iy issue list --author=\$1 --label=\$2`,
+			`- Adding alias for iy: issue list --author=\$1 --label=\$2`,
+			`iy: issue list --author=\$1 --label=\$2`},
+
+		{`alias set ii 'issue list --author="$1" --label="$2"'`,
+			`- Adding alias for ii: issue list --author=\$1 --label=\$2`,
+			`ii: issue list --author=\$1 --label=\$2`},
+
+		{`alias set ix issue list --author='$1' --label='$2'`,
+			`- Adding alias for ix: issue list --author=\$1 --label=\$2`,
+			`ix: issue list --author=\$1 --label=\$2`},
+	}
+
+	for _, c := range cases {
+		mainBuf := bytes.Buffer{}
+		hostsBuf := bytes.Buffer{}
+		defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+		output, err := RunCommand(c.Cmd)
+		if err != nil {
+			t.Fatalf("got unexpected error running %s: %s", c.Cmd, err)
+		}
+
+		test.ExpectLines(t, output.String(), c.ExpectedOutputLine)
+		test.ExpectLines(t, mainBuf.String(), c.ExpectedConfigLine)
+	}
+}
+
+func TestAliasSet_init_alias_cfg(t *testing.T) {
+	cfg := `---
+editor: vim
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	output, err := RunCommand("alias set diff pr diff")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	expected := `editor: vim
+aliases:
+    diff: pr diff
+`
+
+	test.ExpectLines(t, output.String(), "Adding alias for diff: pr diff", "Added alias.")
+	eq(t, mainBuf.String(), expected)
+}
+
+func TestAliasSet_existing_aliases(t *testing.T) {
+	cfg := `---
+aliases:
+    foo: bar
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	output, err := RunCommand("alias set view pr view")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	expected := `aliases:
+    foo: bar
+    view: pr view
+`
+
+	test.ExpectLines(t, output.String(), "Adding alias for view: pr view", "Added alias.")
+	eq(t, mainBuf.String(), expected)
+
+}
+
+func TestExpandAlias(t *testing.T) {
+	cfg := `---
+aliases:
+  co: pr checkout
+  il: issue list --author="$1" --label="$2"
+  ia: issue list --author="$1" --assignee="$1"
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+	for _, c := range []struct {
+		Args         string
+		ExpectedArgs []string
+		Err          string
+	}{
+		{"gh co", []string{"pr", "checkout"}, ""},
+		{"gh il", nil, `not enough arguments for alias: issue list --author="$1" --label="$2"`},
+		{"gh il vilmibm", nil, `not enough arguments for alias: issue list --author="vilmibm" --label="$2"`},
+		{"gh co 123", []string{"pr", "checkout", "123"}, ""},
+		{"gh il vilmibm epic", []string{"issue", "list", `--author=vilmibm`, `--label=epic`}, ""},
+		{"gh ia vilmibm", []string{"issue", "list", `--author=vilmibm`, `--assignee=vilmibm`}, ""},
+		{"gh ia $coolmoney$", []string{"issue", "list", `--author=$coolmoney$`, `--assignee=$coolmoney$`}, ""},
+		{"gh pr status", []string{"pr", "status"}, ""},
+		{"gh il vilmibm epic -R vilmibm/testing", []string{"issue", "list", "--author=vilmibm", "--label=epic", "-R", "vilmibm/testing"}, ""},
+		{"gh dne", []string{"dne"}, ""},
+		{"gh", []string{}, ""},
+		{"", []string{}, ""},
+	} {
+		args := []string{}
+		if c.Args != "" {
+			args = strings.Split(c.Args, " ")
+		}
+
+		out, err := ExpandAlias(args)
+
+		if err == nil && c.Err != "" {
+			t.Errorf("expected error %s for %s", c.Err, c.Args)
+			continue
+		}
+
+		if err != nil {
+			eq(t, err.Error(), c.Err)
+			continue
+		}
+
+		eq(t, out, c.ExpectedArgs)
+	}
+}
+
+func TestAliasSet_invalid_command(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+	_, err := RunCommand("alias set co pe checkout")
+	if err == nil {
+		t.Fatal("expected error")
+	}
+
+	eq(t, err.Error(), "could not create alias: pe checkout does not correspond to a gh command")
+}
+
+func TestAliasList_empty(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+
+	output, err := RunCommand("alias list")
+
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	eq(t, output.String(), "")
+}
+
+func TestAliasList(t *testing.T) {
+	cfg := `---
+aliases:
+  co: pr checkout
+  il: issue list --author=$1 --label=$2
+  clone: repo clone
+  prs: pr status
+  cs: config set editor 'quoted path'
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	output, err := RunCommand("alias list")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	expected := `clone	repo clone
+co	pr checkout
+cs	config set editor 'quoted path'
+il	issue list --author=$1 --label=$2
+prs	pr status
+`
+
+	eq(t, output.String(), expected)
+}
+
+func TestAliasDelete_nonexistent_command(t *testing.T) {
+	cfg := `---
+aliases:
+  co: pr checkout
+  il: issue list --author="$1" --label="$2"
+  ia: issue list --author="$1" --assignee="$1"
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	_, err := RunCommand("alias delete cool")
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+
+	eq(t, err.Error(), "no such alias cool")
+}
+
+func TestAliasDelete(t *testing.T) {
+	cfg := `---
+aliases:
+  co: pr checkout
+  il: issue list --author="$1" --label="$2"
+  ia: issue list --author="$1" --assignee="$1"
+`
+	initBlankContext(cfg, "OWNER/REPO", "trunk")
+
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	output, err := RunCommand("alias delete co")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Deleted alias co; was pr checkout")
+
+	expected := `aliases:
+    il: issue list --author="$1" --label="$2"
+    ia: issue list --author="$1" --assignee="$1"
+`
+
+	eq(t, mainBuf.String(), expected)
+}

command/completion.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/cli/cli/internal/cobrafish"
 	"github.com/cli/cli/utils"
 	"github.com/spf13/cobra"
 )
@@ -29,7 +28,7 @@ For example, for bash you could add this to your '~/.bash_profile':
 
 When installing GitHub CLI through a package manager, however, it's possible that
 no additional shell configuration is necessary to gain completion support. For
-Homebrew, see <https://docs.brew.sh/Shell-Completion>
+Homebrew, see https://docs.brew.sh/Shell-Completion
 `,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		shellType, err := cmd.Flags().GetString("shell")
@@ -58,7 +57,7 @@ Homebrew, see <https://docs.brew.sh/Shell-Completion>
 		case "powershell":
 			return RootCmd.GenPowerShellCompletion(cmd.OutOrStdout())
 		case "fish":
-			return cobrafish.GenCompletion(RootCmd, cmd.OutOrStdout())
+			return RootCmd.GenFishCompletion(cmd.OutOrStdout(), true)
 		default:
 			return fmt.Errorf("unsupported shell type %q", shellType)
 		}

command/config.go

@@ -32,7 +32,7 @@ Current respected settings:
 
 var configGetCmd = &cobra.Command{
 	Use:   "get <key>",
-	Short: "Prints the value of a given configuration key.",
+	Short: "Prints the value of a given configuration key",
 	Long: `Get the value for a given configuration key.
 
 Examples:
@@ -45,7 +45,7 @@ Examples:
 
 var configSetCmd = &cobra.Command{
 	Use:   "set <key> <value>",
-	Short: "Updates configuration with the value of a given key.",
+	Short: "Updates configuration with the value of a given key",
 	Long: `Update the configuration by setting a key to a value.
 
 Examples:

command/config_test.go

@@ -49,23 +49,31 @@ func TestConfigGet_not_found(t *testing.T) {
 func TestConfigSet(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 
-	buf := bytes.NewBufferString("")
-	defer config.StubWriteConfig(buf)()
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
 	output, err := RunCommand("config set editor ed")
 	if err != nil {
 		t.Fatalf("error running command `config set editor ed`: %v", err)
 	}
 
-	eq(t, output.String(), "")
+	if len(output.String()) > 0 {
+		t.Errorf("expected output to be blank: %q", output.String())
+	}
 
-	expected := `hosts:
-    github.com:
-        user: OWNER
-        oauth_token: 1234567890
-editor: ed
+	expectedMain := "editor: ed\n"
+	expectedHosts := `github.com:
+    user: OWNER
+    oauth_token: "1234567890"
 `
 
-	eq(t, buf.String(), expected)
+	if mainBuf.String() != expectedMain {
+		t.Errorf("expected config.yml to be %q, got %q", expectedMain, mainBuf.String())
+	}
+	if hostsBuf.String() != expectedHosts {
+		t.Errorf("expected hosts.yml to be %q, got %q", expectedHosts, hostsBuf.String())
+	}
 }
 
 func TestConfigSet_update(t *testing.T) {
@@ -79,23 +87,31 @@ editor: ed
 
 	initBlankContext(cfg, "OWNER/REPO", "master")
 
-	buf := bytes.NewBufferString("")
-	defer config.StubWriteConfig(buf)()
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
 
 	output, err := RunCommand("config set editor vim")
 	if err != nil {
 		t.Fatalf("error running command `config get editor`: %v", err)
 	}
 
-	eq(t, output.String(), "")
+	if len(output.String()) > 0 {
+		t.Errorf("expected output to be blank: %q", output.String())
+	}
 
-	expected := `hosts:
-    github.com:
-        user: OWNER
-        oauth_token: MUSTBEHIGHCUZIMATOKEN
-editor: vim
+	expectedMain := "editor: vim\n"
+	expectedHosts := `github.com:
+    user: OWNER
+    oauth_token: MUSTBEHIGHCUZIMATOKEN
 `
-	eq(t, buf.String(), expected)
+
+	if mainBuf.String() != expectedMain {
+		t.Errorf("expected config.yml to be %q, got %q", expectedMain, mainBuf.String())
+	}
+	if hostsBuf.String() != expectedHosts {
+		t.Errorf("expected hosts.yml to be %q, got %q", expectedHosts, hostsBuf.String())
+	}
 }
 
 func TestConfigGetHost(t *testing.T) {
@@ -141,23 +157,32 @@ git_protocol: ssh
 func TestConfigSetHost(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 
-	buf := bytes.NewBufferString("")
-	defer config.StubWriteConfig(buf)()
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
+
 	output, err := RunCommand("config set -hgithub.com git_protocol ssh")
 	if err != nil {
 		t.Fatalf("error running command `config set editor ed`: %v", err)
 	}
 
-	eq(t, output.String(), "")
+	if len(output.String()) > 0 {
+		t.Errorf("expected output to be blank: %q", output.String())
+	}
 
-	expected := `hosts:
-    github.com:
-        user: OWNER
-        oauth_token: 1234567890
-        git_protocol: ssh
+	expectedMain := ""
+	expectedHosts := `github.com:
+    user: OWNER
+    oauth_token: "1234567890"
+    git_protocol: ssh
 `
 
-	eq(t, buf.String(), expected)
+	if mainBuf.String() != expectedMain {
+		t.Errorf("expected config.yml to be %q, got %q", expectedMain, mainBuf.String())
+	}
+	if hostsBuf.String() != expectedHosts {
+		t.Errorf("expected hosts.yml to be %q, got %q", expectedHosts, hostsBuf.String())
+	}
 }
 
 func TestConfigSetHost_update(t *testing.T) {
@@ -171,21 +196,30 @@ hosts:
 
 	initBlankContext(cfg, "OWNER/REPO", "master")
 
-	buf := bytes.NewBufferString("")
-	defer config.StubWriteConfig(buf)()
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer config.StubWriteConfig(&mainBuf, &hostsBuf)()
 
 	output, err := RunCommand("config set -hgithub.com git_protocol https")
 	if err != nil {
 		t.Fatalf("error running command `config get editor`: %v", err)
 	}
 
-	eq(t, output.String(), "")
+	if len(output.String()) > 0 {
+		t.Errorf("expected output to be blank: %q", output.String())
+	}
 
-	expected := `hosts:
-    github.com:
-        git_protocol: https
-        user: OWNER
-        oauth_token: MUSTBEHIGHCUZIMATOKEN
+	expectedMain := ""
+	expectedHosts := `github.com:
+    git_protocol: https
+    user: OWNER
+    oauth_token: MUSTBEHIGHCUZIMATOKEN
 `
-	eq(t, buf.String(), expected)
+
+	if mainBuf.String() != expectedMain {
+		t.Errorf("expected config.yml to be %q, got %q", expectedMain, mainBuf.String())
+	}
+	if hostsBuf.String() != expectedHosts {
+		t.Errorf("expected hosts.yml to be %q, got %q", expectedHosts, hostsBuf.String())
+	}
 }

command/credits.go

@@ -41,19 +41,22 @@ func init() {
 }
 
 var creditsCmd = &cobra.Command{
-	Use:   "credits [repository]",
-	Short: "View project's credits",
-	Long: `View animated credits for this or another project.
-
-Examples:
-
-  gh credits            # see a credits animation for this project
+	Use:   "credits",
+	Short: "View credits for this tool",
+	Long:  `View animated credits for gh, the tool you are currently using :)`,
+	Example: `gh credits            # see a credits animation for this project
   gh credits owner/repo # see a credits animation for owner/repo
   gh credits -s         # display a non-animated thank you
   gh credits | cat      # just print the contributors, one per line
 `,
-	Args: cobra.MaximumNArgs(1),
-	RunE: credits,
+	Args:   cobra.ExactArgs(0),
+	RunE:   ghCredits,
+	Hidden: true,
+}
+
+func ghCredits(cmd *cobra.Command, _ []string) error {
+	args := []string{"cli/cli"}
+	return credits(cmd, args)
 }
 
 func credits(cmd *cobra.Command, args []string) error {
@@ -64,9 +67,18 @@ func credits(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	owner := "cli"
-	repo := "cli"
-	if len(args) > 0 {
+	var owner string
+	var repo string
+
+	if len(args) == 0 {
+		baseRepo, err := determineBaseRepo(client, cmd, ctx)
+		if err != nil {
+			return err
+		}
+
+		owner = baseRepo.RepoOwner()
+		repo = baseRepo.RepoName()
+	} else {
 		parts := strings.SplitN(args[0], "/", 2)
 		owner = parts[0]
 		repo = parts[1]

command/gist.go

@@ -0,0 +1,150 @@
+package command
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path"
+
+	"github.com/cli/cli/api"
+	"github.com/cli/cli/utils"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	RootCmd.AddCommand(gistCmd)
+	gistCmd.AddCommand(gistCreateCmd)
+	gistCreateCmd.Flags().StringP("desc", "d", "", "A description for this gist")
+	gistCreateCmd.Flags().BoolP("public", "p", false, "When true, the gist will be public and available for anyone to see (default: private)")
+}
+
+var gistCmd = &cobra.Command{
+	Use:   "gist",
+	Short: "Create gists",
+	Long:  `Work with GitHub gists.`,
+}
+
+var gistCreateCmd = &cobra.Command{
+	Use:   `create {<filename>|-}...`,
+	Short: "Create a new gist",
+	Long: `gh gist create: create gists
+
+Gists can be created from one or many files. This command can also read from STDIN. By default, gists are private; use --public to change this.
+
+Examples
+
+    gh gist create hello.py                   # turn file hello.py into a gist
+    gh gist create --public hello.py          # turn file hello.py into a public gist
+    gh gist create -d"a file!" hello.py       # turn file hello.py into a gist, with description
+    gh gist create hello.py world.py cool.txt # make a gist out of several files
+    gh gist create -                          # read from STDIN to create a gist
+    cat cool.txt | gh gist create             # read the output of another command and make a gist out of it
+`,
+	RunE: gistCreate,
+}
+
+type Opts struct {
+	Description string
+	Public      bool
+}
+
+func gistCreate(cmd *cobra.Command, args []string) error {
+	ctx := contextForCommand(cmd)
+	client, err := apiClientForContext(ctx)
+	if err != nil {
+		return err
+	}
+
+	// This performs a dummy query, checks what scopes we have, and then asks for a user to reauth
+	// with expanded scopes. it introduces latency whenever this command is run: a trade-off to avoid
+	// having every single user reauth as a result of this feature even if they never once use gists.
+	//
+	// In the future we'd rather have the ability to detect a "reauth needed" scenario and replay
+	// failed requests but some short spikes indicated that that would be a fair bit of work.
+	client, err = ensureScopes(ctx, client, "gist")
+	if err != nil {
+		return err
+	}
+
+	opts, err := processOpts(cmd)
+	if err != nil {
+		return fmt.Errorf("did not understand arguments: %w", err)
+	}
+
+	info, err := os.Stdin.Stat()
+	if err != nil {
+		return fmt.Errorf("failed to check STDIN: %w", err)
+	}
+	if (info.Mode() & os.ModeCharDevice) != os.ModeCharDevice {
+		args = append(args, "-")
+	}
+
+	files, err := processFiles(os.Stdin, args)
+	if err != nil {
+		return fmt.Errorf("failed to collect files for posting: %w", err)
+	}
+
+	errOut := colorableErr(cmd)
+	fmt.Fprintf(errOut, "%s Creating gist...\n", utils.Gray("-"))
+
+	gist, err := api.GistCreate(client, opts.Description, opts.Public, files)
+	if err != nil {
+		return fmt.Errorf("%s Failed to create gist: %w", utils.Red("X"), err)
+	}
+
+	fmt.Fprintf(errOut, "%s Created gist\n", utils.Green("✓"))
+
+	fmt.Fprintln(cmd.OutOrStdout(), gist.HTMLURL)
+
+	return nil
+}
+
+func processOpts(cmd *cobra.Command) (*Opts, error) {
+	description, err := cmd.Flags().GetString("desc")
+	if err != nil {
+		return nil, err
+	}
+
+	public, err := cmd.Flags().GetBool("public")
+	if err != nil {
+		return nil, err
+	}
+
+	return &Opts{
+		Description: description,
+		Public:      public,
+	}, err
+}
+
+func processFiles(stdin io.Reader, filenames []string) (map[string]string, error) {
+	fs := map[string]string{}
+
+	if len(filenames) == 0 {
+		return fs, errors.New("no filenames passed and nothing on STDIN")
+	}
+
+	for i, f := range filenames {
+		var filename string
+		var content []byte
+		var err error
+		if f == "-" {
+			filename = fmt.Sprintf("gistfile%d.txt", i)
+			content, err = ioutil.ReadAll(stdin)
+			if err != nil {
+				return fs, fmt.Errorf("failed to read from stdin: %w", err)
+			}
+		} else {
+			content, err = ioutil.ReadFile(f)
+			if err != nil {
+				return fs, fmt.Errorf("failed to read file %s: %w", f, err)
+			}
+			filename = path.Base(f)
+		}
+
+		fs[filename] = string(content)
+	}
+
+	return fs, nil
+}

command/gist_test.go

@@ -0,0 +1,52 @@
+package command
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"strings"
+	"testing"
+)
+
+func TestGistCreate(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "trunk")
+
+	http := initFakeHTTP()
+	http.StubResponse(200, bytes.NewBufferString(`
+	{
+		"html_url": "https://gist.github.com/aa5a315d61ae9438b18d"
+	}
+	`))
+
+	output, err := RunCommand(`gist create "../test/fixtures/gistCreate.json" -d "Gist description" --public`)
+	eq(t, err, nil)
+
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[0].Body)
+	reqBody := struct {
+		Description string
+		Public      bool
+		Files       map[string]struct {
+			Content string
+		}
+	}{}
+
+	err = json.Unmarshal(bodyBytes, &reqBody)
+	if err != nil {
+		t.Fatalf("unexpected json error: %s", err)
+	}
+
+	eq(t, reqBody.Description, "Gist description")
+	eq(t, reqBody.Public, true)
+	eq(t, reqBody.Files["gistCreate.json"].Content, "{}")
+	eq(t, output.String(), "https://gist.github.com/aa5a315d61ae9438b18d\n")
+}
+
+func TestGistCreate_stdin(t *testing.T) {
+	fakeStdin := strings.NewReader("hey cool how is it going")
+	files, err := processFiles(fakeStdin, []string{"-"})
+	if err != nil {
+		t.Fatalf("unexpected error processing files: %s", err)
+	}
+
+	eq(t, files["gistfile0.txt"], "hey cool how is it going")
+}

command/issue.go

@@ -73,14 +73,9 @@ var issueStatusCmd = &cobra.Command{
 	RunE:  issueStatus,
 }
 var issueViewCmd = &cobra.Command{
-	Use: "view {<number> | <url>}",
-	Args: func(cmd *cobra.Command, args []string) error {
-		if len(args) < 1 {
-			return FlagError{errors.New("issue number or URL required as argument")}
-		}
-		return nil
-	},
+	Use:   "view {<number> | <url>}",
 	Short: "View an issue",
+	Args:  cobra.ExactArgs(1),
 	Long: `Display the title, body, and other information about an issue.
 
 With '--web', open the issue in a web browser instead.`,
@@ -88,13 +83,13 @@ With '--web', open the issue in a web browser instead.`,
 }
 var issueCloseCmd = &cobra.Command{
 	Use:   "close {<number> | <url>}",
-	Short: "close issue",
+	Short: "Close issue",
 	Args:  cobra.ExactArgs(1),
 	RunE:  issueClose,
 }
 var issueReopenCmd = &cobra.Command{
 	Use:   "reopen {<number> | <url>}",
-	Short: "reopen issue",
+	Short: "Reopen issue",
 	Args:  cobra.ExactArgs(1),
 	RunE:  issueReopen,
 }
@@ -106,7 +101,7 @@ func issueList(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}
@@ -167,12 +162,12 @@ func issueStatus(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}
 
-	currentUser, err := ctx.AuthLogin()
+	currentUser, err := api.CurrentLoginName(apiClient)
 	if err != nil {
 		return err
 	}
@@ -224,7 +219,7 @@ func issueView(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}
@@ -340,9 +335,13 @@ func issueFromArg(apiClient *api.Client, baseRepo ghrepo.Interface, arg string)
 
 func issueCreate(cmd *cobra.Command, args []string) error {
 	ctx := contextForCommand(cmd)
+	apiClient, err := apiClientForContext(ctx)
+	if err != nil {
+		return err
+	}
 
 	// NB no auto forking like over in pr create
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}
@@ -392,11 +391,14 @@ func issueCreate(cmd *cobra.Command, args []string) error {
 		// TODO: move URL generation into GitHubRepository
 		openURL := fmt.Sprintf("https://github.com/%s/issues/new", ghrepo.FullName(baseRepo))
 		if title != "" || body != "" {
-			openURL += fmt.Sprintf(
-				"?title=%s&body=%s",
-				url.QueryEscape(title),
-				url.QueryEscape(body),
-			)
+			milestone := ""
+			if len(milestoneTitles) > 0 {
+				milestone = milestoneTitles[0]
+			}
+			openURL, err = withPrAndIssueQueryParams(openURL, title, body, assignees, labelNames, projectNames, milestone)
+			if err != nil {
+				return err
+			}
 		} else if len(nonLegacyTemplateFiles) > 1 {
 			openURL += "/choose"
 		}
@@ -406,11 +408,6 @@ func issueCreate(cmd *cobra.Command, args []string) error {
 
 	fmt.Fprintf(colorableErr(cmd), "\nCreating issue in %s\n\n", ghrepo.FullName(baseRepo))
 
-	apiClient, err := apiClientForContext(ctx)
-	if err != nil {
-		return err
-	}
-
 	repo, err := api.GitHubRepo(apiClient, baseRepo)
 	if err != nil {
 		return err
@@ -464,12 +461,15 @@ func issueCreate(cmd *cobra.Command, args []string) error {
 	}
 
 	if action == PreviewAction {
-		openURL := fmt.Sprintf(
-			"https://github.com/%s/issues/new/?title=%s&body=%s",
-			ghrepo.FullName(baseRepo),
-			url.QueryEscape(title),
-			url.QueryEscape(body),
-		)
+		openURL := fmt.Sprintf("https://github.com/%s/issues/new/", ghrepo.FullName(baseRepo))
+		milestone := ""
+		if len(milestoneTitles) > 0 {
+			milestone = milestoneTitles[0]
+		}
+		openURL, err = withPrAndIssueQueryParams(openURL, title, body, assignees, labelNames, projectNames, milestone)
+		if err != nil {
+			return err
+		}
 		// TODO could exceed max url length for explorer
 		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", displayURL(openURL))
 		return utils.OpenInBrowser(openURL)
@@ -662,7 +662,7 @@ func issueClose(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}
@@ -697,7 +697,7 @@ func issueReopen(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}

command/issue_test.go

@@ -20,6 +20,9 @@ func TestIssueStatus(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.Register(
+		httpmock.GraphQL(`\bviewer\b`),
+		httpmock.StringResponse(`{"data":{"viewer":{"login":"octocat"}}}`))
 
 	jsonFile, _ := os.Open("../test/fixtures/issueStatus.json")
 	defer jsonFile.Close()
@@ -49,6 +52,9 @@ func TestIssueStatus_blankSlate(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.Register(
+		httpmock.GraphQL(`\bviewer\b`),
+		httpmock.StringResponse(`{"data":{"viewer":{"login":"octocat"}}}`))
 
 	http.StubResponse(200, bytes.NewBufferString(`
 	{ "data": { "repository": {
@@ -86,6 +92,9 @@ func TestIssueStatus_disabledIssues(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.Register(
+		httpmock.GraphQL(`\bviewer\b`),
+		httpmock.StringResponse(`{"data":{"viewer":{"login":"octocat"}}}`))
 
 	http.StubResponse(200, bytes.NewBufferString(`
 	{ "data": { "repository": {
@@ -637,7 +646,7 @@ func TestIssueCreate_webTitleBody(t *testing.T) {
 		t.Fatal("expected a command to run")
 	}
 	url := strings.ReplaceAll(seenCmd.Args[len(seenCmd.Args)-1], "^", "")
-	eq(t, url, "https://github.com/OWNER/REPO/issues/new?title=mytitle&body=mybody")
+	eq(t, url, "https://github.com/OWNER/REPO/issues/new?body=mybody&title=mytitle")
 	eq(t, output.String(), "Opening github.com/OWNER/REPO/issues/new in your browser.\n")
 }
 

command/pr.go

@@ -1,6 +1,7 @@
 package command
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"regexp"
@@ -8,6 +9,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/context"
 	"github.com/cli/cli/git"
@@ -26,9 +28,11 @@ func init() {
 	prCmd.AddCommand(prCloseCmd)
 	prCmd.AddCommand(prReopenCmd)
 	prCmd.AddCommand(prMergeCmd)
-	prMergeCmd.Flags().BoolP("merge", "m", true, "Merge the commits with the base branch")
+	prMergeCmd.Flags().BoolP("delete-branch", "d", true, "Delete the local and remote branch after merge")
+	prMergeCmd.Flags().BoolP("merge", "m", false, "Merge the commits with the base branch")
 	prMergeCmd.Flags().BoolP("rebase", "r", false, "Rebase the commits onto the base branch")
 	prMergeCmd.Flags().BoolP("squash", "s", false, "Squash the commits into one commit and merge it into the base branch")
+	prCmd.AddCommand(prReadyCmd)
 
 	prCmd.AddCommand(prListCmd)
 	prListCmd.Flags().IntP("limit", "L", 30, "Maximum number of items to fetch")
@@ -84,13 +88,18 @@ var prReopenCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	RunE:  prReopen,
 }
-
 var prMergeCmd = &cobra.Command{
 	Use:   "merge [<number> | <url> | <branch>]",
 	Short: "Merge a pull request",
 	Args:  cobra.MaximumNArgs(1),
 	RunE:  prMerge,
 }
+var prReadyCmd = &cobra.Command{
+	Use:   "ready [<number> | <url> | <branch>]",
+	Short: "Mark a pull request as ready for review",
+	Args:  cobra.MaximumNArgs(1),
+	RunE:  prReady,
+}
 
 func prStatus(cmd *cobra.Command, args []string) error {
 	ctx := contextForCommand(cmd)
@@ -99,12 +108,7 @@ func prStatus(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	currentUser, err := ctx.AuthLogin()
-	if err != nil {
-		return err
-	}
-
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}
@@ -116,6 +120,8 @@ func prStatus(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("could not query for pull request for current branch: %w", err)
 	}
 
+	// the `@me` macro is available because the API lookup is ElasticSearch-based
+	currentUser := "@me"
 	prPayload, err := api.PullRequests(apiClient, baseRepo, currentPRNumber, currentPRHeadRef, currentUser)
 	if err != nil {
 		return err
@@ -168,7 +174,7 @@ func prList(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 	if err != nil {
 		return err
 	}
@@ -296,59 +302,16 @@ func prView(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	var baseRepo ghrepo.Interface
-	var prArg string
-	if len(args) > 0 {
-		prArg = args[0]
-		if prNum, repo := prFromURL(prArg); repo != nil {
-			prArg = prNum
-			baseRepo = repo
-		}
-	}
-
-	if baseRepo == nil {
-		baseRepo, err = determineBaseRepo(cmd, ctx)
-		if err != nil {
-			return err
-		}
-	}
-
 	web, err := cmd.Flags().GetBool("web")
 	if err != nil {
 		return err
 	}
 
-	var openURL string
-	var pr *api.PullRequest
-	if len(args) > 0 {
-		pr, err = prFromArg(apiClient, baseRepo, prArg)
-		if err != nil {
-			return err
-		}
-		openURL = pr.URL
-	} else {
-		prNumber, branchWithOwner, err := prSelectorForCurrentBranch(ctx, baseRepo)
-		if err != nil {
-			return err
-		}
-
-		if prNumber > 0 {
-			openURL = fmt.Sprintf("https://github.com/%s/pull/%d", ghrepo.FullName(baseRepo), prNumber)
-			if !web {
-				pr, err = api.PullRequestByNumber(apiClient, baseRepo, prNumber)
-				if err != nil {
-					return err
-				}
-			}
-		} else {
-			pr, err = api.PullRequestForBranch(apiClient, baseRepo, "", branchWithOwner)
-			if err != nil {
-				return err
-			}
-
-			openURL = pr.URL
-		}
+	pr, _, err := prFromArgs(ctx, apiClient, cmd, args)
+	if err != nil {
+		return err
 	}
+	openURL := pr.URL
 
 	if web {
 		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", openURL)
@@ -366,12 +329,7 @@ func prClose(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
-	if err != nil {
-		return err
-	}
-
-	pr, err := prFromArg(apiClient, baseRepo, args[0])
+	pr, baseRepo, err := prFromArgs(ctx, apiClient, cmd, args)
 	if err != nil {
 		return err
 	}
@@ -401,12 +359,7 @@ func prReopen(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
-	if err != nil {
-		return err
-	}
-
-	pr, err := prFromArg(apiClient, baseRepo, args[0])
+	pr, baseRepo, err := prFromArgs(ctx, apiClient, cmd, args)
 	if err != nil {
 		return err
 	}
@@ -438,68 +391,186 @@ func prMerge(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	baseRepo, err := determineBaseRepo(cmd, ctx)
+	pr, baseRepo, err := prFromArgs(ctx, apiClient, cmd, args)
 	if err != nil {
 		return err
 	}
 
-	var pr *api.PullRequest
-	if len(args) > 0 {
-		pr, err = prFromArg(apiClient, baseRepo, args[0])
-		if err != nil {
-			return err
-		}
-	} else {
-		prNumber, branchWithOwner, err := prSelectorForCurrentBranch(ctx, baseRepo)
-		if err != nil {
-			return err
-		}
-
-		if prNumber != 0 {
-			pr, err = api.PullRequestByNumber(apiClient, baseRepo, prNumber)
-		} else {
-			pr, err = api.PullRequestForBranch(apiClient, baseRepo, "", branchWithOwner)
-		}
-		if err != nil {
-			return err
-		}
-	}
-
-	if pr.State == "MERGED" {
+	if pr.Mergeable == "CONFLICTING" {
+		err := fmt.Errorf("%s Pull request #%d has conflicts and isn't mergeable ", utils.Red("!"), pr.Number)
+		return err
+	} else if pr.Mergeable == "UNKNOWN" {
+		err := fmt.Errorf("%s Pull request #%d can't be merged right now; try again in a few seconds", utils.Red("!"), pr.Number)
+		return err
+	} else if pr.State == "MERGED" {
 		err := fmt.Errorf("%s Pull request #%d was already merged", utils.Red("!"), pr.Number)
 		return err
 	}
 
-	rebase, err := cmd.Flags().GetBool("rebase")
-	if err != nil {
-		return err
-	}
-	squash, err := cmd.Flags().GetBool("squash")
+	var mergeMethod api.PullRequestMergeMethod
+	deleteBranch, err := cmd.Flags().GetBool("delete-branch")
 	if err != nil {
 		return err
 	}
 
-	var output string
-	if rebase {
-		output = fmt.Sprintf("%s Rebased and merged pull request #%d\n", utils.Green("✔"), pr.Number)
+	deleteLocalBranch := !cmd.Flags().Changed("repo")
+	crossRepoPR := pr.HeadRepositoryOwner.Login != baseRepo.RepoOwner()
+
+	// Ensure only one merge method is specified
+	enabledFlagCount := 0
+	isInteractive := false
+	if b, _ := cmd.Flags().GetBool("merge"); b {
+		enabledFlagCount++
+		mergeMethod = api.PullRequestMergeMethodMerge
+	}
+	if b, _ := cmd.Flags().GetBool("rebase"); b {
+		enabledFlagCount++
+		mergeMethod = api.PullRequestMergeMethodRebase
+	}
+	if b, _ := cmd.Flags().GetBool("squash"); b {
+		enabledFlagCount++
+		mergeMethod = api.PullRequestMergeMethodSquash
+	}
+
+	if enabledFlagCount == 0 {
+		isInteractive = true
+	} else if enabledFlagCount > 1 {
+		return errors.New("expected exactly one of --merge, --rebase, or --squash to be true")
+	}
+
+	if isInteractive {
+		mergeMethod, deleteBranch, err = prInteractiveMerge(deleteLocalBranch, crossRepoPR)
+		if err != nil {
+			return nil
+		}
+	}
+
+	var action string
+	if mergeMethod == api.PullRequestMergeMethodRebase {
+		action = "Rebased and merged"
 		err = api.PullRequestMerge(apiClient, baseRepo, pr, api.PullRequestMergeMethodRebase)
-	} else if squash {
-		output = fmt.Sprintf("%s Squashed and merged pull request #%d\n", utils.Green("✔"), pr.Number)
+	} else if mergeMethod == api.PullRequestMergeMethodSquash {
+		action = "Squashed and merged"
 		err = api.PullRequestMerge(apiClient, baseRepo, pr, api.PullRequestMergeMethodSquash)
-	} else {
-		output = fmt.Sprintf("%s Merged pull request #%d\n", utils.Green("✔"), pr.Number)
+	} else if mergeMethod == api.PullRequestMergeMethodMerge {
+		action = "Merged"
 		err = api.PullRequestMerge(apiClient, baseRepo, pr, api.PullRequestMergeMethodMerge)
+	} else {
+		err = fmt.Errorf("unknown merge method (%d) used", mergeMethod)
+		return err
 	}
 
 	if err != nil {
 		return fmt.Errorf("API call failed: %w", err)
 	}
 
-	fmt.Fprint(colorableOut(cmd), output)
+	fmt.Fprintf(colorableOut(cmd), "%s %s pull request #%d\n", utils.Magenta("✔"), action, pr.Number)
+
+	if deleteBranch {
+		repo, err := api.GitHubRepo(apiClient, baseRepo)
+		if err != nil {
+			return err
+		}
+
+		currentBranch, err := ctx.Branch()
+		if err != nil {
+			return err
+		}
+
+		branchSwitchString := ""
+
+		if deleteLocalBranch && !crossRepoPR {
+			var branchToSwitchTo string
+			if currentBranch == pr.HeadRefName {
+				branchToSwitchTo = repo.DefaultBranchRef.Name
+				err = git.CheckoutBranch(repo.DefaultBranchRef.Name)
+				if err != nil {
+					return err
+				}
+			}
+
+			localBranchExists := git.HasLocalBranch(pr.HeadRefName)
+			if localBranchExists {
+				err = git.DeleteLocalBranch(pr.HeadRefName)
+				if err != nil {
+					err = fmt.Errorf("failed to delete local branch %s: %w", utils.Cyan(pr.HeadRefName), err)
+					return err
+				}
+			}
+
+			if branchToSwitchTo != "" {
+				branchSwitchString = fmt.Sprintf(" and switched to branch %s", utils.Cyan(branchToSwitchTo))
+			}
+		}
+
+		if !crossRepoPR {
+			err = api.BranchDeleteRemote(apiClient, baseRepo, pr.HeadRefName)
+			if err != nil {
+				err = fmt.Errorf("failed to delete remote branch %s: %w", utils.Cyan(pr.HeadRefName), err)
+				return err
+			}
+		}
+
+		fmt.Fprintf(colorableOut(cmd), "%s Deleted branch %s%s\n", utils.Red("✔"), utils.Cyan(pr.HeadRefName), branchSwitchString)
+	}
 
 	return nil
 }
 
+func prInteractiveMerge(deleteLocalBranch bool, crossRepoPR bool) (api.PullRequestMergeMethod, bool, error) {
+	mergeMethodQuestion := &survey.Question{
+		Name: "mergeMethod",
+		Prompt: &survey.Select{
+			Message: "What merge method would you like to use?",
+			Options: []string{"Create a merge commit", "Rebase and merge", "Squash and merge"},
+			Default: "Create a merge commit",
+		},
+	}
+
+	qs := []*survey.Question{mergeMethodQuestion}
+
+	if !crossRepoPR {
+		var message string
+		if deleteLocalBranch {
+			message = "Delete the branch locally and on GitHub?"
+		} else {
+			message = "Delete the branch on GitHub?"
+		}
+
+		deleteBranchQuestion := &survey.Question{
+			Name: "deleteBranch",
+			Prompt: &survey.Confirm{
+				Message: message,
+				Default: true,
+			},
+		}
+		qs = append(qs, deleteBranchQuestion)
+	}
+
+	answers := struct {
+		MergeMethod  int
+		DeleteBranch bool
+	}{}
+
+	err := SurveyAsk(qs, &answers)
+	if err != nil {
+		return 0, false, fmt.Errorf("could not prompt: %w", err)
+	}
+
+	var mergeMethod api.PullRequestMergeMethod
+	switch answers.MergeMethod {
+	case 0:
+		mergeMethod = api.PullRequestMergeMethodMerge
+	case 1:
+		mergeMethod = api.PullRequestMergeMethodRebase
+	case 2:
+		mergeMethod = api.PullRequestMergeMethodSquash
+	}
+
+	deleteBranch := answers.DeleteBranch
+	return mergeMethod, deleteBranch, nil
+}
+
 func printPrPreview(out io.Writer, pr *api.PullRequest) error {
 	// Header (Title and State)
 	fmt.Fprintln(out, utils.Bold(pr.Title))
@@ -551,12 +622,44 @@ func printPrPreview(out io.Writer, pr *api.PullRequest) error {
 	return nil
 }
 
+func prReady(cmd *cobra.Command, args []string) error {
+	ctx := contextForCommand(cmd)
+	apiClient, err := apiClientForContext(ctx)
+	if err != nil {
+		return err
+	}
+
+	pr, baseRepo, err := prFromArgs(ctx, apiClient, cmd, args)
+	if err != nil {
+		return err
+	}
+
+	if pr.Closed {
+		err := fmt.Errorf("%s Pull request #%d is closed. Only draft pull requests can be marked as \"ready for review\"", utils.Red("!"), pr.Number)
+		return err
+	} else if !pr.IsDraft {
+		fmt.Fprintf(colorableErr(cmd), "%s Pull request #%d is already \"ready for review\"\n", utils.Yellow("!"), pr.Number)
+		return nil
+	}
+
+	err = api.PullRequestReady(apiClient, baseRepo, pr)
+	if err != nil {
+		return fmt.Errorf("API call failed: %w", err)
+	}
+
+	fmt.Fprintf(colorableErr(cmd), "%s Pull request #%d is marked as \"ready for review\"\n", utils.Green("✔"), pr.Number)
+
+	return nil
+}
+
 // Ref. https://developer.github.com/v4/enum/pullrequestreviewstate/
 const (
 	requestedReviewState        = "REQUESTED" // This is our own state for review request
 	approvedReviewState         = "APPROVED"
 	changesRequestedReviewState = "CHANGES_REQUESTED"
 	commentedReviewState        = "COMMENTED"
+	dismissedReviewState        = "DISMISSED"
+	pendingReviewState          = "PENDING"
 )
 
 type reviewerState struct {
@@ -582,8 +685,14 @@ func colorFuncForReviewerState(state string) func(string) string {
 
 // formattedReviewerState formats a reviewerState with state color
 func formattedReviewerState(reviewer *reviewerState) string {
-	stateColorFunc := colorFuncForReviewerState(reviewer.State)
-	return fmt.Sprintf("%s (%s)", reviewer.Name, stateColorFunc(strings.ReplaceAll(strings.Title(strings.ToLower(reviewer.State)), "_", " ")))
+	state := reviewer.State
+	if state == dismissedReviewState {
+		// Show "DISMISSED" review as "COMMENTED", since "dimissed" only makes
+		// sense when displayed in an events timeline but not in the final tally.
+		state = commentedReviewState
+	}
+	stateColorFunc := colorFuncForReviewerState(state)
+	return fmt.Sprintf("%s (%s)", reviewer.Name, stateColorFunc(strings.ReplaceAll(strings.Title(strings.ToLower(state)), "_", " ")))
 }
 
 // prReviewerList generates a reviewer list with their last state
@@ -639,6 +748,9 @@ func parseReviewers(pr api.PullRequest) []*reviewerState {
 	// Convert map to slice for ease of sort
 	result := make([]*reviewerState, 0, len(reviewerStates))
 	for _, reviewer := range reviewerStates {
+		if reviewer.State == pendingReviewState {
+			continue
+		}
 		result = append(result, reviewer)
 	}
 
@@ -716,23 +828,6 @@ func prProjectList(pr api.PullRequest) string {
 	return list
 }
 
-var prURLRE = regexp.MustCompile(`^https://github\.com/([^/]+)/([^/]+)/pull/(\d+)`)
-
-func prFromURL(arg string) (string, ghrepo.Interface) {
-	if m := prURLRE.FindStringSubmatch(arg); m != nil {
-		return m[3], ghrepo.New(m[1], m[2])
-	}
-	return "", nil
-}
-
-func prFromArg(apiClient *api.Client, baseRepo ghrepo.Interface, arg string) (*api.PullRequest, error) {
-	if prNumber, err := strconv.Atoi(strings.TrimPrefix(arg, "#")); err == nil {
-		return api.PullRequestByNumber(apiClient, baseRepo, prNumber)
-	}
-
-	return api.PullRequestForBranch(apiClient, baseRepo, "", arg)
-}
-
 func prSelectorForCurrentBranch(ctx context.Context, baseRepo ghrepo.Interface) (prNumber int, prHeadRef string, err error) {
 	prHeadRef, err = ctx.Branch()
 	if err != nil {

command/pr_checkout.go

@@ -26,21 +26,7 @@ func prCheckout(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	var baseRepo ghrepo.Interface
-	prArg := args[0]
-	if prNum, repo := prFromURL(prArg); repo != nil {
-		prArg = prNum
-		baseRepo = repo
-	}
-
-	if baseRepo == nil {
-		baseRepo, err = determineBaseRepo(cmd, ctx)
-		if err != nil {
-			return err
-		}
-	}
-
-	pr, err := prFromArg(apiClient, baseRepo, prArg)
+	pr, baseRepo, err := prFromArgs(ctx, apiClient, cmd, args)
 	if err != nil {
 		return err
 	}
@@ -59,6 +45,7 @@ func prCheckout(cmd *cobra.Command, args []string) error {
 
 	var cmdQueue [][]string
 	newBranchName := pr.HeadRefName
+
 	if headRemote != nil {
 		// there is an existing git remote for PR head
 		remoteBranch := fmt.Sprintf("%s/%s", headRemote.Name, pr.HeadRefName)

command/pr_checkout_test.go

@@ -76,7 +76,6 @@ func TestPRCheckout_urlArg(t *testing.T) {
 		return ctx
 	}
 	http := initFakeHTTP()
-
 	http.StubResponse(200, bytes.NewBufferString(`
 	{ "data": { "repository": { "pullRequest": {
 		"number": 123,
@@ -125,7 +124,6 @@ func TestPRCheckout_urlArg_differentBase(t *testing.T) {
 		return ctx
 	}
 	http := initFakeHTTP()
-
 	http.StubResponse(200, bytes.NewBufferString(`
 	{ "data": { "repository": { "pullRequest": {
 		"number": 123,

command/pr_create.go

@@ -252,6 +252,9 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	if isDraft && isWeb {
 		return errors.New("the --draft flag is not supported with --web")
 	}
+	if len(reviewers) > 0 && isWeb {
+		return errors.New("the --reviewer flag is not supported with --web")
+	}
 
 	didForkRepo := false
 	// if a head repository could not be determined so far, automatically create
@@ -339,7 +342,14 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 
 		fmt.Fprintln(cmd.OutOrStdout(), pr.URL)
 	} else if action == PreviewAction {
-		openURL := generateCompareURL(baseRepo, baseBranch, headBranchLabel, title, body)
+		milestone := ""
+		if len(milestoneTitles) > 0 {
+			milestone = milestoneTitles[0]
+		}
+		openURL, err := generateCompareURL(baseRepo, baseBranch, headBranchLabel, title, body, assignees, labelNames, projectNames, milestone)
+		if err != nil {
+			return err
+		}
 		// TODO could exceed max url length for explorer
 		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", displayURL(openURL))
 		return utils.OpenInBrowser(openURL)
@@ -391,20 +401,46 @@ func determineTrackingBranch(remotes context.Remotes, headBranch string) *git.Tr
 	return nil
 }
 
-func generateCompareURL(r ghrepo.Interface, base, head, title, body string) string {
+func withPrAndIssueQueryParams(baseURL, title, body string, assignees, labels, projects []string, milestone string) (string, error) {
+	u, err := url.Parse(baseURL)
+	if err != nil {
+		return "", nil
+	}
+	q := u.Query()
+	if title != "" {
+		q.Set("title", title)
+	}
+	if body != "" {
+		q.Set("body", body)
+	}
+	if len(assignees) > 0 {
+		q.Set("assignees", strings.Join(assignees, ","))
+	}
+	if len(labels) > 0 {
+		q.Set("labels", strings.Join(labels, ","))
+	}
+	if len(projects) > 0 {
+		q.Set("projects", strings.Join(projects, ","))
+	}
+	if milestone != "" {
+		q.Set("milestone", milestone)
+	}
+	u.RawQuery = q.Encode()
+	return u.String(), nil
+}
+
+func generateCompareURL(r ghrepo.Interface, base, head, title, body string, assignees, labels, projects []string, milestone string) (string, error) {
 	u := fmt.Sprintf(
 		"https://github.com/%s/compare/%s...%s?expand=1",
 		ghrepo.FullName(r),
 		base,
 		head,
 	)
-	if title != "" {
-		u += "&title=" + url.QueryEscape(title)
+	url, err := withPrAndIssueQueryParams(u, title, body, assignees, labels, projects, milestone)
+	if err != nil {
+		return "", err
 	}
-	if body != "" {
-		u += "&body=" + url.QueryEscape(body)
-	}
-	return u
+	return url, nil
 }
 
 var prCreateCmd = &cobra.Command{

command/pr_diff.go

@@ -0,0 +1,104 @@
+package command
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/cli/cli/utils"
+	"github.com/spf13/cobra"
+)
+
+var prDiffCmd = &cobra.Command{
+	Use:   "diff {<number> | <url>}",
+	Short: "View a pull request's changes.",
+	RunE:  prDiff,
+}
+
+func init() {
+	prDiffCmd.Flags().StringP("color", "c", "auto", "Whether or not to output color: {always|never|auto}")
+
+	prCmd.AddCommand(prDiffCmd)
+}
+
+func prDiff(cmd *cobra.Command, args []string) error {
+	color, err := cmd.Flags().GetString("color")
+	if err != nil {
+		return err
+	}
+	if !validColorFlag(color) {
+		return fmt.Errorf("did not understand color: %q. Expected one of always, never, or auto", color)
+	}
+
+	ctx := contextForCommand(cmd)
+	apiClient, err := apiClientForContext(ctx)
+	if err != nil {
+		return err
+	}
+
+	pr, baseRepo, err := prFromArgs(ctx, apiClient, cmd, args)
+	if err != nil {
+		return fmt.Errorf("could not find pull request: %w", err)
+	}
+
+	diff, err := apiClient.PullRequestDiff(baseRepo, pr.Number)
+	if err != nil {
+		return fmt.Errorf("could not find pull request diff: %w", err)
+	}
+
+	out := cmd.OutOrStdout()
+	if color == "auto" {
+		color = "never"
+		isTTY := false
+		if outFile, isFile := out.(*os.File); isFile {
+			isTTY = utils.IsTerminal(outFile)
+			if isTTY {
+				color = "always"
+			}
+		}
+	}
+
+	if color == "never" {
+		fmt.Fprint(out, diff)
+		return nil
+	}
+
+	out = colorableOut(cmd)
+	for _, diffLine := range strings.Split(diff, "\n") {
+		output := diffLine
+		switch {
+		case isHeaderLine(diffLine):
+			output = utils.Bold(diffLine)
+		case isAdditionLine(diffLine):
+			output = utils.Green(diffLine)
+		case isRemovalLine(diffLine):
+			output = utils.Red(diffLine)
+		}
+
+		fmt.Fprintln(out, output)
+	}
+
+	return nil
+}
+
+func isHeaderLine(dl string) bool {
+	prefixes := []string{"+++", "---", "diff", "index"}
+	for _, p := range prefixes {
+		if strings.HasPrefix(dl, p) {
+			return true
+		}
+	}
+	return false
+}
+
+func isAdditionLine(dl string) bool {
+	return strings.HasPrefix(dl, "+")
+}
+
+func isRemovalLine(dl string) bool {
+	return strings.HasPrefix(dl, "-")
+}
+
+func validColorFlag(c string) bool {
+	return c == "auto" || c == "always" || c == "never"
+}

command/pr_diff_test.go

@@ -0,0 +1,104 @@
+package command
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestPRDiff_validation(t *testing.T) {
+	_, err := RunCommand("pr diff --color=doublerainbow")
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	eq(t, err.Error(), `did not understand color: "doublerainbow". Expected one of always, never, or auto`)
+}
+
+func TestPRDiff_no_current_pr(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes": [
+			{ "url": "https://github.com/OWNER/REPO/pull/123",
+			  "number": 123,
+			  "id": "foobar123",
+			  "headRefName": "feature",
+				"baseRefName": "master" }
+		] } } } }`))
+	http.StubResponse(200, bytes.NewBufferString(testDiff))
+	_, err := RunCommand("pr diff")
+	if err == nil {
+		t.Fatal("expected error", err)
+	}
+	eq(t, err.Error(), `could not find pull request: no open pull requests found for branch "master"`)
+}
+
+func TestPRDiff_argument_not_found(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": {
+		"pullRequest": { "number": 123 }
+	} } }
+`))
+	http.StubResponse(404, bytes.NewBufferString(""))
+	_, err := RunCommand("pr diff 123")
+	if err == nil {
+		t.Fatal("expected error", err)
+	}
+	eq(t, err.Error(), `could not find pull request diff: pull request not found`)
+}
+
+func TestPRDiff(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "feature")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes": [
+			{ "url": "https://github.com/OWNER/REPO/pull/123",
+			  "number": 123,
+			  "id": "foobar123",
+			  "headRefName": "feature",
+				"baseRefName": "master" }
+		] } } } }`))
+	http.StubResponse(200, bytes.NewBufferString(testDiff))
+	output, err := RunCommand("pr diff")
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	eq(t, output.String(), testDiff)
+}
+
+const testDiff = `diff --git a/.github/workflows/releases.yml b/.github/workflows/releases.yml
+index 73974448..b7fc0154 100644
+--- a/.github/workflows/releases.yml
++++ b/.github/workflows/releases.yml
+@@ -44,6 +44,11 @@ jobs:
+           token: ${{secrets.SITE_GITHUB_TOKEN}}
+       - name: Publish documentation site
+         if: "!contains(github.ref, '-')" # skip prereleases
++        env:
++          GIT_COMMITTER_NAME: cli automation
++          GIT_AUTHOR_NAME: cli automation
++          GIT_COMMITTER_EMAIL: noreply@github.com
++          GIT_AUTHOR_EMAIL: noreply@github.com
+         run: make site-publish
+       - name: Move project cards
+         if: "!contains(github.ref, '-')" # skip prereleases
+diff --git a/Makefile b/Makefile
+index f2b4805c..3d7bd0f9 100644
+--- a/Makefile
++++ b/Makefile
+@@ -22,8 +22,8 @@ test:
+ 	go test ./...
+ .PHONY: test
+ 
+-site:
+-	git clone https://github.com/github/cli.github.com.git "$@"
++site: bin/gh
++	bin/gh repo clone github/cli.github.com "$@"
+ 
+ site-docs: site
+ 	git -C site pull
+`

command/pr_lookup.go

@@ -0,0 +1,109 @@
+package command
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/cli/cli/api"
+	"github.com/cli/cli/context"
+	"github.com/cli/cli/git"
+	"github.com/cli/cli/internal/ghrepo"
+	"github.com/spf13/cobra"
+)
+
+func prFromArgs(ctx context.Context, apiClient *api.Client, cmd *cobra.Command, args []string) (*api.PullRequest, ghrepo.Interface, error) {
+	if len(args) == 1 {
+		// First check to see if the prString is a url, return repo from url if found. This
+		// is run first because we don't need to run determineBaseRepo for this path
+		prString := args[0]
+		pr, r, err := prFromURL(ctx, apiClient, prString)
+		if pr != nil || err != nil {
+			return pr, r, err
+		}
+	}
+
+	repo, err := determineBaseRepo(apiClient, cmd, ctx)
+	if err != nil {
+		return nil, nil, fmt.Errorf("could not determine base repo: %w", err)
+	}
+
+	// If there are no args see if we can guess the PR from the current branch
+	if len(args) == 0 {
+		pr, err := prForCurrentBranch(ctx, apiClient, repo)
+		return pr, repo, err
+	} else {
+		prString := args[0]
+		// Next see if the prString is a number and use that to look up the url
+		pr, err := prFromNumberString(ctx, apiClient, repo, prString)
+		if pr != nil || err != nil {
+			return pr, repo, err
+		}
+
+		// Last see if it is a branch name
+		pr, err = api.PullRequestForBranch(apiClient, repo, "", prString)
+		return pr, repo, err
+	}
+}
+
+func prFromNumberString(ctx context.Context, apiClient *api.Client, repo ghrepo.Interface, s string) (*api.PullRequest, error) {
+	if prNumber, err := strconv.Atoi(strings.TrimPrefix(s, "#")); err == nil {
+		return api.PullRequestByNumber(apiClient, repo, prNumber)
+	}
+
+	return nil, nil
+}
+
+func prFromURL(ctx context.Context, apiClient *api.Client, s string) (*api.PullRequest, ghrepo.Interface, error) {
+	r := regexp.MustCompile(`^https://github\.com/([^/]+)/([^/]+)/pull/(\d+)`)
+	if m := r.FindStringSubmatch(s); m != nil {
+		repo := ghrepo.New(m[1], m[2])
+		prNumberString := m[3]
+		pr, err := prFromNumberString(ctx, apiClient, repo, prNumberString)
+		return pr, repo, err
+	}
+
+	return nil, nil, nil
+}
+
+func prForCurrentBranch(ctx context.Context, apiClient *api.Client, repo ghrepo.Interface) (*api.PullRequest, error) {
+	prHeadRef, err := ctx.Branch()
+	if err != nil {
+		return nil, err
+	}
+
+	branchConfig := git.ReadBranchConfig(prHeadRef)
+
+	// the branch is configured to merge a special PR head ref
+	prHeadRE := regexp.MustCompile(`^refs/pull/(\d+)/head$`)
+	if m := prHeadRE.FindStringSubmatch(branchConfig.MergeRef); m != nil {
+		return prFromNumberString(ctx, apiClient, repo, m[1])
+	}
+
+	var branchOwner string
+	if branchConfig.RemoteURL != nil {
+		// the branch merges from a remote specified by URL
+		if r, err := ghrepo.FromURL(branchConfig.RemoteURL); err == nil {
+			branchOwner = r.RepoOwner()
+		}
+	} else if branchConfig.RemoteName != "" {
+		// the branch merges from a remote specified by name
+		rem, _ := ctx.Remotes()
+		if r, err := rem.FindByName(branchConfig.RemoteName); err == nil {
+			branchOwner = r.RepoOwner()
+		}
+	}
+
+	if branchOwner != "" {
+		if strings.HasPrefix(branchConfig.MergeRef, "refs/heads/") {
+			prHeadRef = strings.TrimPrefix(branchConfig.MergeRef, "refs/heads/")
+		}
+		// prepend `OWNER:` if this branch is pushed to a fork
+		if !strings.EqualFold(branchOwner, repo.RepoOwner()) {
+			prHeadRef = fmt.Sprintf("%s:%s", branchOwner, prHeadRef)
+		}
+	}
+
+	return api.PullRequestForBranch(apiClient, repo, "", prHeadRef)
+}

command/pr_review.go

@@ -3,8 +3,6 @@ package command
 import (
 	"errors"
 	"fmt"
-	"strconv"
-	"strings"
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
@@ -24,7 +22,7 @@ func init() {
 }
 
 var prReviewCmd = &cobra.Command{
-	Use:   "review [{<number> | <url> | <branch>]",
+	Use:   "review [<number> | <url> | <branch>]",
 	Short: "Add a review to a pull request.",
 	Args:  cobra.MaximumNArgs(1),
 	Long: `Add a review to either a specified pull request or the pull request associated with the current branch.
@@ -86,35 +84,14 @@ func processReviewOpt(cmd *cobra.Command) (*api.PullRequestReviewInput, error) {
 
 func prReview(cmd *cobra.Command, args []string) error {
 	ctx := contextForCommand(cmd)
-	baseRepo, err := determineBaseRepo(cmd, ctx)
-	if err != nil {
-		return fmt.Errorf("could not determine base repo: %w", err)
-	}
-
 	apiClient, err := apiClientForContext(ctx)
 	if err != nil {
 		return err
 	}
 
-	var prNum int
-	branchWithOwner := ""
-
-	if len(args) == 0 {
-		prNum, branchWithOwner, err = prSelectorForCurrentBranch(ctx, baseRepo)
-		if err != nil {
-			return fmt.Errorf("could not query for pull request for current branch: %w", err)
-		}
-	} else {
-		prArg, repo := prFromURL(args[0])
-		if repo != nil {
-			baseRepo = repo
-		} else {
-			prArg = strings.TrimPrefix(args[0], "#")
-		}
-		prNum, err = strconv.Atoi(prArg)
-		if err != nil {
-			return errors.New("could not parse pull request argument")
-		}
+	pr, _, err := prFromArgs(ctx, apiClient, cmd, args)
+	if err != nil {
+		return err
 	}
 
 	reviewData, err := processReviewOpt(cmd)
@@ -122,20 +99,6 @@ func prReview(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("did not understand desired review action: %w", err)
 	}
 
-	var pr *api.PullRequest
-	if prNum > 0 {
-		pr, err = api.PullRequestByNumber(apiClient, baseRepo, prNum)
-		if err != nil {
-			return fmt.Errorf("could not find pull request: %w", err)
-		}
-	} else {
-		pr, err = api.PullRequestForBranch(apiClient, baseRepo, "", branchWithOwner)
-		if err != nil {
-			return fmt.Errorf("could not find pull request: %w", err)
-		}
-		prNum = pr.Number
-	}
-
 	out := colorableOut(cmd)
 
 	if reviewData == nil {
@@ -156,11 +119,11 @@ func prReview(cmd *cobra.Command, args []string) error {
 
 	switch reviewData.State {
 	case api.ReviewComment:
-		fmt.Fprintf(out, "%s Reviewed pull request #%d\n", utils.Gray("-"), prNum)
+		fmt.Fprintf(out, "%s Reviewed pull request #%d\n", utils.Gray("-"), pr.Number)
 	case api.ReviewApprove:
-		fmt.Fprintf(out, "%s Approved pull request #%d\n", utils.Green("✓"), prNum)
+		fmt.Fprintf(out, "%s Approved pull request #%d\n", utils.Green("✓"), pr.Number)
 	case api.ReviewRequestChanges:
-		fmt.Fprintf(out, "%s Requested changes to pull request #%d\n", utils.Red("+"), prNum)
+		fmt.Fprintf(out, "%s Requested changes to pull request #%d\n", utils.Red("+"), pr.Number)
 	}
 
 	return nil

command/pr_review_test.go

@@ -18,6 +18,11 @@ func TestPRReview_validation(t *testing.T) {
 		`pr review --approve --comment -b"hey" 123`,
 	} {
 		http.StubRepoResponse("OWNER", "REPO")
+		http.StubResponse(200, bytes.NewBufferString(`
+			{ "data": { "repository": {
+				"pullRequest": { "number": 123 }
+			} } }
+		`))
 		_, err := RunCommand(cmd)
 		if err == nil {
 			t.Fatal("expected error")
@@ -30,7 +35,12 @@ func TestPRReview_bad_body(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
-	_, err := RunCommand(`pr review -b "radical"`)
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": {
+			"pullRequest": { "number": 123 }
+		} } }
+	`))
+	_, err := RunCommand(`pr review 123 -b "radical"`)
 	if err == nil {
 		t.Fatal("expected error")
 	}
@@ -40,7 +50,6 @@ func TestPRReview_bad_body(t *testing.T) {
 func TestPRReview_url_arg(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
-	http.StubRepoResponse("OWNER", "REPO")
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequest": {
 			"id": "foobar123",
@@ -67,7 +76,7 @@ func TestPRReview_url_arg(t *testing.T) {
 
 	test.ExpectLines(t, output.String(), "Approved pull request #123")
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[1].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -173,6 +182,11 @@ func TestPRReview_blank_comment(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": {
+			"pullRequest": { "number": 123 }
+		} } }
+	`))
 
 	_, err := RunCommand(`pr review --comment 123`)
 	eq(t, err.Error(), "did not understand desired review action: body cannot be blank for comment review")
@@ -182,6 +196,11 @@ func TestPRReview_blank_request_changes(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": {
+			"pullRequest": { "number": 123 }
+		} } }
+	`))
 
 	_, err := RunCommand(`pr review -r 123`)
 	eq(t, err.Error(), "did not understand desired review action: body cannot be blank for request-changes review")

command/pr_test.go

@@ -477,7 +477,7 @@ func TestPRView_Preview(t *testing.T) {
 			fixture:   "../test/fixtures/prViewPreviewWithReviewersByNumber.json",
 			expectedOutputs: []string{
 				`Blueberries are from a fork`,
-				`Reviewers: DEF \(Commented\), def \(Changes requested\), ghost \(Approved\), xyz \(Approved\), 123 \(Requested\), Team 1 \(Requested\), abc \(Requested\)\n`,
+				`Reviewers: DEF \(Commented\), def \(Changes requested\), ghost \(Approved\), hubot \(Commented\), xyz \(Approved\), 123 \(Requested\), Team 1 \(Requested\), abc \(Requested\)\n`,
 				`blueberries taste good`,
 				`View this pull request on GitHub: https://github.com/OWNER/REPO/pull/12\n`,
 			},
@@ -722,11 +722,10 @@ func TestPRView_web_numberArgWithHash(t *testing.T) {
 func TestPRView_web_urlArg(t *testing.T) {
 	initBlankContext("", "OWNER/REPO", "master")
 	http := initFakeHTTP()
-
 	http.StubResponse(200, bytes.NewBufferString(`
-	{ "data": { "repository": { "pullRequest": {
-		"url": "https://github.com/OWNER/REPO/pull/23"
-	} } } }
+		{ "data": { "repository": { "pullRequest": {
+			"url": "https://github.com/OWNER/REPO/pull/23"
+		} } } }
 	`))
 
 	var seenCmd *exec.Cmd
@@ -982,10 +981,10 @@ func initWithStubs(branch string, stubs ...stubResponse) {
 	initBlankContext("", "OWNER/REPO", branch)
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
-
 	for _, s := range stubs {
 		http.StubResponse(s.ResponseCode, s.ResponseBody)
 	}
+	http.StubRepoResponse("OWNER", "REPO")
 }
 
 func TestPrMerge(t *testing.T) {
@@ -994,9 +993,19 @@ func TestPrMerge(t *testing.T) {
 			"pullRequest": { "number": 1, "closed": false, "state": "OPEN"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
-	output, err := RunCommand("pr merge 1")
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("branch.blueberries.remote origin\nbranch.blueberries.merge refs/heads/blueberries") // git config --get-regexp ^branch\.master\.(remote|merge)
+	cs.Stub("")                                                                                  // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("")                                                                                  // git symbolic-ref --quiet --short HEAD
+	cs.Stub("")                                                                                  // git checkout master
+	cs.Stub("")
+
+	output, err := RunCommand("pr merge 1 --merge")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
 	}
@@ -1008,11 +1017,96 @@ func TestPrMerge(t *testing.T) {
 	}
 }
 
+func TestPrMerge_withRepoFlag(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubResponse(200, bytes.NewBufferString(`{ "data": { "repository": {
+		"pullRequest": { "number": 1, "closed": false, "state": "OPEN"}
+		} } }`))
+	http.StubResponse(200, bytes.NewBufferString(`{ "data": {} }`))
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`{"node_id": "THE-ID"}`))
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	eq(t, len(cs.Calls), 0)
+
+	output, err := RunCommand("pr merge 1 --merge -R stinky/boi")
+	if err != nil {
+		t.Fatalf("error running command `pr merge`: %v", err)
+	}
+
+	r := regexp.MustCompile(`Merged pull request #1`)
+
+	if !r.MatchString(output.String()) {
+		t.Fatalf("output did not match regexp /%s/\n> output\n%q\n", r, output.Stderr())
+	}
+}
+
+func TestPrMerge_deleteBranch(t *testing.T) {
+	initWithStubs("blueberries",
+		stubResponse{200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes": [
+			{ "headRefName": "blueberries", "id": "THE-ID", "number": 3}
+		] } } } }`)},
+		stubResponse{200, bytes.NewBufferString(`{ "data": {} }`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
+	)
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git rev-parse --verify blueberries`
+	cs.Stub("") // git branch -d
+	cs.Stub("") // git push origin --delete blueberries
+
+	output, err := RunCommand(`pr merge --merge --delete-branch`)
+	if err != nil {
+		t.Fatalf("Got unexpected error running `pr merge` %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Merged pull request #3", "Deleted branch blueberries")
+}
+
+func TestPrMerge_deleteNonCurrentBranch(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "another-branch")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "pullRequests": { "nodes": [
+		{ "headRefName": "blueberries", "id": "THE-ID", "number": 3}
+	] } } } }`))
+	http.StubResponse(200, bytes.NewBufferString(`{ "data": {} }`))
+	http.StubResponse(200, bytes.NewBufferString(`{"node_id": "THE-ID"}`))
+	http.StubRepoResponse("OWNER", "REPO")
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+	// We don't expect the default branch to be checked out, just that blueberries is deleted
+	cs.Stub("") // git rev-parse --verify blueberries
+	cs.Stub("") // git branch -d blueberries
+	cs.Stub("") // git push origin --delete blueberries
+
+	output, err := RunCommand(`pr merge --merge --delete-branch blueberries`)
+	if err != nil {
+		t.Fatalf("Got unexpected error running `pr merge` %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Merged pull request #3", "Deleted branch blueberries")
+}
+
 func TestPrMerge_noPrNumberGiven(t *testing.T) {
 	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
 	cs.Stub("branch.blueberries.remote origin\nbranch.blueberries.merge refs/heads/blueberries") // git config --get-regexp ^branch\.master\.(remote|merge)
+	cs.Stub("")                                                                                  // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("")                                                                                  // git symbolic-ref --quiet --short HEAD
+	cs.Stub("")                                                                                  // git checkout master
+	cs.Stub("")                                                                                  // git branch -d
 
 	jsonFile, _ := os.Open("../test/fixtures/prViewPreviewWithMetadataByBranch.json")
 	defer jsonFile.Close()
@@ -1020,9 +1114,10 @@ func TestPrMerge_noPrNumberGiven(t *testing.T) {
 	initWithStubs("blueberries",
 		stubResponse{200, jsonFile},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
-	output, err := RunCommand("pr merge")
+	output, err := RunCommand("pr merge --merge")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
 	}
@@ -1040,8 +1135,17 @@ func TestPrMerge_rebase(t *testing.T) {
 			"pullRequest": { "number": 2, "closed": false, "state": "OPEN"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git branch -d
+
 	output, err := RunCommand("pr merge 2 --rebase")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
@@ -1060,8 +1164,17 @@ func TestPrMerge_squash(t *testing.T) {
 			"pullRequest": { "number": 3, "closed": false, "state": "OPEN"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git branch -d
+
 	output, err := RunCommand("pr merge 3 --squash")
 	if err != nil {
 		t.Fatalf("error running command `pr merge`: %v", err)
@@ -1080,8 +1193,17 @@ func TestPrMerge_alreadyMerged(t *testing.T) {
 			"pullRequest": { "number": 4, "closed": true, "state": "MERGED"}
 		} } }`)},
 		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
 	)
 
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git branch -d
+
 	output, err := RunCommand("pr merge 4")
 	if err == nil {
 		t.Fatalf("expected an error running command `pr merge`: %v", err)
@@ -1093,3 +1215,126 @@ func TestPrMerge_alreadyMerged(t *testing.T) {
 		t.Fatalf("output did not match regexp /%s/\n> output\n%q\n", r, output.Stderr())
 	}
 }
+
+func TestPRMerge_interactive(t *testing.T) {
+	initWithStubs("blueberries",
+		stubResponse{200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes": [
+			{ "headRefName": "blueberries", "headRepositoryOwner": {"login": "OWNER"}, "id": "THE-ID", "number": 3}
+		] } } } }`)},
+		stubResponse{200, bytes.NewBufferString(`{"node_id": "THE-ID"}`)},
+		stubResponse{200, bytes.NewBufferString(`{ "data": {} }`)})
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("") // git config --get-regexp ^branch\.blueberries\.(remote|merge)$
+	cs.Stub("") // git symbolic-ref --quiet --short HEAD
+	cs.Stub("") // git checkout master
+	cs.Stub("") // git push origin --delete blueberries
+	cs.Stub("") // git branch -d
+
+	as, surveyTeardown := initAskStubber()
+	defer surveyTeardown()
+
+	as.Stub([]*QuestionStub{
+		{
+			Name:  "mergeMethod",
+			Value: 0,
+		},
+		{
+			Name:  "deleteBranch",
+			Value: true,
+		},
+	})
+
+	output, err := RunCommand(`pr merge`)
+	if err != nil {
+		t.Fatalf("Got unexpected error running `pr merge` %s", err)
+	}
+
+	test.ExpectLines(t, output.String(), "Merged pull request #3", "Deleted branch blueberries")
+}
+
+func TestPrMerge_multipleMergeMethods(t *testing.T) {
+	initWithStubs("master",
+		stubResponse{200, bytes.NewBufferString(`{ "data": { "repository": {
+			"pullRequest": { "number": 1, "closed": false, "state": "OPEN"}
+		} } }`)},
+		stubResponse{200, bytes.NewBufferString(`{"id": "THE-ID"}`)},
+	)
+
+	_, err := RunCommand("pr merge 1 --merge --squash")
+	if err == nil {
+		t.Fatal("expected error running `pr merge` with multiple merge methods")
+	}
+}
+
+func TestPRReady(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": {
+		"pullRequest": { "number": 444, "closed": false, "isDraft": true}
+	} } }
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`{"id": "THE-ID"}`))
+
+	output, err := RunCommand("pr ready 444")
+	if err != nil {
+		t.Fatalf("error running command `pr ready`: %v", err)
+	}
+
+	r := regexp.MustCompile(`Pull request #444 is marked as "ready for review"`)
+
+	if !r.MatchString(output.Stderr()) {
+		t.Fatalf("output did not match regexp /%s/\n> output\n%q\n", r, output.Stderr())
+	}
+}
+
+func TestPRReady_alreadyReady(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": {
+		"pullRequest": { "number": 445, "closed": false, "isDraft": false}
+	} } }
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`{"id": "THE-ID"}`))
+
+	output, err := RunCommand("pr ready 445")
+	if err != nil {
+		t.Fatalf("error running command `pr ready`: %v", err)
+	}
+
+	r := regexp.MustCompile(`Pull request #445 is already "ready for review"`)
+
+	if !r.MatchString(output.Stderr()) {
+		t.Fatalf("output did not match regexp /%s/\n> output\n%q\n", r, output.Stderr())
+	}
+}
+
+func TestPRReady_closed(t *testing.T) {
+	initBlankContext("", "OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": {
+		"pullRequest": { "number": 446, "closed": true, "isDraft": true}
+	} } }
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`{"id": "THE-ID"}`))
+
+	_, err := RunCommand("pr ready 446")
+	if err == nil {
+		t.Fatalf("expected an error running command `pr ready` on a review that is closed!: %v", err)
+	}
+
+	r := regexp.MustCompile(`Pull request #446 is closed. Only draft pull requests can be marked as "ready for review"`)
+
+	if !r.MatchString(err.Error()) {
+		t.Fatalf("output did not match regexp /%s/\n> output\n%q\n", r, err.Error())
+	}
+}

command/repo.go

@@ -38,6 +38,9 @@ func init() {
 
 	repoCmd.AddCommand(repoViewCmd)
 	repoViewCmd.Flags().BoolP("web", "w", false, "Open a repository in the browser")
+
+	repoCmd.AddCommand(repoCreditsCmd)
+	repoCreditsCmd.Flags().BoolP("static", "s", false, "Print a static version of the credits")
 }
 
 var repoCmd = &cobra.Command{
@@ -56,6 +59,9 @@ var repoCloneCmd = &cobra.Command{
 	Short: "Clone a repository locally",
 	Long: `Clone a GitHub repository locally.
 
+If the "OWNER/" portion of the "OWNER/REPO" repository argument is omitted, it
+defaults to the name of the authenticating user.
+
 To pass 'git clone' flags, separate them with '--'.`,
 	RunE: repoClone,
 }
@@ -89,6 +95,19 @@ With '--web', open the repository in a web browser instead.`,
 	RunE: repoView,
 }
 
+var repoCreditsCmd = &cobra.Command{
+	Use:   "credits [<repository>]",
+	Short: "View credits for a repository",
+	Example: `$ gh repo credits           # view credits for the current repository
+$ gh repo credits cool/repo # view credits for cool/repo
+$ gh repo credits -s        # print a non-animated thank you
+$ gh repo credits | cat     # pipe to just print the contributors, one per line
+`,
+	Args:   cobra.MaximumNArgs(1),
+	RunE:   repoCredits,
+	Hidden: true,
+}
+
 func parseCloneArgs(extraArgs []string) (args []string, target string) {
 	args = extraArgs
 
@@ -125,8 +144,21 @@ func runClone(cloneURL string, args []string) (target string, err error) {
 }
 
 func repoClone(cmd *cobra.Command, args []string) error {
+	ctx := contextForCommand(cmd)
+	apiClient, err := apiClientForContext(ctx)
+	if err != nil {
+		return err
+	}
+
 	cloneURL := args[0]
 	if !strings.Contains(cloneURL, ":") {
+		if !strings.Contains(cloneURL, "/") {
+			currentUser, err := api.CurrentLoginName(apiClient)
+			if err != nil {
+				return err
+			}
+			cloneURL = currentUser + "/" + cloneURL
+		}
 		cloneURL = formatRemoteURL(cmd, cloneURL)
 	}
 
@@ -140,12 +172,6 @@ func repoClone(cmd *cobra.Command, args []string) error {
 	}
 
 	if repo != nil {
-		ctx := contextForCommand(cmd)
-		apiClient, err := apiClientForContext(ctx)
-		if err != nil {
-			return err
-		}
-
 		parentRepo, err = api.RepoParent(apiClient, repo)
 		if err != nil {
 			return err
@@ -189,7 +215,10 @@ func repoCreate(cmd *cobra.Command, args []string) error {
 	if len(args) > 0 {
 		name = args[0]
 		if strings.Contains(name, "/") {
-			newRepo := ghrepo.FromFullName(name)
+			newRepo, err := ghrepo.FromFullName(name)
+			if err != nil {
+				return fmt.Errorf("argument error: %w", err)
+			}
 			orgName = newRepo.RepoOwner()
 			name = newRepo.RepoName()
 		}
@@ -336,7 +365,7 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	var repoToFork ghrepo.Interface
 	inParent := false // whether or not we're forking the repo we're currently "in"
 	if len(args) == 0 {
-		baseRepo, err := determineBaseRepo(cmd, ctx)
+		baseRepo, err := determineBaseRepo(apiClient, cmd, ctx)
 		if err != nil {
 			return fmt.Errorf("unable to determine base repository: %w", err)
 		}
@@ -366,9 +395,9 @@ func repoFork(cmd *cobra.Command, args []string) error {
 				return fmt.Errorf("did not understand argument: %w", err)
 			}
 		} else {
-			repoToFork = ghrepo.FromFullName(repoArg)
-			if repoToFork.RepoName() == "" || repoToFork.RepoOwner() == "" {
-				return fmt.Errorf("could not parse owner or repo name from %s", repoArg)
+			repoToFork, err = ghrepo.FromFullName(repoArg)
+			if err != nil {
+				return fmt.Errorf("argument error: %w", err)
 			}
 		}
 	}
@@ -487,11 +516,15 @@ var Confirm = func(prompt string, result *bool) error {
 
 func repoView(cmd *cobra.Command, args []string) error {
 	ctx := contextForCommand(cmd)
+	apiClient, err := apiClientForContext(ctx)
+	if err != nil {
+		return err
+	}
 
 	var toView ghrepo.Interface
 	if len(args) == 0 {
 		var err error
-		toView, err = determineBaseRepo(cmd, ctx)
+		toView, err = determineBaseRepo(apiClient, cmd, ctx)
 		if err != nil {
 			return err
 		}
@@ -508,14 +541,14 @@ func repoView(cmd *cobra.Command, args []string) error {
 				return fmt.Errorf("did not understand argument: %w", err)
 			}
 		} else {
-			toView = ghrepo.FromFullName(repoArg)
+			var err error
+			toView, err = ghrepo.FromFullName(repoArg)
+			if err != nil {
+				return fmt.Errorf("argument error: %w", err)
+			}
 		}
 	}
 
-	apiClient, err := apiClientForContext(ctx)
-	if err != nil {
-		return err
-	}
 	repo, err := api.GitHubRepo(apiClient, toView)
 	if err != nil {
 		return err
@@ -580,3 +613,7 @@ func repoView(cmd *cobra.Command, args []string) error {
 
 	return nil
 }
+
+func repoCredits(cmd *cobra.Command, args []string) error {
+	return credits(cmd, args)
+}

command/repo_test.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/cli/cli/context"
 	"github.com/cli/cli/internal/run"
+	"github.com/cli/cli/pkg/httpmock"
 	"github.com/cli/cli/test"
 	"github.com/cli/cli/utils"
 )
@@ -508,6 +509,37 @@ func TestRepoClone_hasParent(t *testing.T) {
 	eq(t, strings.Join(cs.Calls[1].Args, " "), "git -C REPO remote add -f upstream https://github.com/hubot/ORIG.git")
 }
 
+func TestRepo_withoutUsername(t *testing.T) {
+	http := initFakeHTTP()
+	http.Register(
+		httpmock.GraphQL(`\bviewer\b`),
+		httpmock.StringResponse(`
+		{ "data": { "viewer": {
+			"login": "OWNER"
+		}}}`))
+	http.Register(
+		httpmock.GraphQL(`\brepository\(`),
+		httpmock.StringResponse(`
+		{ "data": { "repository": {
+			"parent": null
+		} } }`))
+
+	cs, restore := test.InitCmdStubber()
+	defer restore()
+
+	cs.Stub("") // git clone
+
+	output, err := RunCommand("repo clone REPO")
+	if err != nil {
+		t.Fatalf("error running command `repo clone`: %v", err)
+	}
+
+	eq(t, output.String(), "")
+	eq(t, output.Stderr(), "")
+	eq(t, cs.Count, 1)
+	eq(t, strings.Join(cs.Calls[0].Args, " "), "git clone https://github.com/OWNER/REPO.git")
+}
+
 func TestRepoCreate(t *testing.T) {
 	ctx := context.NewBlank()
 	ctx.SetBranch("master")

command/root.go

@@ -1,8 +1,10 @@
 package command
 
 import (
+	"errors"
 	"fmt"
 	"io"
+	"net/http"
 	"os"
 	"regexp"
 	"runtime/debug"
@@ -12,7 +14,11 @@ import (
 	"github.com/cli/cli/context"
 	"github.com/cli/cli/internal/config"
 	"github.com/cli/cli/internal/ghrepo"
+	apiCmd "github.com/cli/cli/pkg/cmd/api"
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
 	"github.com/cli/cli/utils"
+	"github.com/google/shlex"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -59,21 +65,26 @@ func init() {
 		if err == pflag.ErrHelp {
 			return err
 		}
-		return &FlagError{Err: err}
+		return &cmdutil.FlagError{Err: err}
 	})
-}
 
-// FlagError is the kind of error raised in flag processing
-type FlagError struct {
-	Err error
-}
-
-func (fe FlagError) Error() string {
-	return fe.Err.Error()
-}
-
-func (fe FlagError) Unwrap() error {
-	return fe.Err
+	// TODO: iron out how a factory incorporates context
+	cmdFactory := &cmdutil.Factory{
+		IOStreams: iostreams.System(),
+		HttpClient: func() (*http.Client, error) {
+			token := os.Getenv("GITHUB_TOKEN")
+			if len(token) == 0 {
+				ctx := context.New()
+				var err error
+				token, err = ctx.AuthToken()
+				if err != nil {
+					return nil, err
+				}
+			}
+			return httpClient(token), nil
+		},
+	}
+	RootCmd.AddCommand(apiCmd.NewCmdApi(cmdFactory, nil))
 }
 
 // RootCmd is the entry point of command-line execution
@@ -100,6 +111,9 @@ var initContext = func() context.Context {
 	if repo := os.Getenv("GH_REPO"); repo != "" {
 		ctx.SetBaseRepo(repo)
 	}
+	if token := os.Getenv("GITHUB_TOKEN"); token != "" {
+		ctx.SetAuthToken(token)
+	}
 	return ctx
 }
 
@@ -112,11 +126,15 @@ func BasicClient() (*api.Client, error) {
 	}
 	opts = append(opts, api.AddHeader("User-Agent", fmt.Sprintf("GitHub CLI %s", Version)))
 
-	if c, err := config.ParseDefaultConfig(); err == nil {
-		if token, _ := c.Get(defaultHostname, "oauth_token"); token != "" {
-			opts = append(opts, api.AddHeader("Authorization", fmt.Sprintf("token %s", token)))
+	token := os.Getenv("GITHUB_TOKEN")
+	if token == "" {
+		if c, err := config.ParseDefaultConfig(); err == nil {
+			token, _ = c.Get(defaultHostname, "oauth_token")
 		}
 	}
+	if token != "" {
+		opts = append(opts, api.AddHeader("Authorization", fmt.Sprintf("token %s", token)))
+	}
 	return api.NewClient(opts...), nil
 }
 
@@ -128,6 +146,19 @@ func contextForCommand(cmd *cobra.Command) context.Context {
 	return ctx
 }
 
+// for cmdutil-powered commands
+func httpClient(token string) *http.Client {
+	var opts []api.ClientOption
+	if verbose := os.Getenv("DEBUG"); verbose != "" {
+		opts = append(opts, apiVerboseLog())
+	}
+	opts = append(opts,
+		api.AddHeader("Authorization", fmt.Sprintf("token %s", token)),
+		api.AddHeader("User-Agent", fmt.Sprintf("GitHub CLI %s", Version)),
+	)
+	return api.NewHTTPClient(opts...)
+}
+
 // overridden in tests
 var apiClientForContext = func(ctx context.Context) (*api.Client, error) {
 	token, err := ctx.AuthToken()
@@ -144,30 +175,30 @@ var apiClientForContext = func(ctx context.Context) (*api.Client, error) {
 		return fmt.Sprintf("token %s", token)
 	}
 
+	tokenFromEnv := func() bool {
+		return os.Getenv("GITHUB_TOKEN") == token
+	}
+
 	checkScopesFunc := func(appID string) error {
-		if config.IsGitHubApp(appID) && utils.IsTerminal(os.Stdin) && utils.IsTerminal(os.Stderr) {
-			newToken, loginHandle, err := config.AuthFlow("Notice: additional authorization required")
-			if err != nil {
-				return err
-			}
+		if config.IsGitHubApp(appID) && !tokenFromEnv() && utils.IsTerminal(os.Stdin) && utils.IsTerminal(os.Stderr) {
 			cfg, err := ctx.Config()
 			if err != nil {
 				return err
 			}
-			_ = cfg.Set(defaultHostname, "oauth_token", newToken)
-			_ = cfg.Set(defaultHostname, "user", loginHandle)
-			// update config file on disk
-			err = cfg.Write()
+			newToken, err := config.AuthFlowWithConfig(cfg, defaultHostname, "Notice: additional authorization required")
 			if err != nil {
 				return err
 			}
 			// update configuration in memory
 			token = newToken
-			config.AuthFlowComplete()
 		} else {
 			fmt.Fprintln(os.Stderr, "Warning: gh now requires the `read:org` OAuth scope.")
 			fmt.Fprintln(os.Stderr, "Visit https://github.com/settings/tokens and edit your token to enable `read:org`")
-			fmt.Fprintln(os.Stderr, "or generate a new token and paste it via `gh config set -h github.com oauth_token MYTOKEN`")
+			if tokenFromEnv() {
+				fmt.Fprintln(os.Stderr, "or generate a new token for the GITHUB_TOKEN environment variable")
+			} else {
+				fmt.Fprintln(os.Stderr, "or generate a new token and paste it via `gh config set -h github.com oauth_token MYTOKEN`")
+			}
 		}
 		return nil
 	}
@@ -183,6 +214,46 @@ var apiClientForContext = func(ctx context.Context) (*api.Client, error) {
 	return api.NewClient(opts...), nil
 }
 
+var ensureScopes = func(ctx context.Context, client *api.Client, wantedScopes ...string) (*api.Client, error) {
+	hasScopes, appID, err := client.HasScopes(wantedScopes...)
+	if err != nil {
+		return client, err
+	}
+
+	if hasScopes {
+		return client, nil
+	}
+
+	tokenFromEnv := len(os.Getenv("GITHUB_TOKEN")) > 0
+
+	if config.IsGitHubApp(appID) && !tokenFromEnv && utils.IsTerminal(os.Stdin) && utils.IsTerminal(os.Stderr) {
+		cfg, err := ctx.Config()
+		if err != nil {
+			return nil, err
+		}
+		_, err = config.AuthFlowWithConfig(cfg, defaultHostname, "Notice: additional authorization required")
+		if err != nil {
+			return nil, err
+		}
+
+		reloadedClient, err := apiClientForContext(ctx)
+		if err != nil {
+			return client, err
+		}
+		return reloadedClient, nil
+	} else {
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("Warning: gh now requires %s OAuth scopes.", wantedScopes))
+		fmt.Fprintln(os.Stderr, fmt.Sprintf("Visit https://github.com/settings/tokens and edit your token to enable %s", wantedScopes))
+		if tokenFromEnv {
+			fmt.Fprintln(os.Stderr, "or generate a new token for the GITHUB_TOKEN environment variable")
+		} else {
+			fmt.Fprintln(os.Stderr, "or generate a new token and paste it via `gh config set -h github.com oauth_token MYTOKEN`")
+		}
+		return client, errors.New("Unable to reauthenticate")
+	}
+
+}
+
 func apiVerboseLog() api.ClientOption {
 	logTraffic := strings.Contains(os.Getenv("DEBUG"), "api")
 	colorize := utils.IsTerminal(os.Stderr)
@@ -216,15 +287,14 @@ func changelogURL(version string) string {
 	return url
 }
 
-func determineBaseRepo(cmd *cobra.Command, ctx context.Context) (ghrepo.Interface, error) {
+func determineBaseRepo(apiClient *api.Client, cmd *cobra.Command, ctx context.Context) (ghrepo.Interface, error) {
 	repo, err := cmd.Flags().GetString("repo")
 	if err == nil && repo != "" {
-		return ghrepo.FromFullName(repo), nil
-	}
-
-	apiClient, err := apiClientForContext(ctx)
-	if err != nil {
-		return nil, err
+		baseRepo, err := ghrepo.FromFullName(repo)
+		if err != nil {
+			return nil, fmt.Errorf("argument error: %w", err)
+		}
+		return baseRepo, nil
 	}
 
 	baseOverride, err := cmd.Flags().GetString("repo")
@@ -250,9 +320,33 @@ func determineBaseRepo(cmd *cobra.Command, ctx context.Context) (ghrepo.Interfac
 	return baseRepo, nil
 }
 
-func rootHelpFunc(command *cobra.Command, s []string) {
+func rootHelpFunc(command *cobra.Command, args []string) {
 	if command != RootCmd {
-		cobraDefaultHelpFunc(command, s)
+		// Display helpful error message in case subcommand name was mistyped.
+		// This matches Cobra's behavior for root command, which Cobra
+		// confusingly doesn't apply to nested commands.
+		if command.Parent() == RootCmd && len(args) >= 2 {
+			if command.SuggestionsMinimumDistance <= 0 {
+				command.SuggestionsMinimumDistance = 2
+			}
+			candidates := command.SuggestionsFor(args[1])
+
+			errOut := command.OutOrStderr()
+			fmt.Fprintf(errOut, "unknown command %q for %q\n", args[1], "gh "+args[0])
+
+			if len(candidates) > 0 {
+				fmt.Fprint(errOut, "\nDid you mean this?\n")
+				for _, c := range candidates {
+					fmt.Fprintf(errOut, "\t%s\n", c)
+				}
+				fmt.Fprint(errOut, "\n")
+			}
+
+			oldOut := command.OutOrStdout()
+			command.SetOut(errOut)
+			defer command.SetOut(oldOut)
+		}
+		cobraDefaultHelpFunc(command, args)
 		return
 	}
 
@@ -271,7 +365,7 @@ func rootHelpFunc(command *cobra.Command, s []string) {
 		s := "  " + rpad(c.Name()+":", c.NamePadding()) + c.Short
 		if includes(coreCommandNames, c.Name()) {
 			coreCommands = append(coreCommands, s)
-		} else if c != creditsCmd {
+		} else if !c.Hidden {
 			additionalCommands = append(additionalCommands, s)
 		}
 	}
@@ -290,9 +384,9 @@ func rootHelpFunc(command *cobra.Command, s []string) {
   $ gh pr checkout 321`},
 		{"LEARN MORE", `
   Use "gh <command> <subcommand> --help" for more information about a command.
-  Read the manual at <http://cli.github.com/manual>`},
+  Read the manual at http://cli.github.com/manual`},
 		{"FEEDBACK", `
-  Fill out our feedback form <https://forms.gle/umxd3h31c7aMQFKG7>
+  Fill out our feedback form https://forms.gle/umxd3h31c7aMQFKG7
   Open an issue using “gh issue create -R cli/cli”`},
 	}
 
@@ -352,3 +446,48 @@ func determineEditor(cmd *cobra.Command) (string, error) {
 
 	return editorCommand, nil
 }
+
+func ExpandAlias(args []string) ([]string, error) {
+	empty := []string{}
+	if len(args) < 2 {
+		// the command is lacking a subcommand
+		return empty, nil
+	}
+
+	ctx := initContext()
+	cfg, err := ctx.Config()
+	if err != nil {
+		return empty, err
+	}
+	aliases, err := cfg.Aliases()
+	if err != nil {
+		return empty, err
+	}
+
+	expansion, ok := aliases.Get(args[1])
+	if ok {
+		extraArgs := []string{}
+		for i, a := range args[2:] {
+			if !strings.Contains(expansion, "$") {
+				extraArgs = append(extraArgs, a)
+			} else {
+				expansion = strings.ReplaceAll(expansion, fmt.Sprintf("$%d", i+1), a)
+			}
+		}
+		lingeringRE := regexp.MustCompile(`\$\d`)
+		if lingeringRE.MatchString(expansion) {
+			return empty, fmt.Errorf("not enough arguments for alias: %s", expansion)
+		}
+
+		newArgs, err := shlex.Split(expansion)
+		if err != nil {
+			return nil, err
+		}
+
+		newArgs = append(newArgs, extraArgs...)
+
+		return newArgs, nil
+	}
+
+	return args[1:], nil
+}

command/testing.go

@@ -19,7 +19,7 @@ import (
 const defaultTestConfig = `hosts:
   github.com:
     user: OWNER
-    oauth_token: 1234567890
+    oauth_token: "1234567890"
 `
 
 type askStubber struct {
@@ -88,7 +88,7 @@ func initBlankContext(cfg, repo, branch string) {
 
 		// NOTE we are not restoring the original readConfig; we never want to touch the config file on
 		// disk during tests.
-		config.StubConfig(cfg)
+		config.StubConfig(cfg, "")
 
 		return ctx
 	}
@@ -96,6 +96,9 @@ func initBlankContext(cfg, repo, branch string) {
 
 func initFakeHTTP() *httpmock.Registry {
 	http := &httpmock.Registry{}
+	ensureScopes = func(ctx context.Context, client *api.Client, wantedScopes ...string) (*api.Client, error) {
+		return client, nil
+	}
 	apiClientForContext = func(context.Context) (*api.Client, error) {
 		return api.NewClient(api.ReplaceTripper(http)), nil
 	}

command/title_body_survey.go

@@ -180,6 +180,7 @@ func titleBodySurvey(cmd *cobra.Command, issueState *issueMetadataState, apiClie
 	bodyQuestion := &survey.Question{
 		Name: "body",
 		Prompt: &surveyext.GhEditor{
+			BlankAllowed:  true,
 			EditorCommand: editorCommand,
 			Editor: &survey.Editor{
 				Message:       "Body",
@@ -279,6 +280,13 @@ func titleBodySurvey(cmd *cobra.Command, issueState *issueMetadataState, apiClie
 			milestones = append(milestones, m.Title)
 		}
 
+		type metadataValues struct {
+			Reviewers []string
+			Assignees []string
+			Labels    []string
+			Projects  []string
+			Milestone string
+		}
 		var mqs []*survey.Question
 		if isChosen("Reviewers") {
 			if len(users) > 0 || len(teams) > 0 {
@@ -338,7 +346,7 @@ func titleBodySurvey(cmd *cobra.Command, issueState *issueMetadataState, apiClie
 		}
 		if isChosen("Milestone") {
 			if len(milestones) > 1 {
-				var milestoneDefault interface{}
+				var milestoneDefault string
 				if len(issueState.Milestones) > 0 {
 					milestoneDefault = issueState.Milestones[0]
 				}
@@ -354,11 +362,16 @@ func titleBodySurvey(cmd *cobra.Command, issueState *issueMetadataState, apiClie
 				cmd.PrintErrln("warning: no milestones in the repository")
 			}
 		}
-
-		err = SurveyAsk(mqs, issueState, survey.WithKeepFilter(true))
+		values := metadataValues{}
+		err = SurveyAsk(mqs, &values, survey.WithKeepFilter(true))
 		if err != nil {
 			return fmt.Errorf("could not prompt: %w", err)
 		}
+		issueState.Reviewers = values.Reviewers
+		issueState.Assignees = values.Assignees
+		issueState.Labels = values.Labels
+		issueState.Projects = values.Projects
+		issueState.Milestones = []string{values.Milestone}
 
 		if len(issueState.Milestones) > 0 && issueState.Milestones[0] == noMilestone {
 			issueState.Milestones = issueState.Milestones[0:0]

context/blank_context.go

@@ -17,14 +17,13 @@ func NewBlank() *blankContext {
 // A Context implementation that queries the filesystem
 type blankContext struct {
 	authToken string
-	authLogin string
 	branch    string
 	baseRepo  ghrepo.Interface
 	remotes   Remotes
 }
 
 func (c *blankContext) Config() (config.Config, error) {
-	cfg, err := config.ParseConfig("boom.txt")
+	cfg, err := config.ParseConfig("config.yml")
 	if err != nil {
 		panic(fmt.Sprintf("failed to parse config during tests. did you remember to stub? error: %s", err))
 	}
@@ -39,14 +38,6 @@ func (c *blankContext) SetAuthToken(t string) {
 	c.authToken = t
 }
 
-func (c *blankContext) SetAuthLogin(login string) {
-	c.authLogin = login
-}
-
-func (c *blankContext) AuthLogin() (string, error) {
-	return c.authLogin, nil
-}
-
 func (c *blankContext) Branch() (string, error) {
 	if c.branch == "" {
 		return "", fmt.Errorf("branch was not initialized")
@@ -92,5 +83,6 @@ func (c *blankContext) BaseRepo() (ghrepo.Interface, error) {
 }
 
 func (c *blankContext) SetBaseRepo(nwo string) {
-	c.baseRepo = ghrepo.FromFullName(nwo)
+	repo, _ := ghrepo.FromFullName(nwo)
+	c.baseRepo = repo
 }

context/context.go

@@ -3,6 +3,7 @@ package context
 import (
 	"errors"
 	"fmt"
+	"os"
 	"sort"
 
 	"github.com/cli/cli/api"
@@ -18,7 +19,6 @@ const defaultHostname = "github.com"
 type Context interface {
 	AuthToken() (string, error)
 	SetAuthToken(string)
-	AuthLogin() (string, error)
 	Branch() (string, error)
 	SetBranch(string)
 	Remotes() (Remotes, error)
@@ -39,7 +39,7 @@ func ResolveRemotesToRepos(remotes Remotes, client *api.Client, base string) (Re
 	}
 
 	hasBaseOverride := base != ""
-	baseOverride := ghrepo.FromFullName(base)
+	baseOverride, _ := ghrepo.FromFullName(base)
 	foundBaseOverride := false
 	repos := make([]ghrepo.Interface, 0, lenRemotesForLookup)
 	for _, r := range remotes[:lenRemotesForLookup] {
@@ -163,11 +163,13 @@ type fsContext struct {
 
 func (c *fsContext) Config() (config.Config, error) {
 	if c.config == nil {
-		config, err := config.ParseOrSetupConfigFile(config.ConfigFile())
-		if err != nil {
+		cfg, err := config.ParseDefaultConfig()
+		if errors.Is(err, os.ErrNotExist) {
+			cfg = config.NewBlankConfig()
+		} else if err != nil {
 			return nil, err
 		}
-		c.config = config
+		c.config = cfg
 		c.authToken = ""
 	}
 	return c.config, nil
@@ -183,8 +185,12 @@ func (c *fsContext) AuthToken() (string, error) {
 		return "", err
 	}
 
+	var notFound *config.NotFoundError
 	token, err := cfg.Get(defaultHostname, "oauth_token")
-	if token == "" || err != nil {
+	if token == "" || errors.As(err, &notFound) {
+		// interactive OAuth flow
+		return config.AuthFlowWithConfig(cfg, defaultHostname, "Notice: authentication required")
+	} else if err != nil {
 		return "", err
 	}
 
@@ -195,20 +201,6 @@ func (c *fsContext) SetAuthToken(t string) {
 	c.authToken = t
 }
 
-func (c *fsContext) AuthLogin() (string, error) {
-	config, err := c.Config()
-	if err != nil {
-		return "", err
-	}
-
-	login, err := config.Get(defaultHostname, "user")
-	if login == "" || err != nil {
-		return "", err
-	}
-
-	return login, nil
-}
-
 func (c *fsContext) Branch() (string, error) {
 	if c.branch != "" {
 		return c.branch, nil
@@ -266,5 +258,5 @@ func (c *fsContext) BaseRepo() (ghrepo.Interface, error) {
 }
 
 func (c *fsContext) SetBaseRepo(nwo string) {
-	c.baseRepo = ghrepo.FromFullName(nwo)
+	c.baseRepo, _ = ghrepo.FromFullName(nwo)
 }

docs/releasing.md

@@ -1,13 +1,20 @@
 # Releasing
 
-## Release to production
+_First create a prerelease to verify the relase infrastructure_
 
-This can all be done from your local terminal.
+1. `git tag v1.2.3-pre`
+2. `git push origin v1.2.3-pre`
+3. Wait several minutes for the build to run <https://github.com/cli/cli/actions>
+4. Verify the prerelease succeeded and has the correct artifacts at <https://github.com/cli/cli/releases>
 
-1. `git tag v1.2.3`
-2. `git push origin v1.2.3`
-3. Wait a few minutes for the build to run <https://github.com/cli/cli/actions>
-4. Check <https://github.com/cli/cli/releases>
+_Next create a the production release_
+
+5. `git tag v1.2.3`
+6. `git push origin v1.2.3`
+7. Wait several minutes for the build to run <https://github.com/cli/cli/actions>
+8. Check <https://github.com/cli/cli/releases>
+9. Verify the marketing site was updated https://cli.github.com/
+10. Delete the prerelease on GitHub <https://github.com/cli/cli/releases>
 
 ## Release locally for debugging
 

docs/source.md

@@ -7,6 +7,8 @@
    go version go1.14
    ```
 
+   If `go` is not installed, follow instructions on [the Go website](https://golang.org/doc/install).
+
 1. Clone this repository
 
    ```sh

git/git.go

@@ -203,6 +203,24 @@ func ReadBranchConfig(branch string) (cfg BranchConfig) {
 	return
 }
 
+func DeleteLocalBranch(branch string) error {
+	branchCmd := GitCommand("branch", "-D", branch)
+	err := run.PrepareCmd(branchCmd).Run()
+	return err
+}
+
+func HasLocalBranch(branch string) bool {
+	configCmd := GitCommand("rev-parse", "--verify", "refs/heads/"+branch)
+	_, err := run.PrepareCmd(configCmd).Output()
+	return err == nil
+}
+
+func CheckoutBranch(branch string) error {
+	configCmd := GitCommand("checkout", branch)
+	err := run.PrepareCmd(configCmd).Run()
+	return err
+}
+
 func isFilesystemPath(p string) bool {
 	return p == "." || strings.HasPrefix(p, "./") || strings.HasPrefix(p, "/")
 }

go.mod

@@ -4,27 +4,27 @@ go 1.13
 
 require (
 	github.com/AlecAivazis/survey/v2 v2.0.7
-	github.com/briandowns/spinner v1.10.1-0.20200410162419-bf6cf7ae6727
+	github.com/briandowns/spinner v1.11.1
 	github.com/charmbracelet/glamour v0.1.1-0.20200320173916-301d3bcf3058
 	github.com/dlclark/regexp2 v1.2.0 // indirect
-	github.com/google/go-cmp v0.2.0
+	github.com/google/go-cmp v0.4.1
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/hashicorp/go-version v1.2.0
-	github.com/henvic/httpretty v0.0.4
+	github.com/henvic/httpretty v0.0.5
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51
 	github.com/mattn/go-colorable v0.1.6
 	github.com/mattn/go-isatty v0.0.12
-	github.com/mattn/go-runewidth v0.0.8 // indirect
+	github.com/mattn/go-runewidth v0.0.9 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0
+	github.com/shurcooL/githubv4 v0.0.0-20200414012201-bbc966b061dd
 	github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f // indirect
-	github.com/spf13/cobra v0.0.6
+	github.com/spf13/cobra v1.0.0
 	github.com/spf13/pflag v1.0.5
-	github.com/stretchr/testify v1.4.0 // indirect
-	golang.org/x/crypto v0.0.0-20200219234226-1ad67e1f0ef4
-	golang.org/x/net v0.0.0-20200219183655-46282727080f // indirect
+	github.com/stretchr/testify v1.5.1
+	golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37
+	golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2 // indirect
 	golang.org/x/text v0.3.2
 	gopkg.in/yaml.v2 v2.2.8 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71
+	gopkg.in/yaml.v3 v3.0.0-20200506231410-2ff61e1afc86
 )

go.sum

@@ -20,8 +20,8 @@ github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRF
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/briandowns/spinner v1.10.1-0.20200410162419-bf6cf7ae6727 h1:DOyHtIQZmwFEOt/makVyey2RMTPkpi1IQsWsWX0OcGE=
-github.com/briandowns/spinner v1.10.1-0.20200410162419-bf6cf7ae6727/go.mod h1:QOuQk7x+EaDASo80FEXwlwiA+j/PPIcX3FScO+3/ZPQ=
+github.com/briandowns/spinner v1.11.1 h1:OixPqDEcX3juo5AjQZAnFPbeUA0jvkp2qzB5gOZJ/L0=
+github.com/briandowns/spinner v1.11.1/go.mod h1:QOuQk7x+EaDASo80FEXwlwiA+j/PPIcX3FScO+3/ZPQ=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/charmbracelet/glamour v0.1.1-0.20200320173916-301d3bcf3058 h1:Ks+RZ6s6UriHnL+yusm3OoaLwpV9WPvMV+FXQ6qMD7M=
 github.com/charmbracelet/glamour v0.1.1-0.20200320173916-301d3bcf3058/go.mod h1:sC1EP6T+3nFnl5vwf0TYEs1inMigQxZ7n912YKoxJow=
@@ -63,6 +63,8 @@ github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5y
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.4.1 h1:/exdXoGamhu5ONeUJH0deniYLWYvQwW66yvlfiiKTu0=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/goterm v0.0.0-20190703233501-fc88cf888a3f h1:5CjVwnuUcp5adK4gmY6i72gpVFVnZDP2h5TmPScB6u4=
 github.com/google/goterm v0.0.0-20190703233501-fc88cf888a3f/go.mod h1:nOFQdrUlIlx6M6ODdSpBj1NVA+VgLC6kmw60mkw34H4=
 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
@@ -74,8 +76,8 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t
 github.com/hashicorp/go-version v1.2.0 h1:3vNe/fWF5CBgRIguda1meWhsZHy3m8gCJ5wx+dIzX/E=
 github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/henvic/httpretty v0.0.4 h1:hyMkO0HugjsmWu63Z+7chDw7+RilkKBJ1vCwlqUOvOk=
-github.com/henvic/httpretty v0.0.4/go.mod h1:X38wLjWXHkXT7r2+uK8LjCMne9rsuNaBLJ+5cU2/Pmo=
+github.com/henvic/httpretty v0.0.5 h1:XmOHN7HHt+ZhlLNzsMC54yncJDybipkP5NHOGVBOr1s=
+github.com/henvic/httpretty v0.0.5/go.mod h1:X38wLjWXHkXT7r2+uK8LjCMne9rsuNaBLJ+5cU2/Pmo=
 github.com/hinshun/vt10x v0.0.0-20180616224451-1954e6464174 h1:WlZsjVhE8Af9IcZDGgJGQpNflI3+MJSBhsgT5PCtzBQ=
 github.com/hinshun/vt10x v0.0.0-20180616224451-1954e6464174/go.mod h1:DqJ97dSdRW1W22yXSB90986pcOyQ7r45iio1KN2ez1A=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
@@ -109,8 +111,8 @@ github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHX
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
-github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
@@ -147,8 +149,8 @@ github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0 h1:T9uus1QvcPgeLShS30YOnnzk3r9Vvygp45muhlrufgY=
-github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0/go.mod h1:hAF0iLZy4td2EX+/8Tw+4nodhlMrwN3HupfaXj3zkGo=
+github.com/shurcooL/githubv4 v0.0.0-20200414012201-bbc966b061dd h1:EwtC+kDj8s9OKiaStPZtTv3neldOyr98AXIxvmn3Gss=
+github.com/shurcooL/githubv4 v0.0.0-20200414012201-bbc966b061dd/go.mod h1:hAF0iLZy4td2EX+/8Tw+4nodhlMrwN3HupfaXj3zkGo=
 github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f h1:tygelZueB1EtXkPI6mQ4o9DQ0+FKW41hTbunoXZCTqk=
 github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f/go.mod h1:AuYgA5Kyo4c7HfUmvRGs/6rGlMMV/6B1bVnB9JxJEEg=
 github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
@@ -158,8 +160,8 @@ github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4k
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/spf13/cobra v0.0.6 h1:breEStsVwemnKh2/s6gMvSdMEkwW0sK8vGStnlVBMCs=
-github.com/spf13/cobra v0.0.6/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
+github.com/spf13/cobra v1.0.0 h1:6m/oheQuQ13N9ks4hubMG6BnvwOeaJrqSPLahSnczz8=
+github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
@@ -167,13 +169,14 @@ github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
@@ -188,8 +191,8 @@ golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5 h1:8dUaAV7K4uHsF56JQWkprecIQKdPHtR9jCHF5nB8uzc=
 golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200219234226-1ad67e1f0ef4 h1:4icQlpeqbz3WxfgP6Eq3szTj95KTrlH/CwzBzoxuFd0=
-golang.org/x/crypto v0.0.0-20200219234226-1ad67e1f0ef4/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37 h1:cg5LA/zNPRzIXIWSCxQW10Rvpy94aQh3LT/ShoCpkHw=
+golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -199,8 +202,8 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20200219183655-46282727080f h1:dB42wwhNuwPvh8f+5zZWNcU+F2Xs/B9wXXwvUCOH7r8=
-golang.org/x/net v0.0.0-20200219183655-46282727080f/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2 h1:eDrdRpKgkcCqKZQwyZRyeFZgfqt37SL7Kv3tok06cKE=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be h1:vEDujvNQGv4jgYKudGeI/+DAX4Jffq6hpD55MmoEvKs=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -218,6 +221,8 @@ golang.org/x/sys v0.0.0-20190530182044-ad28b68e88f1/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae h1:/WDfKMnPU+m5M4xB+6x4kaepxRw6jWvR5iDRdvjHgy8=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
@@ -227,6 +232,8 @@ golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.1.0 h1:igQkv0AAhEIvTEpD5LIpAfav2eeVO9HBTjvKHVJPRSs=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
@@ -244,6 +251,6 @@ gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71 h1:Xe2gvTZUJpsvOWUnvmL/tmhVBZUmHSvLbMjRj6NUUKo=
-gopkg.in/yaml.v3 v3.0.0-20200121175148-a6ecf24a6d71/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200506231410-2ff61e1afc86 h1:OfFoIUYv/me30yv7XlMy4F9RJw8DEm8WQ6QG1Ph4bH0=
+gopkg.in/yaml.v3 v3.0.0-20200506231410-2ff61e1afc86/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

internal/cobrafish/completion.go

@@ -1,171 +0,0 @@
-// imported from https://github.com/spf13/cobra/pull/754
-// author: Tim Reddehase
-
-package cobrafish
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-func GenCompletion(c *cobra.Command, w io.Writer) error {
-	buf := new(bytes.Buffer)
-
-	writeFishPreamble(c, buf)
-	writeFishCommandCompletion(c, c, buf)
-
-	_, err := buf.WriteTo(w)
-	return err
-}
-
-func writeFishPreamble(cmd *cobra.Command, buf *bytes.Buffer) {
-	subCommandNames := []string{}
-	rangeCommands(cmd, func(subCmd *cobra.Command) {
-		subCommandNames = append(subCommandNames, subCmd.Name())
-	})
-	buf.WriteString(fmt.Sprintf(`
-function __fish_%s_no_subcommand --description 'Test if %s has yet to be given the subcommand'
-	for i in (commandline -opc)
-		if contains -- $i %s
-			return 1
-		end
-	end
-	return 0
-end
-function __fish_%s_seen_subcommand_path --description 'Test whether the full path of subcommands is the current path'
-	  set -l cmd (commandline -opc)
-	  set -e cmd[1]
-    set -l pattern (string replace -a " " ".+" "$argv")
-    string match -r "$pattern" (string trim -- "$cmd")
-end
-# borrowed from current fish-shell master, since it is not in current 2.7.1 release
-function __fish_seen_argument
-	argparse 's/short=+' 'l/long=+' -- $argv
-	set cmd (commandline -co)
-	set -e cmd[1]
-	for t in $cmd
-		for s in $_flag_s
-			if string match -qr "^-[A-z0-9]*"$s"[A-z0-9]*\$" -- $t
-				return 0
-			end
-		end
-		for l in $_flag_l
-			if string match -q -- "--$l" $t
-				return 0
-			end
-		end
-	end
-	return 1
-end
-`, cmd.Name(), cmd.Name(), strings.Join(subCommandNames, " "), cmd.Name()))
-}
-
-func writeFishCommandCompletion(rootCmd, cmd *cobra.Command, buf *bytes.Buffer) {
-	rangeCommands(cmd, func(subCmd *cobra.Command) {
-		condition := commandCompletionCondition(rootCmd, cmd)
-		escapedDescription := strings.Replace(subCmd.Short, "'", "\\'", -1)
-		buf.WriteString(fmt.Sprintf("complete -c %s -f %s -a %s -d '%s'\n", rootCmd.Name(), condition, subCmd.Name(), escapedDescription))
-	})
-	for _, validArg := range append(cmd.ValidArgs, cmd.ArgAliases...) {
-		condition := commandCompletionCondition(rootCmd, cmd)
-		buf.WriteString(
-			fmt.Sprintf("complete -c %s -f %s -a %s -d '%s'\n",
-				rootCmd.Name(), condition, validArg, fmt.Sprintf("Positional Argument to %s", cmd.Name())))
-	}
-	writeCommandFlagsCompletion(rootCmd, cmd, buf)
-	rangeCommands(cmd, func(subCmd *cobra.Command) {
-		writeFishCommandCompletion(rootCmd, subCmd, buf)
-	})
-}
-
-func writeCommandFlagsCompletion(rootCmd, cmd *cobra.Command, buf *bytes.Buffer) {
-	cmd.NonInheritedFlags().VisitAll(func(flag *pflag.Flag) {
-		if nonCompletableFlag(flag) {
-			return
-		}
-		writeCommandFlagCompletion(rootCmd, cmd, buf, flag)
-	})
-	cmd.InheritedFlags().VisitAll(func(flag *pflag.Flag) {
-		if nonCompletableFlag(flag) {
-			return
-		}
-		writeCommandFlagCompletion(rootCmd, cmd, buf, flag)
-	})
-}
-
-func writeCommandFlagCompletion(rootCmd, cmd *cobra.Command, buf *bytes.Buffer, flag *pflag.Flag) {
-	shortHandPortion := ""
-	if len(flag.Shorthand) > 0 {
-		shortHandPortion = fmt.Sprintf("-s %s", flag.Shorthand)
-	}
-	condition := completionCondition(rootCmd, cmd)
-	escapedUsage := strings.Replace(flag.Usage, "'", "\\'", -1)
-	buf.WriteString(fmt.Sprintf("complete -c %s -f %s %s %s -l %s -d '%s'\n",
-		rootCmd.Name(), condition, flagRequiresArgumentCompletion(flag), shortHandPortion, flag.Name, escapedUsage))
-}
-
-func flagRequiresArgumentCompletion(flag *pflag.Flag) string {
-	if flag.Value.Type() != "bool" {
-		return "-r"
-	}
-	return ""
-}
-
-func subCommandPath(rootCmd *cobra.Command, cmd *cobra.Command) string {
-	path := make([]string, 0, 1)
-	currentCmd := cmd
-	if rootCmd == cmd {
-		return ""
-	}
-	for {
-		path = append([]string{currentCmd.Name()}, path...)
-		if currentCmd.Parent() == rootCmd {
-			return strings.Join(path, " ")
-		}
-		currentCmd = currentCmd.Parent()
-	}
-}
-
-func rangeCommands(cmd *cobra.Command, callback func(subCmd *cobra.Command)) {
-	for _, subCmd := range cmd.Commands() {
-		if !subCmd.IsAvailableCommand() || strings.HasPrefix(subCmd.Use, "help") {
-			continue
-		}
-		callback(subCmd)
-	}
-}
-
-func commandCompletionCondition(rootCmd, cmd *cobra.Command) string {
-	localNonPersistentFlags := cmd.LocalNonPersistentFlags()
-	bareConditions := make([]string, 0, 1)
-	if rootCmd != cmd {
-		bareConditions = append(bareConditions, fmt.Sprintf("__fish_%s_seen_subcommand_path %s", rootCmd.Name(), subCommandPath(rootCmd, cmd)))
-	} else {
-		bareConditions = append(bareConditions, fmt.Sprintf("__fish_%s_no_subcommand", rootCmd.Name()))
-	}
-	localNonPersistentFlags.VisitAll(func(flag *pflag.Flag) {
-		flagSelector := fmt.Sprintf("-l %s", flag.Name)
-		if len(flag.Shorthand) > 0 {
-			flagSelector = fmt.Sprintf("-s %s %s", flag.Shorthand, flagSelector)
-		}
-		bareConditions = append(bareConditions, fmt.Sprintf("not __fish_seen_argument %s", flagSelector))
-	})
-	return fmt.Sprintf("-n '%s'", strings.Join(bareConditions, "; and "))
-}
-
-func completionCondition(rootCmd, cmd *cobra.Command) string {
-	condition := fmt.Sprintf("-n '__fish_%s_no_subcommand'", rootCmd.Name())
-	if rootCmd != cmd {
-		condition = fmt.Sprintf("-n '__fish_%s_seen_subcommand_path %s'", rootCmd.Name(), subCommandPath(rootCmd, cmd))
-	}
-	return condition
-}
-
-func nonCompletableFlag(flag *pflag.Flag) bool {
-	return flag.Hidden || len(flag.Deprecated) > 0
-}

internal/config/alias_config.go

@@ -0,0 +1,60 @@
+package config
+
+import (
+	"fmt"
+)
+
+type AliasConfig struct {
+	ConfigMap
+	Parent Config
+}
+
+func (a *AliasConfig) Get(alias string) (string, bool) {
+	if a.Empty() {
+		return "", false
+	}
+	value, _ := a.GetStringValue(alias)
+
+	return value, value != ""
+}
+
+func (a *AliasConfig) Add(alias, expansion string) error {
+	err := a.SetStringValue(alias, expansion)
+	if err != nil {
+		return fmt.Errorf("failed to update config: %w", err)
+	}
+
+	err = a.Parent.Write()
+	if err != nil {
+		return fmt.Errorf("failed to write config: %w", err)
+	}
+
+	return nil
+}
+
+func (a *AliasConfig) Delete(alias string) error {
+	a.RemoveEntry(alias)
+
+	err := a.Parent.Write()
+	if err != nil {
+		return fmt.Errorf("failed to write config: %w", err)
+	}
+
+	return nil
+}
+
+func (a *AliasConfig) All() map[string]string {
+	out := map[string]string{}
+
+	if a.Empty() {
+		return out
+	}
+
+	for i := 0; i < len(a.Root.Content)-1; i += 2 {
+		key := a.Root.Content[i].Value
+		value := a.Root.Content[i+1].Value
+		out[key] = value
+	}
+
+	return out
+}

internal/config/config_file.go

@@ -21,20 +21,16 @@ func ConfigFile() string {
 	return path.Join(ConfigDir(), "config.yml")
 }
 
-func ParseOrSetupConfigFile(fn string) (Config, error) {
-	config, err := ParseConfig(fn)
-	if err != nil && errors.Is(err, os.ErrNotExist) {
-		return setupConfigFile(fn)
-	}
-	return config, err
+func hostsConfigFile(filename string) string {
+	return path.Join(path.Dir(filename), "hosts.yml")
 }
 
 func ParseDefaultConfig() (Config, error) {
 	return ParseConfig(ConfigFile())
 }
 
-var ReadConfigFile = func(fn string) ([]byte, error) {
-	f, err := os.Open(fn)
+var ReadConfigFile = func(filename string) ([]byte, error) {
+	f, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
@@ -48,8 +44,13 @@ var ReadConfigFile = func(fn string) ([]byte, error) {
 	return data, nil
 }
 
-var WriteConfigFile = func(fn string, data []byte) error {
-	cfgFile, err := os.OpenFile(ConfigFile(), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600) // cargo coded from setup
+var WriteConfigFile = func(filename string, data []byte) error {
+	err := os.MkdirAll(path.Dir(filename), 0771)
+	if err != nil {
+		return err
+	}
+
+	cfgFile, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600) // cargo coded from setup
 	if err != nil {
 		return err
 	}
@@ -63,12 +64,12 @@ var WriteConfigFile = func(fn string, data []byte) error {
 	return err
 }
 
-var BackupConfigFile = func(fn string) error {
-	return os.Rename(fn, fn+".bak")
+var BackupConfigFile = func(filename string) error {
+	return os.Rename(filename, filename+".bak")
 }
 
-func parseConfigFile(fn string) ([]byte, *yaml.Node, error) {
-	data, err := ReadConfigFile(fn)
+func parseConfigFile(filename string) ([]byte, *yaml.Node, error) {
+	data, err := ReadConfigFile(filename)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -78,8 +79,11 @@ func parseConfigFile(fn string) ([]byte, *yaml.Node, error) {
 	if err != nil {
 		return data, nil, err
 	}
-	if len(root.Content) < 1 {
-		return data, &root, fmt.Errorf("malformed config")
+	if len(root.Content) == 0 {
+		return data, &yaml.Node{
+			Kind:    yaml.DocumentNode,
+			Content: []*yaml.Node{{Kind: yaml.MappingNode}},
+		}, nil
 	}
 	if root.Content[0].Kind != yaml.MappingNode {
 		return data, &root, fmt.Errorf("expected a top level map")
@@ -90,91 +94,76 @@ func parseConfigFile(fn string) ([]byte, *yaml.Node, error) {
 
 func isLegacy(root *yaml.Node) bool {
 	for _, v := range root.Content[0].Content {
-		if v.Value == "hosts" {
-			return false
+		if v.Value == "github.com" {
+			return true
 		}
 	}
 
-	return true
+	return false
 }
 
-func migrateConfig(fn string, root *yaml.Node) error {
-	type ConfigEntry map[string]string
-	type ConfigHash map[string]ConfigEntry
-
-	newConfigData := map[string]ConfigHash{}
-	newConfigData["hosts"] = ConfigHash{}
-
-	topLevelKeys := root.Content[0].Content
-
-	for i, x := range topLevelKeys {
-		if x.Value == "" {
-			continue
-		}
-		if i+1 == len(topLevelKeys) {
-			break
-		}
-		hostname := x.Value
-		newConfigData["hosts"][hostname] = ConfigEntry{}
-
-		authKeys := topLevelKeys[i+1].Content[0].Content
-
-		for j, y := range authKeys {
-			if j+1 == len(authKeys) {
-				break
-			}
-			switch y.Value {
-			case "user":
-				newConfigData["hosts"][hostname]["user"] = authKeys[j+1].Value
-			case "oauth_token":
-				newConfigData["hosts"][hostname]["oauth_token"] = authKeys[j+1].Value
-			}
-		}
-	}
-
-	if _, ok := newConfigData["hosts"][defaultHostname]; !ok {
-		return errors.New("could not find default host configuration")
-	}
-
-	defaultHostConfig := newConfigData["hosts"][defaultHostname]
-
-	if _, ok := defaultHostConfig["user"]; !ok {
-		return errors.New("default host configuration missing user")
-	}
-
-	if _, ok := defaultHostConfig["oauth_token"]; !ok {
-		return errors.New("default host configuration missing oauth_token")
-	}
-
-	newConfig, err := yaml.Marshal(newConfigData)
+func migrateConfig(filename string) error {
+	b, err := ReadConfigFile(filename)
 	if err != nil {
 		return err
 	}
 
-	err = BackupConfigFile(fn)
+	var hosts map[string][]yaml.Node
+	err = yaml.Unmarshal(b, &hosts)
+	if err != nil {
+		return fmt.Errorf("error decoding legacy format: %w", err)
+	}
+
+	cfg := NewBlankConfig()
+	for hostname, entries := range hosts {
+		if len(entries) < 1 {
+			continue
+		}
+		mapContent := entries[0].Content
+		for i := 0; i < len(mapContent)-1; i += 2 {
+			if err := cfg.Set(hostname, mapContent[i].Value, mapContent[i+1].Value); err != nil {
+				return err
+			}
+		}
+	}
+
+	err = BackupConfigFile(filename)
 	if err != nil {
 		return fmt.Errorf("failed to back up existing config: %w", err)
 	}
 
-	return WriteConfigFile(fn, newConfig)
+	return cfg.Write()
 }
 
-func ParseConfig(fn string) (Config, error) {
-	_, root, err := parseConfigFile(fn)
+func ParseConfig(filename string) (Config, error) {
+	_, root, err := parseConfigFile(filename)
 	if err != nil {
 		return nil, err
 	}
 
 	if isLegacy(root) {
-		err = migrateConfig(fn, root)
+		err = migrateConfig(filename)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("error migrating legacy config: %w", err)
 		}
 
-		_, root, err = parseConfigFile(fn)
+		_, root, err = parseConfigFile(filename)
 		if err != nil {
 			return nil, fmt.Errorf("failed to reparse migrated config: %w", err)
 		}
+	} else {
+		if _, hostsRoot, err := parseConfigFile(hostsConfigFile(filename)); err == nil {
+			if len(hostsRoot.Content[0].Content) > 0 {
+				newContent := []*yaml.Node{
+					{Value: "hosts"},
+					hostsRoot.Content[0],
+				}
+				restContent := root.Content[0].Content
+				root.Content[0].Content = append(newContent, restContent...)
+			}
+		} else if !errors.Is(err, os.ErrNotExist) {
+			return nil, err
+		}
 	}
 
 	return NewConfig(root), nil

internal/config/config_file_test.go

@@ -3,6 +3,7 @@ package config
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"reflect"
 	"testing"
 
@@ -22,8 +23,8 @@ hosts:
   github.com:
     user: monalisa
     oauth_token: OTOKEN
-`)()
-	config, err := ParseConfig("filename")
+`, "")()
+	config, err := ParseConfig("config.yml")
 	eq(t, err, nil)
 	user, err := config.Get("github.com", "user")
 	eq(t, err, nil)
@@ -42,8 +43,24 @@ hosts:
   github.com:
     user: monalisa
     oauth_token: OTOKEN
+`, "")()
+	config, err := ParseConfig("config.yml")
+	eq(t, err, nil)
+	user, err := config.Get("github.com", "user")
+	eq(t, err, nil)
+	eq(t, user, "monalisa")
+	token, err := config.Get("github.com", "oauth_token")
+	eq(t, err, nil)
+	eq(t, token, "OTOKEN")
+}
+
+func Test_parseConfig_hostsFile(t *testing.T) {
+	defer StubConfig("", `---
+github.com:
+  user: monalisa
+  oauth_token: OTOKEN
 `)()
-	config, err := ParseConfig("filename")
+	config, err := ParseConfig("config.yml")
 	eq(t, err, nil)
 	user, err := config.Get("github.com", "user")
 	eq(t, err, nil)
@@ -59,38 +76,47 @@ hosts:
   example.com:
     user: wronguser
     oauth_token: NOTTHIS
-`)()
-	config, err := ParseConfig("filename")
+`, "")()
+	config, err := ParseConfig("config.yml")
 	eq(t, err, nil)
 	_, err = config.Get("github.com", "user")
-	eq(t, err, errors.New(`could not find config entry for "github.com"`))
+	eq(t, err, &NotFoundError{errors.New(`could not find config entry for "github.com"`)})
 }
 
-func Test_migrateConfig(t *testing.T) {
-	oldStyle := `---
+func Test_ParseConfig_migrateConfig(t *testing.T) {
+	defer StubConfig(`---
 github.com:
   - user: keiyuri
-    oauth_token: 123456`
-
-	var root yaml.Node
-	err := yaml.Unmarshal([]byte(oldStyle), &root)
-	if err != nil {
-		panic("failed to parse test yaml")
-	}
-
-	buf := bytes.NewBufferString("")
-	defer StubWriteConfig(buf)()
+    oauth_token: 123456
+`, "")()
 
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer StubWriteConfig(&mainBuf, &hostsBuf)()
 	defer StubBackupConfig()()
 
-	err = migrateConfig("boom.txt", &root)
+	_, err := ParseConfig("config.yml")
 	eq(t, err, nil)
 
-	expected := `hosts:
-    github.com:
-        oauth_token: "123456"
-        user: keiyuri
+	expectedMain := ""
+	expectedHosts := `github.com:
+    user: keiyuri
+    oauth_token: "123456"
 `
 
-	eq(t, buf.String(), expected)
+	eq(t, mainBuf.String(), expectedMain)
+	eq(t, hostsBuf.String(), expectedHosts)
+}
+
+func Test_parseConfigFile(t *testing.T) {
+	fileContents := []string{"", " ", "\n"}
+	for _, contents := range fileContents {
+		t.Run(fmt.Sprintf("contents: %q", contents), func(t *testing.T) {
+			defer StubConfig(contents, "")()
+			_, yamlRoot, err := parseConfigFile("config.yml")
+			eq(t, err, nil)
+			eq(t, yamlRoot.Content[0].Kind, yaml.MappingNode)
+			eq(t, len(yamlRoot.Content[0].Content), 0)
+		})
+	}
 }

internal/config/config_setup.go

@@ -5,16 +5,10 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/auth"
-	"gopkg.in/yaml.v3"
-)
-
-const (
-	oauthHost = "github.com"
 )
 
 var (
@@ -31,7 +25,31 @@ func IsGitHubApp(id string) bool {
 	return id == "178c6fc778ccc68e1d6a" || id == "4d747ba5675d5d66553f"
 }
 
-func AuthFlow(notice string) (string, string, error) {
+func AuthFlowWithConfig(cfg Config, hostname, notice string) (string, error) {
+	token, userLogin, err := authFlow(hostname, notice)
+	if err != nil {
+		return "", err
+	}
+
+	err = cfg.Set(hostname, "user", userLogin)
+	if err != nil {
+		return "", err
+	}
+	err = cfg.Set(hostname, "oauth_token", token)
+	if err != nil {
+		return "", err
+	}
+
+	err = cfg.Write()
+	if err != nil {
+		return "", err
+	}
+
+	AuthFlowComplete()
+	return token, nil
+}
+
+func authFlow(oauthHost, notice string) (string, string, error) {
 	var verboseStream io.Writer
 	if strings.Contains(os.Getenv("DEBUG"), "oauth") {
 		verboseStream = os.Stderr
@@ -41,7 +59,7 @@ func AuthFlow(notice string) (string, string, error) {
 		Hostname:     oauthHost,
 		ClientID:     oauthClientID,
 		ClientSecret: oauthClientSecret,
-		Scopes:       []string{"repo", "read:org"},
+		Scopes:       []string{"repo", "read:org", "gist"},
 		WriteSuccessHTML: func(w io.Writer) {
 			fmt.Fprintln(w, oauthSuccessPage)
 		},
@@ -69,61 +87,9 @@ func AuthFlowComplete() {
 	_ = waitForEnter(os.Stdin)
 }
 
-// FIXME: make testable
-func setupConfigFile(filename string) (Config, error) {
-	token, userLogin, err := AuthFlow("Notice: authentication required")
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO this sucks. It precludes us laying out a nice config with comments and such.
-	type yamlConfig struct {
-		Hosts map[string]map[string]string
-	}
-
-	yamlHosts := map[string]map[string]string{}
-	yamlHosts[oauthHost] = map[string]string{}
-	yamlHosts[oauthHost]["user"] = userLogin
-	yamlHosts[oauthHost]["oauth_token"] = token
-
-	defaultConfig := yamlConfig{
-		Hosts: yamlHosts,
-	}
-
-	err = os.MkdirAll(filepath.Dir(filename), 0771)
-	if err != nil {
-		return nil, err
-	}
-
-	cfgFile, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		return nil, err
-	}
-	defer cfgFile.Close()
-
-	yamlData, err := yaml.Marshal(defaultConfig)
-	if err != nil {
-		return nil, err
-	}
-	_, err = cfgFile.Write(yamlData)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO cleaner error handling? this "should" always work given that we /just/ wrote the file...
-	return ParseConfig(filename)
-}
-
 func getViewer(token string) (string, error) {
 	http := api.NewClient(api.AddHeader("Authorization", fmt.Sprintf("token %s", token)))
-
-	response := struct {
-		Viewer struct {
-			Login string
-		}
-	}{}
-	err := http.GraphQL("{ viewer { login } }", nil, &response)
-	return response.Viewer.Login, err
+	return api.CurrentLoginName(http)
 }
 
 func waitForEnter(r io.Reader) error {

internal/config/config_type.go

@@ -1,20 +1,20 @@
 package config
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 
 	"gopkg.in/yaml.v3"
 )
 
-const defaultHostname = "github.com"
 const defaultGitProtocol = "https"
 
 // This interface describes interacting with some persistent configuration for gh.
 type Config interface {
-	Hosts() ([]*HostConfig, error)
 	Get(string, string) (string, error)
 	Set(string, string, string) error
+	Aliases() (*AliasConfig, error)
 	Write() error
 }
 
@@ -34,19 +34,25 @@ type ConfigMap struct {
 	Root *yaml.Node
 }
 
+func (cm *ConfigMap) Empty() bool {
+	return cm.Root == nil || len(cm.Root.Content) == 0
+}
+
 func (cm *ConfigMap) GetStringValue(key string) (string, error) {
-	_, valueNode, err := cm.FindEntry(key)
+	entry, err := cm.FindEntry(key)
 	if err != nil {
 		return "", err
 	}
-	return valueNode.Value, nil
+	return entry.ValueNode.Value, nil
 }
 
 func (cm *ConfigMap) SetStringValue(key, value string) error {
-	_, valueNode, err := cm.FindEntry(key)
+	entry, err := cm.FindEntry(key)
 
 	var notFound *NotFoundError
 
+	valueNode := entry.ValueNode
+
 	if err != nil && errors.As(err, &notFound) {
 		keyNode := &yaml.Node{
 			Kind:  yaml.ScalarNode,
@@ -54,6 +60,7 @@ func (cm *ConfigMap) SetStringValue(key, value string) error {
 		}
 		valueNode = &yaml.Node{
 			Kind:  yaml.ScalarNode,
+			Tag:   "!!str",
 			Value: "",
 		}
 
@@ -67,19 +74,45 @@ func (cm *ConfigMap) SetStringValue(key, value string) error {
 	return nil
 }
 
-func (cm *ConfigMap) FindEntry(key string) (keyNode, valueNode *yaml.Node, err error) {
+type ConfigEntry struct {
+	KeyNode   *yaml.Node
+	ValueNode *yaml.Node
+	Index     int
+}
+
+func (cm *ConfigMap) FindEntry(key string) (ce *ConfigEntry, err error) {
 	err = nil
 
+	ce = &ConfigEntry{}
+
 	topLevelKeys := cm.Root.Content
 	for i, v := range topLevelKeys {
-		if v.Value == key && i+1 < len(topLevelKeys) {
-			keyNode = v
-			valueNode = topLevelKeys[i+1]
+		if v.Value == key {
+			ce.KeyNode = v
+			ce.Index = i
+			if i+1 < len(topLevelKeys) {
+				ce.ValueNode = topLevelKeys[i+1]
+			}
 			return
 		}
 	}
 
-	return nil, nil, &NotFoundError{errors.New("not found")}
+	return ce, &NotFoundError{errors.New("not found")}
+}
+
+func (cm *ConfigMap) RemoveEntry(key string) {
+	newContent := []*yaml.Node{}
+
+	content := cm.Root.Content
+	for i := 0; i < len(content); i++ {
+		if content[i].Value == key {
+			i++ // skip the next node which is this key's value
+		} else {
+			newContent = append(newContent, content[i])
+		}
+	}
+
+	cm.Root.Content = newContent
 }
 
 func NewConfig(root *yaml.Node) Config {
@@ -89,11 +122,21 @@ func NewConfig(root *yaml.Node) Config {
 	}
 }
 
+func NewBlankConfig() Config {
+	return NewConfig(&yaml.Node{
+		Kind:    yaml.DocumentNode,
+		Content: []*yaml.Node{{Kind: yaml.MappingNode}},
+	})
+}
+
 // This type implements a Config interface and represents a config file on disk.
 type fileConfig struct {
 	ConfigMap
 	documentRoot *yaml.Node
-	hosts        []*HostConfig
+}
+
+func (c *fileConfig) Root() *yaml.Node {
+	return c.ConfigMap.Root
 }
 
 func (c *fileConfig) Get(hostname, key string) (string, error) {
@@ -137,7 +180,10 @@ func (c *fileConfig) Set(hostname, key, value string) error {
 		return c.SetStringValue(key, value)
 	} else {
 		hostCfg, err := c.configForHost(hostname)
-		if err != nil {
+		var notFound *NotFoundError
+		if errors.As(err, &notFound) {
+			hostCfg = c.makeConfigForHost(hostname)
+		} else if err != nil {
 			return err
 		}
 		return hostCfg.SetStringValue(key, value)
@@ -145,7 +191,7 @@ func (c *fileConfig) Set(hostname, key, value string) error {
 }
 
 func (c *fileConfig) configForHost(hostname string) (*HostConfig, error) {
-	hosts, err := c.Hosts()
+	hosts, err := c.hostEntries()
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse hosts config: %w", err)
 	}
@@ -155,38 +201,146 @@ func (c *fileConfig) configForHost(hostname string) (*HostConfig, error) {
 			return hc, nil
 		}
 	}
-	return nil, fmt.Errorf("could not find config entry for %q", hostname)
+	return nil, &NotFoundError{fmt.Errorf("could not find config entry for %q", hostname)}
 }
 
 func (c *fileConfig) Write() error {
-	marshalled, err := yaml.Marshal(c.documentRoot)
+	mainData := yaml.Node{Kind: yaml.MappingNode}
+	hostsData := yaml.Node{Kind: yaml.MappingNode}
+
+	nodes := c.documentRoot.Content[0].Content
+	for i := 0; i < len(nodes)-1; i += 2 {
+		if nodes[i].Value == "hosts" {
+			hostsData.Content = append(hostsData.Content, nodes[i+1].Content...)
+		} else {
+			mainData.Content = append(mainData.Content, nodes[i], nodes[i+1])
+		}
+	}
+
+	mainBytes, err := yaml.Marshal(&mainData)
 	if err != nil {
 		return err
 	}
 
-	return WriteConfigFile(ConfigFile(), marshalled)
-}
-
-func (c *fileConfig) Hosts() ([]*HostConfig, error) {
-	if len(c.hosts) > 0 {
-		return c.hosts, nil
+	filename := ConfigFile()
+	err = WriteConfigFile(filename, yamlNormalize(mainBytes))
+	if err != nil {
+		return err
 	}
 
-	_, hostsEntry, err := c.FindEntry("hosts")
+	hostsBytes, err := yaml.Marshal(&hostsData)
+	if err != nil {
+		return err
+	}
+
+	return WriteConfigFile(hostsConfigFile(filename), yamlNormalize(hostsBytes))
+}
+
+func yamlNormalize(b []byte) []byte {
+	if bytes.Equal(b, []byte("{}\n")) {
+		return []byte{}
+	}
+	return b
+}
+
+func (c *fileConfig) Aliases() (*AliasConfig, error) {
+	// The complexity here is for dealing with either a missing or empty aliases key. It's something
+	// we'll likely want for other config sections at some point.
+	entry, err := c.FindEntry("aliases")
+	var nfe *NotFoundError
+	notFound := errors.As(err, &nfe)
+	if err != nil && !notFound {
+		return nil, err
+	}
+
+	toInsert := []*yaml.Node{}
+
+	keyNode := entry.KeyNode
+	valueNode := entry.ValueNode
+
+	if keyNode == nil {
+		keyNode = &yaml.Node{
+			Kind:  yaml.ScalarNode,
+			Value: "aliases",
+		}
+		toInsert = append(toInsert, keyNode)
+	}
+
+	if valueNode == nil || valueNode.Kind != yaml.MappingNode {
+		valueNode = &yaml.Node{
+			Kind:  yaml.MappingNode,
+			Value: "",
+		}
+		toInsert = append(toInsert, valueNode)
+	}
+
+	if len(toInsert) > 0 {
+		newContent := []*yaml.Node{}
+		if notFound {
+			newContent = append(c.Root().Content, keyNode, valueNode)
+		} else {
+			for i := 0; i < len(c.Root().Content); i++ {
+				if i == entry.Index {
+					newContent = append(newContent, keyNode, valueNode)
+					i++
+				} else {
+					newContent = append(newContent, c.Root().Content[i])
+				}
+			}
+		}
+		c.Root().Content = newContent
+	}
+
+	return &AliasConfig{
+		Parent:    c,
+		ConfigMap: ConfigMap{Root: valueNode},
+	}, nil
+}
+
+func (c *fileConfig) hostEntries() ([]*HostConfig, error) {
+	entry, err := c.FindEntry("hosts")
 	if err != nil {
 		return nil, fmt.Errorf("could not find hosts config: %w", err)
 	}
 
-	hostConfigs, err := c.parseHosts(hostsEntry)
+	hostConfigs, err := c.parseHosts(entry.ValueNode)
 	if err != nil {
 		return nil, fmt.Errorf("could not parse hosts config: %w", err)
 	}
 
-	c.hosts = hostConfigs
-
 	return hostConfigs, nil
 }
 
+func (c *fileConfig) makeConfigForHost(hostname string) *HostConfig {
+	hostRoot := &yaml.Node{Kind: yaml.MappingNode}
+	hostCfg := &HostConfig{
+		Host:      hostname,
+		ConfigMap: ConfigMap{Root: hostRoot},
+	}
+
+	var notFound *NotFoundError
+	hostsEntry, err := c.FindEntry("hosts")
+	if errors.As(err, &notFound) {
+		hostsEntry.KeyNode = &yaml.Node{
+			Kind:  yaml.ScalarNode,
+			Value: "hosts",
+		}
+		hostsEntry.ValueNode = &yaml.Node{Kind: yaml.MappingNode}
+		root := c.Root()
+		root.Content = append(root.Content, hostsEntry.KeyNode, hostsEntry.ValueNode)
+	} else if err != nil {
+		panic(err)
+	}
+
+	hostsEntry.ValueNode.Content = append(hostsEntry.ValueNode.Content,
+		&yaml.Node{
+			Kind:  yaml.ScalarNode,
+			Value: hostname,
+		}, hostRoot)
+
+	return hostCfg
+}
+
 func (c *fileConfig) parseHosts(hostsEntry *yaml.Node) ([]*HostConfig, error) {
 	hostConfigs := []*HostConfig{}
 

internal/config/config_type_test.go

@@ -0,0 +1,41 @@
+package config
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_fileConfig_Set(t *testing.T) {
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	c := NewBlankConfig()
+	assert.NoError(t, c.Set("", "editor", "nano"))
+	assert.NoError(t, c.Set("github.com", "git_protocol", "ssh"))
+	assert.NoError(t, c.Set("example.com", "editor", "vim"))
+	assert.NoError(t, c.Set("github.com", "user", "hubot"))
+	assert.NoError(t, c.Write())
+
+	assert.Equal(t, "editor: nano\n", mainBuf.String())
+	assert.Equal(t, `github.com:
+    git_protocol: ssh
+    user: hubot
+example.com:
+    editor: vim
+`, hostsBuf.String())
+}
+
+func Test_fileConfig_Write(t *testing.T) {
+	mainBuf := bytes.Buffer{}
+	hostsBuf := bytes.Buffer{}
+	defer StubWriteConfig(&mainBuf, &hostsBuf)()
+
+	c := NewBlankConfig()
+	assert.NoError(t, c.Write())
+
+	assert.Equal(t, "", mainBuf.String())
+	assert.Equal(t, "", hostsBuf.String())
+}

internal/config/testing.go

@@ -1,7 +1,10 @@
 package config
 
 import (
+	"fmt"
 	"io"
+	"os"
+	"path"
 )
 
 func StubBackupConfig() func() {
@@ -15,21 +18,41 @@ func StubBackupConfig() func() {
 	}
 }
 
-func StubWriteConfig(w io.Writer) func() {
+func StubWriteConfig(wc io.Writer, wh io.Writer) func() {
 	orig := WriteConfigFile
 	WriteConfigFile = func(fn string, data []byte) error {
-		_, err := w.Write(data)
-		return err
+		switch path.Base(fn) {
+		case "config.yml":
+			_, err := wc.Write(data)
+			return err
+		case "hosts.yml":
+			_, err := wh.Write(data)
+			return err
+		default:
+			return fmt.Errorf("write to unstubbed file: %q", fn)
+		}
 	}
 	return func() {
 		WriteConfigFile = orig
 	}
 }
 
-func StubConfig(content string) func() {
+func StubConfig(main, hosts string) func() {
 	orig := ReadConfigFile
 	ReadConfigFile = func(fn string) ([]byte, error) {
-		return []byte(content), nil
+		switch path.Base(fn) {
+		case "config.yml":
+			return []byte(main), nil
+		case "hosts.yml":
+			if hosts == "" {
+				return []byte(nil), os.ErrNotExist
+			} else {
+				return []byte(hosts), nil
+			}
+		default:
+			return []byte(nil), fmt.Errorf("read from unstubbed file: %q", fn)
+		}
+
 	}
 	return func() {
 		ReadConfigFile = orig

internal/ghrepo/repo.go

@@ -28,14 +28,15 @@ func FullName(r Interface) string {
 	return fmt.Sprintf("%s/%s", r.RepoOwner(), r.RepoName())
 }
 
-// FromFullName extracts the GitHub repository inforation from an "OWNER/REPO" string
-func FromFullName(nwo string) Interface {
+// FromFullName extracts the GitHub repository information from an "OWNER/REPO" string
+func FromFullName(nwo string) (Interface, error) {
 	var r ghRepo
 	parts := strings.SplitN(nwo, "/", 2)
-	if len(parts) == 2 {
-		r.owner, r.name = parts[0], parts[1]
+	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
+		return &r, fmt.Errorf("expected OWNER/REPO format, got %q", nwo)
 	}
-	return &r
+	r.owner, r.name = parts[0], parts[1]
+	return &r, nil
 }
 
 // FromURL extracts the GitHub repository information from a URL

pkg/cmd/api/api.go

@@ -0,0 +1,190 @@
+package api
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
+	"github.com/spf13/cobra"
+)
+
+type ApiOptions struct {
+	IO *iostreams.IOStreams
+
+	RequestMethod       string
+	RequestMethodPassed bool
+	RequestPath         string
+	MagicFields         []string
+	RawFields           []string
+	RequestHeaders      []string
+	ShowResponseHeaders bool
+
+	HttpClient func() (*http.Client, error)
+}
+
+func NewCmdApi(f *cmdutil.Factory, runF func(*ApiOptions) error) *cobra.Command {
+	opts := ApiOptions{
+		IO:         f.IOStreams,
+		HttpClient: f.HttpClient,
+	}
+
+	cmd := &cobra.Command{
+		Use:   "api <endpoint>",
+		Short: "Make an authenticated GitHub API request",
+		Long: `Makes an authenticated HTTP request to the GitHub API and prints the response.
+
+The <endpoint> argument should either be a path of a GitHub API v3 endpoint, or
+"graphql" to access the GitHub API v4.
+
+The default HTTP request method is "GET" normally and "POST" if any parameters
+were added. Override the method with '--method'.
+
+Pass one or more '--raw-field' values in "<key>=<value>" format to add
+JSON-encoded string parameters to the POST body.
+
+The '--field' flag behaves like '--raw-field' with magic type conversion based
+on the format of the value:
+
+- literal values "true", "false", "null", and integer numbers get converted to
+  appropriate JSON types;
+- if the value starts with "@", the rest of the value is interpreted as a
+  filename to read the value from. Pass "-" to read from standard input.
+`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(c *cobra.Command, args []string) error {
+			opts.RequestPath = args[0]
+			opts.RequestMethodPassed = c.Flags().Changed("method")
+
+			if runF != nil {
+				return runF(&opts)
+			}
+			return apiRun(&opts)
+		},
+	}
+
+	cmd.Flags().StringVarP(&opts.RequestMethod, "method", "X", "GET", "The HTTP method for the request")
+	cmd.Flags().StringArrayVarP(&opts.MagicFields, "field", "F", nil, "Add a parameter of inferred type")
+	cmd.Flags().StringArrayVarP(&opts.RawFields, "raw-field", "f", nil, "Add a string parameter")
+	cmd.Flags().StringArrayVarP(&opts.RequestHeaders, "header", "H", nil, "Add an additional HTTP request header")
+	cmd.Flags().BoolVarP(&opts.ShowResponseHeaders, "include", "i", false, "Include HTTP response headers in the output")
+	return cmd
+}
+
+func apiRun(opts *ApiOptions) error {
+	params, err := parseFields(opts)
+	if err != nil {
+		return err
+	}
+
+	method := opts.RequestMethod
+	if len(params) > 0 && !opts.RequestMethodPassed {
+		method = "POST"
+	}
+
+	httpClient, err := opts.HttpClient()
+	if err != nil {
+		return err
+	}
+
+	resp, err := httpRequest(httpClient, method, opts.RequestPath, params, opts.RequestHeaders)
+	if err != nil {
+		return err
+	}
+
+	if opts.ShowResponseHeaders {
+		for name, vals := range resp.Header {
+			fmt.Fprintf(opts.IO.Out, "%s: %s\r\n", name, strings.Join(vals, ", "))
+		}
+		fmt.Fprint(opts.IO.Out, "\r\n")
+	}
+
+	if resp.StatusCode == 204 {
+		return nil
+	}
+	defer resp.Body.Close()
+
+	_, err = io.Copy(opts.IO.Out, resp.Body)
+	if err != nil {
+		return err
+	}
+
+	// TODO: detect GraphQL errors
+	if resp.StatusCode > 299 {
+		return cmdutil.SilentError
+	}
+
+	return nil
+}
+
+func parseFields(opts *ApiOptions) (map[string]interface{}, error) {
+	params := make(map[string]interface{})
+	for _, f := range opts.RawFields {
+		key, value, err := parseField(f)
+		if err != nil {
+			return params, err
+		}
+		params[key] = value
+	}
+	for _, f := range opts.MagicFields {
+		key, strValue, err := parseField(f)
+		if err != nil {
+			return params, err
+		}
+		value, err := magicFieldValue(strValue, opts.IO.In)
+		if err != nil {
+			return params, fmt.Errorf("error parsing %q value: %w", key, err)
+		}
+		params[key] = value
+	}
+	return params, nil
+}
+
+func parseField(f string) (string, string, error) {
+	idx := strings.IndexRune(f, '=')
+	if idx == -1 {
+		return f, "", fmt.Errorf("field %q requires a value separated by an '=' sign", f)
+	}
+	return f[0:idx], f[idx+1:], nil
+}
+
+func magicFieldValue(v string, stdin io.ReadCloser) (interface{}, error) {
+	if strings.HasPrefix(v, "@") {
+		return readUserFile(v[1:], stdin)
+	}
+
+	if n, err := strconv.Atoi(v); err == nil {
+		return n, nil
+	}
+
+	switch v {
+	case "true":
+		return true, nil
+	case "false":
+		return false, nil
+	case "null":
+		return nil, nil
+	default:
+		return v, nil
+	}
+}
+
+func readUserFile(fn string, stdin io.ReadCloser) ([]byte, error) {
+	var r io.ReadCloser
+	if fn == "-" {
+		r = stdin
+	} else {
+		var err error
+		r, err = os.Open(fn)
+		if err != nil {
+			return nil, err
+		}
+	}
+	defer r.Close()
+	return ioutil.ReadAll(r)
+}

pkg/cmd/api/api_test.go

@@ -0,0 +1,307 @@
+package api
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"testing"
+
+	"github.com/cli/cli/pkg/cmdutil"
+	"github.com/cli/cli/pkg/iostreams"
+	"github.com/google/shlex"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_NewCmdApi(t *testing.T) {
+	f := &cmdutil.Factory{}
+
+	tests := []struct {
+		name     string
+		cli      string
+		wants    ApiOptions
+		wantsErr bool
+	}{
+		{
+			name: "no flags",
+			cli:  "graphql",
+			wants: ApiOptions{
+				RequestMethod:       "GET",
+				RequestMethodPassed: false,
+				RequestPath:         "graphql",
+				RawFields:           []string(nil),
+				MagicFields:         []string(nil),
+				RequestHeaders:      []string(nil),
+				ShowResponseHeaders: false,
+			},
+			wantsErr: false,
+		},
+		{
+			name: "override method",
+			cli:  "repos/octocat/Spoon-Knife -XDELETE",
+			wants: ApiOptions{
+				RequestMethod:       "DELETE",
+				RequestMethodPassed: true,
+				RequestPath:         "repos/octocat/Spoon-Knife",
+				RawFields:           []string(nil),
+				MagicFields:         []string(nil),
+				RequestHeaders:      []string(nil),
+				ShowResponseHeaders: false,
+			},
+			wantsErr: false,
+		},
+		{
+			name: "with fields",
+			cli:  "graphql -f query=QUERY -F body=@file.txt",
+			wants: ApiOptions{
+				RequestMethod:       "GET",
+				RequestMethodPassed: false,
+				RequestPath:         "graphql",
+				RawFields:           []string{"query=QUERY"},
+				MagicFields:         []string{"body=@file.txt"},
+				RequestHeaders:      []string(nil),
+				ShowResponseHeaders: false,
+			},
+			wantsErr: false,
+		},
+		{
+			name: "with headers",
+			cli:  "user -H 'accept: text/plain' -i",
+			wants: ApiOptions{
+				RequestMethod:       "GET",
+				RequestMethodPassed: false,
+				RequestPath:         "user",
+				RawFields:           []string(nil),
+				MagicFields:         []string(nil),
+				RequestHeaders:      []string{"accept: text/plain"},
+				ShowResponseHeaders: true,
+			},
+			wantsErr: false,
+		},
+		{
+			name:     "no arguments",
+			cli:      "",
+			wantsErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd := NewCmdApi(f, func(o *ApiOptions) error {
+				assert.Equal(t, tt.wants.RequestMethod, o.RequestMethod)
+				assert.Equal(t, tt.wants.RequestMethodPassed, o.RequestMethodPassed)
+				assert.Equal(t, tt.wants.RequestPath, o.RequestPath)
+				assert.Equal(t, tt.wants.RawFields, o.RawFields)
+				assert.Equal(t, tt.wants.MagicFields, o.MagicFields)
+				assert.Equal(t, tt.wants.RequestHeaders, o.RequestHeaders)
+				assert.Equal(t, tt.wants.ShowResponseHeaders, o.ShowResponseHeaders)
+				return nil
+			})
+
+			argv, err := shlex.Split(tt.cli)
+			assert.NoError(t, err)
+			cmd.SetArgs(argv)
+			cmd.SetIn(&bytes.Buffer{})
+			cmd.SetOut(&bytes.Buffer{})
+			cmd.SetErr(&bytes.Buffer{})
+			_, err = cmd.ExecuteC()
+			if tt.wantsErr {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+		})
+	}
+}
+
+func Test_apiRun(t *testing.T) {
+	tests := []struct {
+		name         string
+		options      ApiOptions
+		httpResponse *http.Response
+		err          error
+		stdout       string
+		stderr       string
+	}{
+		{
+			name: "success",
+			httpResponse: &http.Response{
+				StatusCode: 200,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`bam!`)),
+			},
+			err:    nil,
+			stdout: `bam!`,
+			stderr: ``,
+		},
+		{
+			name: "show response headers",
+			options: ApiOptions{
+				ShowResponseHeaders: true,
+			},
+			httpResponse: &http.Response{
+				StatusCode: 200,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`body`)),
+				Header:     http.Header{"Content-Type": []string{"text/plain"}},
+			},
+			err:    nil,
+			stdout: "Content-Type: text/plain\r\n\r\nbody",
+			stderr: ``,
+		},
+		{
+			name: "success 204",
+			httpResponse: &http.Response{
+				StatusCode: 204,
+				Body:       nil,
+			},
+			err:    nil,
+			stdout: ``,
+			stderr: ``,
+		},
+		{
+			name: "failure",
+			httpResponse: &http.Response{
+				StatusCode: 502,
+				Body:       ioutil.NopCloser(bytes.NewBufferString(`gateway timeout`)),
+			},
+			err:    cmdutil.SilentError,
+			stdout: `gateway timeout`,
+			stderr: ``,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			io, _, stdout, stderr := iostreams.Test()
+
+			tt.options.IO = io
+			tt.options.HttpClient = func() (*http.Client, error) {
+				var tr roundTripper = func(req *http.Request) (*http.Response, error) {
+					resp := tt.httpResponse
+					resp.Request = req
+					return resp, nil
+				}
+				return &http.Client{Transport: tr}, nil
+			}
+
+			err := apiRun(&tt.options)
+			if err != tt.err {
+				t.Errorf("expected error %v, got %v", tt.err, err)
+			}
+
+			if stdout.String() != tt.stdout {
+				t.Errorf("expected output %q, got %q", tt.stdout, stdout.String())
+			}
+			if stderr.String() != tt.stderr {
+				t.Errorf("expected error output %q, got %q", tt.stderr, stderr.String())
+			}
+		})
+	}
+}
+
+func Test_parseFields(t *testing.T) {
+	io, stdin, _, _ := iostreams.Test()
+	fmt.Fprint(stdin, "pasted contents")
+
+	opts := ApiOptions{
+		IO: io,
+		RawFields: []string{
+			"robot=Hubot",
+			"destroyer=false",
+			"helper=true",
+			"location=@work",
+		},
+		MagicFields: []string{
+			"input=@-",
+			"enabled=true",
+			"victories=123",
+		},
+	}
+
+	params, err := parseFields(&opts)
+	if err != nil {
+		t.Fatalf("parseFields error: %v", err)
+	}
+
+	expect := map[string]interface{}{
+		"robot":     "Hubot",
+		"destroyer": "false",
+		"helper":    "true",
+		"location":  "@work",
+		"input":     []byte("pasted contents"),
+		"enabled":   true,
+		"victories": 123,
+	}
+	assert.Equal(t, expect, params)
+}
+
+func Test_magicFieldValue(t *testing.T) {
+	f, err := ioutil.TempFile("", "gh-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fmt.Fprint(f, "file contents")
+	f.Close()
+	t.Cleanup(func() { os.Remove(f.Name()) })
+
+	type args struct {
+		v     string
+		stdin io.ReadCloser
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    interface{}
+		wantErr bool
+	}{
+		{
+			name:    "string",
+			args:    args{v: "hello"},
+			want:    "hello",
+			wantErr: false,
+		},
+		{
+			name:    "bool true",
+			args:    args{v: "true"},
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name:    "bool false",
+			args:    args{v: "false"},
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name:    "null",
+			args:    args{v: "null"},
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:    "file",
+			args:    args{v: "@" + f.Name()},
+			want:    []byte("file contents"),
+			wantErr: false,
+		},
+		{
+			name:    "file error",
+			args:    args{v: "@"},
+			want:    nil,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := magicFieldValue(tt.args.v, tt.args.stdin)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("magicFieldValue() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if tt.wantErr {
+				return
+			}
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

pkg/cmd/api/http.go

@@ -0,0 +1,115 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+func httpRequest(client *http.Client, method string, p string, params interface{}, headers []string) (*http.Response, error) {
+	// TODO: GHE support
+	url := "https://api.github.com/" + p
+	var body io.Reader
+	var bodyIsJSON bool
+	isGraphQL := p == "graphql"
+
+	switch pp := params.(type) {
+	case map[string]interface{}:
+		if strings.EqualFold(method, "GET") {
+			url = addQuery(url, pp)
+		} else {
+			for key, value := range pp {
+				switch vv := value.(type) {
+				case []byte:
+					pp[key] = string(vv)
+				}
+			}
+			if isGraphQL {
+				pp = groupGraphQLVariables(pp)
+			}
+			b, err := json.Marshal(pp)
+			if err != nil {
+				return nil, fmt.Errorf("error serializing parameters: %w", err)
+			}
+			body = bytes.NewBuffer(b)
+			bodyIsJSON = true
+		}
+	case io.Reader:
+		body = pp
+	case nil:
+		body = nil
+	default:
+		return nil, fmt.Errorf("unrecognized parameters type: %v", params)
+	}
+
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, h := range headers {
+		idx := strings.IndexRune(h, ':')
+		if idx == -1 {
+			return nil, fmt.Errorf("header %q requires a value separated by ':'", h)
+		}
+		req.Header.Add(h[0:idx], strings.TrimSpace(h[idx+1:]))
+	}
+	if bodyIsJSON && req.Header.Get("Content-Type") == "" {
+		req.Header.Set("Content-Type", "application/json; charset=utf-8")
+	}
+
+	return client.Do(req)
+}
+
+func groupGraphQLVariables(params map[string]interface{}) map[string]interface{} {
+	topLevel := make(map[string]interface{})
+	variables := make(map[string]interface{})
+
+	for key, val := range params {
+		switch key {
+		case "query":
+			topLevel[key] = val
+		default:
+			variables[key] = val
+		}
+	}
+
+	if len(variables) > 0 {
+		topLevel["variables"] = variables
+	}
+	return topLevel
+}
+
+func addQuery(path string, params map[string]interface{}) string {
+	if len(params) == 0 {
+		return path
+	}
+
+	query := url.Values{}
+	for key, value := range params {
+		switch v := value.(type) {
+		case string:
+			query.Add(key, v)
+		case []byte:
+			query.Add(key, string(v))
+		case nil:
+			query.Add(key, "")
+		case int:
+			query.Add(key, fmt.Sprintf("%d", v))
+		case bool:
+			query.Add(key, fmt.Sprintf("%v", v))
+		default:
+			panic(fmt.Sprintf("unknown type %v", v))
+		}
+	}
+
+	sep := "?"
+	if strings.ContainsRune(path, '?') {
+		sep = "&"
+	}
+	return path + sep + query.Encode()
+}

pkg/cmd/api/http_test.go

@@ -0,0 +1,306 @@
+package api
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_groupGraphQLVariables(t *testing.T) {
+	tests := []struct {
+		name string
+		args map[string]interface{}
+		want map[string]interface{}
+	}{
+		{
+			name: "empty",
+			args: map[string]interface{}{},
+			want: map[string]interface{}{},
+		},
+		{
+			name: "query only",
+			args: map[string]interface{}{
+				"query": "QUERY",
+			},
+			want: map[string]interface{}{
+				"query": "QUERY",
+			},
+		},
+		{
+			name: "variables only",
+			args: map[string]interface{}{
+				"name": "hubot",
+			},
+			want: map[string]interface{}{
+				"variables": map[string]interface{}{
+					"name": "hubot",
+				},
+			},
+		},
+		{
+			name: "query + variables",
+			args: map[string]interface{}{
+				"query": "QUERY",
+				"name":  "hubot",
+				"power": 9001,
+			},
+			want: map[string]interface{}{
+				"query": "QUERY",
+				"variables": map[string]interface{}{
+					"name":  "hubot",
+					"power": 9001,
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := groupGraphQLVariables(tt.args)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+type roundTripper func(*http.Request) (*http.Response, error)
+
+func (f roundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	return f(req)
+}
+
+func Test_httpRequest(t *testing.T) {
+	var tr roundTripper = func(req *http.Request) (*http.Response, error) {
+		return &http.Response{Request: req}, nil
+	}
+	httpClient := http.Client{Transport: tr}
+
+	type args struct {
+		client  *http.Client
+		method  string
+		p       string
+		params  interface{}
+		headers []string
+	}
+	type expects struct {
+		method  string
+		u       string
+		body    string
+		headers string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    expects
+		wantErr bool
+	}{
+		{
+			name: "simple GET",
+			args: args{
+				client:  &httpClient,
+				method:  "GET",
+				p:       "repos/octocat/spoon-knife",
+				params:  nil,
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "GET",
+				u:       "https://api.github.com/repos/octocat/spoon-knife",
+				body:    "",
+				headers: "",
+			},
+		},
+		{
+			name: "GET with params",
+			args: args{
+				client: &httpClient,
+				method: "GET",
+				p:      "repos/octocat/spoon-knife",
+				params: map[string]interface{}{
+					"a": "b",
+				},
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "GET",
+				u:       "https://api.github.com/repos/octocat/spoon-knife?a=b",
+				body:    "",
+				headers: "",
+			},
+		},
+		{
+			name: "POST with params",
+			args: args{
+				client: &httpClient,
+				method: "POST",
+				p:      "repos",
+				params: map[string]interface{}{
+					"a": "b",
+				},
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "POST",
+				u:       "https://api.github.com/repos",
+				body:    `{"a":"b"}`,
+				headers: "Content-Type: application/json; charset=utf-8\r\n",
+			},
+		},
+		{
+			name: "POST GraphQL",
+			args: args{
+				client: &httpClient,
+				method: "POST",
+				p:      "graphql",
+				params: map[string]interface{}{
+					"a": []byte("b"),
+				},
+				headers: []string{},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "POST",
+				u:       "https://api.github.com/graphql",
+				body:    `{"variables":{"a":"b"}}`,
+				headers: "Content-Type: application/json; charset=utf-8\r\n",
+			},
+		},
+		{
+			name: "POST with body and type",
+			args: args{
+				client: &httpClient,
+				method: "POST",
+				p:      "repos",
+				params: bytes.NewBufferString("CUSTOM"),
+				headers: []string{
+					"content-type: text/plain",
+					"accept: application/json",
+				},
+			},
+			wantErr: false,
+			want: expects{
+				method:  "POST",
+				u:       "https://api.github.com/repos",
+				body:    `CUSTOM`,
+				headers: "Accept: application/json\r\nContent-Type: text/plain\r\n",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := httpRequest(tt.args.client, tt.args.method, tt.args.p, tt.args.params, tt.args.headers)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("httpRequest() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			req := got.Request
+			if req.Method != tt.want.method {
+				t.Errorf("Request.Method = %q, want %q", req.Method, tt.want.method)
+			}
+			if req.URL.String() != tt.want.u {
+				t.Errorf("Request.URL = %q, want %q", req.URL.String(), tt.want.u)
+			}
+
+			if tt.want.body != "" {
+				bb, err := ioutil.ReadAll(req.Body)
+				if err != nil {
+					t.Errorf("Request.Body ReadAll error = %v", err)
+					return
+				}
+				if string(bb) != tt.want.body {
+					t.Errorf("Request.Body = %q, want %q", string(bb), tt.want.body)
+				}
+			}
+
+			h := bytes.Buffer{}
+			err = req.Header.WriteSubset(&h, map[string]bool{})
+			if err != nil {
+				t.Errorf("Request.Header WriteSubset error = %v", err)
+				return
+			}
+			if h.String() != tt.want.headers {
+				t.Errorf("Request.Header = %q, want %q", h.String(), tt.want.headers)
+			}
+		})
+	}
+}
+
+func Test_addQuery(t *testing.T) {
+	type args struct {
+		path   string
+		params map[string]interface{}
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "string",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": "hello"},
+			},
+			want: "?a=hello",
+		},
+		{
+			name: "append",
+			args: args{
+				path:   "path",
+				params: map[string]interface{}{"a": "b"},
+			},
+			want: "path?a=b",
+		},
+		{
+			name: "append query",
+			args: args{
+				path:   "path?foo=bar",
+				params: map[string]interface{}{"a": "b"},
+			},
+			want: "path?foo=bar&a=b",
+		},
+		{
+			name: "[]byte",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": []byte("hello")},
+			},
+			want: "?a=hello",
+		},
+		{
+			name: "int",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": 123},
+			},
+			want: "?a=123",
+		},
+		{
+			name: "nil",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": nil},
+			},
+			want: "?a=",
+		},
+		{
+			name: "bool",
+			args: args{
+				path:   "",
+				params: map[string]interface{}{"a": true, "b": false},
+			},
+			want: "?a=true&b=false",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := addQuery(tt.args.path, tt.args.params); got != tt.want {
+				t.Errorf("addQuery() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

pkg/cmdutil/errors.go

@@ -0,0 +1,19 @@
+package cmdutil
+
+import "errors"
+
+// FlagError is the kind of error raised in flag processing
+type FlagError struct {
+	Err error
+}
+
+func (fe FlagError) Error() string {
+	return fe.Err.Error()
+}
+
+func (fe FlagError) Unwrap() error {
+	return fe.Err
+}
+
+// SilentError is an error that triggers exit code 1 without any error messaging
+var SilentError = errors.New("SilentError")

pkg/cmdutil/factory.go

@@ -0,0 +1,12 @@
+package cmdutil
+
+import (
+	"net/http"
+
+	"github.com/cli/cli/pkg/iostreams"
+)
+
+type Factory struct {
+	IOStreams  *iostreams.IOStreams
+	HttpClient func() (*http.Client, error)
+}

pkg/iostreams/iostreams.go

@@ -0,0 +1,33 @@
+package iostreams
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"os"
+)
+
+type IOStreams struct {
+	In     io.ReadCloser
+	Out    io.Writer
+	ErrOut io.Writer
+}
+
+func System() *IOStreams {
+	return &IOStreams{
+		In:     os.Stdin,
+		Out:    os.Stdout,
+		ErrOut: os.Stderr,
+	}
+}
+
+func Test() (*IOStreams, *bytes.Buffer, *bytes.Buffer, *bytes.Buffer) {
+	in := &bytes.Buffer{}
+	out := &bytes.Buffer{}
+	errOut := &bytes.Buffer{}
+	return &IOStreams{
+		In:     ioutil.NopCloser(in),
+		Out:    out,
+		ErrOut: errOut,
+	}, in, out, errOut
+}

test/fixtures/gistCreate.json

@@ -0,0 +1 @@
+{}

test/fixtures/prViewPreviewWithReviewersByNumber.json

@@ -70,6 +70,24 @@
                 "login": ""
               },
               "state": "APPROVED"
+            },
+            {
+              "author": {
+                "login": "hubot"
+              },
+              "state": "CHANGES_REQUESTED"
+            },
+            {
+              "author": {
+                "login": "hubot"
+              },
+              "state": "DISMISSED"
+            },
+            {
+              "author": {
+                "login": "monalisa"
+              },
+              "state": "PENDING"
             }
           ]
         },

test/helpers.go

@@ -68,6 +68,7 @@ func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {
 		if call >= len(cs.Stubs) {
 			panic(fmt.Sprintf("more execs than stubs. most recent call: %v", cmd))
 		}
+		// fmt.Printf("Called stub for `%v`\n", cmd) // Helpful for debugging
 		return cs.Stubs[call]
 	}
 }

wix.json

@@ -27,6 +27,6 @@
     "description": "Use GitHub from the CLI",
     "project-url": "https://github.com/cli/cli",
     "tags": "github cli git",
-    "license-url": "https://github.com/cli/cli/blob/master/LICENSE"
+    "license-url": "https://github.com/cli/cli/blob/trunk/LICENSE"
   }
 }