Add map indexes for O(1) lookups in Registry

Address review feedback to use maps for collections. Added lookup maps
(toolsByName, resourcesByURI, promptsByName) while keeping slices for
ordered iteration. This provides O(1) lookup for:

- FindToolByName
- filterToolsByName (used by ForMCPRequest)
- filterResourcesByURI
- filterPromptsByName

Maps are built once during Build() and shared in ForMCPRequest copies.

Author: SamMorrowDrums

.gitignore

@@ -19,4 +19,5 @@ bin/
 # binary
 github-mcp-server
 
-.historyconformance-report/
+.history
+conformance-report/

pkg/registry/builder.go

@@ -124,6 +124,9 @@ func (b *Builder) Build() *Registry {
 		featureChecker:    b.featureChecker,
 	}
 
+	// Note: lookup maps (toolsByName, resourcesByURI, promptsByName) are
+	// lazy-initialized on first use via getToolsByName(), etc.
+
 	// Process toolsets
 	r.enabledToolsets, r.unrecognizedToolsets = b.processToolsets()
 

pkg/registry/filters.go

@@ -151,40 +151,32 @@ func (r *Registry) AvailablePrompts(ctx context.Context) []ServerPrompt {
 // filterToolsByName returns tools matching the given name, checking deprecated aliases.
 // Returns from the current tools slice (respects existing filter chain).
 func (r *Registry) filterToolsByName(name string) []ServerTool {
-	// First check for exact match
-	for i := range r.tools {
-		if r.tools[i].Tool.Name == name {
-			return []ServerTool{r.tools[i]}
-		}
+	toolsByName := r.getToolsByName()
+	// First check for exact match using map
+	if tool, ok := toolsByName[name]; ok {
+		return []ServerTool{*tool}
 	}
 	// Check if name is a deprecated alias
 	if canonical, isAlias := r.deprecatedAliases[name]; isAlias {
-		for i := range r.tools {
-			if r.tools[i].Tool.Name == canonical {
-				return []ServerTool{r.tools[i]}
-			}
+		if tool, ok := toolsByName[canonical]; ok {
+			return []ServerTool{*tool}
 		}
 	}
 	return []ServerTool{}
 }
 
 // filterResourcesByURI returns resource templates matching the given URI pattern.
 func (r *Registry) filterResourcesByURI(uri string) []ServerResourceTemplate {
-	for i := range r.resourceTemplates {
-		// Check if URI matches the template pattern (exact match on URITemplate string)
-		if r.resourceTemplates[i].Template.URITemplate == uri {
-			return []ServerResourceTemplate{r.resourceTemplates[i]}
-		}
+	if res, ok := r.getResourcesByURI()[uri]; ok {
+		return []ServerResourceTemplate{*res}
 	}
 	return []ServerResourceTemplate{}
 }
 
 // filterPromptsByName returns prompts matching the given name.
 func (r *Registry) filterPromptsByName(name string) []ServerPrompt {
-	for i := range r.prompts {
-		if r.prompts[i].Prompt.Name == name {
-			return []ServerPrompt{r.prompts[i]}
-		}
+	if prompt, ok := r.getPromptsByName()[name]; ok {
+		return []ServerPrompt{*prompt}
 	}
 	return []ServerPrompt{}
 }

pkg/registry/registry.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"slices"
 	"sort"
+	"sync"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
@@ -25,12 +26,21 @@ import (
 //   - Lazy dependency injection during registration via RegisterAll()
 //   - Runtime toolset enabling for dynamic toolsets mode
 type Registry struct {
-	// tools holds all tools in this group
+	// tools holds all tools in this group (ordered for iteration)
 	tools []ServerTool
-	// resourceTemplates holds all resource templates in this group
+	// toolsByName provides O(1) lookup by tool name (lazy-initialized)
+	toolsByName     map[string]*ServerTool
+	toolsByNameOnce sync.Once
+	// resourceTemplates holds all resource templates in this group (ordered for iteration)
 	resourceTemplates []ServerResourceTemplate
-	// prompts holds all prompts in this group
+	// resourcesByURI provides O(1) lookup by URI template (lazy-initialized)
+	resourcesByURI     map[string]*ServerResourceTemplate
+	resourcesByURIOnce sync.Once
+	// prompts holds all prompts in this group (ordered for iteration)
 	prompts []ServerPrompt
+	// promptsByName provides O(1) lookup by prompt name (lazy-initialized)
+	promptsByName     map[string]*ServerPrompt
+	promptsByNameOnce sync.Once
 	// deprecatedAliases maps old tool names to new canonical names
 	deprecatedAliases map[string]string
 
@@ -57,6 +67,39 @@ func (r *Registry) UnrecognizedToolsets() []string {
 	return r.unrecognizedToolsets
 }
 
+// getToolsByName returns the toolsByName map, initializing it lazily on first call.
+func (r *Registry) getToolsByName() map[string]*ServerTool {
+	r.toolsByNameOnce.Do(func() {
+		r.toolsByName = make(map[string]*ServerTool, len(r.tools))
+		for i := range r.tools {
+			r.toolsByName[r.tools[i].Tool.Name] = &r.tools[i]
+		}
+	})
+	return r.toolsByName
+}
+
+// getResourcesByURI returns the resourcesByURI map, initializing it lazily on first call.
+func (r *Registry) getResourcesByURI() map[string]*ServerResourceTemplate {
+	r.resourcesByURIOnce.Do(func() {
+		r.resourcesByURI = make(map[string]*ServerResourceTemplate, len(r.resourceTemplates))
+		for i := range r.resourceTemplates {
+			r.resourcesByURI[r.resourceTemplates[i].Template.URITemplate] = &r.resourceTemplates[i]
+		}
+	})
+	return r.resourcesByURI
+}
+
+// getPromptsByName returns the promptsByName map, initializing it lazily on first call.
+func (r *Registry) getPromptsByName() map[string]*ServerPrompt {
+	r.promptsByNameOnce.Do(func() {
+		r.promptsByName = make(map[string]*ServerPrompt, len(r.prompts))
+		for i := range r.prompts {
+			r.promptsByName[r.prompts[i].Prompt.Name] = &r.prompts[i]
+		}
+	})
+	return r.promptsByName
+}
+
 // MCP method constants for use with ForMCPRequest.
 const (
 	MCPMethodInitialize             = "initialize"
@@ -90,6 +133,8 @@ const (
 // All existing filters (read-only, toolsets, etc.) still apply to the returned items.
 func (r *Registry) ForMCPRequest(method string, itemName string) *Registry {
 	// Create a shallow copy with shared filter settings
+	// Note: lazy-init maps (toolsByName, etc.) are NOT copied - the new Registry
+	// will initialize its own maps on first use if needed
 	result := &Registry{
 		tools:                r.tools,
 		resourceTemplates:    r.resourceTemplates,
@@ -269,11 +314,8 @@ func (r *Registry) ResolveToolAliases(toolNames []string) (resolved []string, al
 // Returns the tool, its toolset ID, and an error if not found.
 // This searches ALL tools regardless of filters.
 func (r *Registry) FindToolByName(toolName string) (*ServerTool, ToolsetID, error) {
-	for i := range r.tools {
-		tool := &r.tools[i]
-		if tool.Tool.Name == toolName {
-			return tool, tool.Toolset.ID, nil
-		}
+	if tool, ok := r.getToolsByName()[toolName]; ok {
+		return tool, tool.Toolset.ID, nil
 	}
 	return nil, "", NewToolDoesNotExistError(toolName)
 }