nook: type-to-filter the completion popup instead of dismissing on keystroke

With the completion menu open, typing an identifier rune now narrows the
visible list to the items whose label still matches the word under the
cursor (a case-insensitive subsequence, so "wg" keeps "WaitGroup"), and
Backspace widens it back. Previously any key other than an arrow or Enter
closed the menu, so a completion was only usable if the first prefix the
server saw already surfaced the right item — that is the Zed/VSCode gap.

The complete.Popup retains the full server result set and re-filters
against it, so widening on Backspace needs no fresh round-trip. The host
recomputes the word-prefix from the live buffer each keystroke rather than
tracking it incrementally, so paste and multi-rune edits stay honest; an
empty prefix or a filter that matches nothing dismisses the popup.

Author: truffle-dev

CHANGELOG.md

@@ -6,6 +6,18 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Added
+
+- nook's completion popup now filters as you type instead of dismissing.
+  With the menu open, typing an identifier rune narrows the visible list to
+  the items whose label still matches the word under the cursor (a
+  case-insensitive subsequence, so `wg` keeps `WaitGroup`), and Backspace
+  widens it back — matching Zed and VSCode. Previously any key that wasn't
+  an arrow or Enter closed the menu, so a completion was only usable if the
+  first typed prefix already surfaced the right item. The filter recomputes
+  the prefix from the live buffer each keystroke, so paste and multi-rune
+  edits stay honest, and a prefix that matches nothing dismisses the popup.
+
 ## [0.51.0] — 2026-06-30
 
 Two files at once. nook gains split panes — the headline Zed-parity

cmd/nook/internal/complete/complete.go

@@ -35,6 +35,11 @@ const defaultMaxRows = 8
 // the selection. The host treats Popup like any other tea-style value:
 // derive a new one from each transition.
 type Popup struct {
+	// all is the full sorted result set the server returned. items is the
+	// currently-visible subset after any live Narrow filter. Retaining all
+	// lets Narrow widen back when the user deletes characters without a
+	// fresh server round-trip.
+	all       []nooklsp.CompletionItem
 	items     []nooklsp.CompletionItem
 	selected  int
 	prefixLen int
@@ -68,12 +73,65 @@ func (p Popup) WithItems(items []nooklsp.CompletionItem, prefixLen int) Popup {
 		}
 		return ordered[i].Label < ordered[j].Label
 	})
+	p.all = ordered
 	p.items = ordered
 	p.selected = 0
 	p.prefixLen = prefixLen
 	return p
 }
 
+// Narrow returns a popup whose visible items are those in the full result
+// set whose label matches sub as a case-insensitive subsequence, keeping
+// the server's SortText order among the survivors. It filters against the
+// retained full set rather than the current view, so deleting characters
+// widens the list back without a fresh server request. An empty sub
+// restores the full set. Selection resets to the first survivor.
+//
+// Subsequence (not prefix) matching mirrors what fuzzy finders and the Zed
+// and VSCode completion menus do as the user keeps typing: "wg" still
+// surfaces "WaitGroup". The host feeds sub the identifier prefix under the
+// cursor after each keystroke while the popup is open.
+func (p Popup) Narrow(sub string) Popup {
+	if sub == "" {
+		p.items = p.all
+		p.selected = 0
+		return p
+	}
+	lower := strings.ToLower(sub)
+	var kept []nooklsp.CompletionItem
+	for _, it := range p.all {
+		label := it.Label
+		if label == "" {
+			label = it.InsertText
+		}
+		if subsequence(lower, strings.ToLower(label)) {
+			kept = append(kept, it)
+		}
+	}
+	p.items = kept
+	p.selected = 0
+	return p
+}
+
+// subsequence reports whether every rune of sub appears in s in order,
+// not necessarily contiguously. Both are expected already lower-cased.
+func subsequence(sub, s string) bool {
+	if sub == "" {
+		return true
+	}
+	subRunes := []rune(sub)
+	i := 0
+	for _, r := range s {
+		if r == subRunes[i] {
+			i++
+			if i == len(subRunes) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 // sortKey is the primary ordering key for an item: its SortText when the
 // server supplied one, otherwise its Label. This mirrors the LSP spec's
 // fallback rule so a server that omits SortText still ranks sensibly.
@@ -304,6 +362,12 @@ func WordPrefix(s string) string {
 	return string(runes[i:])
 }
 
+// IsIdentRune reports whether r is part of an identifier (letter, digit,
+// or underscore). The host uses it to decide whether a keystroke typed
+// while the popup is open should narrow the list (identifier rune) or
+// dismiss it (anything else).
+func IsIdentRune(r rune) bool { return isIdentRune(r) }
+
 func isIdentRune(r rune) bool {
 	switch {
 	case r >= 'a' && r <= 'z':

cmd/nook/internal/complete/complete_test.go

@@ -258,6 +258,88 @@ func TestNarrowWidthStillRenders(t *testing.T) {
 	}
 }
 
+// TestNarrowFiltersBySubsequence confirms Narrow keeps only the items
+// whose label matches the typed prefix as a case-insensitive subsequence,
+// preserves SortText order among survivors, and resets the selection.
+func TestNarrowFiltersBySubsequence(t *testing.T) {
+	t.Parallel()
+	items := []nooklsp.CompletionItem{
+		{Label: "Print", InsertText: "Print", SortText: "0"},
+		{Label: "Printf", InsertText: "Printf", SortText: "1"},
+		{Label: "Println", InsertText: "Println", SortText: "2"},
+		{Label: "Prepare", InsertText: "Prepare", SortText: "3"},
+		{Label: "WaitGroup", InsertText: "WaitGroup", SortText: "4"},
+	}
+	p := New().WithItems(items, 2)
+
+	// "pri" (case-insensitive) drops Prepare (no i after Pr) and WaitGroup.
+	p = p.Narrow("pri")
+	got := labels(p.items)
+	want := []string{"Print", "Printf", "Println"}
+	if !equalStrings(got, want) {
+		t.Fatalf("Narrow(pri) = %v, want %v", got, want)
+	}
+	// Selection resets to the first survivor.
+	if sel, ok := p.Selected(); !ok || sel.Label != "Print" {
+		t.Errorf("after Narrow selected = %v, want Print", sel.Label)
+	}
+
+	// Non-contiguous subsequence still matches: "wg" -> WaitGroup.
+	p2 := New().WithItems(items, 0).Narrow("wg")
+	if got := labels(p2.items); !equalStrings(got, []string{"WaitGroup"}) {
+		t.Errorf("Narrow(wg) = %v, want [WaitGroup]", got)
+	}
+}
+
+// TestNarrowWidensBack confirms Narrow filters the full retained set, not
+// the current view, so a shorter prefix restores items an earlier, longer
+// prefix had filtered out (the backspace-widens case).
+func TestNarrowWidensBack(t *testing.T) {
+	t.Parallel()
+	items := []nooklsp.CompletionItem{
+		{Label: "Print", SortText: "0"},
+		{Label: "Prepare", SortText: "1"},
+	}
+	p := New().WithItems(items, 2)
+
+	p = p.Narrow("pri") // drops Prepare
+	if got := labels(p.items); !equalStrings(got, []string{"Print"}) {
+		t.Fatalf("Narrow(pri) = %v, want [Print]", got)
+	}
+	p = p.Narrow("pr") // widen: both match again
+	if got := labels(p.items); !equalStrings(got, []string{"Print", "Prepare"}) {
+		t.Fatalf("Narrow(pr) widen = %v, want [Print Prepare]", got)
+	}
+	// Empty restores the full set.
+	p = p.Narrow("")
+	if got := labels(p.items); !equalStrings(got, []string{"Print", "Prepare"}) {
+		t.Errorf("Narrow(\"\") = %v, want full set", got)
+	}
+}
+
+// TestNarrowToEmpty confirms a prefix that matches nothing leaves the
+// popup empty so the host can dismiss it.
+func TestNarrowToEmpty(t *testing.T) {
+	t.Parallel()
+	p := New().WithItems([]nooklsp.CompletionItem{{Label: "Print"}}, 0)
+	p = p.Narrow("xyz")
+	if !p.Empty() {
+		t.Errorf("Narrow(xyz) Len = %d, want empty", p.Len())
+	}
+}
+
+func equalStrings(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
 func stripANSI(s string) string {
 	var b strings.Builder
 	inEsc := false

cmd/nook/main.go

@@ -237,6 +237,14 @@ type model struct {
 	completeReqRow  int
 	completeReqCol  int
 
+	// completeNarrowPending is set when a keystroke routed while the
+	// completion popup is open should narrow the visible list rather than
+	// dismiss it — an identifier rune or a Backspace. The completion
+	// overlay block arms it and falls through so the key still edits the
+	// buffer; the post-edit tail then recomputes the word-prefix from the
+	// live buffer and calls Narrow (or dismisses if nothing matches).
+	completeNarrowPending bool
+
 	// LSP completion-doc side panel. Auto-fires completionItem/resolve as
 	// the user navigates the popup so the highlighted item's documentation
 	// renders beside the menu. docReqLabel pins the most recent request so
@@ -2064,10 +2072,12 @@ func (m model) routeKey(km tea.KeyMsg) (tea.Model, tea.Cmd) {
 
 	// Completion popup intercepts navigation keys: ↑/↓ move selection,
 	// Enter accepts (replacing the trailing word-prefix with the chosen
-	// item's InsertText), Esc dismisses silently. Any other key dismisses
-	// AND falls through to the editor so the user can keep typing — this
-	// matches VS Code's behavior where pressing 'a' after the popup is
-	// open closes the menu and types 'a'.
+	// item's InsertText), Esc dismisses silently. An identifier rune or a
+	// Backspace narrows the list live: the key still edits the buffer, and
+	// the post-edit tail re-filters the popup against the new word-prefix
+	// (Zed/VS Code behavior — typing "Pr" over an open menu keeps only the
+	// items that still match instead of closing the menu). Any other key
+	// dismisses AND falls through so the keystroke reaches the editor.
 	if m.overlay == overlayCompletion {
 		switch km.Type {
 		case tea.KeyUp:
@@ -2081,9 +2091,21 @@ func (m model) routeKey(km tea.KeyMsg) (tea.Model, tea.Cmd) {
 		case tea.KeyEsc:
 			m.dismissCompletion()
 			return m, nil
+		case tea.KeyBackspace:
+			// Deleting a char shortens the prefix; narrow (widen) rather
+			// than dismiss. If backspacing clears the whole prefix the
+			// post-edit tail dismisses.
+			m.completeNarrowPending = true
+		case tea.KeyRunes:
+			if len(km.Runes) == 1 && !km.Alt && complete.IsIdentRune(km.Runes[0]) {
+				m.completeNarrowPending = true
+			} else {
+				m.dismissCompletion()
+			}
+		default:
+			// Any other key: dismiss the popup and fall through.
+			m.dismissCompletion()
 		}
-		// Any other key: dismiss the popup and fall through.
-		m.dismissCompletion()
 	}
 
 	// Code-action popup swallows its own keys end-to-end: ↑/↓ navigate,
@@ -2684,6 +2706,27 @@ func (m model) routeKey(km tea.KeyMsg) (tea.Model, tea.Cmd) {
 	var cmd tea.Cmd
 	*p, cmd = p.Update(km)
 
+	// If the completion popup is open and this keystroke was an identifier
+	// rune or a Backspace, narrow the visible list against the freshly
+	// edited buffer instead of dismissing. Recomputing the prefix from the
+	// live line (rather than tracking it incrementally) keeps the filter
+	// honest across paste, multi-rune edits, and word boundaries. An empty
+	// prefix or a filter that matches nothing dismisses the popup.
+	if m.completeNarrowPending {
+		m.completeNarrowPending = false
+		if m.overlay == overlayCompletion {
+			prefix := complete.WordPrefix(p.LinePrefix())
+			if prefix == "" {
+				m.dismissCompletion()
+			} else {
+				m.completePopup = m.completePopup.Narrow(prefix)
+				if m.completePopup.Empty() {
+					m.dismissCompletion()
+				}
+			}
+		}
+	}
+
 	cmds := []tea.Cmd{}
 	if cmd != nil {
 		cmds = append(cmds, cmd)