Add search/filtering to TUI tree

Press `/` to enter search mode, type to filter the tree live with
case-insensitive substring matching. Ancestors of matches stay visible
for context and are auto-expanded. Two-tone highlighting: matching rows
get a subtle purple-tinted background, exact matching characters get a
stronger bold purple style. `Enter` or `Esc` clears the filter while
preserving cursor position on the selected item.

Also fixes shorthand GitHub URL args (e.g. `owner/repo/pull/123`) being
misidentified as tokens by the CLI arg parser.

Closes #19

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: stefanpenner

cmd/gha-analyzer/main.go

@@ -213,6 +213,10 @@ func main() {
 	if token == "" {
 		for i, arg := range args {
 			if !strings.HasPrefix(arg, "http") && !strings.HasPrefix(arg, "-") {
+				// Skip arguments that look like GitHub URLs (shorthand or full)
+				if _, err := utils.ParseGitHubURL(arg); err == nil {
+					continue
+				}
 				token = arg
 				args = append(args[:i], args[i+1:]...)
 				break

pkg/tui/results/items.go

@@ -230,6 +230,18 @@ func FlattenVisibleItems(items []*TreeItem, expandedState map[string]bool) []Tre
 	return result
 }
 
+// FilterVisibleItems filters already-flattened visible items to only include
+// items whose ID is in matchIDs or ancestorIDs.
+func FilterVisibleItems(items []TreeItem, matchIDs, ancestorIDs map[string]bool) []TreeItem {
+	var result []TreeItem
+	for _, item := range items {
+		if matchIDs[item.ID] || ancestorIDs[item.ID] {
+			result = append(result, item)
+		}
+	}
+	return result
+}
+
 func makeNodeID(parentID, name string, index int) string {
 	if parentID == "" {
 		return fmt.Sprintf("%s/%d", name, index)

pkg/tui/results/keys.go

@@ -19,6 +19,7 @@ type KeyMap struct {
 	ExpandAll   key.Binding
 	CollapseAll key.Binding
 	Perfetto    key.Binding
+	Search      key.Binding
 	Mouse       key.Binding
 	Help        key.Binding
 	Quit        key.Binding
@@ -87,6 +88,10 @@ func DefaultKeyMap() KeyMap {
 			key.WithKeys("p"),
 			key.WithHelp("p", "perfetto"),
 		),
+		Search: key.NewBinding(
+			key.WithKeys("/"),
+			key.WithHelp("/", "search"),
+		),
 		Mouse: key.NewBinding(
 			key.WithKeys("m"),
 			key.WithHelp("m", "toggle mouse"),
@@ -104,7 +109,7 @@ func DefaultKeyMap() KeyMap {
 
 // ShortHelp returns a short help string for the footer
 func (k KeyMap) ShortHelp() string {
-	return "↑↓ nav • ←→ expand/collapse • space toggle • o open • ? help • q quit"
+	return "↑↓ nav • ←→ expand/collapse • space toggle • / search • o open • ? help • q quit"
 }
 
 // FullHelp returns all key bindings for the help modal
@@ -125,6 +130,7 @@ func (k KeyMap) FullHelp() [][]string {
 		{"c", "Collapse all"},
 		{"r", "Reload data"},
 		{"p", "Open in Perfetto"},
+		{"/", "Search/filter"},
 		{"m", "Toggle mouse mode"},
 		{"?", "Show this help"},
 		{"q", "Quit"},

pkg/tui/results/model.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 	"time"
+	"unicode/utf8"
 
 	"github.com/charmbracelet/bubbles/key"
 	"github.com/charmbracelet/bubbles/spinner"
@@ -86,6 +87,11 @@ type Model struct {
 	openPerfettoFunc func()
 	// Mouse mode state
 	mouseEnabled bool
+	// Search/filter state
+	isSearching    bool
+	searchQuery    string
+	searchMatchIDs map[string]bool // IDs of items matching the query (not ancestors)
+	searchAncIDs   map[string]bool // IDs of ancestor items (for context)
 }
 
 // ReloadFunc is the function signature for reloading data
@@ -341,6 +347,63 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, nil
 		}
 
+		// Handle search input mode
+		if m.isSearching {
+			switch msg.Type {
+			case tea.KeyEsc:
+				m.isSearching = false
+				m.searchQuery = ""
+				m.searchMatchIDs = nil
+				m.searchAncIDs = nil
+				m.rebuildItems()
+				return m, nil
+			case tea.KeyEnter, tea.KeyDown, tea.KeyTab:
+				// Exit search input but keep filter active
+				m.isSearching = false
+				return m, nil
+			case tea.KeyBackspace:
+				if len(m.searchQuery) > 0 {
+					_, size := utf8.DecodeLastRuneInString(m.searchQuery)
+					m.searchQuery = m.searchQuery[:len(m.searchQuery)-size]
+				}
+				m.applySearchFilter()
+				m.rebuildItems()
+				return m, nil
+			default:
+				if msg.Type == tea.KeyRunes {
+					m.searchQuery += string(msg.Runes)
+					m.applySearchFilter()
+					m.rebuildItems()
+				}
+				return m, nil
+			}
+		}
+
+		// Esc or Enter clears active search filter (when not in input mode).
+		// Enter preserves cursor on the current item in the full tree;
+		// Esc simply clears and resets.
+		if m.searchQuery != "" && (msg.Type == tea.KeyEsc || msg.Type == tea.KeyEnter) {
+			// Remember current item ID so we can find it after rebuild
+			var curID string
+			if m.cursor >= 0 && m.cursor < len(m.visibleItems) {
+				curID = m.visibleItems[m.cursor].ID
+			}
+			m.searchQuery = ""
+			m.searchMatchIDs = nil
+			m.searchAncIDs = nil
+			m.rebuildItems()
+			// Restore cursor to the same item in the unfiltered list
+			if curID != "" {
+				for i, item := range m.visibleItems {
+					if item.ID == curID {
+						m.cursor = i
+						break
+					}
+				}
+			}
+			return m, nil
+		}
+
 		switch {
 		case key.Matches(msg, m.keys.Quit):
 			return m, tea.Quit
@@ -422,6 +485,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			}
 			return m, tea.DisableMouse
 
+		case key.Matches(msg, m.keys.Search):
+			m.isSearching = true
+			m.searchQuery = ""
+			m.searchMatchIDs = nil
+			m.searchAncIDs = nil
+			return m, nil
+
 		case key.Matches(msg, m.keys.Help):
 			m.showHelpModal = true
 			return m, nil
@@ -532,6 +602,10 @@ func (m Model) View() string {
 	// Calculate available height for items
 	headerLines := 9 // header box (6 lines) + 1 newline + time axis + 1 blank line
 	footerLines := 3 // blank line + help line + bottom border
+	searchActive := m.isSearching || m.searchQuery != ""
+	if searchActive {
+		headerLines++ // search bar takes one line
+	}
 	availableHeight := height - headerLines - footerLines
 	if availableHeight < 1 {
 		availableHeight = 10
@@ -559,6 +633,12 @@ func (m Model) View() string {
 	b.WriteString(blankLine)
 	b.WriteString("\n")
 
+	// Search bar (between blank line and content)
+	if searchActive {
+		b.WriteString(m.renderSearchBar(contentWidth))
+		b.WriteString("\n")
+	}
+
 	// Determine scroll window
 	startIdx := 0
 	endIdx := totalItems
@@ -709,11 +789,75 @@ func addHorizontalPadding(content string, pad int) string {
 	return result.String()
 }
 
+// applySearchFilter computes searchMatchIDs and searchAncIDs based on searchQuery.
+// It also auto-expands ancestors of matching items.
+func (m *Model) applySearchFilter() {
+	if m.searchQuery == "" {
+		m.searchMatchIDs = nil
+		m.searchAncIDs = nil
+		return
+	}
+
+	query := strings.ToLower(m.searchQuery)
+	m.searchMatchIDs = make(map[string]bool)
+	m.searchAncIDs = make(map[string]bool)
+
+	// Walk tree items recursively looking for matches
+	var walk func(items []*TreeItem)
+	walk = func(items []*TreeItem) {
+		for _, item := range items {
+			if strings.Contains(strings.ToLower(item.Name), query) {
+				m.searchMatchIDs[item.ID] = true
+				// Collect and expand ancestors
+				m.addAncestors(item.ParentID)
+			}
+			walk(item.Children)
+		}
+	}
+	walk(m.treeItems)
+}
+
+// addAncestors walks up the tree from parentID, adding each ancestor to searchAncIDs
+// and expanding them so they become visible.
+func (m *Model) addAncestors(parentID string) {
+	if parentID == "" {
+		return
+	}
+	if m.searchAncIDs[parentID] {
+		return // already processed
+	}
+	m.searchAncIDs[parentID] = true
+	m.expandedState[parentID] = true
+
+	// Find the parent item to continue up
+	var findParent func(items []*TreeItem) string
+	findParent = func(items []*TreeItem) string {
+		for _, item := range items {
+			if item.ID == parentID {
+				return item.ParentID
+			}
+			if found := findParent(item.Children); found != "" {
+				return found
+			}
+		}
+		return ""
+	}
+	grandparentID := findParent(m.treeItems)
+	if grandparentID != "" {
+		m.addAncestors(grandparentID)
+	}
+}
+
 // rebuildItems rebuilds the flattened item list based on expanded state
 func (m *Model) rebuildItems() {
 	m.treeItems = BuildTreeItems(m.roots, m.expandedState, m.inputURLs)
 	m.visibleItems = FlattenVisibleItems(m.treeItems, m.expandedState)
 
+	// Apply search filter if active
+	if m.searchQuery != "" && (m.searchMatchIDs != nil || m.searchAncIDs != nil) {
+		m.visibleItems = FilterVisibleItems(m.visibleItems, m.searchMatchIDs, m.searchAncIDs)
+	}
+
 	// Ensure cursor is valid
 	if m.cursor >= len(m.visibleItems) {
 		m.cursor = len(m.visibleItems) - 1
@@ -774,6 +918,49 @@ func (m *Model) openCurrentItem() {
 	}
 }
 
+// renderSearchBar renders the search input bar
+func (m Model) renderSearchBar(contentWidth int) string {
+	// Format: │ / query█              N matches │
+	prefix := SearchBarStyle.Render(" / ")
+	query := SearchBarStyle.Render(m.searchQuery)
+	cursor := ""
+	if m.isSearching {
+		cursor = SearchBarStyle.Render("█")
+	}
+
+	// Count matches
+	matchCount := len(m.searchMatchIDs)
+	countStr := ""
+	if m.searchQuery != "" {
+		countStr = SearchCountStyle.Render(fmt.Sprintf("%d matches ", matchCount))
+	}
+
+	// Calculate padding
+	prefixWidth := 3 // " / "
+	queryWidth := len(m.searchQuery)
+	cursorWidth := 0
+	if m.isSearching {
+		cursorWidth = 1
+	}
+	countWidth := 0
+	if countStr != "" {
+		if matchCount >= 100 {
+			countWidth = 12 // "NNN matches "
+		} else if matchCount >= 10 {
+			countWidth = 11 // "NN matches "
+		} else {
+			countWidth = 10 // "N matches "
+		}
+	}
+
+	padWidth := contentWidth - prefixWidth - queryWidth - cursorWidth - countWidth
+	if padWidth < 1 {
+		padWidth = 1
+	}
+
+	return BorderStyle.Render("│") + prefix + query + cursor + strings.Repeat(" ", padWidth) + countStr + BorderStyle.Render("│")
+}
+
 // renderLoadingView renders the loading progress display
 func (m Model) renderLoadingView() string {
 	var b strings.Builder