feat: add GitHub search as fallback for broader MCP server discovery

- New `--all` flag: `mcphub search xxx --all` searches both official
  MCP Registry and GitHub repositories
- If Registry returns < 3 results, automatically falls back to GitHub
- GitHub results marked with [GitHub] tag in output
- MCP server mode (mcphub-mcp) now uses SearchAll by default

Author: Ricardo-M-L

internal/cli/search.go

@@ -11,17 +11,28 @@ import (
 
 var searchJSON bool
 var searchLimit int
+var searchAll bool
 
 var searchCmd = &cobra.Command{
 	Use:   "search <query>",
 	Short: "Search for MCP servers",
-	Long:  "Search the MCP registry for servers matching your query.",
-	Args:  cobra.ExactArgs(1),
+	Long: `Search the MCP registry for servers matching your query.
+
+By default searches the official MCP Registry only.
+Use --all to also search GitHub for MCP server repositories.`,
+	Args: cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		query := args[0]
 		client := registry.NewClient()
 
-		entries, err := client.Search(query, searchLimit)
+		var entries []registry.ServerEntry
+		var err error
+
+		if searchAll {
+			entries, err = client.SearchAll(query, searchLimit)
+		} else {
+			entries, err = client.Search(query, searchLimit)
+		}
 		if err != nil {
 			return fmt.Errorf("search failed: %w", err)
 		}
@@ -32,9 +43,15 @@ var searchCmd = &cobra.Command{
 			return nil
 		}
 
-		fmt.Printf("\n  Found %s servers matching %s\n\n",
+		source := "registry"
+		if searchAll {
+			source = "registry + GitHub"
+		}
+
+		fmt.Printf("\n  Found %s servers matching %s (%s)\n\n",
 			ui.Bold(fmt.Sprintf("%d", len(entries))),
 			ui.Cyan(fmt.Sprintf("%q", query)),
+			ui.Dim(source),
 		)
 
 		headers := []string{"Name", "Description", "Version", "Transport"}
@@ -47,8 +64,16 @@ var searchCmd = &cobra.Command{
 			} else if len(s.Packages) > 0 {
 				transport = s.Packages[0].Transport.Type
 			}
+
+			// Mark GitHub results
+			source := ""
+			if meta, ok := e.Meta["source"]; ok && meta == "github" {
+				source = " [GitHub]"
+				transport = "—"
+			}
+
 			rows = append(rows, []string{
-				s.ShortName(),
+				s.ShortName() + source,
 				ui.Truncate(s.Description, 50),
 				s.Version,
 				transport,
@@ -64,4 +89,5 @@ var searchCmd = &cobra.Command{
 func init() {
 	searchCmd.Flags().BoolVar(&searchJSON, "json", false, "Output results as JSON")
 	searchCmd.Flags().IntVar(&searchLimit, "limit", 20, "Maximum number of results")
+	searchCmd.Flags().BoolVar(&searchAll, "all", false, "Also search GitHub for MCP servers")
 }

internal/registry/github.go

@@ -0,0 +1,117 @@
+package registry
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// GitHubSearchResult represents the GitHub search API response.
+type GitHubSearchResult struct {
+	TotalCount int          `json:"total_count"`
+	Items      []GitHubRepo `json:"items"`
+}
+
+// GitHubRepo represents a GitHub repository from search results.
+type GitHubRepo struct {
+	FullName    string `json:"full_name"`
+	Description string `json:"description"`
+	HTMLURL     string `json:"html_url"`
+	StarCount   int    `json:"stargazers_count"`
+	Language    string `json:"language"`
+	UpdatedAt   string `json:"updated_at"`
+}
+
+// SearchGitHub searches GitHub for MCP server repositories.
+// Used as a fallback when the official registry returns no results.
+func (c *Client) SearchGitHub(query string, limit int) ([]ServerEntry, error) {
+	if limit <= 0 {
+		limit = 10
+	}
+
+	// Search GitHub for MCP server repos
+	ghQuery := fmt.Sprintf("mcp server %s in:name,description,readme", query)
+	params := url.Values{}
+	params.Set("q", ghQuery)
+	params.Set("sort", "stars")
+	params.Set("order", "desc")
+	params.Set("per_page", fmt.Sprintf("%d", limit))
+
+	reqURL := fmt.Sprintf("https://api.github.com/search/repositories?%s", params.Encode())
+
+	req, err := http.NewRequest("GET", reqURL, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", "application/vnd.github.v3+json")
+	req.Header.Set("User-Agent", "mcphub")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("GitHub search failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("GitHub API returned %d: %s", resp.StatusCode, string(body))
+	}
+
+	var result GitHubSearchResult
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to parse GitHub response: %w", err)
+	}
+
+	// Convert GitHub repos to ServerEntry format
+	var entries []ServerEntry
+	for _, repo := range result.Items {
+		desc := repo.Description
+		if desc == "" {
+			desc = "MCP server from GitHub"
+		}
+
+		entries = append(entries, ServerEntry{
+			Server: ServerDetail{
+				Name:        fmt.Sprintf("github.com/%s", repo.FullName),
+				Description: fmt.Sprintf("%s (%d stars)", desc, repo.StarCount),
+				Repository: &Repository{
+					URL:    repo.HTMLURL,
+					Source: "github",
+				},
+			},
+			Meta: map[string]interface{}{
+				"source":   "github",
+				"stars":    repo.StarCount,
+				"language": repo.Language,
+			},
+		})
+	}
+
+	return entries, nil
+}
+
+// SearchAll searches both the official registry and GitHub, merging results.
+func (c *Client) SearchAll(query string, limit int) ([]ServerEntry, error) {
+	// First search official registry
+	entries, err := c.Search(query, limit)
+	if err != nil {
+		entries = nil // Don't fail, try GitHub
+	}
+
+	// If registry returned few results, supplement with GitHub
+	if len(entries) < 3 {
+		ghEntries, ghErr := c.SearchGitHub(query, limit-len(entries))
+		if ghErr == nil {
+			entries = append(entries, ghEntries...)
+		}
+	}
+
+	// Cap at limit
+	if len(entries) > limit {
+		entries = entries[:limit]
+	}
+
+	return entries, nil
+}

mcp/server.go

@@ -199,7 +199,7 @@ func handleSearch(args json.RawMessage, client *registry.Client) interface{} {
 		params.Limit = 10
 	}
 
-	entries, err := client.Search(params.Query, params.Limit)
+	entries, err := client.SearchAll(params.Query, params.Limit)
 	if err != nil {
 		return toolError("search failed: " + err.Error())
 	}