steps 4-7: one picker every drawer conforms to, ^V, and an alert that retires

THREE LISTS BECAME ONE. The completion menu had a sliding window with a marker
and ^N/^P cycling; the drawer had a second window with a different marker and
its own cursor; the help and status panels had neither -- so the list that
tells you how to scroll was the one list you could not scroll, losing its
bottom on any pane shorter than the panel with no way to reach it.

picker.go is now the only one, and every drawer conforms: help, status, queue,
notifications, command output and the hosted live views. j/k, the arrow
cluster, u/d and gg/G drive whichever drawer is open -- moving a CURSOR where
there is one and the WINDOW where there is not, so `j` means one thing to a
reader everywhere. What a drawer still owns is its rows and its verb keys.

A MESSAGE IS A GLANCE, NOT A LIST: one row, nothing to move, so it keeps the
any-key-dismisses rule. Measured -- gating motions on "has a picker" alone left
a failed `:999` note surviving every keystroke, because a note is a drawer too.

AndMore is the truncation marker, in one spelling, on both edges of the window
("… 3 more above"). `figaro ls`, `form show` and the drawer had three.

^V toggles the BAR's verbosity -- names beside the glyphs, the model, the hints
and the last-interaction time -- seeded by cli.status_verbose and distinct from
^O, which is verbose TOOL OUTPUT. In the command box the same chord is PASTE,
which is Gluck's reversal of the "deliberately unbound" note in keymap.go: that
argument was that quoting has no use where every printable byte is already
literal, and paste is a different verb with an obvious one.

THE ALERT RETIRES ON THE TICKER. A notification holds the bar's first slot for
cli.notice_ttl (10s) and then goes, or a newer one displaces it. Nothing waits
to be dismissed. The expiry rides the 11 Hz ticker that is already alive and
already holds the render lock -- no second scheduler, no teardown path -- and
the clock is read there rather than in render(), which stays pure.

Two things only the pty could say. `g` in a drawer never armed pendG, because
the drawer branch returns before the dispatcher's epilogue where the arming
lives -- so gg reached the end of a list and never came back; the unit tests
press keys through a path that armed it anyway. And a stubbed clipboard is now
mandatory in this package (clipboard_stub_test.go): the first ^V implementation
shelled out to wl-paste inside the keymap oracle, so the suite asserted against
whatever the developer had last copied, and mine was a directory listing.

The panel oracles are regenerated, deliberately and in one systematic move:
every drawer owning its motions is exactly the change, and the cells that moved
are the panel states' motion keys.

Author: gluck

internal/cli/clipboard.go

@@ -0,0 +1,66 @@
+package cli
+
+// Reading the system clipboard, for `^V` in the command box.
+//
+// Writing is OSC 52 (term.SetClipboard): the terminal takes a string and the
+// program never touches a selection. READING has no equivalent worth using --
+// OSC 52 queries are refused by most terminals by default, precisely because a
+// program that can read your clipboard can read whatever you last copied
+// anywhere. So this shells out, and says so when it cannot.
+
+import (
+	"os/exec"
+	"strings"
+)
+
+// clipboardReaders are tried in order. Wayland first, then X, then macOS: the
+// first that EXISTS wins, whether or not it returns anything, because a
+// present-but-empty clipboard is an answer and a missing tool is not.
+var clipboardReaders = [][]string{
+	{"wl-paste", "--no-newline"},
+	{"xclip", "-selection", "clipboard", "-o"},
+	{"xsel", "--clipboard", "--output"},
+	{"pbpaste"},
+	{"powershell.exe", "-NoProfile", "-Command", "Get-Clipboard"},
+}
+
+// clipboardRead is the seam. A test that shells out to wl-paste reads the
+// DEVELOPER'S clipboard: measured, and it is how a keymap oracle came back
+// carrying a directory listing that happened to be on mine. The package's
+// tests stub this (see clipboard_stub_test.go); production never touches it.
+var clipboardRead = clipboardText
+
+// clipboardText returns the clipboard's contents, or a reason it could not.
+func clipboardText() (string, error) {
+	var missing []string
+	for _, argv := range clipboardReaders {
+		path, err := exec.LookPath(argv[0])
+		if err != nil {
+			missing = append(missing, argv[0])
+			continue
+		}
+		out, err := exec.Command(path, argv[1:]...).Output()
+		if err != nil {
+			return "", err
+		}
+		return string(out), nil
+	}
+	return "", errNoClipboardTool{tried: missing}
+}
+
+type errNoClipboardTool struct{ tried []string }
+
+func (e errNoClipboardTool) Error() string {
+	if len(e.tried) == 0 {
+		return "no clipboard tool available"
+	}
+	return "no clipboard tool: install one of " + strings.Join(e.tried, ", ")
+}
+
+// pasteIntoLine folds pasted text into something a ONE-LINE editor can hold.
+// Newlines become spaces rather than being dropped: a multi-line paste into a
+// command line is nearly always a prompt that wants to arrive whole, and
+// silently truncating at the first newline would send half of it.
+func pasteIntoLine(s string) string {
+	return strings.Join(strings.Fields(s), " ")
+}

internal/cli/clipboard_stub_test.go

@@ -0,0 +1,11 @@
+package cli
+
+// THE TEST BINARY DOES NOT TOUCH THE REAL CLIPBOARD. Every test in this package
+// runs with paste stubbed to "nothing on the clipboard", because a test that
+// shells out to wl-paste asserts against whatever the person running it last
+// copied -- which is not a test, it is a coin flip that happened to be green
+// on the machine where it was written. A test that wants paste sets this
+// itself, for the duration it needs.
+func init() {
+	clipboardRead = func() (string, error) { return "", nil }
+}

internal/cli/drawer.go

@@ -29,7 +29,6 @@ package cli
 // nothing else may write to the status row ever again.
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/jack-work/figaro/internal/cmdkit"
@@ -93,43 +92,44 @@ type drawer struct {
 	// for rows and forwards keys to it; it knows nothing about drawers and the
 	// drawer knows nothing about forms. See cmdkit.LiveView.
 	live cmdkit.LiveView
-	// top is the first visible row: pagination is a window over rows, not a
-	// truncation of them, so "… N more" can be honest in both directions.
-	top int
+	// pick is the LIST, and every behaviour of one: the window, the cursor,
+	// the motions and the truncation marker. The drawer used to own a second
+	// implementation of all four (see picker.go for the three that existed).
+	// It is nil only for a drawer with no rows -- a message, or a hosted live
+	// view that renders itself.
+	pick *picker
 }
 
 func (d *drawer) open() bool { return d.kind != drawerNone }
 
 // close empties the drawer. Esc reaches here from every kind.
 func (d *drawer) close() {
-	if d.live != nil {
-		d.live.Close()
-	}
 	*d = drawer{}
 }
 
 // showLive hosts a verb that renders itself. The drawer owns the region and
 // the dismissal; the view owns everything inside it.
 func (d *drawer) showLive(name string, v cmdkit.LiveView) {
-	*d = drawer{kind: drawerLive, name: name, live: v, cursor: -1}
+	d.kind, d.name, d.title = drawerLive, name, ""
+	d.flash, d.pick = "", nil
+	d.live = v
 }
 
 // showMessage is the one-line drawer: an error, a result, a note. It carries
 // its own dismissal hint because a message that cannot be dismissed is a
 // message that has taken the screen hostage.
 func (d *drawer) showMessage(text string) {
-	*d = drawer{kind: drawerMessage, name: "message", cursor: -1,
-		rows: []drawerRow{staticRow(text)}}
+	d.kind, d.name, d.title = drawerMessage, "message", ""
+	d.flash, d.live = "", nil
+	d.pick = newPicker([]drawerRow{staticRow("  " + text)}, false)
 }
 
 // showList opens a list drawer, selecting the first selectable row when the
 // caller asked for selection.
 func (d *drawer) showList(name, title string, rows []drawerRow, selectable bool) {
-	*d = drawer{kind: drawerList, name: name, title: title, rows: rows, cursor: -1}
-	if selectable {
-		d.cursor = d.nextSelectable(-1, 1)
-		d.scrollToCursor()
-	}
+	d.kind, d.name, d.title = drawerList, name, title
+	d.flash, d.live = "", nil
+	d.pick = newPicker(rows, selectable)
 }
 
 // visible is how many rows of the list fit: the fixed page, bounded by what the
@@ -153,76 +153,81 @@ func (d *drawer) visible(h int) int {
 
 // nextSelectable finds the next selectable row from i in direction dir (+1/-1),
 // or i itself when there is none.
-func (d *drawer) nextSelectable(i, dir int) int {
-	for j := i + dir; j >= 0 && j < len(d.rows); j += dir {
-		if d.rows[j].selectable() {
-			return j
-		}
-	}
-	if i >= 0 && i < len(d.rows) && d.rows[i].selectable() {
-		return i
-	}
-	// Nothing in that direction: find the first selectable row at all.
-	for j := 0; j < len(d.rows); j++ {
-		if d.rows[j].selectable() {
-			return j
-		}
-	}
-	return -1
-}
+// THE LIST BEHAVIOURS ARE THE PICKER'S. What used to be six methods here --
+// nextSelectable, moveSelection, scrollToCursor, scrollToCursorIn, selected,
+// removeSelected -- was a second implementation of what the completion menu
+// already did, differing from it in the marker it drew and in nothing else.
+// These forward; picker.go decides.
 
-// moveSelection is ^N/^P inside a list drawer.
 func (d *drawer) moveSelection(dir int, h int) {
-	if d.kind != drawerList || d.cursor < 0 {
+	if d.pick == nil {
 		return
 	}
-	if n := d.nextSelectable(d.cursor, dir); n != d.cursor {
-		d.cursor = n
-	}
-	d.scrollToCursorIn(d.visible(h))
+	d.pick.height = clampInt(h, 1, pickerRows)
+	d.pick.move(dir)
 }
 
-func (d *drawer) scrollToCursor() { d.scrollToCursorIn(drawerPageRows) }
+// scrollBy is j/k and the arrow cluster: it moves the SELECTION in a drawer
+// that has one and the WINDOW in a drawer that does not, which is what makes
+// `j` mean one thing to a reader across every drawer.
+func (d *drawer) scrollBy(dir int, h int) { d.moveSelection(dir, h) }
 
-// scrollToCursorIn keeps the selected row inside the visible window.
-func (d *drawer) scrollToCursorIn(n int) {
-	if d.cursor < 0 {
+func (d *drawer) halfPage(dir int, h int) {
+	if d.pick == nil {
 		return
 	}
-	if d.cursor < d.top {
-		d.top = d.cursor
-	}
-	if d.cursor >= d.top+n {
-		d.top = d.cursor - n + 1
+	d.pick.height = clampInt(h, 1, pickerRows)
+	d.pick.half(dir)
+}
+
+func (d *drawer) toTop() {
+	if d.pick != nil {
+		d.pick.home()
 	}
-	if d.top < 0 {
-		d.top = 0
+}
+func (d *drawer) toBottom() {
+	if d.pick != nil {
+		d.pick.end()
 	}
 }
 
-// selected is the row under the cursor, if any.
 func (d *drawer) selected() (drawerRow, bool) {
-	if d.kind != drawerList || d.cursor < 0 || d.cursor >= len(d.rows) {
+	if d.kind != drawerList || d.pick == nil {
 		return drawerRow{}, false
 	}
-	return d.rows[d.cursor], true
+	return d.pick.selected()
 }
 
-// removeSelected drops the selected row and keeps the selection sensible: what
-// `x` on a queued message does to the list it was addressing.
-func (d *drawer) removeSelected() {
-	if d.cursor < 0 || d.cursor >= len(d.rows) {
+// replaceRows swaps the list under a live cursor, keeping the selection ON THE
+// SAME ROW ID rather than at the same index: a queue that re-sorts under the
+// cursor on every poll is a queue nobody can hit `x` on, and an index-keyed
+// restore is how `x` came to drop the wrong message.
+func (d *drawer) replaceRows(rows []drawerRow, keepID string) {
+	if d.pick == nil {
+		d.pick = newPicker(rows, true)
 		return
 	}
-	d.rows = append(d.rows[:d.cursor], d.rows[d.cursor+1:]...)
-	d.cursor = d.nextSelectable(d.cursor-1, 1)
-	d.scrollToCursor()
+	sel := d.pick.selectable()
+	top := d.pick.top
+	d.pick = newPicker(rows, sel)
+	d.pick.top = top
+	if keepID != "" {
+		for i, r := range rows {
+			if r.id == keepID {
+				d.pick.cursor = i
+				break
+			}
+		}
+	}
+	d.pick.follow()
+}
+
+func (d *drawer) removeSelected() {
+	if d.pick != nil {
+		d.pick.remove()
+	}
 }
 
-// lines renders the drawer's body: the title, the visible page, and a marker at
-// each end saying what is out of view. THE MARKERS ARE NOT DECORATION -- a list
-// that silently shows ten of seven hundred is a list that lies about the size of
-// the thing you are looking at.
 func (d *drawer) lines(w, h int) []string {
 	if !d.open() {
 		return nil
@@ -234,25 +239,17 @@ func (d *drawer) lines(w, h int) []string {
 		}
 		return rows
 	}
-	n := d.visible(h)
-	if d.top > max(len(d.rows)-n, 0) {
-		d.top = max(len(d.rows)-n, 0)
-	}
-	out := make([]string, 0, n+3)
+	out := make([]string, 0, d.visible(h)+3)
 	if d.title != "" {
 		out = append(out, drawerGray(clipToWidth(d.title, w)))
 	}
-	if d.top > 0 {
-		out = append(out, drawerGray(clipToWidth(fmt.Sprintf("  … %d more", d.top), w)))
-	}
-	end := min(d.top+n, len(d.rows))
-	for i := d.top; i < end; i++ {
-		out = append(out, d.rowLine(i, w))
-	}
-	if end < len(d.rows) {
-		out = append(out, drawerGray(clipToWidth(fmt.Sprintf("  … %d more", len(d.rows)-end), w)))
+	if d.pick == nil {
+		return out
 	}
-	return out
+	// EVERY LIST IS A PICKER. The window, the cursor, the selection marker and
+	// the "… N more" on both edges come from one place; what a drawer still
+	// owns is its rows and its verb keys.
+	return append(out, d.pick.lines(drawerID(d.name), w, d.visible(h)-len(out))...)
 }
 
 // rowLine draws one row, with the selection cue in the gutter the transcript

internal/cli/keymap.go

@@ -175,6 +175,18 @@ var keymap = []keyBinding{
 		chord: byteChord(0x0f), modes: inAnyBox &^ inJumpBox,
 		open: opensPager, help: helpVerbose, input: inputToggleVerbose,
 	},
+	{
+		// ^V is the BAR's verbosity: state names, the model, the hints and the
+		// last-interaction time. A different axis from ^O above, which is
+		// verbose TOOL OUTPUT -- and the two are deliberately different keys
+		// because they answer different questions.
+		chord: byteChord(0x16), modes: inAnyBox &^ inJumpBox,
+		open: opensPager, help: helpBarVerbose, input: inputToggleBarVerbose,
+	},
+	{
+		chord: ctrlChord('v'), modes: inAnyBox &^ inJumpBox,
+		open: opensPager, help: helpNone, input: inputToggleBarVerbose,
+	},
 	{
 		// In incipit 'y' copies the aria id, a feature of its own, not a
 		// reason to open the pager. In the search box it is literal text.
@@ -422,6 +434,8 @@ var keymap = []keyBinding{
 
 	// Completion.
 	{chord: byteChord(0x09), modes: inJumpBox, open: staysInline, why: "only reachable with the command line up", help: helpCmdComplete, pager: cmdComplete},
+	{chord: byteChord(0x16), modes: inJumpBox, open: staysInline, why: "only reachable with the command line up", help: helpCmdPaste, pager: cmdPaste},
+	{chord: ctrlChord('v'), modes: inJumpBox, open: staysInline, why: "only reachable with the command line up", help: helpNone, pager: cmdPaste},
 	{chord: metaChord('?'), modes: inJumpBox, open: staysInline, why: "only reachable with the command line up", help: helpNone, pager: cmdListComplete},
 	{chord: metaChord('*'), modes: inJumpBox, open: staysInline, why: "only reachable with the command line up", help: helpNone, pager: cmdInsertComplete},
 
@@ -448,11 +462,14 @@ var keymap = []keyBinding{
 
 	// NOT BOUND, each for a reason:
 	//
-	//   ^V / ^Q (quoted-insert)  Every printable byte in this box is ALREADY
+	//   ^Q (quoted-insert)      Every printable byte in this box is ALREADY
 	//                            literal text -- there is no binding to escape
 	//                            past -- and the only thing quoting could add
 	//                            is a control character the line can neither
-	//                            render nor send.
+	//                            render nor send. (^V was on this list for the
+	//                            same reason and has been taken off it: it is
+	//                            PASTE here, which is a different verb with an
+	//                            obvious use.)
 	//   ^X <anything>            readline's second keymap: macros (^X( ^X) ^Xe),
 	//                            ^X^U (undo, which ^_ already is), ^X Del (^U),
 	//                            ^X^R (re-read inputrc, meaningless here). A
@@ -524,6 +541,8 @@ const (
 	helpCmdHistory
 	helpCmdComplete
 	helpCmdEdit
+	helpCmdPaste
+	helpBarVerbose
 	helpCmdAbort
 	helpDrawerDrop
 )
@@ -562,6 +581,8 @@ var helpRows = []helpRow{
 	{helpDrawerDrop, "(in a list) x", "drop the selected entry (queue)"},
 	{helpYank, "y", "copy selection (or aria id if none)"},
 	{helpVerbose, "^O", "toggle verbose tool output"},
+	{helpBarVerbose, "^V", "toggle the status bar's detail (names, model, time)"},
+	{helpCmdPaste, "(in :) ^V", "paste the clipboard"},
 	{helpSelect, "^N/^P", "select next/previous node"},
 	{helpSelectExtend, "^N/^P + Shift", "extend node selection (Alt+^N/^P fallback)"},
 	{helpExpand, "Enter", "expand tools within the selection"},