fix: address reviewed regressions for PR #3265

Author: Amidwestnoob

pkg/github/issues.go

@@ -1878,6 +1878,10 @@ func SearchIssues(t translations.TranslationHelperFunc, opts ...ToolOption) inve
 		},
 		Required: []string{"query"},
 	}
+	if mode == searchModeLexical {
+		schema.Properties["search_type"].Enum = []any{"lexical"}
+		schema.Properties["search_type"].Description = "Search engine. Only lexical search is supported on this host."
+	}
 	schema.Properties["fields"] = fieldsSchemaProperty(
 		"Subset of fields to return for each issue result. If omitted, all fields are returned. Use this to reduce response size when you only need specific fields; omitting 'body', 'reactions', and 'labels' in particular drops the largest per-result data.",
 		searchIssuesItemFieldEnum,

pkg/github/search_mode_regression_test.go

@@ -0,0 +1,49 @@
+package github
+
+import (
+	"context"
+	"testing"
+
+	"github.com/github/github-mcp-server/pkg/translations"
+	"github.com/github/github-mcp-server/pkg/utils"
+	"github.com/google/jsonschema-go/jsonschema"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_SearchModeNaturalLanguageAndSyntax(t *testing.T) {
+	for _, q := range []string{
+		"login does not work after password reset", "connecting to postgres and redis", "should I use hooks or plugins",
+		`why does "this AND that" fail`, `explain "foo OR bar"`, `why "NOT ready" appears`,
+		`explain "label:bug" text`, `why "escaped \" AND operator" fails`,
+	} {
+		t.Run(q, func(t *testing.T) {
+			got, err := resolveIssuesSearchMode(searchModeSemantic, map[string]any{"query": q})
+			require.NoError(t, err)
+			require.Equal(t, searchModeSemantic, got)
+		})
+	}
+	for _, q := range []string{"foo AND bar", "foo OR bar", "foo NOT bar", "foo AND(bar OR baz)", `label:"needs triage"`, `repo:owner/repo`, `-author:bot`, `(label:bug OR label:critical)`} {
+		t.Run(q, func(t *testing.T) {
+			got, err := resolveIssuesSearchMode(searchModeSemantic, map[string]any{"query": q})
+			require.NoError(t, err)
+			require.Equal(t, searchModeLexical, got)
+			got, err = resolveIssuesSearchMode(searchModeSemantic, map[string]any{"query": q, "search_type": "semantic"})
+			require.NoError(t, err)
+			require.Equal(t, searchModeSemantic, got)
+		})
+	}
+}
+
+func Test_SearchIssuesGHESRejectsSemanticOverride(t *testing.T) {
+	got, err := resolveIssuesSearchMode(searchModeLexical, map[string]any{"query": "question", "search_type": "semantic"})
+	require.ErrorContains(t, err, "not supported")
+	require.NotEqual(t, searchModeSemantic, got)
+	tool := SearchIssues(translations.NullTranslationHelper, WithHost(utils.HostTypeGHES))
+	require.Equal(t, []any{"lexical"}, tool.Tool.InputSchema.(*jsonschema.Schema).Properties["search_type"].Enum)
+	// No client: the capability error must be returned before attempting a request.
+	deps := &BaseDeps{}
+	request := createMCPRequest(map[string]any{"query": "question", "search_type": "semantic"})
+	result, err := tool.Handler(deps)(ContextWithDeps(context.Background(), deps), &request)
+	require.NoError(t, err)
+	require.True(t, result.IsError)
+}

pkg/github/search_utils.go

@@ -85,19 +85,24 @@ const (
 )
 
 // booleanSearchOpPattern matches OR / AND / NOT as free-standing operators.
-var booleanSearchOpPattern = regexp.MustCompile(`(?i)(^|\s)(OR|AND|NOT)(\s|$)`)
+var booleanSearchOpPattern = regexp.MustCompile(`(^|[\s(])(OR|AND|NOT)([\s()]|$)`)
+
+// quotedIssueSearchText masks literal contents while retaining a nonempty
+// qualifier value (label:"needs triage"). Escaped quotes stay inside the literal.
+var quotedIssueSearchText = regexp.MustCompile(`"(?:\\.|[^"\\])*(?:"|$)`)
 
 // qualifierPattern matches GitHub search qualifiers such as label:bug or -author:octocat.
 var qualifierPattern = regexp.MustCompile(`(^|\s|\W)-?[\w.]+:\S+`)
 
 // looksLikeLexicalIssueSearch reports whether the raw caller query uses GitHub
 // issues search syntax that semantic search mishandles.
 func looksLikeLexicalIssueSearch(query string) bool {
+	query = quotedIssueSearchText.ReplaceAllString(query, `""`)
 	return qualifierPattern.MatchString(query) || booleanSearchOpPattern.MatchString(query)
 }
 
 // resolveIssuesSearchMode chooses lexical vs semantic for search_issues.
-// An explicit search_type wins. Otherwise GHES stays lexical, and Dotcom uses
+// An explicit search_type wins within the host capability boundary. Dotcom uses
 // lexical for scoped or syntax-like queries so keyword search matches REST.
 func resolveIssuesSearchMode(defaultMode searchMode, args map[string]any) (searchMode, error) {
 	searchType, err := OptionalParam[string](args, "search_type")
@@ -110,6 +115,9 @@ func resolveIssuesSearchMode(defaultMode searchMode, args map[string]any) (searc
 	case "lexical":
 		return searchModeLexical, nil
 	case "semantic":
+		if defaultMode == searchModeLexical {
+			return 0, fmt.Errorf("semantic issue search is not supported on this host")
+		}
 		return searchModeSemantic, nil
 	default:
 		return 0, fmt.Errorf(`invalid search_type %q: must be "lexical" or "semantic"`, searchType)