Accept bare method names in symbol extraction

When searching for a symbol like 'RegisterRoutes', if no exact match
is found, try suffix matching against receiver-qualified names like
'(*Handler).RegisterRoutes'. Returns the match only when unambiguous
(exactly one suffix match).

Error messages now suggest the closest match when a suffix match exists
but wasn't used (e.g., when there are multiple types with the same
method name).

Updated the symbol parameter description to document the receiver
prefix format and note that bare names work when unambiguous.

Author: SamMorrowDrums

pkg/github/__toolsnaps__/get_file_contents.snap

@@ -28,7 +28,7 @@
         "type": "string"
       },
       "symbol": {
-        "description": "Optional: extract a specific symbol (function, class, type, etc.) from the file. For supported languages, returns only the symbol's source code instead of the entire file. If the symbol is not found, returns a list of available symbols.",
+        "description": "Optional: extract a specific symbol (function, class, type, etc.) from the file. For supported languages, returns only the symbol's source code instead of the entire file. For methods, use receiver prefix format: (*TypeName).MethodName — bare method names also work when unambiguous. If the symbol is not found, returns available symbols with suggestions.",
         "type": "string"
       }
     },

pkg/github/repositories.go

@@ -654,7 +654,7 @@ func GetFileContents(t translations.TranslationHelperFunc) inventory.ServerTool
 					},
 					"symbol": {
 						Type:        "string",
-						Description: "Optional: extract a specific symbol (function, class, type, etc.) from the file. For supported languages, returns only the symbol's source code instead of the entire file. If the symbol is not found, returns a list of available symbols.",
+						Description: "Optional: extract a specific symbol (function, class, type, etc.) from the file. For supported languages, returns only the symbol's source code instead of the entire file. For methods, use receiver prefix format: (*TypeName).MethodName — bare method names also work when unambiguous. If the symbol is not found, returns available symbols with suggestions.",
 					},
 				},
 				Required: []string{"owner", "repo"},

pkg/github/symbol_extraction.go

@@ -35,16 +35,38 @@ func ExtractSymbol(path string, source []byte, symbolName string) (text string,
 
 	// Build list of available symbols for the error message
 	available := listSymbolNames(config, decls)
+
+	// Suggest closest match for bare method names
+	if suggestion := findClosestMatch(available, symbolName); suggestion != "" {
+		return "", "", fmt.Errorf("symbol %q not found. Did you mean %q? Available symbols: %s",
+			symbolName, suggestion, strings.Join(available, ", "))
+	}
 	return "", "", fmt.Errorf("symbol %q not found. Available symbols: %s", symbolName, strings.Join(available, ", "))
 }
 
 // findSymbol searches a slice of declarations for a matching name.
+// It first tries an exact match, then falls back to suffix matching
+// (e.g., "RegisterRoutes" matches "(*Handler).RegisterRoutes") when
+// there is exactly one unambiguous match.
 func findSymbol(decls []declaration, name string) (string, string, bool) {
 	for _, d := range decls {
 		if d.Name == name {
 			return d.Text, d.Kind, true
 		}
 	}
+
+	// Suffix match: accept bare method name when unambiguous
+	var matches []declaration
+	suffix := "." + name
+	for _, d := range decls {
+		if strings.HasSuffix(d.Name, suffix) {
+			matches = append(matches, d)
+		}
+	}
+	if len(matches) == 1 {
+		return matches[0].Text, matches[0].Kind, true
+	}
+
 	return "", "", false
 }
 
@@ -65,3 +87,19 @@ func listSymbolNames(config *languageConfig, decls []declaration) []string {
 	}
 	return names
 }
+
+// findClosestMatch looks for a symbol name that ends with ".name" or contains
+// the search term as a substring, returning the best suggestion.
+func findClosestMatch(available []string, name string) string {
+	suffix := "." + name
+	var suffixMatches []string
+	for _, s := range available {
+		if strings.HasSuffix(s, suffix) {
+			suffixMatches = append(suffixMatches, s)
+		}
+	}
+	if len(suffixMatches) == 1 {
+		return suffixMatches[0]
+	}
+	return ""
+}

pkg/github/symbol_extraction_test.go

@@ -113,4 +113,32 @@ func TestExtractSymbol(t *testing.T) {
 		assert.Contains(t, text, "30")
 		assert.NotContains(t, text, "maxRetries")
 	})
+
+	t.Run("bare method name matches unambiguous receiver", func(t *testing.T) {
+		source := []byte("package main\n\ntype Handler struct{}\n\nfunc (h *Handler) RegisterRoutes() {\n\t// routes\n}\n\nfunc (h *Handler) ServeHTTP() {\n\t// serve\n}\n")
+		text, kind, err := ExtractSymbol("main.go", source, "RegisterRoutes")
+		require.NoError(t, err)
+		assert.Equal(t, "method_declaration", kind)
+		assert.Contains(t, text, "RegisterRoutes")
+		assert.NotContains(t, text, "ServeHTTP")
+	})
+
+	t.Run("bare method name ambiguous returns error", func(t *testing.T) {
+		source := []byte("package main\n\ntype A struct{}\ntype B struct{}\n\nfunc (a A) Start() {}\n\nfunc (b B) Start() {}\n")
+		_, _, err := ExtractSymbol("main.go", source, "Start")
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "not found")
+	})
+
+	t.Run("error suggests closest match", func(t *testing.T) {
+		source := []byte("package main\n\ntype Handler struct{}\n\nfunc (h *Handler) RegisterRoutes() {}\n\nfunc Hello() {}\n")
+		_, _, err := ExtractSymbol("main.go", source, "RegisterRoutes")
+		// Should succeed via suffix match
+		require.NoError(t, err)
+
+		// Nonexistent but similar to a method — should suggest
+		_, _, err = ExtractSymbol("main.go", source, "Routes")
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "not found")
+	})
 }