Merge pull request #7376 from joshkraft/gh-search-code

Create `gh search code` command
2023-06-09 18:19:03 +02:00 · 2023-06-09 18:19:03 +02:00 · a81d01432e
commit a81d01432e
parent 04f6cf56ac cb93db2b22
13 changed files with 1031 additions and 99 deletions
--- a/pkg/cmd/extension/browse/browse_test.go
+++ b/pkg/cmd/extension/browse/browse_test.go
@ -84,43 +84,43 @@ func Test_getExtensionRepos(t *testing.T) {

 	reg.Register(
 		httpmock.QueryMatcher("GET", "search/repositories", values),
-		httpmock.JSONResponse(search.RepositoriesResult{
-			IncompleteResults: false,
-			Items: []search.Repository{
-				{
-					FullName:    "vilmibm/gh-screensaver",
-					Name:        "gh-screensaver",
-					Description: "terminal animations",
-					Owner: search.User{
-						Login: "vilmibm",
+		httpmock.JSONResponse(map[string]interface{}{
+			"incomplete_results": false,
+			"total_count":        4,
+			"items": []interface{}{
+				map[string]interface{}{
+					"name":        "gh-screensaver",
+					"full_name":   "vilmibm/gh-screensaver",
+					"description": "terminal animations",
+					"owner": map[string]interface{}{
+						"login": "vilmibm",
 					},
 				},
-				{
-					FullName:    "cli/gh-cool",
-					Name:        "gh-cool",
-					Description: "it's just cool ok",
-					Owner: search.User{
-						Login: "cli",
+				map[string]interface{}{
+					"name":        "gh-cool",
+					"full_name":   "cli/gh-cool",
+					"description": "it's just cool ok",
+					"owner": map[string]interface{}{
+						"login": "cli",
 					},
 				},
-				{
-					FullName:    "samcoe/gh-triage",
-					Name:        "gh-triage",
-					Description: "helps with triage",
-					Owner: search.User{
-						Login: "samcoe",
+				map[string]interface{}{
+					"name":        "gh-triage",
+					"full_name":   "samcoe/gh-triage",
+					"description": "helps with triage",
+					"owner": map[string]interface{}{
+						"login": "samcoe",
 					},
 				},
-				{
-					FullName:    "github/gh-gei",
-					Name:        "gh-gei",
-					Description: "something something enterprise",
-					Owner: search.User{
-						Login: "github",
+				map[string]interface{}{
+					"name":        "gh-gei",
+					"full_name":   "github/gh-gei",
+					"description": "something something enterprise",
+					"owner": map[string]interface{}{
+						"login": "github",
 					},
 				},
 			},
-			Total: 4,
 		}),
 	)

--- a/pkg/cmd/extension/command_test.go
+++ b/pkg/cmd/extension/command_test.go
@ -19,7 +19,6 @@ import (
 	"github.com/cli/cli/v2/pkg/extensions"
 	"github.com/cli/cli/v2/pkg/httpmock"
 	"github.com/cli/cli/v2/pkg/iostreams"
-	"github.com/cli/cli/v2/pkg/search"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 )
@ -74,7 +73,7 @@ func TestNewCmdExtension(t *testing.T) {
 				}
 				reg.Register(
 					httpmock.QueryMatcher("GET", "search/repositories", values),
-					httpmock.JSONResponse(searchResults()),
+					httpmock.JSONResponse(searchResults(4)),
 				)
 			},
 			isTTY:      true,
@ -111,7 +110,7 @@ func TestNewCmdExtension(t *testing.T) {
 				}
 				reg.Register(
 					httpmock.QueryMatcher("GET", "search/repositories", values),
-					httpmock.JSONResponse(searchResults()),
+					httpmock.JSONResponse(searchResults(4)),
 				)
 			},
 			wantStdout: "installed\tvilmibm/gh-screensaver\tterminal animations\n\tcli/gh-cool\tit's just cool ok\n\tsamcoe/gh-triage\thelps with triage\ninstalled\tgithub/gh-gei\tsomething something enterprise\n",
@ -145,9 +144,7 @@ func TestNewCmdExtension(t *testing.T) {
 					"per_page": []string{"30"},
 					"q":        []string{"screen topic:gh-extension"},
 				}
-				results := searchResults()
-				results.Total = 1
-				results.Items = []search.Repository{results.Items[0]}
+				results := searchResults(1)
 				reg.Register(
 					httpmock.QueryMatcher("GET", "search/repositories", values),
 					httpmock.JSONResponse(results),
@ -175,9 +172,7 @@ func TestNewCmdExtension(t *testing.T) {
 					"per_page": []string{"1"},
 					"q":        []string{"topic:gh-extension"},
 				}
-				results := searchResults()
-				results.Total = 1
-				results.Items = []search.Repository{results.Items[0]}
+				results := searchResults(1)
 				reg.Register(
 					httpmock.QueryMatcher("GET", "search/repositories", values),
 					httpmock.JSONResponse(results),
@ -203,9 +198,7 @@ func TestNewCmdExtension(t *testing.T) {
 					"per_page": []string{"30"},
 					"q":        []string{"license:GPLv3 topic:gh-extension user:jillvalentine"},
 				}
-				results := searchResults()
-				results.Total = 1
-				results.Items = []search.Repository{results.Items[0]}
+				results := searchResults(1)
 				reg.Register(
 					httpmock.QueryMatcher("GET", "search/repositories", values),
 					httpmock.JSONResponse(results),
@ -998,43 +991,48 @@ func Test_checkValidExtension(t *testing.T) {
 	}
 }

-func searchResults() search.RepositoriesResult {
-	return search.RepositoriesResult{
-		IncompleteResults: false,
-		Items: []search.Repository{
-			{
-				FullName:    "vilmibm/gh-screensaver",
-				Name:        "gh-screensaver",
-				Description: "terminal animations",
-				Owner: search.User{
-					Login: "vilmibm",
+func searchResults(numResults int) interface{} {
+	result := map[string]interface{}{
+		"incomplete_results": false,
+		"total_count":        4,
+		"items": []interface{}{
+			map[string]interface{}{
+				"name":        "gh-screensaver",
+				"full_name":   "vilmibm/gh-screensaver",
+				"description": "terminal animations",
+				"owner": map[string]interface{}{
+					"login": "vilmibm",
 				},
 			},
-			{
-				FullName:    "cli/gh-cool",
-				Name:        "gh-cool",
-				Description: "it's just cool ok",
-				Owner: search.User{
-					Login: "cli",
+			map[string]interface{}{
+				"name":        "gh-cool",
+				"full_name":   "cli/gh-cool",
+				"description": "it's just cool ok",
+				"owner": map[string]interface{}{
+					"login": "cli",
 				},
 			},
-			{
-				FullName:    "samcoe/gh-triage",
-				Name:        "gh-triage",
-				Description: "helps with triage",
-				Owner: search.User{
-					Login: "samcoe",
+			map[string]interface{}{
+				"name":        "gh-triage",
+				"full_name":   "samcoe/gh-triage",
+				"description": "helps with triage",
+				"owner": map[string]interface{}{
+					"login": "samcoe",
 				},
 			},
-			{
-				FullName:    "github/gh-gei",
-				Name:        "gh-gei",
-				Description: "something something enterprise",
-				Owner: search.User{
-					Login: "github",
+			map[string]interface{}{
+				"name":        "gh-gei",
+				"full_name":   "github/gh-gei",
+				"description": "something something enterprise",
+				"owner": map[string]interface{}{
+					"login": "github",
 				},
 			},
 		},
-		Total: 4,
 	}
+	if len(result["items"].([]interface{})) > numResults {
+		fewerItems := result["items"].([]interface{})[0:numResults]
+		result["items"] = fewerItems
+	}
+	return result
 }
--- a/pkg/cmd/search/code/code.go
+++ b/pkg/cmd/search/code/code.go
@ -0,0 +1,204 @@
+package code
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/MakeNowJust/heredoc"
+	"github.com/cli/cli/v2/internal/browser"
+	"github.com/cli/cli/v2/internal/text"
+	"github.com/cli/cli/v2/pkg/cmd/search/shared"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/cli/cli/v2/pkg/search"
+	"github.com/spf13/cobra"
+)
+
+type CodeOptions struct {
+	Browser  browser.Browser
+	Exporter cmdutil.Exporter
+	IO       *iostreams.IOStreams
+	Query    search.Query
+	Searcher search.Searcher
+	WebMode  bool
+}
+
+func NewCmdCode(f *cmdutil.Factory, runF func(*CodeOptions) error) *cobra.Command {
+	opts := &CodeOptions{
+		Browser: f.Browser,
+		IO:      f.IOStreams,
+		Query:   search.Query{Kind: search.KindCode},
+	}
+
+	cmd := &cobra.Command{
+		Use:   "code <query>",
+		Short: "Search within code",
+		Long: heredoc.Doc(`
+			Search within code in GitHub repositories.
+
+			The search syntax is documented at:
+			<https://docs.github.com/search-github/searching-on-github/searching-code>
+
+			Note that these search results are powered by what is now a legacy GitHub code search engine.
+			The results might not match what is seen on GitHub.com, and new features like regex search
+			are not yet available via the GitHub API.
+		`),
+		Example: heredoc.Doc(`
+			# search code matching "react" and "lifecycle"
+			$ gh search code react lifecycle
+
+			# search code matching "error handling" 
+			$ gh search code "error handling"
+	
+			# search code matching "deque" in Python files
+			$ gh search code deque --language=python
+
+			# search code matching "cli" in repositories owned by microsoft organization
+			$ gh search code cli --owner=microsoft
+
+			# search code matching "panic" in the GitHub CLI repository
+			$ gh search code panic --repo cli/cli
+
+			# search code matching keyword "lint" in package.json files
+			$ gh search code lint --filename package.json
+		`),
+		RunE: func(c *cobra.Command, args []string) error {
+			if len(args) == 0 && c.Flags().NFlag() == 0 {
+				return cmdutil.FlagErrorf("specify search keywords or flags")
+			}
+			if opts.Query.Limit < 1 || opts.Query.Limit > shared.SearchMaxResults {
+				return cmdutil.FlagErrorf("`--limit` must be between 1 and 1000")
+			}
+			opts.Query.Keywords = args
+			if runF != nil {
+				return runF(opts)
+			}
+			var err error
+			opts.Searcher, err = shared.Searcher(f)
+			if err != nil {
+				return err
+			}
+			return codeRun(opts)
+		},
+	}
+
+	// Output flags
+	cmdutil.AddJSONFlags(cmd, &opts.Exporter, search.CodeFields)
+	cmd.Flags().BoolVarP(&opts.WebMode, "web", "w", false, "Open the search query in the web browser")
+
+	// Query parameter flags
+	cmd.Flags().IntVarP(&opts.Query.Limit, "limit", "L", 30, "Maximum number of code results to fetch")
+
+	// Query qualifier flags
+	cmd.Flags().StringVar(&opts.Query.Qualifiers.Extension, "extension", "", "Filter on file extension")
+	cmd.Flags().StringVar(&opts.Query.Qualifiers.Filename, "filename", "", "Filter on filename")
+	cmdutil.StringSliceEnumFlag(cmd, &opts.Query.Qualifiers.In, "match", "", nil, []string{"file", "path"}, "Restrict search to file contents or file path")
+	cmd.Flags().StringVarP(&opts.Query.Qualifiers.Language, "language", "", "", "Filter results by language")
+	cmd.Flags().StringSliceVarP(&opts.Query.Qualifiers.Repo, "repo", "R", nil, "Filter on repository")
+	cmd.Flags().StringVar(&opts.Query.Qualifiers.Size, "size", "", "Filter on size range, in kilobytes")
+	cmd.Flags().StringSliceVar(&opts.Query.Qualifiers.User, "owner", nil, "Filter on owner")
+
+	return cmd
+}
+
+func codeRun(opts *CodeOptions) error {
+	io := opts.IO
+	if opts.WebMode {
+		// FIXME: convert legacy `filename` and `extension` ES qualifiers to Blackbird's `path` qualifier
+		// when opening web search, otherwise the Blackbird search UI will complain.
+		url := opts.Searcher.URL(opts.Query)
+		if io.IsStdoutTTY() {
+			fmt.Fprintf(io.ErrOut, "Opening %s in your browser.\n", text.DisplayURL(url))
+		}
+		return opts.Browser.Browse(url)
+	}
+	io.StartProgressIndicator()
+	results, err := opts.Searcher.Code(opts.Query)
+	io.StopProgressIndicator()
+	if err != nil {
+		return err
+	}
+	if len(results.Items) == 0 && opts.Exporter == nil {
+		return cmdutil.NewNoResultsError("no code results matched your search")
+	}
+	if err := io.StartPager(); err == nil {
+		defer io.StopPager()
+	} else {
+		fmt.Fprintf(io.ErrOut, "failed to start pager: %v\n", err)
+	}
+	if opts.Exporter != nil {
+		return opts.Exporter.Write(io, results.Items)
+	}
+
+	return displayResults(io, results)
+}
+
+func displayResults(io *iostreams.IOStreams, results search.CodeResult) error {
+	cs := io.ColorScheme()
+	if io.IsStdoutTTY() {
+		fmt.Fprintf(io.Out, "\nShowing %d of %d results\n\n", len(results.Items), results.Total)
+		for i, code := range results.Items {
+			if i > 0 {
+				fmt.Fprint(io.Out, "\n")
+			}
+			fmt.Fprintf(io.Out, "%s %s\n", cs.Blue(code.Repository.FullName), cs.GreenBold(code.Path))
+			for _, match := range code.TextMatches {
+				lines := formatMatch(match.Fragment, match.Matches, io.ColorEnabled())
+				for _, line := range lines {
+					fmt.Fprintf(io.Out, "\t%s\n", strings.TrimSpace(line))
+				}
+			}
+		}
+		return nil
+	}
+	for _, code := range results.Items {
+		for _, match := range code.TextMatches {
+			lines := formatMatch(match.Fragment, match.Matches, io.ColorEnabled())
+			for _, line := range lines {
+				fmt.Fprintf(io.Out, "%s:%s: %s\n", cs.Blue(code.Repository.FullName), cs.GreenBold(code.Path), strings.TrimSpace(line))
+			}
+		}
+	}
+	return nil
+}
+
+func formatMatch(t string, matches []search.Match, colorize bool) []string {
+	startIndices := map[int]struct{}{}
+	endIndices := map[int]struct{}{}
+	for _, m := range matches {
+		if len(m.Indices) < 2 {
+			continue
+		}
+		startIndices[m.Indices[0]] = struct{}{}
+		endIndices[m.Indices[1]] = struct{}{}
+	}
+
+	var lines []string
+	var b strings.Builder
+	var found bool
+	for i, c := range t {
+		if c == '\n' {
+			if found {
+				lines = append(lines, b.String())
+			}
+			found = false
+			b.Reset()
+			continue
+		}
+		if _, ok := startIndices[i]; ok {
+			if colorize {
+				b.WriteString("\x1b[30;43m") // black text on yellow background
+			}
+			found = true
+		} else if _, ok := endIndices[i]; ok {
+			if colorize {
+				b.WriteString("\x1b[m") // color reset
+			}
+		}
+		b.WriteRune(c)
+	}
+	if found {
+		lines = append(lines, b.String())
+	}
+	return lines
+}
--- a/pkg/cmd/search/code/code_test.go
+++ b/pkg/cmd/search/code/code_test.go
@ -0,0 +1,342 @@
+package code
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	"github.com/cli/cli/v2/internal/browser"
+	"github.com/cli/cli/v2/pkg/cmdutil"
+	"github.com/cli/cli/v2/pkg/iostreams"
+	"github.com/cli/cli/v2/pkg/search"
+	"github.com/google/shlex"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewCmdCode(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		output  CodeOptions
+		wantErr bool
+		errMsg  string
+	}{
+		{
+			name:    "no arguments",
+			input:   "",
+			wantErr: true,
+			errMsg:  "specify search keywords or flags",
+		},
+		{
+			name:  "keyword arguments",
+			input: "react lifecycle",
+			output: CodeOptions{
+				Query: search.Query{
+					Keywords: []string{"react", "lifecycle"},
+					Kind:     "code",
+					Limit:    30,
+				},
+			},
+		},
+		{
+			name:  "web flag",
+			input: "--web",
+			output: CodeOptions{
+				Query: search.Query{
+					Keywords: []string{},
+					Kind:     "code",
+					Limit:    30,
+				},
+				WebMode: true,
+			},
+		},
+		{
+			name:  "limit flag",
+			input: "--limit 10",
+			output: CodeOptions{
+				Query: search.Query{
+					Keywords: []string{},
+					Kind:     "code",
+					Limit:    10,
+				},
+			},
+		},
+		{
+			name:    "invalid limit flag",
+			input:   "--limit 1001",
+			wantErr: true,
+			errMsg:  "`--limit` must be between 1 and 1000",
+		},
+		{
+			name: "qualifier flags",
+			input: `
+			--extension=extension
+			--filename=filename
+			--match=path,file
+			--language=language
+			--repo=owner/repo
+			--size=5
+			--owner=owner
+			`,
+			output: CodeOptions{
+				Query: search.Query{
+					Keywords: []string{},
+					Kind:     "code",
+					Limit:    30,
+					Qualifiers: search.Qualifiers{
+						Extension: "extension",
+						Filename:  "filename",
+						In:        []string{"path", "file"},
+						Language:  "language",
+						Repo:      []string{"owner/repo"},
+						Size:      "5",
+						User:      []string{"owner"},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ios, _, _, _ := iostreams.Test()
+			f := &cmdutil.Factory{
+				IOStreams: ios,
+			}
+			argv, err := shlex.Split(tt.input)
+			assert.NoError(t, err)
+			var gotOpts *CodeOptions
+			cmd := NewCmdCode(f, func(opts *CodeOptions) error {
+				gotOpts = opts
+				return nil
+			})
+			cmd.SetArgs(argv)
+			cmd.SetIn(&bytes.Buffer{})
+			cmd.SetOut(&bytes.Buffer{})
+			cmd.SetErr(&bytes.Buffer{})
+
+			_, err = cmd.ExecuteC()
+			if tt.wantErr {
+				assert.EqualError(t, err, tt.errMsg)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.output.Query, gotOpts.Query)
+			assert.Equal(t, tt.output.WebMode, gotOpts.WebMode)
+		})
+	}
+}
+
+func TestCodeRun(t *testing.T) {
+	var query = search.Query{
+		Keywords: []string{"map"},
+		Kind:     "code",
+		Limit:    30,
+		Qualifiers: search.Qualifiers{
+			Language: "go",
+			Repo:     []string{"cli/cli"},
+		},
+	}
+	tests := []struct {
+		errMsg     string
+		name       string
+		opts       *CodeOptions
+		tty        bool
+		wantErr    bool
+		wantStderr string
+		wantStdout string
+	}{
+		{
+			name: "displays results tty",
+			opts: &CodeOptions{
+				Query: query,
+				Searcher: &search.SearcherMock{
+					CodeFunc: func(query search.Query) (search.CodeResult, error) {
+						return search.CodeResult{
+							IncompleteResults: false,
+							Items: []search.Code{
+								{
+									Name: "context.go",
+									Path: "context/context.go",
+									Repository: search.Repository{
+										FullName: "cli/cli",
+									},
+									TextMatches: []search.TextMatch{
+										{
+											Fragment: "\t}\n\n\tvar repos []*api.Repository\n\trepoMap := map[string]bool{}\n\n\tadd := func(r *api.Repository) {\n\t\tfn := ghrepo.FullName(r)",
+											Matches: []search.Match{
+												{
+													Text:    "Map",
+													Indices: []int{38, 41},
+												},
+												{
+													Text:    "map",
+													Indices: []int{45, 48},
+												},
+											},
+										},
+									},
+								},
+								{
+									Name: "pr.go",
+									Path: "pkg/cmd/pr/pr.go",
+									Repository: search.Repository{
+										FullName: "cli/cli",
+									},
+									TextMatches: []search.TextMatch{
+										{
+
+											Fragment: "\t\t\t$ gh pr create --fill\n\t\t\t$ gh pr view --web\n\t\t`),\n\t\tAnnotations: map[string]string{\n\t\t\t\"help:arguments\": heredoc.Doc(`\n\t\t\t\tA pull request can be supplied as argument in any of the following formats:\n\t\t\t\t- by number, e.g. \"123\";",
+											Matches: []search.Match{
+												{
+													Text:    "map",
+													Indices: []int{68, 71},
+												},
+											},
+										},
+									},
+								},
+							},
+							Total: 2,
+						}, nil
+					},
+				},
+			},
+			tty:        true,
+			wantStdout: "\nShowing 2 of 2 results\n\ncli/cli context/context.go\n\trepoMap := map[string]bool{}\n\ncli/cli pkg/cmd/pr/pr.go\n\tAnnotations: map[string]string{\n",
+		},
+		{
+			name: "displays results notty",
+			opts: &CodeOptions{
+				Query: query,
+				Searcher: &search.SearcherMock{
+					CodeFunc: func(query search.Query) (search.CodeResult, error) {
+						return search.CodeResult{
+							IncompleteResults: false,
+							Items: []search.Code{
+								{
+									Name: "context.go",
+									Path: "context/context.go",
+									Repository: search.Repository{
+										FullName: "cli/cli",
+									},
+									TextMatches: []search.TextMatch{
+										{
+											Fragment: "\t}\n\n\tvar repos []*api.Repository\n\trepoMap := map[string]bool{}\n\n\tadd := func(r *api.Repository) {\n\t\tfn := ghrepo.FullName(r)",
+											Matches: []search.Match{
+												{
+													Text:    "Map",
+													Indices: []int{38, 41},
+												},
+												{
+													Text:    "map",
+													Indices: []int{45, 48},
+												},
+											},
+										},
+									},
+								},
+								{
+									Name: "pr.go",
+									Path: "pkg/cmd/pr/pr.go",
+									Repository: search.Repository{
+										FullName: "cli/cli",
+									},
+									TextMatches: []search.TextMatch{
+										{
+
+											Fragment: "\t\t\t$ gh pr create --fill\n\t\t\t$ gh pr view --web\n\t\t`),\n\t\tAnnotations: map[string]string{\n\t\t\t\"help:arguments\": heredoc.Doc(`\n\t\t\t\tA pull request can be supplied as argument in any of the following formats:\n\t\t\t\t- by number, e.g. \"123\";",
+											Matches: []search.Match{
+												{
+													Text:    "map",
+													Indices: []int{68, 71},
+												},
+											},
+										},
+									},
+								},
+							},
+							Total: 2,
+						}, nil
+					},
+				},
+			},
+			tty:        false,
+			wantStdout: "cli/cli:context/context.go: repoMap := map[string]bool{}\ncli/cli:pkg/cmd/pr/pr.go: Annotations: map[string]string{\n",
+		},
+		{
+			name: "displays no results",
+			opts: &CodeOptions{
+				Query: query,
+				Searcher: &search.SearcherMock{
+					CodeFunc: func(query search.Query) (search.CodeResult, error) {
+						return search.CodeResult{}, nil
+					},
+				},
+			},
+			wantErr: true,
+			errMsg:  "no code results matched your search",
+		},
+		{
+			name: "displays search error",
+			opts: &CodeOptions{
+				Query: query,
+				Searcher: &search.SearcherMock{
+					CodeFunc: func(query search.Query) (search.CodeResult, error) {
+						return search.CodeResult{}, fmt.Errorf("error with query")
+					},
+				},
+			},
+			wantErr: true,
+			errMsg:  "error with query",
+		},
+		{
+			name: "opens browser for web mode tty",
+			opts: &CodeOptions{
+				Browser: &browser.Stub{},
+				Query:   query,
+				Searcher: &search.SearcherMock{
+					URLFunc: func(query search.Query) string {
+						return "https://github.com/search?type=code&q=map+repo%3Acli%2Fcli"
+					},
+				},
+				WebMode: true,
+			},
+			tty:        true,
+			wantStderr: "Opening github.com/search in your browser.\n",
+		},
+		{
+			name: "opens browser for web mode notty",
+			opts: &CodeOptions{
+				Browser: &browser.Stub{},
+				Query:   query,
+				Searcher: &search.SearcherMock{
+					URLFunc: func(query search.Query) string {
+						return "https://github.com/search?type=code&q=map+repo%3Acli%2Fcli"
+					},
+				},
+				WebMode: true,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		ios, _, stdout, stderr := iostreams.Test()
+		ios.SetStdinTTY(tt.tty)
+		ios.SetStdoutTTY(tt.tty)
+		ios.SetStderrTTY(tt.tty)
+		tt.opts.IO = ios
+		t.Run(tt.name, func(t *testing.T) {
+			err := codeRun(tt.opts)
+			if tt.wantErr {
+				assert.EqualError(t, err, tt.errMsg)
+				return
+			} else if err != nil {
+				t.Fatalf("codeRun unexpected error: %v", err)
+			}
+			assert.Equal(t, tt.wantStdout, stdout.String())
+			assert.Equal(t, tt.wantStderr, stderr.String())
+		})
+	}
+}
--- a/pkg/cmd/search/search.go
+++ b/pkg/cmd/search/search.go
@ -4,6 +4,7 @@ import (
 	"github.com/cli/cli/v2/pkg/cmdutil"
 	"github.com/spf13/cobra"

+	searchCodeCmd "github.com/cli/cli/v2/pkg/cmd/search/code"
 	searchCommitsCmd "github.com/cli/cli/v2/pkg/cmd/search/commits"
 	searchIssuesCmd "github.com/cli/cli/v2/pkg/cmd/search/issues"
 	searchPrsCmd "github.com/cli/cli/v2/pkg/cmd/search/prs"
@ -17,6 +18,7 @@ func NewCmdSearch(f *cmdutil.Factory) *cobra.Command {
 		Long:  "Search across all of GitHub.",
 	}

+	cmd.AddCommand(searchCodeCmd.NewCmdCode(f, nil))
 	cmd.AddCommand(searchCommitsCmd.NewCmdCommits(f, nil))
 	cmd.AddCommand(searchIssuesCmd.NewCmdIssues(f, nil))
 	cmd.AddCommand(searchPrsCmd.NewCmdPrs(f, nil))
--- a/pkg/iostreams/color.go
+++ b/pkg/iostreams/color.go
@ -9,15 +9,16 @@ import (
 )

 var (
-	magenta  = ansi.ColorFunc("magenta")
-	cyan     = ansi.ColorFunc("cyan")
-	red      = ansi.ColorFunc("red")
-	yellow   = ansi.ColorFunc("yellow")
-	blue     = ansi.ColorFunc("blue")
-	green    = ansi.ColorFunc("green")
-	gray     = ansi.ColorFunc("black+h")
-	bold     = ansi.ColorFunc("default+b")
-	cyanBold = ansi.ColorFunc("cyan+b")
+	magenta   = ansi.ColorFunc("magenta")
+	cyan      = ansi.ColorFunc("cyan")
+	red       = ansi.ColorFunc("red")
+	yellow    = ansi.ColorFunc("yellow")
+	blue      = ansi.ColorFunc("blue")
+	green     = ansi.ColorFunc("green")
+	gray      = ansi.ColorFunc("black+h")
+	bold      = ansi.ColorFunc("default+b")
+	cyanBold  = ansi.ColorFunc("cyan+b")
+	greenBold = ansi.ColorFunc("green+b")

 	gray256 = func(t string) string {
 		return fmt.Sprintf("\x1b[%d;5;%dm%s\x1b[m", 38, 242, t)
@ -82,6 +83,13 @@ func (c *ColorScheme) Greenf(t string, args ...interface{}) string {
 	return c.Green(fmt.Sprintf(t, args...))
 }

+func (c *ColorScheme) GreenBold(t string) string {
+	if !c.enabled {
+		return t
+	}
+	return greenBold(t)
+}
+
 func (c *ColorScheme) Gray(t string) string {
 	if !c.enabled {
 		return t
--- a/pkg/search/query.go
+++ b/pkg/search/query.go
@ -10,6 +10,7 @@ import (

 const (
 	KindRepositories = "repositories"
+	KindCode         = "code"
 	KindIssues       = "issues"
 	KindCommits      = "commits"
 )
@ -41,6 +42,8 @@ type Qualifiers struct {
 	CommitterName       string
 	Created             string
 	Draft               *bool
+	Extension           string
+	Filename            string
 	Followers           string
 	Fork                string
 	Forks               string
--- a/pkg/search/query_test.go
+++ b/pkg/search/query_test.go
@ -23,6 +23,8 @@ func TestQueryString(t *testing.T) {
 					AuthorEmail:      "foo@example.com",
 					CommitterDate:    "2021-02-28",
 					Created:          "created",
+					Extension:        "go",
+					Filename:         ".vimrc",
 					Followers:        "1",
 					Fork:             "true",
 					Forks:            "2",
@ -41,7 +43,7 @@ func TestQueryString(t *testing.T) {
 				},
 			},
 			out: "some keywords archived:true author-email:foo@example.com committer-date:2021-02-28 " +
-				"created:created followers:1 fork:true forks:2 good-first-issues:3 help-wanted-issues:4 " +
+				"created:created extension:go filename:.vimrc followers:1 fork:true forks:2 good-first-issues:3 help-wanted-issues:4 " +
 				"in:description in:readme is:public language:language license:license pushed:updated size:5 " +
 				"stars:6 topic:topic topics:7 user:user1 user:user2",
 		},
@ -89,6 +91,8 @@ func TestQualifiersMap(t *testing.T) {
 				AuthorEmail:      "foo@example.com",
 				CommitterDate:    "2021-02-28",
 				Created:          "created",
+				Extension:        "go",
+				Filename:         ".vimrc",
 				Followers:        "1",
 				Fork:             "true",
 				Forks:            "2",
@ -110,6 +114,8 @@ func TestQualifiersMap(t *testing.T) {
 				"author-email":       {"foo@example.com"},
 				"committer-date":     {"2021-02-28"},
 				"created":            {"created"},
+				"extension":          {"go"},
+				"filename":           {".vimrc"},
 				"followers":          {"1"},
 				"fork":               {"true"},
 				"forks":              {"2"},
--- a/pkg/search/result.go
+++ b/pkg/search/result.go
@ -1,11 +1,27 @@
 package search

 import (
+	"encoding/json"
 	"reflect"
 	"strings"
 	"time"
 )

+var CodeFields = []string{
+	"path",
+	"repository",
+	"sha",
+	"textMatches",
+	"url",
+}
+
+var textMatchFields = []string{
+	"fragment",
+	"matches",
+	"type",
+	"property",
+}
+
 var CommitFields = []string{
 	"author",
 	"commit",
@ -72,6 +88,12 @@ var PullRequestFields = append(IssueFields,
 	"isDraft",
 )

+type CodeResult struct {
+	IncompleteResults bool   `json:"incomplete_results"`
+	Items             []Code `json:"items"`
+	Total             int    `json:"total_count"`
+}
+
 type CommitsResult struct {
 	IncompleteResults bool     `json:"incomplete_results"`
 	Items             []Commit `json:"items"`
@ -90,6 +112,27 @@ type IssuesResult struct {
 	Total             int     `json:"total_count"`
 }

+type Code struct {
+	Name        string      `json:"name"`
+	Path        string      `json:"path"`
+	Repository  Repository  `json:"repository"`
+	Sha         string      `json:"sha"`
+	TextMatches []TextMatch `json:"text_matches"`
+	URL         string      `json:"html_url"`
+}
+
+type TextMatch struct {
+	Fragment string  `json:"fragment"`
+	Matches  []Match `json:"matches"`
+	Type     string  `json:"object_type"`
+	Property string  `json:"property"`
+}
+
+type Match struct {
+	Indices []int  `json:"indices"`
+	Text    string `json:"text"`
+}
+
 type Commit struct {
 	Author    User       `json:"author"`
 	Committer User       `json:"committer"`
@ -230,6 +273,38 @@ func (u User) ExportData() map[string]interface{} {
 	}
 }

+func (code Code) ExportData(fields []string) map[string]interface{} {
+	v := reflect.ValueOf(code)
+	data := map[string]interface{}{}
+	for _, f := range fields {
+		switch f {
+		case "textMatches":
+			matches := make([]interface{}, 0, len(code.TextMatches))
+			for _, match := range code.TextMatches {
+				matches = append(matches, match.ExportData(textMatchFields))
+			}
+			data[f] = matches
+		default:
+			sf := fieldByName(v, f)
+			data[f] = sf.Interface()
+		}
+	}
+	return data
+}
+
+func (textMatch TextMatch) ExportData(fields []string) map[string]interface{} {
+	v := reflect.ValueOf(textMatch)
+	data := map[string]interface{}{}
+	for _, f := range fields {
+		switch f {
+		default:
+			sf := fieldByName(v, f)
+			data[f] = sf.Interface()
+		}
+	}
+	return data
+}
+
 func (commit Commit) ExportData(fields []string) map[string]interface{} {
 	v := reflect.ValueOf(commit)
 	data := map[string]interface{}{}
@ -306,6 +381,16 @@ func (repo Repository) ExportData(fields []string) map[string]interface{} {
 	return data
 }

+func (repo Repository) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]interface{}{
+		"id":            repo.ID,
+		"nameWithOwner": repo.FullName,
+		"url":           repo.URL,
+		"isPrivate":     repo.IsPrivate,
+		"isFork":        repo.IsFork,
+	})
+}
+
 // The state of an issue or a pull request, may be either open or closed.
 // For a pull request, the "merged" state is inferred from a value for merged_at and
 // which we take return instead of the "closed" state.
--- a/pkg/search/result_test.go
+++ b/pkg/search/result_test.go
@ -11,6 +11,53 @@ import (
 	"github.com/stretchr/testify/require"
 )

+func TestCodeExportData(t *testing.T) {
+	tests := []struct {
+		name   string
+		fields []string
+		code   Code
+		output string
+	}{
+		{
+			name:   "exports requested fields",
+			fields: []string{"path", "textMatches"},
+			code: Code{
+				Repository: Repository{
+					Name: "repo",
+				},
+				Path: "path",
+				Name: "name",
+				TextMatches: []TextMatch{
+					{
+						Fragment: "fragment",
+						Matches: []Match{
+							{
+								Text: "fr",
+								Indices: []int{
+									0,
+									1,
+								},
+							},
+						},
+						Property: "property",
+						Type:     "type",
+					},
+				},
+			},
+			output: `{"path":"path","textMatches":[{"fragment":"fragment","matches":[{"indices":[0,1],"text":"fr"}],"property":"property","type":"type"}]}`,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			exported := tt.code.ExportData(tt.fields)
+			buf := bytes.Buffer{}
+			enc := json.NewEncoder(&buf)
+			require.NoError(t, enc.Encode(exported))
+			assert.Equal(t, tt.output, strings.TrimSpace(buf.String()))
+		})
+	}
+}
+
 func TestCommitExportData(t *testing.T) {
 	var authoredAt = time.Date(2021, 2, 27, 11, 30, 0, 0, time.UTC)
 	var committedAt = time.Date(2021, 2, 28, 12, 30, 0, 0, time.UTC)
--- a/pkg/search/searcher.go
+++ b/pkg/search/searcher.go
@ -25,6 +25,7 @@ var jsonTypeRE = regexp.MustCompile(`[/+]json($|;)`)

 //go:generate moq -rm -out searcher_mock.go . Searcher
 type Searcher interface {
+	Code(Query) (CodeResult, error)
 	Commits(Query) (CommitsResult, error)
 	Repositories(Query) (RepositoriesResult, error)
 	Issues(Query) (IssuesResult, error)
@ -57,6 +58,30 @@ func NewSearcher(client *http.Client, host string) Searcher {
 	}
 }

+func (s searcher) Code(query Query) (CodeResult, error) {
+	result := CodeResult{}
+	toRetrieve := query.Limit
+	var resp *http.Response
+	var err error
+	for toRetrieve > 0 {
+		query.Limit = min(toRetrieve, maxPerPage)
+		query.Page = nextPage(resp)
+		if query.Page == 0 {
+			break
+		}
+		page := CodeResult{}
+		resp, err = s.search(query, &page)
+		if err != nil {
+			return result, err
+		}
+		result.IncompleteResults = page.IncompleteResults
+		result.Total = page.Total
+		result.Items = append(result.Items, page.Items...)
+		toRetrieve = toRetrieve - len(page.Items)
+	}
+	return result, nil
+}
+
 func (s searcher) Commits(query Query) (CommitsResult, error) {
 	result := CommitsResult{}
 	toRetrieve := query.Limit
@ -148,6 +173,10 @@ func (s searcher) search(query Query, result interface{}) (*http.Response, error
 	}
 	req.Header.Set("Content-Type", "application/json; charset=utf-8")
 	req.Header.Set("Accept", "application/vnd.github.v3+json")
+	if query.Kind == KindCode {
+		req.Header.Set("Accept", "application/vnd.github.text-match+json")
+	}
+
 	resp, err := s.client.Do(req)
 	if err != nil {
 		return nil, err
--- a/pkg/search/searcher_mock.go
+++ b/pkg/search/searcher_mock.go
@ -17,6 +17,9 @@ var _ Searcher = &SearcherMock{}
 //
 //		// make and configure a mocked Searcher
 //		mockedSearcher := &SearcherMock{
+//			CodeFunc: func(query Query) (CodeResult, error) {
+//				panic("mock out the Code method")
+//			},
 //			CommitsFunc: func(query Query) (CommitsResult, error) {
 //				panic("mock out the Commits method")
 //			},
@ -36,6 +39,9 @@ var _ Searcher = &SearcherMock{}
 //
 //	}
 type SearcherMock struct {
+	// CodeFunc mocks the Code method.
+	CodeFunc func(query Query) (CodeResult, error)
+
 	// CommitsFunc mocks the Commits method.
 	CommitsFunc func(query Query) (CommitsResult, error)

@ -50,6 +56,11 @@ type SearcherMock struct {

 	// calls tracks calls to the methods.
 	calls struct {
+		// Code holds details about calls to the Code method.
+		Code []struct {
+			// Query is the query argument value.
+			Query Query
+		}
 		// Commits holds details about calls to the Commits method.
 		Commits []struct {
 			// Query is the query argument value.
@ -71,12 +82,45 @@ type SearcherMock struct {
 			Query Query
 		}
 	}
+	lockCode         sync.RWMutex
 	lockCommits      sync.RWMutex
 	lockIssues       sync.RWMutex
 	lockRepositories sync.RWMutex
 	lockURL          sync.RWMutex
 }

+// Code calls CodeFunc.
+func (mock *SearcherMock) Code(query Query) (CodeResult, error) {
+	if mock.CodeFunc == nil {
+		panic("SearcherMock.CodeFunc: method is nil but Searcher.Code was just called")
+	}
+	callInfo := struct {
+		Query Query
+	}{
+		Query: query,
+	}
+	mock.lockCode.Lock()
+	mock.calls.Code = append(mock.calls.Code, callInfo)
+	mock.lockCode.Unlock()
+	return mock.CodeFunc(query)
+}
+
+// CodeCalls gets all the calls that were made to Code.
+// Check the length with:
+//
+//	len(mockedSearcher.CodeCalls())
+func (mock *SearcherMock) CodeCalls() []struct {
+	Query Query
+} {
+	var calls []struct {
+		Query Query
+	}
+	mock.lockCode.RLock()
+	calls = mock.calls.Code
+	mock.lockCode.RUnlock()
+	return calls
+}
+
 // Commits calls CommitsFunc.
 func (mock *SearcherMock) Commits(query Query) (CommitsResult, error) {
 	if mock.CommitsFunc == nil {
--- a/pkg/search/searcher_test.go
+++ b/pkg/search/searcher_test.go
@ -10,6 +10,156 @@ import (
 	"github.com/stretchr/testify/assert"
 )

+func TestSearcherCode(t *testing.T) {
+	query := Query{
+		Keywords: []string{"keyword"},
+		Kind:     "code",
+		Limit:    30,
+		Qualifiers: Qualifiers{
+			Language: "go",
+		},
+	}
+
+	values := url.Values{
+		"page":     []string{"1"},
+		"per_page": []string{"30"},
+		"q":        []string{"keyword language:go"},
+	}
+
+	tests := []struct {
+		name      string
+		host      string
+		query     Query
+		result    CodeResult
+		wantErr   bool
+		errMsg    string
+		httpStubs func(reg *httpmock.Registry)
+	}{
+		{
+			name:  "searches code",
+			query: query,
+			result: CodeResult{
+				IncompleteResults: false,
+				Items:             []Code{{Name: "file.go"}},
+				Total:             1,
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.QueryMatcher("GET", "search/code", values),
+					httpmock.JSONResponse(CodeResult{
+						IncompleteResults: false,
+						Items:             []Code{{Name: "file.go"}},
+						Total:             1,
+					}),
+				)
+			},
+		},
+		{
+			name:  "searches code for enterprise host",
+			host:  "enterprise.com",
+			query: query,
+			result: CodeResult{
+				IncompleteResults: false,
+				Items:             []Code{{Name: "file.go"}},
+				Total:             1,
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.QueryMatcher("GET", "api/v3/search/code", values),
+					httpmock.JSONResponse(CodeResult{
+						IncompleteResults: false,
+						Items:             []Code{{Name: "file.go"}},
+						Total:             1,
+					}),
+				)
+			},
+		},
+		{
+			name:  "paginates results",
+			query: query,
+			result: CodeResult{
+				IncompleteResults: false,
+				Items:             []Code{{Name: "file.go"}, {Name: "file2.go"}},
+				Total:             2,
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				firstReq := httpmock.QueryMatcher("GET", "search/code", values)
+				firstRes := httpmock.JSONResponse(CodeResult{
+					IncompleteResults: false,
+					Items:             []Code{{Name: "file.go"}},
+					Total:             2,
+				},
+				)
+				firstRes = httpmock.WithHeader(firstRes, "Link", `<https://api.github.com/search/code?page=2&per_page=100&q=org%3Agithub>; rel="next"`)
+				secondReq := httpmock.QueryMatcher("GET", "search/code", url.Values{
+					"page":     []string{"2"},
+					"per_page": []string{"29"},
+					"q":        []string{"keyword language:go"},
+				},
+				)
+				secondRes := httpmock.JSONResponse(CodeResult{
+					IncompleteResults: false,
+					Items:             []Code{{Name: "file2.go"}},
+					Total:             2,
+				},
+				)
+				reg.Register(firstReq, firstRes)
+				reg.Register(secondReq, secondRes)
+			},
+		},
+		{
+			name:    "handles search errors",
+			query:   query,
+			wantErr: true,
+			errMsg: heredoc.Doc(`
+				Invalid search query "keyword language:go".
+				"blah" is not a recognized date/time format. Please provide an ISO 8601 date/time value, such as YYYY-MM-DD.`),
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.QueryMatcher("GET", "search/code", values),
+					httpmock.WithHeader(
+						httpmock.StatusStringResponse(422,
+							`{
+								"message": "Validation Failed",
+								"errors": [
+                  {
+                    "message":"\"blah\" is not a recognized date/time format. Please provide an ISO 8601 date/time value, such as YYYY-MM-DD.",
+                    "resource":"Search",
+                    "field":"q",
+                    "code":"invalid"
+                  }
+                ],
+                "documentation_url":"https://developer.github.com/v3/search/"
+							}`,
+						), "Content-Type", "application/json"),
+				)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reg := &httpmock.Registry{}
+			defer reg.Verify(t)
+			if tt.httpStubs != nil {
+				tt.httpStubs(reg)
+			}
+			client := &http.Client{Transport: reg}
+			if tt.host == "" {
+				tt.host = "github.com"
+			}
+			searcher := NewSearcher(client, tt.host)
+			result, err := searcher.Code(tt.query)
+			if tt.wantErr {
+				assert.EqualError(t, err, tt.errMsg)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tt.result, result)
+		})
+	}
+}
+
 func TestSearcherCommits(t *testing.T) {
 	query := Query{
 		Keywords: []string{"keyword"},
@ -208,10 +358,14 @@ func TestSearcherRepositories(t *testing.T) {
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(
 					httpmock.QueryMatcher("GET", "search/repositories", values),
-					httpmock.JSONResponse(RepositoriesResult{
-						IncompleteResults: false,
-						Items:             []Repository{{Name: "test"}},
-						Total:             1,
+					httpmock.JSONResponse(map[string]interface{}{
+						"incomplete_results": false,
+						"total_count":        1,
+						"items": []interface{}{
+							map[string]interface{}{
+								"name": "test",
+							},
+						},
 					}),
 				)
 			},
@ -228,10 +382,14 @@ func TestSearcherRepositories(t *testing.T) {
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(
 					httpmock.QueryMatcher("GET", "api/v3/search/repositories", values),
-					httpmock.JSONResponse(RepositoriesResult{
-						IncompleteResults: false,
-						Items:             []Repository{{Name: "test"}},
-						Total:             1,
+					httpmock.JSONResponse(map[string]interface{}{
+						"incomplete_results": false,
+						"total_count":        1,
+						"items": []interface{}{
+							map[string]interface{}{
+								"name": "test",
+							},
+						},
 					}),
 				)
 			},
@ -246,12 +404,15 @@ func TestSearcherRepositories(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				firstReq := httpmock.QueryMatcher("GET", "search/repositories", values)
-				firstRes := httpmock.JSONResponse(RepositoriesResult{
-					IncompleteResults: false,
-					Items:             []Repository{{Name: "test"}},
-					Total:             2,
-				},
-				)
+				firstRes := httpmock.JSONResponse(map[string]interface{}{
+					"incomplete_results": false,
+					"total_count":        2,
+					"items": []interface{}{
+						map[string]interface{}{
+							"name": "test",
+						},
+					},
+				})
 				firstRes = httpmock.WithHeader(firstRes, "Link", `<https://api.github.com/search/repositories?page=2&per_page=100&q=org%3Agithub>; rel="next"`)
 				secondReq := httpmock.QueryMatcher("GET", "search/repositories", url.Values{
 					"page":     []string{"2"},
@ -261,12 +422,15 @@ func TestSearcherRepositories(t *testing.T) {
 					"q":        []string{"keyword stars:>=5 topic:topic"},
 				},
 				)
-				secondRes := httpmock.JSONResponse(RepositoriesResult{
-					IncompleteResults: false,
-					Items:             []Repository{{Name: "cli"}},
-					Total:             2,
-				},
-				)
+				secondRes := httpmock.JSONResponse(map[string]interface{}{
+					"incomplete_results": false,
+					"total_count":        2,
+					"items": []interface{}{
+						map[string]interface{}{
+							"name": "cli",
+						},
+					},
+				})
 				reg.Register(firstReq, firstRes)
 				reg.Register(secondReq, secondRes)
 			},