feat: progressive tool filtering for permission screens

Replace built-in list filter with always-visible filter bar using
two-mode design (filter/action) in both the denied tools editor and
namespace tool permissions editor. Filter is case-insensitive substring
match; bulk ops always act on the full unfiltered set.

Author: Bigsy

internal/tui/views/tool_deny_editor.go

@@ -9,6 +9,7 @@ import (
 	"github.com/Bigsy/mcpmu/internal/tui/theme"
 	"github.com/charmbracelet/bubbles/key"
 	"github.com/charmbracelet/bubbles/list"
+	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 )
@@ -44,6 +45,11 @@ type ToolDenyEditorModel struct {
 	// Current deny state: toolName -> denied
 	denied map[string]bool
 
+	// Filter
+	filterInput   textinput.Model
+	allItems      []list.Item // full unfiltered list, set in Show()
+	filterFocused bool
+
 	// Key bindings
 	escKey   key.Binding
 	enterKey key.Binding
@@ -56,16 +62,19 @@ func NewToolDenyEditor(th theme.Theme) ToolDenyEditorModel {
 	l := list.New([]list.Item{}, delegate, 0, 0)
 	l.Title = "Denied Tools"
 	l.SetShowStatusBar(false)
-	l.SetFilteringEnabled(true)
+	l.SetFilteringEnabled(false)
 	l.SetShowHelp(false)
 	l.Styles.Title = th.Title
-	l.FilterInput.PromptStyle = th.Primary
-	l.FilterInput.Cursor.Style = th.Primary
+
+	ti := textinput.New()
+	ti.Placeholder = "/ to filter..."
+	ti.CharLimit = 100
 
 	return ToolDenyEditorModel{
-		theme:  th,
-		list:   l,
-		denied: make(map[string]bool),
+		theme:       th,
+		list:        l,
+		denied:      make(map[string]bool),
+		filterInput: ti,
 		escKey: key.NewBinding(
 			key.WithKeys("esc"),
 			key.WithHelp("esc", "cancel"),
@@ -100,6 +109,10 @@ func (m *ToolDenyEditorModel) Show(serverName string, tools []mcp.Tool, deniedTo
 		})
 	}
 
+	m.allItems = items
+	m.filterInput.SetValue("")
+	m.filterInput.Blur()
+	m.filterFocused = false
 	m.list.SetItems(items)
 	m.list.SetDelegate(newToolDenyDelegate(m.theme, m.denied))
 }
@@ -121,7 +134,24 @@ func (m *ToolDenyEditorModel) SetSize(width, height int) {
 	if height < 30 {
 		editorHeight = height - 5
 	}
-	m.list.SetSize(editorWidth-6, editorHeight-6)
+	m.list.SetSize(editorWidth-6, editorHeight-8)
+}
+
+// applyFilter filters the list items based on the current filter input value.
+func (m *ToolDenyEditorModel) applyFilter() {
+	query := strings.ToLower(m.filterInput.Value())
+	if query == "" {
+		m.list.SetItems(m.allItems)
+		return
+	}
+	var filtered []list.Item
+	for _, item := range m.allItems {
+		ti := item.(toolDenyItem)
+		if strings.Contains(strings.ToLower(ti.toolName), query) {
+			filtered = append(filtered, item)
+		}
+	}
+	m.list.SetItems(filtered)
 }
 
 // Update handles messages.
@@ -130,28 +160,22 @@ func (m *ToolDenyEditorModel) Update(msg tea.Msg) tea.Cmd {
 		return nil
 	}
 
-	// When filtering is active, let the list handle most keys
-	if m.list.FilterState() == list.Filtering {
+	kmsg, isKey := msg.(tea.KeyMsg)
+	if !isKey {
 		var cmd tea.Cmd
 		m.list, cmd = m.list.Update(msg)
 		return cmd
 	}
 
-	switch msg := msg.(type) {
-	case tea.KeyMsg:
+	if m.filterFocused {
 		switch {
-		case key.Matches(msg, m.escKey):
-			if m.list.FilterState() == list.FilterApplied {
-				m.list.ResetFilter()
-				return nil
-			}
-			m.visible = false
-			return func() tea.Msg {
-				return ToolDenyResult{ServerName: m.serverName, Submitted: false}
-			}
-		case key.Matches(msg, m.enterKey):
+		case key.Matches(kmsg, m.escKey):
+			// Exit filter mode, keep filter text
+			m.filterFocused = false
+			m.filterInput.Blur()
+			return nil
+		case key.Matches(kmsg, m.enterKey):
 			m.visible = false
-			// Collect denied tools
 			var denied []string
 			for toolName, isDenied := range m.denied {
 				if isDenied {
@@ -165,16 +189,66 @@ func (m *ToolDenyEditorModel) Update(msg tea.Msg) tea.Cmd {
 					Submitted:   true,
 				}
 			}
-		case key.Matches(msg, m.spaceKey):
+		case key.Matches(kmsg, m.spaceKey):
 			if item := m.list.SelectedItem(); item != nil {
 				ti := item.(toolDenyItem)
 				m.denied[ti.toolName] = !m.denied[ti.toolName]
 				m.list.SetDelegate(newToolDenyDelegate(m.theme, m.denied))
 			}
 			return nil
+		case kmsg.Type == tea.KeyUp || kmsg.Type == tea.KeyDown:
+			var cmd tea.Cmd
+			m.list, cmd = m.list.Update(msg)
+			return cmd
+		default:
+			// Send to textinput, then apply filter
+			var cmd tea.Cmd
+			m.filterInput, cmd = m.filterInput.Update(msg)
+			m.applyFilter()
+			return cmd
 		}
 	}
 
+	// Action mode
+	switch {
+	case kmsg.Type == tea.KeyRunes && string(kmsg.Runes) == "/":
+		m.filterFocused = true
+		m.filterInput.Focus()
+		return nil
+	case key.Matches(kmsg, m.escKey):
+		if m.filterInput.Value() != "" {
+			m.filterInput.SetValue("")
+			m.applyFilter()
+			return nil
+		}
+		m.visible = false
+		return func() tea.Msg {
+			return ToolDenyResult{ServerName: m.serverName, Submitted: false}
+		}
+	case key.Matches(kmsg, m.enterKey):
+		m.visible = false
+		var denied []string
+		for toolName, isDenied := range m.denied {
+			if isDenied {
+				denied = append(denied, toolName)
+			}
+		}
+		return func() tea.Msg {
+			return ToolDenyResult{
+				ServerName:  m.serverName,
+				DeniedTools: denied,
+				Submitted:   true,
+			}
+		}
+	case key.Matches(kmsg, m.spaceKey):
+		if item := m.list.SelectedItem(); item != nil {
+			ti := item.(toolDenyItem)
+			m.denied[ti.toolName] = !m.denied[ti.toolName]
+			m.list.SetDelegate(newToolDenyDelegate(m.theme, m.denied))
+		}
+		return nil
+	}
+
 	var cmd tea.Cmd
 	m.list, cmd = m.list.Update(msg)
 	return cmd
@@ -185,7 +259,17 @@ func (m ToolDenyEditorModel) View() string {
 	if !m.visible {
 		return ""
 	}
-	return m.list.View()
+
+	filterLabel := m.theme.Faint.Render("Filter: ")
+	filterView := m.filterInput.View()
+	filterBar := filterLabel + filterView
+
+	listView := m.list.View()
+	if len(m.list.Items()) == 0 && m.filterInput.Value() != "" {
+		listView = "\n" + m.theme.Faint.Render("  No matching tools") + "\n"
+	}
+
+	return filterBar + "\n\n" + listView
 }
 
 // RenderOverlay renders the editor as a centered overlay.

internal/tui/views/tool_deny_editor_test.go

@@ -143,6 +143,158 @@ func TestToolDenyEditor_Cancel(t *testing.T) {
 	}
 }
 
+// ============================================================================
+// Filter Tests
+// ============================================================================
+
+func newDenyEditorWithTools(t *testing.T) ToolDenyEditorModel {
+	t.Helper()
+	th := theme.New()
+	editor := NewToolDenyEditor(th)
+	editor.SetSize(100, 50)
+	tools := []mcp.Tool{
+		{Name: "read_file", Description: "Read a file"},
+		{Name: "read_resource", Description: "Read a resource"},
+		{Name: "write_file", Description: "Write a file"},
+		{Name: "delete_file", Description: "Delete a file"},
+	}
+	editor.Show("srv1", tools, nil)
+	return editor
+}
+
+func sendRune(editor *ToolDenyEditorModel, r rune) {
+	editor.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+}
+
+func enterFilterMode(editor *ToolDenyEditorModel) {
+	sendRune(editor, '/')
+}
+
+func TestToolDenyEditor_FilterReducesList(t *testing.T) {
+	editor := newDenyEditorWithTools(t)
+
+	if len(editor.list.Items()) != 4 {
+		t.Fatalf("expected 4 items, got %d", len(editor.list.Items()))
+	}
+
+	// Enter filter mode and type "read"
+	enterFilterMode(&editor)
+	for _, r := range "read" {
+		sendRune(&editor, r)
+	}
+
+	items := editor.list.Items()
+	if len(items) != 2 {
+		t.Errorf("expected 2 filtered items, got %d", len(items))
+	}
+	for _, item := range items {
+		ti := item.(toolDenyItem)
+		if ti.toolName != "read_file" && ti.toolName != "read_resource" {
+			t.Errorf("unexpected item %q in filtered list", ti.toolName)
+		}
+	}
+}
+
+func TestToolDenyEditor_FilterClearOnEsc(t *testing.T) {
+	editor := newDenyEditorWithTools(t)
+
+	// Enter filter mode, type, then exit filter mode
+	enterFilterMode(&editor)
+	for _, r := range "read" {
+		sendRune(&editor, r)
+	}
+	// Esc exits filter mode (keeps text)
+	editor.Update(tea.KeyMsg{Type: tea.KeyEsc})
+	// Now in action mode with filter text — esc clears filter
+	editor.Update(tea.KeyMsg{Type: tea.KeyEsc})
+
+	if editor.filterInput.Value() != "" {
+		t.Error("filter text should be cleared")
+	}
+	if len(editor.list.Items()) != 4 {
+		t.Errorf("expected all 4 items restored, got %d", len(editor.list.Items()))
+	}
+}
+
+func TestToolDenyEditor_FilterModeEscKeepsText(t *testing.T) {
+	editor := newDenyEditorWithTools(t)
+
+	enterFilterMode(&editor)
+	for _, r := range "read" {
+		sendRune(&editor, r)
+	}
+
+	// Esc should exit filter mode but keep text
+	editor.Update(tea.KeyMsg{Type: tea.KeyEsc})
+
+	if editor.filterFocused {
+		t.Error("filter should not be focused after esc")
+	}
+	if editor.filterInput.Value() != "read" {
+		t.Errorf("expected filter text 'read', got %q", editor.filterInput.Value())
+	}
+	// List should still be filtered
+	if len(editor.list.Items()) != 2 {
+		t.Errorf("expected 2 items (still filtered), got %d", len(editor.list.Items()))
+	}
+}
+
+func TestToolDenyEditor_SpaceWorksInFilterMode(t *testing.T) {
+	editor := newDenyEditorWithTools(t)
+
+	enterFilterMode(&editor)
+	for _, r := range "delete" {
+		sendRune(&editor, r)
+	}
+
+	// Should have 1 item: delete_file
+	if len(editor.list.Items()) != 1 {
+		t.Fatalf("expected 1 filtered item, got %d", len(editor.list.Items()))
+	}
+
+	// Space should toggle the selected item
+	editor.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{' '}})
+	if !editor.denied["delete_file"] {
+		t.Error("delete_file should be denied after space toggle in filter mode")
+	}
+}
+
+func TestToolDenyEditor_FilterNoMatches(t *testing.T) {
+	editor := newDenyEditorWithTools(t)
+
+	enterFilterMode(&editor)
+	for _, r := range "xyznonexistent" {
+		sendRune(&editor, r)
+	}
+
+	if len(editor.list.Items()) != 0 {
+		t.Errorf("expected 0 items, got %d", len(editor.list.Items()))
+	}
+
+	// Space should be a no-op (no panic)
+	editor.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{' '}})
+}
+
+func TestToolDenyEditor_BackspaceToEmpty(t *testing.T) {
+	editor := newDenyEditorWithTools(t)
+
+	enterFilterMode(&editor)
+	for _, r := range "ab" {
+		sendRune(&editor, r)
+	}
+
+	// Backspace twice to empty
+	editor.Update(tea.KeyMsg{Type: tea.KeyBackspace})
+	editor.Update(tea.KeyMsg{Type: tea.KeyBackspace})
+
+	if editor.filterInput.Value() != "" {
+		t.Errorf("expected empty filter, got %q", editor.filterInput.Value())
+	}
+	if len(editor.list.Items()) != 4 {
+		t.Errorf("expected all 4 items restored, got %d", len(editor.list.Items()))
+	}
+}
+
 func TestToolDenyEditor_ShowWithEmptyDenyList(t *testing.T) {
 	th := theme.New()
 	editor := NewToolDenyEditor(th)