Fix generateInstructions to use only enabled toolsets

Previously, generateInstructions() iterated over AvailableToolsets() which
returns all toolsets that have tools defined, rather than only the enabled
toolsets based on WithToolsets() configuration.

This caused instructions for all toolsets to be included regardless of which
toolsets were actually enabled, leading to bloated instructions (e.g., 5886
chars vs 1226 chars when only 'repos' toolset is enabled).

Changes:
- Add EnabledToolsets() method to return only enabled toolset metadata
- Update generateInstructions() to use EnabledToolsets()
- Add regression test for the fix

Fixes #1897

Author: SamMorrowDrums

pkg/inventory/instructions.go

@@ -31,7 +31,7 @@ Tool usage guidance:
 	instructions = append(instructions, baseInstruction)
 
 	// Collect instructions from each enabled toolset
-	for _, toolset := range inv.AvailableToolsets() {
+	for _, toolset := range inv.EnabledToolsets() {
 		if toolset.InstructionsFunc != nil {
 			if toolsetInstructions := toolset.InstructionsFunc(inv); toolsetInstructions != "" {
 				instructions = append(instructions, toolsetInstructions)

pkg/inventory/instructions_test.go

@@ -7,6 +7,7 @@ import (
 )
 
 // createTestInventory creates an inventory with the specified toolsets for testing.
+// All toolsets are enabled by default using WithToolsets([]string{"all"}).
 func createTestInventory(toolsets []ToolsetMetadata) *Inventory {
 	// Create tools for each toolset so they show up in AvailableToolsets()
 	var tools []ServerTool
@@ -18,6 +19,7 @@ func createTestInventory(toolsets []ToolsetMetadata) *Inventory {
 
 	inv, _ := NewBuilder().
 		SetTools(tools).
+		WithToolsets([]string{"all"}).
 		Build()
 
 	return inv
@@ -203,3 +205,61 @@ func TestToolsetInstructionsFunc(t *testing.T) {
 		})
 	}
 }
+
+// TestGenerateInstructionsOnlyEnabledToolsets verifies that generateInstructions
+// only includes instructions from enabled toolsets, not all available toolsets.
+// This is a regression test for https://github.com/github/github-mcp-server/issues/1897
+func TestGenerateInstructionsOnlyEnabledToolsets(t *testing.T) {
+	// Create tools for multiple toolsets
+	reposToolset := ToolsetMetadata{
+		ID:          "repos",
+		Description: "Repository tools",
+		InstructionsFunc: func(_ *Inventory) string {
+			return "REPOS_INSTRUCTIONS"
+		},
+	}
+	issuesToolset := ToolsetMetadata{
+		ID:          "issues",
+		Description: "Issue tools",
+		InstructionsFunc: func(_ *Inventory) string {
+			return "ISSUES_INSTRUCTIONS"
+		},
+	}
+	prsToolset := ToolsetMetadata{
+		ID:          "pull_requests",
+		Description: "PR tools",
+		InstructionsFunc: func(_ *Inventory) string {
+			return "PRS_INSTRUCTIONS"
+		},
+	}
+
+	tools := []ServerTool{
+		{Toolset: reposToolset},
+		{Toolset: issuesToolset},
+		{Toolset: prsToolset},
+	}
+
+	// Build inventory with only "repos" toolset enabled
+	inv, err := NewBuilder().
+		SetTools(tools).
+		WithToolsets([]string{"repos"}).
+		Build()
+	if err != nil {
+		t.Fatalf("Failed to build inventory: %v", err)
+	}
+
+	result := generateInstructions(inv)
+
+	// Should contain instructions from enabled toolset
+	if !strings.Contains(result, "REPOS_INSTRUCTIONS") {
+		t.Errorf("Expected instructions to contain 'REPOS_INSTRUCTIONS' for enabled toolset, but it did not. Result: %s", result)
+	}
+
+	// Should NOT contain instructions from non-enabled toolsets
+	if strings.Contains(result, "ISSUES_INSTRUCTIONS") {
+		t.Errorf("Did not expect instructions to contain 'ISSUES_INSTRUCTIONS' for disabled toolset, but it did. Result: %s", result)
+	}
+	if strings.Contains(result, "PRS_INSTRUCTIONS") {
+		t.Errorf("Did not expect instructions to contain 'PRS_INSTRUCTIONS' for disabled toolset, but it did. Result: %s", result)
+	}
+}

pkg/inventory/registry.go

@@ -295,6 +295,28 @@ func (r *Inventory) AvailableToolsets(exclude ...ToolsetID) []ToolsetMetadata {
 	return result
 }
 
+// EnabledToolsets returns the unique toolsets that are enabled based on current filters.
+// This is similar to AvailableToolsets but respects the enabledToolsets filter.
+// Returns toolsets in sorted order by toolset ID.
+func (r *Inventory) EnabledToolsets() []ToolsetMetadata {
+	// Get all available toolsets first (already sorted by ID)
+	allToolsets := r.AvailableToolsets()
+
+	// If no filter is set, all toolsets are enabled
+	if r.enabledToolsets == nil {
+		return allToolsets
+	}
+
+	// Filter to only enabled toolsets
+	var result []ToolsetMetadata
+	for _, ts := range allToolsets {
+		if r.enabledToolsets[ts.ID] {
+			result = append(result, ts)
+		}
+	}
+	return result
+}
+
 func (r *Inventory) Instructions() string {
 	return r.instructions
 }